HR-ATS-Portal/backend/job/candidate/models.py

import uuid
from datetime import datetime, timezone
from typing import TYPE_CHECKING, List, Optional

from sqlalchemy import DateTime, func
from sqlalchemy.ext.asyncio import AsyncSession
from sqlmodel import Field, Relationship, SQLModel, select

if TYPE_CHECKING:
    from inbox.models import Inbox
    from users.models import Users
    from job.job_post.models import JobPosts


def _now() -> datetime:
    return datetime.now(timezone.utc)


# Every datetime below is aware (see _now, and the API parses ISO input carrying
# an offset), so each column is declared timestamptz. SQLModel maps a bare
# `datetime` to TIMESTAMP WITHOUT TIME ZONE, and asyncpg refuses to bind an aware
# value to one — "can't subtract offset-naive and offset-aware datetimes" — which
# turns every insert here into a 500. Same pairing as job/job_post/models.py.
class Manual_UPLOAD_CANDIDATE(SQLModel, table=True):
    __tablename__ = "manual_upload_candidate"
    id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True)
    candidate_email: str = Field(default="")
    candidate_name: str = Field(default="")
    candidate_phone: str = Field(default="")
    job_post_id: uuid.UUID | None = Field(default=None, foreign_key="job_posts.id")
    full_text: str = Field(default="")
    current_company: str = Field(default="")
    user_id: uuid.UUID | None = Field(default=None, foreign_key="users.id")
    platform: str = Field(default="")
    created_by: uuid.UUID | None = Field(default=None, foreign_key="users.id")
    experience: str = Field(default="")
    status: str = Field(default="")
    # Free text, not a users FK: a referrer is often someone outside the system
    # (a client, a former colleague), and recruiters type whatever the candidate
    # told them. "" rather than NULL keeps it consistent with the columns above.
    #
    # server_default is load-bearing and NOT decoration, unlike the columns above
    # — they arrived with the CREATE TABLE, this one arrives as an ALTER. The
    # startup autogenerate would emit `ADD COLUMN referral_by VARCHAR NOT NULL`,
    # which Postgres rejects outright on a table that already holds rows. The
    # DEFAULT backfills them. Pass the bare "" — SQLAlchemy quotes a plain string
    # into DEFAULT '', whereas "''" would render DEFAULT '''''' instead.
    referral_by: str = Field(default="", sa_column_kwargs={"server_default": ""})
    # The CV as uploaded: file_name is the recruiter-facing original, file_path
    # the absolute location under inbox/decoded_attachments. They differ on
    # purpose — the stored basename is uniquified so two candidates uploading
    # "resume.pdf" cannot overwrite one another (see FileRead.save_manual_upload).
    # Same ALTER-on-a-populated-table reasoning as referral_by above, so both
    # carry a server default.
    file_name: str = Field(default="", sa_column_kwargs={"server_default": ""})
    file_path: str = Field(default="", sa_column_kwargs={"server_default": ""})
    created_at: datetime = Field(default_factory=_now, sa_type=DateTime(timezone=True))
    updated_at: datetime = Field(default_factory=_now, sa_type=DateTime(timezone=True))

    @staticmethod
    def _as_uuid(record_id) -> uuid.UUID | None:
        if record_id in (None, ""):
            return None
        try:
            return uuid.UUID(str(record_id))
        except ValueError:
            return None

    @classmethod
    async def create_manual_upload_candidate(cls, session: AsyncSession, fields: dict):
        import os

        from role.models import EnumRoles, Roles
        from users.models import Users
        from users.plugins import hash_password

        email=(fields.get("candidate_email") or "").strip().lower()
        name=(fields.get("candidate_name") or "").strip() or email
        default_pw=os.getenv("DEFAULT_CANDIDATE_PASSWORD","Utopia!@#")

        user=await Users.get_user_by_email(session,email)
        if not user:
            role=await Roles.get_role_by_name(session,EnumRoles.CANDIDATE.value)
            user=await Users.insert_user(session,{
                "name":name,
                "email":email,
                "role_id":role.id if role else 8,
                "password":hash_password(default_pw),
                "is_active":True,
                "is_deleted":False,
            })

        row=cls(
            candidate_email=email,
            candidate_name=name,
            candidate_phone=(fields.get("candidate_phone") or "").strip(),
            job_post_id=cls._as_uuid(fields.get("job_post_id")),
            full_text=fields.get("full_text") or "",
            current_company=(fields.get("current_company") or "").strip(),
            user_id=user.id,
            platform=(fields.get("platform") or "").strip(),
            created_by=cls._as_uuid(fields.get("created_by")),
            experience=(fields.get("experience") or "").strip(),
            status=(fields.get("status") or "").strip(),
            referral_by=(fields.get("referral_by") or "").strip(),
            file_name=(fields.get("file_name") or "").strip(),
            file_path=(fields.get("file_path") or "").strip(),
        )
        session.add(row)
        await session.commit()
        await session.refresh(row)
        return row


