305 lines
12 KiB
Python
305 lines
12 KiB
Python
import uuid
|
|
from datetime import datetime, timezone
|
|
from typing import TYPE_CHECKING, Optional
|
|
|
|
from sqlalchemy import DateTime, JSON, func, or_
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
from sqlmodel import Field, Relationship, SQLModel, select
|
|
|
|
if TYPE_CHECKING: # runtime import would be circular: users.models imports this module
|
|
from users.models import Users
|
|
|
|
|
|
def _now() -> datetime:
|
|
return datetime.now(timezone.utc)
|
|
|
|
|
|
class JobPosts(SQLModel, table=True):
|
|
__tablename__ = "job_posts"
|
|
|
|
id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True)
|
|
title: str = Field(index=True)
|
|
|
|
# foreign_keys is required, not decoration: current_recruiter_id below is a
|
|
# SECOND foreign key into users.id, so the join condition is ambiguous without
|
|
# it and every mapper fails to initialize. `user` is the AUTHOR of the post —
|
|
# current_recruiter_id is deliberately a bare column with no relationship of
|
|
# its own, because Users already carries five selectin relations that load on
|
|
# every authenticated request. Same pairing as Notes.user / Notes.author.
|
|
user: Optional["Users"] = Relationship(
|
|
back_populates="job_posts",
|
|
sa_relationship_kwargs={"lazy": "joined", "foreign_keys": "[JobPosts.created_by]"},
|
|
)
|
|
|
|
platform: str = Field(default="linkedin")
|
|
is_active: bool = Field(default=True)
|
|
is_deleted: bool = Field(default=False)
|
|
employment_type: str | None = Field(default=None)
|
|
location: str | None = Field(default=None)
|
|
experience_min: int | None = Field(default=None)
|
|
experience_max: int | None = Field(default=None)
|
|
requirements: list[str] = Field(default_factory=list, sa_type=JSON)
|
|
optional_skills: list[str] = Field(default_factory=list, sa_type=JSON)
|
|
salary: str = Field(default="Anonymous")
|
|
description: str | None = Field(default=None)
|
|
post_text: str
|
|
channel_id: str
|
|
buffer_post_id: str | None = Field(default=None)
|
|
buffer_external_link: str | None = Field(default=None)
|
|
buffer_sent_at: datetime | None = Field(default=None, sa_type=DateTime(timezone=True))
|
|
status: str = Field(default="draft")
|
|
buffer_error: str | None = Field(default=None)
|
|
# requisition_status is the hiring lifecycle (open/closed/on_hold). Distinct from
|
|
# `status`, which tracks Buffer publishing (draft/scheduled/published/failed).
|
|
# server_default is load-bearing: this column arrives as an ALTER on a populated table.
|
|
requisition_status: str = Field(default="open", sa_column_kwargs={"server_default": "open"})
|
|
department: str = Field(default="", sa_column_kwargs={"server_default": ""})
|
|
vacancies: int = Field(default=1, sa_column_kwargs={"server_default": "1"})
|
|
closed_at: datetime | None = Field(default=None, sa_type=DateTime(timezone=True))
|
|
current_recruiter_id: uuid.UUID | None = Field(default=None, foreign_key="users.id")
|
|
created_by: uuid.UUID = Field(foreign_key="users.id")
|
|
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: str) -> uuid.UUID | None:
|
|
try:
|
|
return uuid.UUID(str(record_id))
|
|
except ValueError:
|
|
return None
|
|
|
|
@classmethod
|
|
async def get_job_post_by_id(cls, session: AsyncSession, record_id: str):
|
|
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_active_job_posts(cls, session: AsyncSession):
|
|
result = await session.execute(
|
|
select(cls).where(cls.is_active == True, cls.is_deleted == False) # noqa: E712
|
|
)
|
|
return result.scalars().all()
|
|
|
|
@classmethod
|
|
async def get_by_ids(cls, session: AsyncSession, ids: list[str], *, active_only: bool = True):
|
|
uids = []
|
|
for raw in ids or []:
|
|
uid = cls._as_uuid(raw)
|
|
if uid is not None:
|
|
uids.append(uid)
|
|
if not uids:
|
|
return []
|
|
statement = select(cls).where(cls.id.in_(uids))
|
|
if active_only:
|
|
statement = statement.where(cls.is_active == True, cls.is_deleted == False) # noqa: E712
|
|
result = await session.execute(statement)
|
|
rows = list(result.scalars().all())
|
|
by_id = {str(r.id): r for r in rows}
|
|
# Preserve request order so suggestion ranks stay stable.
|
|
return [by_id[str(u)] for u in uids if str(u) in by_id]
|
|
|
|
@classmethod
|
|
async def get_by_titles(cls, session: AsyncSession, titles: list[str], *, active_only: bool = False):
|
|
"""Match job posts whose title equals any of `titles` (trim + case-insensitive).
|
|
|
|
Used by sheet form-data: position_applied_for ↔ job_posts.title. Returns
|
|
non-deleted rows; inactive ones stay in the list so the UI can mark them
|
|
unavailable the same way inbox suggestions do.
|
|
"""
|
|
lowers = sorted({(t or "").strip().lower() for t in (titles or []) if (t or "").strip()})
|
|
if not lowers:
|
|
return []
|
|
statement = select(cls).where(
|
|
cls.is_deleted == False, # noqa: E712
|
|
func.lower(func.trim(cls.title)).in_(lowers),
|
|
)
|
|
if active_only:
|
|
statement = statement.where(cls.is_active == True) # noqa: E712
|
|
statement = statement.order_by(cls.created_at.desc())
|
|
result = await session.execute(statement)
|
|
return list(result.scalars().all())
|
|
|
|
@classmethod
|
|
async def fetch_job_posts(
|
|
cls,
|
|
session: AsyncSession,
|
|
*,
|
|
search: str | None = None,
|
|
top: int | None = None,
|
|
skip: int = 0,
|
|
ids: list[str] | None = None,
|
|
active_only: bool = True,
|
|
include_deleted: bool = False,
|
|
department: str | None = None,
|
|
requisition_status: str | None = None,
|
|
employment_type: str | None = None,
|
|
):
|
|
if ids:
|
|
rows = await cls.get_by_ids(session, ids, active_only=active_only)
|
|
return rows, len(rows)
|
|
|
|
statement = select(cls)
|
|
if active_only:
|
|
statement = statement.where(cls.is_active == True, cls.is_deleted == False) # noqa: E712
|
|
elif not include_deleted:
|
|
statement = statement.where(cls.is_deleted == False) # noqa: E712
|
|
if search:
|
|
like = f"%{search.strip()}%"
|
|
statement = statement.where(
|
|
or_(cls.title.ilike(like), cls.location.ilike(like), cls.department.ilike(like))
|
|
)
|
|
if department:
|
|
statement = statement.where(cls.department == department)
|
|
if requisition_status:
|
|
statement = statement.where(cls.requisition_status == requisition_status)
|
|
if employment_type:
|
|
statement = statement.where(cls.employment_type == employment_type)
|
|
count_statement = select(func.count()).select_from(statement.subquery())
|
|
total = (await session.execute(count_statement)).scalar_one()
|
|
statement = statement.order_by(cls.created_at.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_job_post(cls, session: AsyncSession, fields: dict):
|
|
row = cls(**fields)
|
|
session.add(row)
|
|
await session.commit()
|
|
return await cls.get_job_post_by_id(session, row.id)
|
|
|
|
@classmethod
|
|
async def mark_buffer_result(
|
|
cls,
|
|
session: AsyncSession,
|
|
record_id: str,
|
|
*,
|
|
buffer_post_id: str,
|
|
status: str,
|
|
external_link: str | None = None,
|
|
sent_at: datetime | None = None,
|
|
platform: str | None = None,
|
|
):
|
|
"""Record what Buffer reported.
|
|
`status` is the mapped Buffer PostStatus, not an assumption: a queued post lands
|
|
here as "scheduled" and only becomes "published" once Buffer says `sent`.
|
|
"""
|
|
row = await cls.get_job_post_by_id(session, record_id)
|
|
if not row:
|
|
return None
|
|
row.status = status
|
|
row.buffer_post_id = buffer_post_id
|
|
row.buffer_external_link = external_link
|
|
row.buffer_sent_at = sent_at
|
|
if platform:
|
|
row.platform = platform
|
|
row.buffer_error = None
|
|
row.updated_at = _now()
|
|
session.add(row)
|
|
await session.commit()
|
|
await session.refresh(row)
|
|
return row
|
|
|
|
@classmethod
|
|
async def mark_failed(cls, session: AsyncSession, record_id: str, error: str):
|
|
row = await cls.get_job_post_by_id(session, record_id)
|
|
if not row:
|
|
return None
|
|
row.status = "failed"
|
|
row.buffer_error = error
|
|
row.updated_at = _now()
|
|
session.add(row)
|
|
await session.commit()
|
|
await session.refresh(row)
|
|
return row
|
|
|
|
@classmethod
|
|
async def update_job_post(cls, session: AsyncSession, record_id: str, fields: dict):
|
|
row = await cls.get_job_post_by_id(session, record_id)
|
|
if not row or row.is_deleted:
|
|
return None
|
|
for key, value in fields.items():
|
|
setattr(row, key, value)
|
|
row.updated_at = _now()
|
|
session.add(row)
|
|
await session.commit()
|
|
return await cls.get_job_post_by_id(session, record_id)
|
|
|
|
@classmethod
|
|
async def soft_delete_job_post(cls, session: AsyncSession, record_id: str):
|
|
row = await cls.get_job_post_by_id(session, record_id)
|
|
if not row or row.is_deleted:
|
|
return None
|
|
row.is_deleted = True
|
|
row.is_active = False
|
|
row.updated_at = _now()
|
|
session.add(row)
|
|
await session.commit()
|
|
await session.refresh(row)
|
|
return row
|
|
|
|
@classmethod
|
|
async def set_requisition_status(cls, session: AsyncSession, record_id: str, status: str):
|
|
row = await cls.get_job_post_by_id(session, record_id)
|
|
if not row or row.is_deleted:
|
|
return None
|
|
previous = row.requisition_status
|
|
row.requisition_status = status
|
|
if status == "closed":
|
|
if previous != "closed" or row.closed_at is None:
|
|
row.closed_at = _now()
|
|
else:
|
|
row.closed_at = None
|
|
row.updated_at = _now()
|
|
session.add(row)
|
|
await session.commit()
|
|
return await cls.get_job_post_by_id(session, record_id)
|
|
|
|
|
|
class SocialPlatform(SQLModel, table=True):
|
|
"""Buffer publish aliases (fb → facebook). Spelling tolerance + UI list, not an allowlist."""
|
|
|
|
__tablename__ = "social_platforms"
|
|
|
|
id: int | None = Field(default=None, primary_key=True)
|
|
alias: str = Field(max_length=40, unique=True, index=True)
|
|
buffer_service: str
|
|
label: str
|
|
is_active: bool = Field(default=True)
|
|
created_at: datetime = Field(default_factory=_now, sa_type=DateTime(timezone=True))
|
|
updated_at: datetime = Field(default_factory=_now, sa_type=DateTime(timezone=True))
|
|
|
|
@classmethod
|
|
async def get_by_alias(cls, session: AsyncSession, alias: str):
|
|
key = (alias or "").strip().lower()
|
|
if not key:
|
|
return None
|
|
result = await session.execute(select(cls).where(cls.alias == key))
|
|
return result.scalars().first()
|
|
|
|
@classmethod
|
|
async def list_active(cls, session: AsyncSession):
|
|
result = await session.execute(
|
|
select(cls).where(cls.is_active == True).order_by(cls.id.asc()) # noqa: E712
|
|
)
|
|
return list(result.scalars().all())
|
|
|
|
@classmethod
|
|
async def list_aliases(cls, session: AsyncSession):
|
|
rows = await cls.list_active(session)
|
|
return [r.alias for r in rows]
|
|
|
|
@classmethod
|
|
async def alias_map(cls, session: AsyncSession) -> dict[str, str]:
|
|
"""alias → Buffer service name for normalize_platform / resolve_channel."""
|
|
rows = await cls.list_active(session)
|
|
return {r.alias: r.buffer_service for r in rows}
|
|
|
|
|
|
import users.models as _users_models |