TimeTracker/app/models/project_cost.py

from datetime import datetime
from decimal import Decimal
from app import db


class ProjectCost(db.Model):
    """Project cost model for tracking expenses beyond hourly work"""

    __tablename__ = "project_costs"

    id = db.Column(db.Integer, primary_key=True)
    project_id = db.Column(db.Integer, db.ForeignKey("projects.id"), nullable=False, index=True)
    user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False, index=True)

    # Cost details
    description = db.Column(db.String(500), nullable=False)
    category = db.Column(db.String(50), nullable=False)  # 'travel', 'materials', 'services', 'equipment', 'other'
    amount = db.Column(db.Numeric(10, 2), nullable=False)
    currency_code = db.Column(db.String(3), nullable=False, default="EUR")

    # Billing
    billable = db.Column(db.Boolean, default=True, nullable=False)
    invoiced = db.Column(db.Boolean, default=False, nullable=False)
    invoice_id = db.Column(db.Integer, db.ForeignKey("invoices.id"), nullable=True, index=True)

    # Date and metadata
    cost_date = db.Column(db.Date, nullable=False, index=True)
    notes = db.Column(db.Text, nullable=True)
    receipt_path = db.Column(db.String(500), nullable=True)  # Path to uploaded receipt

    created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, nullable=False)

    # Relationships
    # project and user relationships defined via backref

    def __init__(
        self,
        project_id,
        user_id,
        description,
        category,
        amount,
        cost_date,
        billable=True,
        notes=None,
        currency_code="EUR",
        receipt_path=None,
    ):
        self.project_id = project_id
        self.user_id = user_id
        self.description = description.strip() if description else None
        self.category = category
        self.amount = Decimal(str(amount))
        self.cost_date = cost_date
        self.billable = billable
        self.notes = notes.strip() if notes else None
        self.currency_code = currency_code
        self.receipt_path = receipt_path

    def __repr__(self):
        return f"<ProjectCost {self.description} ({self.amount} {self.currency_code})>"

    @property
    def is_invoiced(self):
        """Check if this cost has been invoiced"""
        return self.invoiced and self.invoice_id is not None

    def mark_as_invoiced(self, invoice_id):
        """Mark this cost as invoiced"""
        self.invoiced = True
        self.invoice_id = invoice_id
        self.updated_at = datetime.utcnow()

    def unmark_as_invoiced(self):
        """Unmark this cost as invoiced (e.g., if invoice is deleted)"""
        self.invoiced = False
        self.invoice_id = None
        self.updated_at = datetime.utcnow()

    def to_dict(self):
        """Convert project cost to dictionary for API responses"""
        return {
            "id": self.id,
            "project_id": self.project_id,
            "user_id": self.user_id,
            "description": self.description,
            "category": self.category,
            "amount": float(self.amount),
            "currency_code": self.currency_code,
            "billable": self.billable,
            "invoiced": self.invoiced,
            "invoice_id": self.invoice_id,
            "cost_date": self.cost_date.isoformat() if self.cost_date else None,
            "notes": self.notes,
            "receipt_path": self.receipt_path,
            "created_at": self.created_at.isoformat() if self.created_at else None,
            "updated_at": self.updated_at.isoformat() if self.updated_at else None,
            "project": self.project.name if self.project else None,
            "user": self.user.username if self.user else None,
        }

    @classmethod
    def get_project_costs(cls, project_id, start_date=None, end_date=None, user_id=None, billable_only=False):
        """Get costs for a specific project with optional filters"""
        query = cls.query.filter_by(project_id=project_id)

        if start_date:
            query = query.filter(cls.cost_date >= start_date)

        if end_date:
            query = query.filter(cls.cost_date <= end_date)

        if user_id:
            query = query.filter(cls.user_id == user_id)

        if billable_only:
            query = query.filter(cls.billable == True)

        return query.order_by(cls.cost_date.desc()).all()

    @classmethod
    def get_total_costs(cls, project_id, start_date=None, end_date=None, user_id=None, billable_only=False):
        """Calculate total costs for a project with optional filters"""
        query = db.session.query(db.func.sum(cls.amount)).filter_by(project_id=project_id)

        if start_date:
            query = query.filter(cls.cost_date >= start_date)

        if end_date:
            query = query.filter(cls.cost_date <= end_date)

        if user_id:
            query = query.filter(cls.user_id == user_id)

        if billable_only:
            query = query.filter(cls.billable == True)

        total = query.scalar() or Decimal("0")
        return float(total)

    @classmethod
    def get_uninvoiced_costs(cls, project_id):
        """Get all billable costs that haven't been invoiced yet"""
        return (
            cls.query.filter_by(project_id=project_id, billable=True, invoiced=False)
            .order_by(cls.cost_date.desc())
            .all()
        )

    @classmethod
    def get_costs_by_category(cls, project_id, start_date=None, end_date=None):
        """Get costs grouped by category"""
        query = db.session.query(
            cls.category, db.func.sum(cls.amount).label("total_amount"), db.func.count(cls.id).label("count")
        ).filter_by(project_id=project_id)

        if start_date:
            query = query.filter(cls.cost_date >= start_date)

        if end_date:
            query = query.filter(cls.cost_date <= end_date)

        results = query.group_by(cls.category).all()

        return [
            {"category": category, "total_amount": float(total_amount), "count": count}
            for category, total_amount, count in results
        ]