class Interviews(SQLModel, table=True):
    __tablename__ = "interviews"

    id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True)
    interview_date: datetime = Field(default_factory=_now, sa_type=DateTime(timezone=True))
    interview_time: datetime = Field(default_factory=_now, sa_type=DateTime(timezone=True))
    interview_type: str = Field(default="")
    interview_status: str = Field(default="")
    inbox_id: int | None = Field(default=None, foreign_key="inbox.id")
    inbox: Optional["Inbox"] = Relationship(
        back_populates="interviews",
        sa_relationship_kwargs={"lazy": "selectin"},
    )

    @staticmethod
    def _as_uuid(record_id) -> uuid.UUID | None:
        try:
            return uuid.UUID(str(record_id))
        except ValueError:
            return None

    @classmethod
    async def get_interview_by_id(cls, session: AsyncSession, record_id):
        uid = cls._as_uuid(record_id)
        if uid is None:
            return None
        result = await session.execute(select(cls).where(cls.id == uid))
        return result.scalars().first()

    @classmethod
    async def get_interviews_by_inbox(cls, session: AsyncSession, inbox_id: int):
        result = await session.execute(
            select(cls).where(cls.inbox_id == inbox_id).order_by(cls.interview_date.desc())
        )
        return result.scalars().all()

    @classmethod
    async def get_interviews_in_range(
        cls,
        session: AsyncSession,
        *,
        from_date=None,
        to_date=None,
        status: str | None = None,
        top: int | None = None,
        skip: int = 0,
    ):
        statement = select(cls)
        if from_date is not None:
            statement = statement.where(cls.interview_date >= from_date)
        if to_date is not None:
            statement = statement.where(cls.interview_date < to_date)
        if status:
            statement = statement.where(cls.interview_status == status)
        count_statement = select(func.count()).select_from(statement.subquery())
        total = (await session.execute(count_statement)).scalar_one()
        statement = statement.order_by(cls.interview_date.asc())
        if skip:
            statement = statement.offset(skip)
        if top is not None:
            statement = statement.limit(top)
        result = await session.execute(statement)
        return list(result.scalars().all()), total

    @classmethod
    async def insert_interview(cls, session: AsyncSession, fields: dict):
        row = cls(**fields)
        session.add(row)
        await session.commit()
        return await cls.get_interview_by_id(session, row.id)

    @classmethod
    async def update_interview(cls, session: AsyncSession, record_id, fields: dict):
        row = await cls.get_interview_by_id(session, record_id)
        if not row:
            return None
        for key, value in fields.items():
            setattr(row, key, value)
        session.add(row)
        await session.commit()
        await session.refresh(row)
        return row


