mirror of
https://github.com/DRYTRIX/TimeTracker.git
synced 2026-01-08 12:40:38 -06:00
293 lines
11 KiB
Python
293 lines
11 KiB
Python
from datetime import datetime
|
|
from app import db
|
|
from app.utils.timezone import now_in_app_timezone
|
|
|
|
class Task(db.Model):
|
|
"""Task model for breaking down projects into manageable components"""
|
|
|
|
__tablename__ = 'tasks'
|
|
|
|
id = db.Column(db.Integer, primary_key=True)
|
|
project_id = db.Column(db.Integer, db.ForeignKey('projects.id'), nullable=False, index=True)
|
|
name = db.Column(db.String(200), nullable=False, index=True)
|
|
description = db.Column(db.Text, nullable=True)
|
|
status = db.Column(db.String(20), default='todo', nullable=False, index=True) # 'todo', 'in_progress', 'review', 'done', 'cancelled'
|
|
priority = db.Column(db.String(20), default='medium', nullable=False) # 'low', 'medium', 'high', 'urgent'
|
|
estimated_hours = db.Column(db.Float, nullable=True)
|
|
due_date = db.Column(db.Date, nullable=True, index=True)
|
|
assigned_to = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=True, index=True)
|
|
created_by = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False, index=True)
|
|
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)
|
|
started_at = db.Column(db.DateTime, nullable=True)
|
|
completed_at = db.Column(db.DateTime, nullable=True)
|
|
|
|
# Relationships
|
|
# project relationship is defined via backref in Project model
|
|
assigned_user = db.relationship('User', foreign_keys=[assigned_to], backref='assigned_tasks')
|
|
creator = db.relationship('User', foreign_keys=[created_by], backref='created_tasks')
|
|
time_entries = db.relationship('TimeEntry', backref='task', lazy='dynamic', cascade='all, delete-orphan')
|
|
# comments relationship is defined via backref in Comment model
|
|
|
|
def __init__(self, project_id, name, description=None, priority='medium', estimated_hours=None,
|
|
due_date=None, assigned_to=None, created_by=None):
|
|
self.project_id = project_id
|
|
self.name = name.strip()
|
|
self.description = description.strip() if description else None
|
|
self.priority = priority
|
|
self.estimated_hours = estimated_hours
|
|
self.due_date = due_date
|
|
self.assigned_to = assigned_to
|
|
self.created_by = created_by
|
|
|
|
def __repr__(self):
|
|
return f'<Task {self.name} ({self.status})>'
|
|
|
|
@property
|
|
def is_active(self):
|
|
"""Check if task is active (not done or cancelled)"""
|
|
return self.status not in ['done', 'cancelled']
|
|
|
|
@property
|
|
def is_overdue(self):
|
|
"""Check if task is overdue"""
|
|
if not self.due_date:
|
|
return False
|
|
from datetime import date
|
|
return date.today() > self.due_date and self.status not in ['done', 'cancelled']
|
|
|
|
@property
|
|
def total_hours(self):
|
|
"""Calculate total hours spent on this task"""
|
|
try:
|
|
total_seconds = db.session.query(
|
|
db.func.sum(
|
|
db.func.coalesce(
|
|
db.func.extract('epoch',
|
|
db.func.greatest(
|
|
db.func.least(
|
|
db.func.coalesce(self.time_entries.end_time, now_in_app_timezone()),
|
|
now_in_app_timezone()
|
|
) - self.time_entries.start_time
|
|
)
|
|
),
|
|
0
|
|
)
|
|
)
|
|
).filter(
|
|
self.time_entries.project_id == self.project_id
|
|
).scalar() or 0
|
|
|
|
return round(total_seconds / 3600, 2)
|
|
except Exception:
|
|
return 0.0
|
|
|
|
@property
|
|
def total_billable_hours(self):
|
|
"""Calculate total billable hours spent on this task"""
|
|
try:
|
|
from .time_entry import TimeEntry
|
|
total_seconds = db.session.query(
|
|
db.func.sum(TimeEntry.duration_seconds)
|
|
).filter(
|
|
TimeEntry.task_id == self.id,
|
|
TimeEntry.end_time.isnot(None),
|
|
TimeEntry.billable == True
|
|
).scalar() or 0
|
|
return round(total_seconds / 3600, 2)
|
|
except Exception:
|
|
return 0.0
|
|
|
|
@property
|
|
def progress_percentage(self):
|
|
"""Calculate progress percentage based on estimated vs actual hours"""
|
|
if not self.estimated_hours or self.estimated_hours == 0:
|
|
return 0
|
|
|
|
actual_hours = self.total_hours
|
|
if actual_hours >= self.estimated_hours:
|
|
return 100
|
|
|
|
return round((actual_hours / self.estimated_hours) * 100, 1)
|
|
|
|
@property
|
|
def status_display(self):
|
|
"""Get human-readable status"""
|
|
status_map = {
|
|
'todo': 'To Do',
|
|
'in_progress': 'In Progress',
|
|
'review': 'Review',
|
|
'done': 'Done',
|
|
'cancelled': 'Cancelled'
|
|
}
|
|
return status_map.get(self.status, self.status)
|
|
|
|
@property
|
|
def priority_display(self):
|
|
"""Get human-readable priority"""
|
|
priority_map = {
|
|
'low': 'Low',
|
|
'medium': 'Medium',
|
|
'high': 'High',
|
|
'urgent': 'Urgent'
|
|
}
|
|
return priority_map.get(self.priority, self.priority)
|
|
|
|
@property
|
|
def priority_class(self):
|
|
"""Get CSS class for priority styling"""
|
|
priority_classes = {
|
|
'low': 'priority-low',
|
|
'medium': 'priority-medium',
|
|
'high': 'priority-high',
|
|
'urgent': 'priority-urgent'
|
|
}
|
|
return priority_classes.get(self.priority, 'priority-medium')
|
|
|
|
def start_task(self):
|
|
"""Mark task as in progress"""
|
|
if self.status == 'done':
|
|
raise ValueError("Cannot start a completed task")
|
|
|
|
self.status = 'in_progress'
|
|
self.started_at = now_in_app_timezone()
|
|
self.updated_at = now_in_app_timezone()
|
|
db.session.commit()
|
|
|
|
def pause_task(self):
|
|
"""Pause task (mark as todo)"""
|
|
if self.status != 'in_progress':
|
|
raise ValueError("Can only pause tasks that are in progress")
|
|
|
|
self.status = 'todo'
|
|
self.updated_at = now_in_app_timezone()
|
|
db.session.commit()
|
|
|
|
def mark_for_review(self):
|
|
"""Mark task as ready for review"""
|
|
if self.status not in ['in_progress', 'todo']:
|
|
raise ValueError("Task must be in progress or todo to mark for review")
|
|
|
|
self.status = 'review'
|
|
self.updated_at = now_in_app_timezone()
|
|
db.session.commit()
|
|
|
|
def complete_task(self):
|
|
"""Mark task as completed"""
|
|
if self.status == 'cancelled':
|
|
raise ValueError("Cannot complete a cancelled task")
|
|
|
|
self.status = 'done'
|
|
self.completed_at = now_in_app_timezone()
|
|
self.updated_at = now_in_app_timezone()
|
|
db.session.commit()
|
|
|
|
def cancel_task(self):
|
|
"""Cancel the task"""
|
|
if self.status == 'done':
|
|
raise ValueError("Cannot cancel a completed task")
|
|
|
|
self.status = 'cancelled'
|
|
self.updated_at = now_in_app_timezone()
|
|
db.session.commit()
|
|
|
|
def reassign(self, user_id):
|
|
"""Reassign task to different user"""
|
|
self.assigned_to = user_id
|
|
self.updated_at = now_in_app_timezone()
|
|
db.session.commit()
|
|
|
|
def update_priority(self, priority):
|
|
"""Update task priority"""
|
|
valid_priorities = ['low', 'medium', 'high', 'urgent']
|
|
if priority not in valid_priorities:
|
|
raise ValueError(f"Invalid priority. Must be one of: {', '.join(valid_priorities)}")
|
|
|
|
self.priority = priority
|
|
self.updated_at = now_in_app_timezone()
|
|
db.session.commit()
|
|
|
|
def update_due_date(self, due_date):
|
|
"""Update task due date"""
|
|
self.due_date = due_date
|
|
self.updated_at = now_in_app_timezone()
|
|
db.session.commit()
|
|
|
|
def to_dict(self):
|
|
"""Convert task to dictionary for API responses"""
|
|
return {
|
|
'id': self.id,
|
|
'project_id': self.project_id,
|
|
'name': self.name,
|
|
'description': self.description,
|
|
'status': self.status,
|
|
'status_display': self.status_display,
|
|
'priority': self.priority,
|
|
'priority_display': self.priority_display,
|
|
'priority_class': self.priority_class,
|
|
'estimated_hours': self.estimated_hours,
|
|
'due_date': self.due_date.isoformat() if self.due_date else None,
|
|
'assigned_to': self.assigned_to,
|
|
'assigned_user': self.assigned_user.username if self.assigned_user else None,
|
|
'created_by': self.created_by,
|
|
'creator': self.creator.username if self.creator 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,
|
|
'started_at': self.started_at.isoformat() if self.started_at else None,
|
|
'completed_at': self.completed_at.isoformat() if self.completed_at else None,
|
|
'total_hours': self.total_hours,
|
|
'total_billable_hours': self.total_billable_hours,
|
|
'progress_percentage': self.progress_percentage,
|
|
'is_active': self.is_active,
|
|
'is_overdue': self.is_overdue
|
|
}
|
|
|
|
@classmethod
|
|
def get_tasks_by_project(cls, project_id, status=None, priority=None):
|
|
"""Get tasks for a specific project with optional filters"""
|
|
query = cls.query.filter_by(project_id=project_id)
|
|
|
|
if status:
|
|
query = query.filter_by(status=status)
|
|
|
|
if priority:
|
|
query = query.filter_by(priority=priority)
|
|
|
|
return query.order_by(cls.priority.desc(), cls.due_date.asc(), cls.created_at.asc()).all()
|
|
|
|
@classmethod
|
|
def get_user_tasks(cls, user_id, status=None, include_assigned=True, include_created=True):
|
|
"""Get tasks for a specific user"""
|
|
if not include_assigned and not include_created:
|
|
return []
|
|
|
|
query = cls.query
|
|
|
|
if include_assigned and include_created:
|
|
query = query.filter(
|
|
db.or_(
|
|
cls.assigned_to == user_id,
|
|
cls.created_by == user_id
|
|
)
|
|
)
|
|
elif include_assigned:
|
|
query = query.filter_by(assigned_to=user_id)
|
|
elif include_created:
|
|
query = query.filter_by(created_by=user_id)
|
|
|
|
if status:
|
|
query = query.filter_by(status=status)
|
|
|
|
return query.order_by(cls.priority.desc(), cls.due_date.asc(), cls.created_at.asc()).all()
|
|
|
|
@classmethod
|
|
def get_overdue_tasks(cls):
|
|
"""Get all overdue tasks"""
|
|
from datetime import date
|
|
today = date.today()
|
|
|
|
return cls.query.filter(
|
|
cls.due_date < today,
|
|
cls.status.in_(['todo', 'in_progress', 'review'])
|
|
).order_by(cls.priority.desc(), cls.due_date.asc()).all()
|