TimeTracker/app/models/kanban_column.py

from app import db
from app.utils.timezone import now_in_app_timezone


class KanbanColumn(db.Model):
    """Model for custom Kanban board columns/task statuses"""

    __tablename__ = "kanban_columns"

    id = db.Column(db.Integer, primary_key=True)
    project_id = db.Column(
        db.Integer, db.ForeignKey("projects.id", ondelete="CASCADE"), nullable=True, index=True
    )  # NULL = global columns
    key = db.Column(db.String(50), nullable=False, index=True)  # Internal identifier (e.g. 'in_progress')
    label = db.Column(db.String(100), nullable=False)  # Display name (e.g. 'In Progress')
    icon = db.Column(db.String(100), default="fas fa-circle")  # Font Awesome icon class
    color = db.Column(db.String(50), default="secondary")  # Bootstrap color class or hex
    position = db.Column(db.Integer, nullable=False, default=0, index=True)  # Order in kanban board
    is_active = db.Column(db.Boolean, default=True, nullable=False)  # Can be disabled without deletion
    is_system = db.Column(db.Boolean, default=False, nullable=False)  # System columns cannot be deleted
    is_complete_state = db.Column(db.Boolean, default=False, nullable=False)  # Marks task as completed
    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)

    # Unique constraint: key must be unique per project (or globally if project_id is NULL)
    __table_args__ = (db.UniqueConstraint("key", "project_id", name="uq_kanban_column_key_project"),)

    def __init__(self, **kwargs):
        """Initialize a new KanbanColumn"""
        super(KanbanColumn, self).__init__(**kwargs)

    def __repr__(self):
        project_info = f" project_id={self.project_id}" if self.project_id else " global"
        return f"<KanbanColumn {self.key}: {self.label}{project_info}>"

    def to_dict(self):
        """Convert column to dictionary for API responses"""
        return {
            "id": self.id,
            "project_id": self.project_id,
            "key": self.key,
            "label": self.label,
            "icon": self.icon,
            "color": self.color,
            "position": self.position,
            "is_active": self.is_active,
            "is_system": self.is_system,
            "is_complete_state": self.is_complete_state,
            "created_at": self.created_at.isoformat() if self.created_at else None,
            "updated_at": self.updated_at.isoformat() if self.updated_at else None,
        }

    @classmethod
    def get_active_columns(cls, project_id=None):
        """Get active columns ordered by position. If project_id is None, returns global columns."""
        try:
            # Force a fresh query by using db.session directly and avoiding cache
            from app import db

            query = db.session.query(cls).filter_by(is_active=True)
            if project_id is None:
                # Return global columns (project_id is NULL) - use IS NULL for PostgreSQL
                query = query.filter(cls.project_id.is_(None))
            else:
                # Return project-specific columns
                query = query.filter_by(project_id=project_id)
            return query.order_by(cls.position.asc()).all()
        except Exception as e:
            # Table might not exist yet during migration
            print(f"Warning: Could not load kanban columns: {e}")
            return []

    @classmethod
    def get_all_columns(cls, project_id=None):
        """Get all columns (including inactive) ordered by position. If project_id is None, returns global columns."""
        try:
            # Force a fresh query by using db.session directly and avoiding cache
            from app import db

            query = db.session.query(cls)
            if project_id is None:
                # Return global columns (project_id is NULL) - use IS NULL for PostgreSQL
                query = query.filter(cls.project_id.is_(None))
            else:
                # Return project-specific columns
                query = query.filter_by(project_id=project_id)
            return query.order_by(cls.position.asc()).all()
        except Exception as e:
            # Table might not exist yet during migration
            print(f"Warning: Could not load all kanban columns: {e}")
            return []

    @classmethod
    def get_column_by_key(cls, key, project_id=None):
        """Get column by its key and project_id. If project_id is None, searches global columns."""
        try:
            query = cls.query.filter_by(key=key)
            if project_id is None:
                # Use IS NULL for PostgreSQL
                query = query.filter(cls.project_id.is_(None))
            else:
                query = query.filter_by(project_id=project_id)
            return query.first()
        except Exception as e:
            # Table might not exist yet
            print(f"Warning: Could not find kanban column by key: {e}")
            return None

    @classmethod
    def get_valid_status_keys(cls, project_id=None):
        """Get list of all valid status keys (for validation). If project_id is None, returns global column keys."""
        columns = cls.get_active_columns(project_id=project_id)
        if not columns:
            # Fallback to default statuses if table doesn't exist
            return ["todo", "in_progress", "review", "done", "cancelled"]
        return [col.key for col in columns]

    @classmethod
    def initialize_default_columns(cls, project_id=None):
        """Initialize default kanban columns if none exist for the given project (or globally if project_id is None)"""
        query = cls.query
        if project_id is None:
            query = query.filter(cls.project_id.is_(None))
        else:
            query = query.filter_by(project_id=project_id)

        if query.count() > 0:
            return False  # Columns already exist

        default_columns = [
            {
                "key": "todo",
                "label": "To Do",
                "icon": "fas fa-list-check",
                "color": "secondary",
                "position": 0,
                "is_system": True,
                "is_complete_state": False,
                "project_id": project_id,
            },
            {
                "key": "in_progress",
                "label": "In Progress",
                "icon": "fas fa-spinner",
                "color": "warning",
                "position": 1,
                "is_system": True,
                "is_complete_state": False,
                "project_id": project_id,
            },
            {
                "key": "review",
                "label": "Review",
                "icon": "fas fa-user-check",
                "color": "info",
                "position": 2,
                "is_system": False,
                "is_complete_state": False,
                "project_id": project_id,
            },
            {
                "key": "done",
                "label": "Done",
                "icon": "fas fa-check-circle",
                "color": "success",
                "position": 3,
                "is_system": True,
                "is_complete_state": True,
                "project_id": project_id,
            },
        ]

        for col_data in default_columns:
            column = cls(**col_data)
            db.session.add(column)

        db.session.commit()
        return True

    @classmethod
    def reorder_columns(cls, column_ids, project_id=None):
        """
        Reorder columns based on list of IDs for a specific project (or globally if project_id is None)
        column_ids: list of column IDs in the desired order
        project_id: project ID to reorder columns for (None for global columns)
        """
        for position, col_id in enumerate(column_ids):
            column = cls.query.get(col_id)
            if column:
                # Verify the column belongs to the correct project
                if (project_id is None and column.project_id is None) or (column.project_id == project_id):
                    column.position = position
                    column.updated_at = now_in_app_timezone()

        db.session.commit()
        # Expire all cached data to force fresh reads
        db.session.expire_all()
        return True