"""The JSON routes the tabs use: roles, companies, sources, applications, agents. `/api/jobs*`, `/api/schedules*`, `/api/notices` and `/ws/jobs` are `pipeline.web`'s and `/api/account*` is `auth`'s, both wired in `app/main.py`. This is roledesk's own API, over the same store. Every refusal is `{"detail": ""}`, which `api()` in `static/app.js` turns into a toast. """ from __future__ import annotations from datetime import timedelta from typing import Annotated, Any from fastapi import APIRouter, HTTPException, Query, Response from pydantic import BaseModel, Field from app import jobs from app.models import ( AFFINITY, Agent, Application, Company, Gate, ScoredRole, Status, Subscription, Weights, company_key, ) from app.storage import Store from app.web.deps import ConfigDep, StoreDep from pipeline.web import QueueDep router = APIRouter(prefix="/api", tags=["roledesk"]) # ------------------------------------------------------------------- roles @router.get("/roles") def list_roles( store: StoreDep, q: str = "", company: str = "", place: str = "", function: str = "", remote: str = "", days: int | None = None, show_muted: bool = False, agent: int | None = None, gated: bool = False, limit: Annotated[int, Query(ge=1, le=1000)] = 200, ) -> list[ScoredRole]: """Open roles, newest first. See `Store.roles` for what each filter does. A muted company's roles are left out unless `show_muted` is set. With `agent`, ordered by that agent's score and carrying `score` and `gated_reason`; a gated role only with `gated=1`.""" if agent is not None and store.agent(agent) is None: raise HTTPException(404, f"no such agent: {agent}") return store.roles(limit=limit, q=q or None, company=company or None, place=place or None, function=function or None, remote=remote or None, days=days, hide_muted=not show_muted, agent=agent, gated=gated) # --------------------------------------------------------------- companies class CompanyOut(BaseModel): """A company row plus what only the store can join in: the ats host it is read from (empty for a company known only from a search), the id of that board's subscription, whether it is on, and how many of its roles are still open.""" key: str name: str board: str subscription_id: int | None = None on: bool | None = None affinity: int open_roles: int def _company_boards(store: Store) -> dict[str, tuple[int, str, bool]]: """`company_key -> (subscription id, ats host, on)`, read off each company's own subscription. Same join as `Store.company_boards`, with the id and switch state a company row needs to draw its own on/off control rather than fetching `/api/sources` as well.""" boards: dict[str, tuple[int, str, bool]] = {} for sub in store.subscriptions(source="ats"): boards.setdefault(company_key(sub.company), (sub.id, sub.board, bool(sub.subscribed and sub.fetch))) return boards @router.get("/companies") def list_companies(store: StoreDep) -> list[CompanyOut]: boards = _company_boards(store) counts = store.open_role_counts() out = [] for c in store.companies(): sub_id, host, on = boards.get(c.key, (None, "", None)) out.append(CompanyOut(key=c.key, name=c.name, board=host, subscription_id=sub_id, on=on, affinity=c.affinity, open_roles=counts.get(c.key, 0))) return out class AffinityBody(BaseModel): affinity: int @router.post("/companies/{key}/affinity") def set_affinity(key: str, body: AffinityBody, store: StoreDep, queue: QueueDep) -> Company: """A change here is not seen in Best match until `score` has run: the queue dedupes to a live job of that kind, so several clicks are one run.""" if body.affinity not in AFFINITY: raise HTTPException(422, "affinity is -1, 0, 1 or 2") try: company = store.update_company(key, affinity=body.affinity) except KeyError: raise HTTPException(404, f"no such company: {key}") from None queue.enqueue("score") return company # ----------------------------------------------------------------- sources class SourceOut(BaseModel): """A board or a saved search, with what it brings in: its open roles, and the countries they are in, most first.""" id: int source: str target: str label: str provider: str params: dict[str, Any] on: bool open_roles: int countries: list[tuple[str, int]] class SourcesOut(BaseModel): searches: list[SourceOut] boards: list[SourceOut] #: Whether an adzuna search can run: a key in the config or the environment. adzuna_key: bool def _source_out(sub: Subscription, countries: dict[str, int]) -> SourceOut: return SourceOut( id=sub.id, source=sub.source, target=sub.target, label=sub.label, provider=sub.board, params=sub.params, on=bool(sub.subscribed and sub.fetch), open_roles=sum(countries.values()), countries=sorted(countries.items(), key=lambda kv: -kv[1])) def _one_source(store: Store, sub_id: int) -> SourceOut: sub = store.subscription(sub_id) if sub is None: raise HTTPException(404, f"no such board or search: {sub_id}") return _source_out(sub, store.open_countries_by_subscription().get(sub_id, {})) @router.get("/sources") def list_sources(store: StoreDep, config: ConfigDep) -> SourcesOut: """Every board, and every search not removed. A board switched off stays listed, so it can be switched back on.""" counts = store.open_countries_by_subscription() searches = [_source_out(s, counts.get(s.id, {})) for s in store.subscriptions(source="search") if s.show] boards = [_source_out(s, counts.get(s.id, {})) for s in store.subscriptions(source="ats")] return SourcesOut(searches=searches, boards=boards, adzuna_key=jobs.sources.has_key(config, "adzuna")) class SwitchBody(BaseModel): on: bool @router.post("/sources/{sub_id}/switch") def switch_source(sub_id: int, body: SwitchBody, store: StoreDep) -> dict[str, Any]: """On or off for the next pull. Off closes the open roles at once; on reopens the ones the next pull still finds.""" if store.subscription(sub_id) is None: raise HTTPException(404, f"no such board or search: {sub_id}") _, closed = jobs.sources.set_fetch(store, sub_id, body.on) return {"source": _one_source(store, sub_id), "closed": closed} class SearchBody(BaseModel): provider: str name: str = "" q: str = "" area: int = 0 country: str = "" where: str = "" pages: Annotated[int, Field(ge=0, le=10)] = 0 def _params(body: SearchBody) -> dict[str, Any]: try: return jobs.sources.search_params(body.provider, body.q, area=body.area, country=body.country, where=body.where, pages=body.pages) except ValueError as exc: raise HTTPException(422, str(exc)) from exc @router.post("/searches/try") def try_search(body: SearchBody, config: ConfigDep) -> dict[str, Any]: """Run a search once without saving it: how many it finds, whether that is every match, and the first ten, so a query can be tuned before it is kept.""" try: rows, complete = jobs.sources.try_search(config, body.provider, body.name, _params(body)) except ValueError as exc: raise HTTPException(422, str(exc)) from exc sample = [{k: r.get(k) for k in ("title", "company", "place", "url")} for r in rows[:10]] return {"found": len(rows), "complete": complete, "sample": sample} @router.post("/searches") def save_search(body: SearchBody, store: StoreDep, config: ConfigDep) -> dict[str, Any]: """Save a search, or update the one of that provider and name. It is run once first and refused if it finds nothing.""" try: sub, found, complete = jobs.sources.save_search(config, store, body.provider, body.name, _params(body)) except ValueError as exc: raise HTTPException(422, str(exc)) from exc return {"source": _one_source(store, sub.id), "found": found, "complete": complete} @router.delete("/searches/{sub_id}") def remove_search(sub_id: int, store: StoreDep) -> dict[str, Any]: try: _, closed = jobs.sources.remove_search(store, sub_id) except KeyError: raise HTTPException(404, f"no such search: {sub_id}") from None return {"closed": closed} class BoardBody(BaseModel): board: str name: str @router.post("/boards", status_code=201) def add_board(body: BoardBody, store: StoreDep) -> dict[str, Any]: """Follow a company's ATS board. It is fetched first, and refused if it does not answer or lists nothing.""" try: sub, found = jobs.sources.add_board(store, body.board, body.name) except ValueError as exc: raise HTTPException(422, str(exc)) from exc return {"source": _one_source(store, sub.id), "found": found} @router.get("/prune") def prune_preview(store: StoreDep, region: str = "europe") -> dict[str, Any]: """The boards a prune would switch off: every one on, none of whose open roles is in the region.""" try: _, plan = jobs.sources.prune_plan(store, region) except ValueError as exc: raise HTTPException(422, str(exc)) from exc return {"region": region, "boards": [{"id": sub.id, "label": sub.label, "target": sub.target, "open_roles": n} for sub, n in plan]} class PruneBody(BaseModel): region: str = "europe" @router.post("/prune") def prune(body: PruneBody, store: StoreDep) -> dict[str, Any]: try: return jobs.sources.prune(store, body.region) except ValueError as exc: raise HTTPException(422, str(exc)) from exc # ----------------------------------------------------------- applications class SaveBody(BaseModel): role_uid: str status: Status = "saved" @router.post("/applications", status_code=201) def save_role(body: SaveBody, store: StoreDep) -> Application: """Track one role. Pressing Save twice does not double-track it: the existing row comes back rather than a second one starting at `saved` over whatever status it has since moved to.""" existing = next((a for a in store.applications() if a.role_uid == body.role_uid), None) if existing is not None: return existing role = store.role(body.role_uid) if role is None: raise HTTPException(404, f"no such role: {body.role_uid}") next_date = (store.clock() + timedelta(days=2)).date().isoformat() application = Application( role_uid=role.uid, company_key=role.company_key, role_title=role.title, url=role.original_url, status=body.status, source=role.source, next_action="Read the posting and decide", next_date=next_date) return store.save_application(application) @router.get("/applications") def list_applications(store: StoreDep) -> list[Application]: """Every tracked application, with the role title and company key it was saved with — enough for the page to list them without a join; the company's full name comes from `/api/companies`, already on the page.""" return store.applications() class StatusBody(BaseModel): status: Status @router.post("/applications/{app_id}/status") def set_status(app_id: str, body: StatusBody, store: StoreDep) -> Application: try: return store.set_application_status(app_id, body.status) except ValueError as exc: raise HTTPException(422, str(exc)) from exc except KeyError: raise HTTPException(404, f"no such application: {app_id}") from None # ------------------------------------------------------------------ agents @router.get("/agents") def list_agents(store: StoreDep) -> list[Agent]: return store.agents() class AgentBody(BaseModel): """Create when `id` is missing, replace that agent's fields when given.""" id: int | None = None name: str = Field(min_length=1) intent: str = "" gates: list[Gate] = [] weights: Weights = Weights() enabled: bool = True @router.post("/agents") def save_agent(body: AgentBody, store: StoreDep) -> Agent: """Scores are not recomputed here: that is the `score` task, which the page starts after a save.""" try: return store.save_agent(body.name, body.intent, body.gates, body.weights, body.enabled, agent_id=body.id) except ValueError as exc: raise HTTPException(409, str(exc)) from exc except KeyError: raise HTTPException(404, f"no such agent: {body.id}") from None @router.delete("/agents/{agent_id}", status_code=204) def delete_agent(agent_id: int, store: StoreDep) -> Response: if not store.delete_agent(agent_id): raise HTTPException(404, f"no such agent: {agent_id}") return Response(status_code=204)