class Notes(SQLModel, table=True):
    __tablename__ = "notes"

    id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True)
    note: str = Field(default="")
    created_at: datetime = Field(default_factory=_now, sa_type=DateTime(timezone=True))
    updated_at: datetime = Field(default_factory=_now, sa_type=DateTime(timezone=True))
    user_id: uuid.UUID | None = Field(default=None, foreign_key="users.id")
    created_by: uuid.UUID | None = Field(default=None, foreign_key="users.id")
    user: Optional["Users"] = Relationship(
        back_populates="notes",
        sa_relationship_kwargs={"lazy": "selectin", "foreign_keys": "[Notes.user_id]"},
    )
    author: Optional["Users"] = Relationship(
        back_populates="authored_notes",
        sa_relationship_kwargs={"lazy": "selectin", "foreign_keys": "[Notes.created_by]"},
    )

    @staticmethod
    def _as_uuid(record_id) -> uuid.UUID | None:
        try:
            return uuid.UUID(str(record_id))
        except ValueError:
            return None

    @classmethod
    async def get_note_by_id(cls, session: AsyncSession, record_id):
        uid = cls._as_uuid(record_id)
        if uid is None:
            return None
        result = await session.execute(select(cls).where(cls.id == uid))
        return result.scalars().first()

    @classmethod
    async def get_notes_by_user(cls, session: AsyncSession, user_id):
        uid = cls._as_uuid(user_id)
        if uid is None:
            return []
        result = await session.execute(
            select(cls).where(cls.user_id == uid).order_by(cls.created_at.desc())
        )
        return result.scalars().all()

    @classmethod
    async def insert_note(cls, session: AsyncSession, fields: dict):
        row = cls(**fields)
        session.add(row)
        await session.commit()
        return await cls.get_note_by_id(session, row.id)

    @classmethod
    async def update_note(cls, session: AsyncSession, record_id, fields: dict):
        row = await cls.get_note_by_id(session, record_id)
        if not row:
            return None
        for key, value in fields.items():
            setattr(row, key, value)
        row.updated_at = _now()
        session.add(row)
        await session.commit()
        await session.refresh(row)
        return row


class Activity(SQLModel, table=True):
    __tablename__ = "activity"

    id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True)
    activity_type: str = Field(default="")
    activity_date: datetime = Field(default_factory=_now, sa_type=DateTime(timezone=True))
    activity_time: datetime = Field(default_factory=_now, sa_type=DateTime(timezone=True))
    activity_status: str = Field(default="")
    description: str | None = Field(default=None)
    inbox_id: int | None = Field(default=None, foreign_key="inbox.id")
    inbox: Optional["Inbox"] = Relationship(
        back_populates="activity",
        sa_relationship_kwargs={"lazy": "selectin"},
    )

    @staticmethod
    def _as_uuid(record_id) -> uuid.UUID | None:
        try:
            return uuid.UUID(str(record_id))
        except ValueError:
            return None

    @classmethod
    async def get_activity_by_id(cls, session: AsyncSession, record_id):
        uid = cls._as_uuid(record_id)
        if uid is None:
            return None
        result = await session.execute(select(cls).where(cls.id == uid))
        return result.scalars().first()

    @classmethod
    async def get_activity_by_inbox(cls, session: AsyncSession, inbox_id: int):
        result = await session.execute(
            select(cls).where(cls.inbox_id == inbox_id).order_by(cls.activity_date.desc())
        )
        return result.scalars().all()

    @classmethod
    async def get_activity_feed(cls, session: AsyncSession, *, top: int | None = None, skip: int = 0):
        statement = select(cls)
        count_statement = select(func.count()).select_from(cls)
        total = (await session.execute(count_statement)).scalar_one()
        statement = statement.order_by(cls.activity_date.desc(), cls.activity_time.desc())
        if skip:
            statement = statement.offset(skip)
        if top is not None:
            statement = statement.limit(top)
        result = await session.execute(statement)
        return list(result.scalars().all()), total

    @classmethod
    async def insert_activity(cls, session: AsyncSession, fields: dict):
        row = cls(**fields)
        session.add(row)
        await session.commit()
        return await cls.get_activity_by_id(session, row.id)

    @classmethod
    async def update_activity(cls, session: AsyncSession, record_id, fields: dict):
        row = await cls.get_activity_by_id(session, record_id)
        if not row:
            return None
        for key, value in fields.items():
            setattr(row, key, value)
        session.add(row)
        await session.commit()
        await session.refresh(row)
        return row


