A search agent is a persona, and every like or pass belongs to the one being viewed. The rail now opens on Viewing as: a full-width chooser, the name alone with one agent, a note with none, remembered in the URL and localStorage. The vote buttons, the reader's affinity control, the feed, the tag counts and the reader fetch all carry that agent; before, votes sent none and every one landed on the default agent. Best first and Newest first are back as the segmented control under Order, independent of the agent. The rail selects no longer clip descenders: Chrome ignores line-height on a select, so the fixed box is gone in favour of padding and a min-height. Settings render inside a sticky rail (Search agents; Sources with Job boards, Company boards, Runs, Messages; Account), a strip under the header on a phone, so Runs is one click away however long the company list gets. Sources shows one section at a time, chosen by the fragment, so the old redirects still land. Search agents are cards, newest first: name, an On/Off switch with its word, the intent in full, the weights, Edit in place, New agent on top, and a link to Roles as that agent. Switching one on rescores it. replace_scores writes nothing for an agent deleted while score was running, instead of failing the run on the foreign key. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
208 lines
8.3 KiB
Python
208 lines
8.3 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 four sections: job boards (the `search` plugin's
|
|
queries), company boards (`ats`), the runs that read them, and the message
|
|
log. One is shown at a time, the one the URL fragment names; 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.
|
|
|
|
`FUNCTIONS` is `plugins.ats`'s, not `app`'s: the nine job functions are the
|
|
classifier's vocabulary, 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 # 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"),
|
|
("messages", "Messages"),
|
|
),
|
|
}
|
|
|
|
#: Where each page that used to be a tab or a sub-tab lives now. The fragment
|
|
#: is the section on the merged page; 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]
|
|
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)]
|
|
|
|
|
|
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, 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, 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)
|
|
|
|
|
|
@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)
|