Every ats parser now writes one human-readable pay line whether or not it
converts to yearly salary_min/salary_max/currency: hourly and daily rates,
Greenhouse's several pay zones, and a range with no currency all survive as
text instead of being dropped outright. Stored in roles.salary_text
(migration 12), replaced whole on every pull like title, so a board that
stops stating pay clears it rather than leaving a stale line. salary_state
is derived, not stored ('normalised', 'stated', or ''), and is what the
feed's new Pay filter and badge read; gates and scoring are unchanged, still
reading only the normalised columns.
Co-Authored-By: Claude Sonnet <noreply@anthropic.com>
218 lines
8.9 KiB
Python
218 lines
8.9 KiB
Python
"""The pages: two tabs, a cog, and three settings pages behind it.
|
|
|
|
`TABS` is the top bar, Roles and Applications, and `SETTINGS` is the rail
|
|
beside every page under the cog at `/settings/<name>`: Search agents,
|
|
Sources, Account. `base.html` renders the first, `settings/_rail.html` the
|
|
second, every page marks itself active by its own `path`, and adding one is
|
|
one entry here plus one template. `SECTIONS` is the rows the rail indents
|
|
under a page that is shown one section at a time, which is only Sources.
|
|
`/settings` itself is Search agents.
|
|
|
|
Every page is a shell. Each is filled and driven by its own script under
|
|
`static/` from the JSON routes in `web/api.py`; the Runs section of Sources
|
|
and the Account page are shells around the modules' own elements.
|
|
`/roles/{uid}` is the Roles page again, with that role open in its reader:
|
|
one page, so a link to a role and the role opened from the feed are the same
|
|
screen. What the server renders is only what a select needs to offer, so the
|
|
options cannot drift from what the store accepts.
|
|
|
|
Sources is one page in three sections: job boards (the `search` plugin's
|
|
queries), company boards (`ats`), and the runs that read them, which end in
|
|
the message log. One is shown at a time, the one the URL fragment names or
|
|
contains; the others stay in the page, hidden, so each section's script (the
|
|
ones they had as pages of their own, each guarding on its own root element)
|
|
keeps working.
|
|
|
|
Every path a page has had before (`/agents`, `/companies`, `/sources`,
|
|
`/jobs`, `/schedules`, `/messages`, `/account`, and the six sub-tabs the
|
|
settings shell started with) answers 301 to its place now, query string
|
|
kept, so a bookmark still lands. A merged page's old path lands on its
|
|
section's anchor; the old Messages paths land on `#messages`, the log's
|
|
block at the end of Runs.
|
|
|
|
`FUNCTIONS` and `HOSTS` are `plugins.ats`'s, not `app`'s: the nine job
|
|
functions are the classifier's vocabulary and the hosts are what it parses,
|
|
and this reaches `plugins/` the same way `app.cli` does, since a plugin is
|
|
app-agnostic and never reaches back into `app`. The
|
|
Jobindex areas and Adzuna countries on the Sources page come from
|
|
`plugins.search` for the same reason.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import sys
|
|
from collections.abc import Callable
|
|
from dataclasses import dataclass
|
|
from pathlib import Path
|
|
|
|
from fastapi import APIRouter, HTTPException, Request
|
|
from fastapi.responses import HTMLResponse, RedirectResponse
|
|
from fastapi.templating import Jinja2Templates
|
|
|
|
from app.models import REMOTE, STATUSES
|
|
from app.web.deps import StoreDep
|
|
|
|
_ROOT = Path(__file__).resolve().parents[2]
|
|
if str(_ROOT) not in sys.path:
|
|
sys.path.insert(0, str(_ROOT))
|
|
|
|
from plugins.ats import FUNCTIONS, HOSTS # noqa: E402
|
|
from plugins.search import ADZUNA_COUNTRIES, JOBINDEX_AREAS # noqa: E402
|
|
|
|
TEMPLATE_DIR = Path(__file__).resolve().parent.parent / "templates"
|
|
STATIC_DIR = Path(__file__).resolve().parent.parent / "static"
|
|
|
|
|
|
@dataclass(frozen=True, slots=True)
|
|
class Tab:
|
|
path: str
|
|
label: str
|
|
template: str
|
|
|
|
|
|
#: The top bar, in order. One list; `base.html` is its only reader.
|
|
TABS: tuple[Tab, ...] = (
|
|
Tab("/", "Roles", "roles.html"),
|
|
Tab("/applications", "Applications", "applications.html"),
|
|
)
|
|
|
|
#: The pages under the cog, in order; `settings/_rail.html` renders them.
|
|
SETTINGS: tuple[Tab, ...] = (
|
|
Tab("/settings/agents", "Search agents", "settings/agents.html"),
|
|
Tab("/settings/sources", "Sources", "settings/sources.html"),
|
|
Tab("/settings/account", "Account", "settings/account.html"),
|
|
)
|
|
|
|
#: `anchor, label` for each section of a settings page that shows one at a
|
|
#: time, keyed by the page's path. The anchor is the section's element id and
|
|
#: the fragment that picks it; the first is what the page opens on without one.
|
|
SECTIONS: dict[str, tuple[tuple[str, str], ...]] = {
|
|
"/settings/sources": (
|
|
("job-boards", "Job boards"),
|
|
("company-boards", "Company boards"),
|
|
("runs", "Runs"),
|
|
),
|
|
}
|
|
|
|
#: Where each page that used to be a tab or a sub-tab lives now. The fragment
|
|
#: is the section on the merged page, or an element in one (`#messages`, in
|
|
#: Runs); a browser keeps it across the 301.
|
|
MOVED: dict[str, str] = {
|
|
"/agents": "/settings/agents",
|
|
"/settings/ranking": "/settings/agents",
|
|
"/companies": "/settings/sources#company-boards",
|
|
"/settings/companies": "/settings/sources#company-boards",
|
|
"/sources": "/settings/sources#job-boards",
|
|
"/settings/searches": "/settings/sources#job-boards",
|
|
"/jobs": "/settings/sources#runs",
|
|
"/schedules": "/settings/sources#runs",
|
|
"/settings/pulls": "/settings/sources#runs",
|
|
"/messages": "/settings/sources#messages",
|
|
"/settings/messages": "/settings/sources#messages",
|
|
"/account": "/settings/account",
|
|
}
|
|
|
|
#: `value, label` for each select option. `FUNCTIONS` is already the value a
|
|
#: role's `function` column holds; only the label is dressed up.
|
|
FUNCTION_OPTIONS = [(f, f.replace("/", " / ").capitalize()) for f in FUNCTIONS]
|
|
REMOTE_OPTIONS = [(r, r.capitalize()) for r in REMOTE if r]
|
|
#: The feed's Pay filter, in `Store.PAY`'s own keys — see its docstring for
|
|
#: what each one keeps.
|
|
PAY_OPTIONS = [("stated", "Stated or normalised"), ("normalised", "Normalised only"),
|
|
("stated_only", "Stated but not normalised")]
|
|
STATUS_OPTIONS = [(s, s.capitalize()) for s in STATUSES]
|
|
AREA_OPTIONS = list(JOBINDEX_AREAS.items())
|
|
COUNTRY_OPTIONS = [(c, c.upper()) for c in sorted(ADZUNA_COUNTRIES)]
|
|
#: The ATS hosts `plugins.ats` reads, for the Follow and Set board selects.
|
|
HOST_OPTIONS = list(HOSTS.items())
|
|
|
|
|
|
def asset(path: str) -> str:
|
|
"""A static URL stamped with the file's modification time, so a changed
|
|
file is a different URL and a cached stale copy is never the answer."""
|
|
name = path.lstrip("/")
|
|
try:
|
|
stamp = int((STATIC_DIR / name).stat().st_mtime)
|
|
except OSError:
|
|
return f"/static/{name}"
|
|
return f"/static/{name}?v={stamp}"
|
|
|
|
|
|
templates = Jinja2Templates(directory=str(TEMPLATE_DIR))
|
|
templates.env.globals["TABS"] = TABS
|
|
templates.env.globals["SETTINGS"] = SETTINGS
|
|
templates.env.globals["SECTIONS"] = SECTIONS
|
|
templates.env.globals["asset"] = asset
|
|
|
|
#: Out of the OpenAPI schema: these are pages.
|
|
router = APIRouter(include_in_schema=False)
|
|
|
|
|
|
def page(request: Request, name: str, **context: object) -> HTMLResponse:
|
|
return templates.TemplateResponse(request, name, context)
|
|
|
|
|
|
@router.get("/", response_class=HTMLResponse)
|
|
def roles(request: Request) -> HTMLResponse:
|
|
return page(request, "roles.html", functions=FUNCTION_OPTIONS,
|
|
remote_options=REMOTE_OPTIONS, pay_options=PAY_OPTIONS, role=None)
|
|
|
|
|
|
@router.get("/roles/{uid}", response_class=HTMLResponse)
|
|
def role(request: Request, uid: str, store: StoreDep) -> HTMLResponse:
|
|
"""The Roles page with one role open in its reader, which is where
|
|
opening a role from the feed puts the address bar. `roles.js` reads the
|
|
uid from the path; the lookup here makes an unknown uid a 404 page rather
|
|
than an empty reader, and gives the tab the role's title. `active_path`
|
|
keeps Roles lit in the top bar."""
|
|
found = store.role(uid)
|
|
if found is None:
|
|
raise HTTPException(404, f"no such role: {uid}")
|
|
return page(request, "roles.html", functions=FUNCTION_OPTIONS,
|
|
remote_options=REMOTE_OPTIONS, pay_options=PAY_OPTIONS,
|
|
role=found, active_path="/")
|
|
|
|
|
|
@router.get("/applications", response_class=HTMLResponse)
|
|
def applications(request: Request) -> HTMLResponse:
|
|
return page(request, "applications.html", status_options=STATUS_OPTIONS)
|
|
|
|
|
|
@router.get("/settings", response_class=RedirectResponse)
|
|
def settings() -> RedirectResponse:
|
|
return RedirectResponse(SETTINGS[0].path, status_code=302)
|
|
|
|
|
|
@router.get("/settings/agents", response_class=HTMLResponse)
|
|
def agents(request: Request) -> HTMLResponse:
|
|
return page(request, "settings/agents.html")
|
|
|
|
|
|
@router.get("/settings/sources", response_class=HTMLResponse)
|
|
def sources(request: Request) -> HTMLResponse:
|
|
return page(request, "settings/sources.html", areas=AREA_OPTIONS,
|
|
countries=COUNTRY_OPTIONS, hosts=HOST_OPTIONS)
|
|
|
|
|
|
@router.get("/settings/account", response_class=HTMLResponse)
|
|
def account(request: Request) -> HTMLResponse:
|
|
return page(request, "settings/account.html")
|
|
|
|
|
|
def _moved(to: str) -> Callable[[Request], RedirectResponse]:
|
|
"""A 301 to `to`, carrying the query string, so `/agents?x=1` keeps it.
|
|
The query goes before `to`'s fragment, if it has one, or the browser
|
|
would read `#runs?x=1` as one fragment."""
|
|
path, _, fragment = to.partition("#")
|
|
def redirect(request: Request) -> RedirectResponse:
|
|
query = request.url.query
|
|
target = f"{path}?{query}" if query else path
|
|
return RedirectResponse(f"{target}#{fragment}" if fragment else target,
|
|
status_code=301)
|
|
return redirect
|
|
|
|
|
|
for _old, _new in MOVED.items():
|
|
router.add_api_route(_old, _moved(_new), methods=["GET"],
|
|
response_class=RedirectResponse)
|