class Feedback(SQLModel, table=True):
    __tablename__ = "feedback"

    id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True)
    review: str = Field(default="")
    financial_status: str = Field(default="")
    score: float = Field(default=0.0)
    note: str | None = Field(default=None)
    created_at: datetime = Field(default_factory=_now, sa_type=DateTime(timezone=True))
    updated_at: datetime = Field(default_factory=_now, sa_type=DateTime(timezone=True))
    reviewed_by: uuid.UUID | None = Field(default=None, foreign_key="users.id")
    inbox_id: int | None = Field(default=None, foreign_key="inbox.id")
    user: Optional["Users"] = Relationship(
        back_populates="feedback",
        sa_relationship_kwargs={"lazy": "selectin"},
    )
    inbox: Optional["Inbox"] = Relationship(
        back_populates="feedback",
        sa_relationship_kwargs={"lazy": "selectin"},
    )

    @staticmethod
    def _as_uuid(record_id) -> uuid.UUID | None:
        try:
            return uuid.UUID(str(record_id))
        except ValueError:
            return None

    @classmethod
    async def get_feedback_by_id(cls, session: AsyncSession, record_id):
        uid = cls._as_uuid(record_id)
        if uid is None:
            return None
        result = await session.execute(select(cls).where(cls.id == uid))
        return result.scalars().first()

    @classmethod
    async def get_feedback_by_inbox(cls, session: AsyncSession, inbox_id: int):
        result = await session.execute(
            select(cls).where(cls.inbox_id == inbox_id).order_by(cls.created_at.desc())
        )
        return result.scalars().all()

    @classmethod
    async def insert_feedback(cls, session: AsyncSession, fields: dict):
        row = cls(**fields)
        session.add(row)
        await session.commit()
        return await cls.get_feedback_by_id(session, row.id)

    @classmethod
    async def update_feedback(cls, session: AsyncSession, record_id, fields: dict):
        row = await cls.get_feedback_by_id(session, record_id)
        if not row:
            return None
        for key, value in fields.items():
            setattr(row, key, value)
        row.updated_at = _now()
        session.add(row)
        await session.commit()
        await session.refresh(row)
        return row


class ApplicationStageTransitions(SQLModel, table=True):
    """Temporal history of inbox_messages.application_status changes.

    valid_from / valid_to make time-in-stage a subtraction rather than a window
    function. NULL valid_to means the stage is still current.
    """

    __tablename__ = "application_stage_transitions"

    id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True)
    inbox_id: int = Field(index=True, foreign_key="inbox.id")
    from_stage: str | None = Field(default=None)
    to_stage: str
    valid_from: datetime = Field(default_factory=_now, sa_type=DateTime(timezone=True))
    valid_to: datetime | None = Field(default=None, sa_type=DateTime(timezone=True))
    changed_by: uuid.UUID | None = Field(default=None, foreign_key="users.id")
    actor_kind: str = Field(default="user")
    change_reason: str | None = Field(default=None)
    created_at: datetime = Field(default_factory=_now, sa_type=DateTime(timezone=True))

    @staticmethod
    def _as_uuid(record_id) -> uuid.UUID | None:
        if record_id in (None, ""):
            return None
        try:
            return uuid.UUID(str(record_id))
        except ValueError:
            return None

    @classmethod
    async def get_by_id(cls, session: AsyncSession, record_id):
        uid = cls._as_uuid(record_id)
        if uid is None:
            return None
        result = await session.execute(select(cls).where(cls.id == uid))
        return result.scalars().first()

    @classmethod
    async def fetch_by_inbox(cls, session: AsyncSession, inbox_id: int):
        result = await session.execute(
            select(cls).where(cls.inbox_id == int(inbox_id)).order_by(cls.valid_from.desc())
        )
        return list(result.scalars().all())

    @classmethod
    async def get_open_transition(cls, session: AsyncSession, inbox_id: int):
        result = await session.execute(
            select(cls)
            .where(cls.inbox_id == int(inbox_id), cls.valid_to.is_(None))
            .order_by(cls.valid_from.desc())
        )
        return result.scalars().first()

    @classmethod
    async def insert_transition(cls, session: AsyncSession, fields: dict, *, commit: bool = True):
        row = cls(**fields)
        session.add(row)
        if commit:
            await session.commit()
            await session.refresh(row)
        return row

    @classmethod
    async def close_open(cls, session: AsyncSession, inbox_id: int, *, at: datetime | None = None, commit: bool = False):
        row = await cls.get_open_transition(session, inbox_id)
        if not row:
            return None
        row.valid_to = at or _now()
        session.add(row)
        if commit:
            await session.commit()
            await session.refresh(row)
        return row

    @classmethod
    async def count_by_inbox(cls, session: AsyncSession, inbox_id: int):
        statement = select(func.count()).select_from(cls).where(cls.inbox_id == int(inbox_id))
        result = await session.execute(statement)
        return result.scalar_one()


import users.models as _users_models  # noqa: E402, F401