mirror of
https://github.com/DRYTRIX/TimeTracker.git
synced 2026-01-05 19:20:21 -06:00
90dde470da
- Normalize line endings from CRLF to LF across all files to match .editorconfig - Standardize quote style from single quotes to double quotes - Normalize whitespace and formatting throughout codebase - Apply consistent code style across 372 files including: * Application code (models, routes, services, utils) * Test files * Configuration files * CI/CD workflows This ensures consistency with the project's .editorconfig settings and improves code maintainability.
212 lines
7.7 KiB
Python
212 lines
7.7 KiB
Python
from datetime import datetime
|
|
from app import db
|
|
from app.utils.timezone import now_in_app_timezone
|
|
|
|
|
|
class Comment(db.Model):
|
|
"""Comment model for project and task discussions"""
|
|
|
|
__tablename__ = "comments"
|
|
|
|
id = db.Column(db.Integer, primary_key=True)
|
|
content = db.Column(db.Text, nullable=False)
|
|
|
|
# Reference to either project, task, or quote (one will be null)
|
|
project_id = db.Column(db.Integer, db.ForeignKey("projects.id"), nullable=True, index=True)
|
|
task_id = db.Column(db.Integer, db.ForeignKey("tasks.id"), nullable=True, index=True)
|
|
quote_id = db.Column(db.Integer, db.ForeignKey("quotes.id", ondelete="CASCADE"), nullable=True, index=True)
|
|
|
|
# Author of the comment
|
|
user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False, index=True)
|
|
|
|
# Visibility: True = internal team comment, False = client-visible comment
|
|
is_internal = db.Column(db.Boolean, default=True, nullable=False)
|
|
|
|
# Timestamps
|
|
created_at = db.Column(db.DateTime, default=now_in_app_timezone, nullable=False)
|
|
updated_at = db.Column(db.DateTime, default=now_in_app_timezone, onupdate=now_in_app_timezone, nullable=False)
|
|
|
|
# Optional: for threaded comments (replies to other comments)
|
|
parent_id = db.Column(db.Integer, db.ForeignKey("comments.id"), nullable=True, index=True)
|
|
|
|
# Relationships
|
|
author = db.relationship("User", backref="comments")
|
|
project = db.relationship("Project", backref="comments")
|
|
task = db.relationship("Task", backref="comments")
|
|
quote = db.relationship("Quote", backref="comments")
|
|
|
|
# Self-referential relationship for replies
|
|
parent = db.relationship("Comment", remote_side=[id], backref="replies")
|
|
|
|
def __init__(
|
|
self, content, user_id, project_id=None, task_id=None, quote_id=None, parent_id=None, is_internal=True
|
|
):
|
|
"""Create a comment.
|
|
|
|
Args:
|
|
content: The comment text
|
|
user_id: ID of the user creating the comment
|
|
project_id: ID of the project (if this is a project comment)
|
|
task_id: ID of the task (if this is a task comment)
|
|
parent_id: ID of parent comment (if this is a reply)
|
|
"""
|
|
if not project_id and not task_id and not quote_id:
|
|
raise ValueError("Comment must be associated with either a project, task, or quote")
|
|
|
|
# Ensure only one target is set
|
|
targets = [x for x in [project_id, task_id, quote_id] if x is not None]
|
|
if len(targets) > 1:
|
|
raise ValueError("Comment cannot be associated with multiple targets")
|
|
|
|
self.content = content.strip()
|
|
self.user_id = user_id
|
|
self.project_id = project_id
|
|
self.task_id = task_id
|
|
self.quote_id = quote_id
|
|
self.parent_id = parent_id
|
|
self.is_internal = is_internal
|
|
|
|
def __repr__(self):
|
|
if self.project_id:
|
|
target = f"Project {self.project_id}"
|
|
elif self.task_id:
|
|
target = f"Task {self.task_id}"
|
|
elif self.quote_id:
|
|
target = f"Quote {self.quote_id}"
|
|
else:
|
|
target = "Unknown"
|
|
return f'<Comment by {self.author.username if self.author else "Unknown"} on {target}>'
|
|
|
|
@property
|
|
def is_reply(self):
|
|
"""Check if this comment is a reply to another comment"""
|
|
return self.parent_id is not None
|
|
|
|
@property
|
|
def target_type(self):
|
|
"""Get the type of target this comment is attached to"""
|
|
if self.project_id:
|
|
return "project"
|
|
elif self.task_id:
|
|
return "task"
|
|
elif self.quote_id:
|
|
return "quote"
|
|
return "unknown"
|
|
|
|
@property
|
|
def target_name(self):
|
|
"""Get the name of the target this comment is attached to"""
|
|
if self.project_id and self.project:
|
|
return self.project.name
|
|
elif self.task_id and self.task:
|
|
return self.task.name
|
|
elif self.quote_id and self.quote:
|
|
return self.quote.title
|
|
return "Unknown"
|
|
|
|
@property
|
|
def reply_count(self):
|
|
"""Get the number of replies to this comment"""
|
|
return len(self.replies) if self.replies else 0
|
|
|
|
def can_edit(self, user):
|
|
"""Check if a user can edit this comment"""
|
|
return user.id == self.user_id or user.is_admin
|
|
|
|
def can_delete(self, user):
|
|
"""Check if a user can delete this comment"""
|
|
return user.id == self.user_id or user.is_admin
|
|
|
|
def edit_content(self, new_content, user):
|
|
"""Edit the comment content"""
|
|
if not self.can_edit(user):
|
|
raise PermissionError("User does not have permission to edit this comment")
|
|
|
|
self.content = new_content.strip()
|
|
self.updated_at = now_in_app_timezone()
|
|
db.session.commit()
|
|
|
|
def delete_comment(self, user):
|
|
"""Delete the comment (soft delete by clearing content)"""
|
|
if not self.can_delete(user):
|
|
raise PermissionError("User does not have permission to delete this comment")
|
|
|
|
# If the comment has replies, we'll mark it as deleted but keep the structure
|
|
if self.replies:
|
|
self.content = "[Comment deleted]"
|
|
self.updated_at = now_in_app_timezone()
|
|
else:
|
|
# If no replies, we can safely delete it
|
|
db.session.delete(self)
|
|
|
|
db.session.commit()
|
|
|
|
def to_dict(self):
|
|
"""Convert comment to dictionary for API responses"""
|
|
return {
|
|
"id": self.id,
|
|
"content": self.content,
|
|
"project_id": self.project_id,
|
|
"task_id": self.task_id,
|
|
"quote_id": self.quote_id,
|
|
"user_id": self.user_id,
|
|
"author": self.author.username if self.author else None,
|
|
"author_full_name": self.author.full_name if self.author and self.author.full_name else None,
|
|
"created_at": self.created_at.isoformat() if self.created_at else None,
|
|
"updated_at": self.updated_at.isoformat() if self.updated_at else None,
|
|
"parent_id": self.parent_id,
|
|
"is_reply": self.is_reply,
|
|
"reply_count": self.reply_count,
|
|
"target_type": self.target_type,
|
|
"target_name": self.target_name,
|
|
"is_internal": self.is_internal,
|
|
}
|
|
|
|
@classmethod
|
|
def get_project_comments(cls, project_id, include_replies=True):
|
|
"""Get all comments for a project"""
|
|
query = cls.query.filter_by(project_id=project_id)
|
|
|
|
if not include_replies:
|
|
query = query.filter_by(parent_id=None)
|
|
|
|
return query.order_by(cls.created_at.asc()).all()
|
|
|
|
@classmethod
|
|
def get_task_comments(cls, task_id, include_replies=True):
|
|
"""Get all comments for a task"""
|
|
query = cls.query.filter_by(task_id=task_id)
|
|
|
|
if not include_replies:
|
|
query = query.filter_by(parent_id=None)
|
|
|
|
return query.order_by(cls.created_at.asc()).all()
|
|
|
|
@classmethod
|
|
def get_user_comments(cls, user_id, limit=None):
|
|
"""Get recent comments by a user"""
|
|
query = cls.query.filter_by(user_id=user_id).order_by(cls.created_at.desc())
|
|
|
|
if limit:
|
|
query = query.limit(limit)
|
|
|
|
return query.all()
|
|
|
|
@classmethod
|
|
def get_quote_comments(cls, quote_id, include_replies=True, include_internal=True):
|
|
"""Get all comments for a quote"""
|
|
query = cls.query.filter_by(quote_id=quote_id)
|
|
|
|
if not include_internal:
|
|
query = query.filter_by(is_internal=False)
|
|
|
|
if not include_replies:
|
|
query = query.filter_by(parent_id=None)
|
|
|
|
return query.order_by(cls.created_at.asc()).all()
|
|
|
|
@classmethod
|
|
def get_recent_comments(cls, limit=10):
|
|
"""Get recent comments across all projects, tasks, and quotes"""
|
|
return cls.query.order_by(cls.created_at.desc()).limit(limit).all()
|