Merge branch 'r2-web'

# Conflicts:
#	app/static/roles.js
#	app/web/api.py
#	tests/test_web.py
This commit is contained in:
Wolf committed 2026-09-29 15:31:35 +02:00
commit a629eda8de
13 files changed
+548 -203

No files matched your search

+68 -2
View File
@@ -823,13 +823,79 @@ class ExtractResult(ModelTaskResult):
class ScoredRole(Role):
"""A role as `/api/roles` serves it: with one agent's score and gate
reason when an agent was asked for, and without otherwise."""
"""A role as `/api/roles/{uid}` serves it: with one agent's score and
gate reason when an agent was asked for, and without otherwise."""
score: float | None = None
gated_reason: str = ""
#: How many characters `RoleRow.excerpt` keeps at most: the feed row's own
#: cap, built once here rather than by the client, so a list response never
#: carries more of a role's text than a row draws.
EXCERPT_LIMIT = 200
def excerpt(text: str, limit: int = EXCERPT_LIMIT) -> str:
"""`text` (a role's summary, or the opening of its description) with its
whitespace collapsed, cut to `limit` characters at a word boundary with
an ellipsis. What `Store.roles_page` builds `RoleRow.excerpt` with, off a
`SUBSTR` of the source column rather than the whole of it, so the feed's
list never carries what only the reader needs."""
collapsed = " ".join((text or "").split())
if len(collapsed) <= limit:
return collapsed
cut = collapsed[:limit]
space = cut.rfind(" ")
trimmed = cut[:space] if space > limit * 0.6 else cut
return trimmed.rstrip(" ,.;:" + chr(0x2013) + "-") + "…"
class RoleRow(Model):
"""One row of the feed: what `GET /api/roles` serves per role, the
fields a row draws and nothing else — never `description`, `feed_text`,
`raw` or `article_text`, the four columns docs/decisions.md measures at
about 5.5 KB a role between them. The reader fetches the rest by uid when
it opens a role (`GET /api/roles/{uid}`, the full `Role`).
`excerpt` is built on the server (see `excerpt`, above): the summary when
there is one, else the description's opening, cut to `EXCERPT_LIMIT`
characters. The pay fields are what the row's badge reads: the three
normalised columns, the line the board stated, and `salary_state`,
derived as on `Role`. `original_url` is one short string, kept so the
`o` key opens a selected row's posting without opening the reader."""
uid: str
company_key: str = ""
company: str = ""
title: str = ""
place: str = ""
country: str = ""
remote: Remote = ""
function: str = ""
salary_min: int | None = None
salary_max: int | None = None
currency: str = ""
salary_text: str = ""
original_url: str = ""
posted_at: str = ""
score: float | None = None
gated_reason: str = ""
vote: Literal[-1, 0, 1] | None = None
voted_at: str | None = None
read_at: str | None = None
tags: list[str] = []
excerpt: str = ""
@computed_field # type: ignore[prop-decorator]
@property
def salary_state(self) -> str:
"""As `Role.salary_state`: 'normalised', 'stated' or ''."""
if self.salary_min is not None or self.salary_max is not None:
return "normalised"
return "stated" if self.salary_text else ""
class Company(Model):
"""A row of `companies`, with `affinity` as the agent it was read for
has it (see `agent_companies`); 0 when no agent was asked for."""
+16 -4
View File
@@ -14,9 +14,10 @@
* forgetting the header is the failure that looks like a server bug.
*
* Beside `api` on `window`, the few helpers more than one page script uses:
* `count`, `cell`, `debounce`, and the company list with its affinity control
* (`loadCompanies`, `companies`, `affinityControl`, `setAffinity`). One copy
* each, since two copies of a helper is one of them being fixed.
* `count`, `cell`, `debounce`, `safeUrl`, and the company list with its
* affinity control (`loadCompanies`, `companies`, `affinityControl`,
* `setAffinity`). One copy each, since two copies of a helper is one of them
* being fixed.
*
* Affinity is per search agent. The three company helpers take the agent's
* id as an optional last argument and send it along; a caller that passes
@@ -104,6 +105,17 @@
};
}
/** An `http(s)` URL, or "" for anything else — `javascript:`, a bare path,
empty. Every link whose address came from a feed, a board, discovery or
a person (a search result's `url`, a company's `careers_url`, a saved
application's `url`, a role's `original_url`) goes through this before
it lands in an `href`, so a board that wrote something other than a URL
cannot make this page navigate to it. Moved here from roles.js, which
first needed it for the reader's outbound links. */
function safeUrl(u) {
return /^https?:\/\//i.test(u || "") ? u : "";
}
// --------------------------------------------------------------- companies
/** @type {Map<string, object>} company_key -> row from /api/companies. One
@@ -170,6 +182,6 @@
}
Object.assign(window, {
api, count, cell, debounce, companies, loadCompanies, affinityControl, setAffinity,
api, count, cell, debounce, safeUrl, companies, loadCompanies, affinityControl, setAffinity,
});
})();
+4 -3
View File
@@ -9,7 +9,7 @@
(function () {
"use strict";
const { api, count, cell, companies, loadCompanies } = window;
const { api, count, cell, safeUrl, companies, loadCompanies } = window;
const $ = (sel, root = document) => root.querySelector(sel);
// `ROLEDESK_STATUSES` is set by applications.html from the same `STATUSES`
@@ -41,13 +41,14 @@
body.replaceChildren();
for (const application of applications) {
const tr = document.createElement("tr");
if (application.role_uid || application.url) {
const externalUrl = safeUrl(application.url);
if (application.role_uid || externalUrl) {
const link = document.createElement("a");
link.textContent = application.role_title || "(untitled)";
if (application.role_uid) {
link.href = `/roles/${encodeURIComponent(application.role_uid)}`;
} else {
link.href = application.url;
link.href = externalUrl;
link.target = "_blank";
link.rel = "noopener";
}
+45 -9
View File
@@ -21,7 +21,7 @@
(function () {
"use strict";
const { api, count, debounce, companies, loadCompanies, affinityControl } = window;
const { api, count, debounce, safeUrl, companies, loadCompanies, affinityControl } = window;
const $ = (sel, root = document) => root.querySelector(sel);
/** @type {object[]} the search agents, by id */
@@ -79,9 +79,10 @@
// where this company posts its roles.
sub.append("board not found");
}
if (company.careers_url && !company.board) {
const careersUrl = safeUrl(company.careers_url);
if (careersUrl && !company.board) {
const link = document.createElement("a");
link.href = company.careers_url;
link.href = careersUrl;
link.target = "_blank";
link.rel = "noopener";
link.textContent = "careers page";
@@ -150,13 +151,22 @@
form.addEventListener("submit", async (event) => {
event.preventDefault();
const board = `${host.value}:${slug.value.trim()}`;
// Replacing a different board closes its roles (see set_board in
// app/jobs/sources.py); ask first, naming both boards and the count,
// the same as Detach and a removed search already do.
if (company.board && company.board !== board
&& !window.confirm(`Replace ${company.name}'s board (${company.board}) `
+ `with ${board}? Its ${count(company.open_roles, "open role")} close.`)) {
return;
}
save.disabled = true;
try {
const result = await api(`/api/companies/${encodeURIComponent(company.key)}/board`,
{ method: "POST", body: { board: `${host.value}:${slug.value.trim()}` } });
{ method: "POST", body: { board } });
const closed = result.closed ? `, ${count(result.closed, "old role")} closed` : "";
window.toast.info(`${company.name}: reading ${result.source.target}, `
+ `${count(result.found, "role")} listed${closed}.`);
window.toast.info(`${company.name}: ${result.source.target} listed `
+ `${count(result.found, "role")}${closed}. Reading now, or with the pull right after.`);
await done();
} catch (err) {
save.disabled = false;
@@ -168,6 +178,11 @@
detach.className = "linky";
detach.textContent = "Detach";
detach.addEventListener("click", async () => {
if (company.open_roles
&& !window.confirm(`Detach ${company.name}'s board (${company.board})? `
+ `Its ${count(company.open_roles, "open role")} close.`)) {
return;
}
detach.disabled = true;
try {
const result = await api(`/api/companies/${encodeURIComponent(company.key)}/board`,
@@ -193,6 +208,14 @@
box.checked = Boolean(company.on);
box.setAttribute("aria-label", `Read ${company.name}'s board`);
box.addEventListener("change", async () => {
// Switching off closes every open role in one tap; ask first, naming
// the count, as removing a search and deleting an agent already do.
if (!box.checked && company.open_roles
&& !window.confirm(`Switch off ${company.name}'s board? `
+ `Its ${count(company.open_roles, "open role")} close.`)) {
box.checked = true;
return;
}
box.disabled = true;
try {
const result = await api(`/api/sources/${company.subscription_id}/switch`,
@@ -200,6 +223,8 @@
company.on = result.source.on;
if (!box.checked && result.closed) {
window.toast.info(`${company.name}: ${count(result.closed, "open role")} closed.`);
} else if (box.checked) {
window.toast.info(`${company.name}: reading now, or with the pull right after.`);
}
} catch (err) {
box.checked = !box.checked;
@@ -263,19 +288,30 @@
event.preventDefault();
const status = $("#board-status");
const button = $("#board-form button[type=submit]");
const name = $("#b-name").value.trim();
const board = `${$("#b-host").value}:${$("#b-slug").value.trim()}`;
// This name may already be a company with a different board: `set_board`
// would replace it and close its roles, the same as the row's own
// editor does, so it asks first too.
const existing = [...companies.values()]
.find((c) => c.name.toLowerCase() === name.toLowerCase());
if (existing && existing.board && existing.board !== board
&& !window.confirm(`Replace ${existing.name}'s board (${existing.board}) `
+ `with ${board}? Its ${count(existing.open_roles, "open role")} close.`)) {
return;
}
button.disabled = true;
status.textContent = "Reading the board once before following it…";
const board = `${$("#b-host").value}:${$("#b-slug").value.trim()}`;
try {
const result = await api("/api/boards", {
method: "POST",
body: { board, name: $("#b-name").value.trim() },
body: { board, name },
});
await loadCompanies(agentId());
render();
$("#board-form").reset();
status.textContent = `Following ${result.source.label}: `
+ `${count(result.found, "role")} listed. They arrive with the next pull.`;
+ `${count(result.found, "role")} listed. Reading now, or with the pull right after.`;
} catch (err) {
status.textContent = "";
}
+92 -42
View File
@@ -47,7 +47,7 @@
(function () {
"use strict";
const { api, esc, debounce, companies, loadCompanies, affinityControl, judgeButtons,
const { api, esc, debounce, safeUrl, companies, loadCompanies, affinityControl, judgeButtons,
loadTracked } = window;
const $ = (sel, root = document) => root.querySelector(sel);
@@ -107,10 +107,9 @@
pushedReader: false, // we own a history entry, so closing is `history.back()`
summarising: null, // the uid whose summary is being waited for
listY: 0, // where the page was scrolled when the reader replaced the feed
feedError: false, // the feed's own fetch failed; the empty state offers a retry
};
const safeUrl = (u) => (/^https?:\/\//i.test(u || "") ? u : "");
function ago(iso) {
const mins = (Date.now() - new Date(iso)) / 60000;
if (!Number.isFinite(mins)) return "";
@@ -202,11 +201,20 @@
try {
data = await api(`/api/roles?${params}`);
} catch (err) {
// An append failure leaves what is already on screen; a first load or
// a reload has nothing to show, so the empty state offers a retry
// rather than leaving the feed blank for good.
if (!append && request === feedRequest) {
state.feedError = true;
state.loaded = false;
renderFeed();
}
return;
} finally {
if (request === feedRequest) state.loading = false;
}
if (request !== feedRequest) return;
state.feedError = false;
const held = append ? state.items[state.selected]?.uid : state.readingUid;
state.total = data.total;
@@ -475,15 +483,23 @@
for (const el of had.values()) el.remove();
}
/* The summary when there is one, else the description's opening, cut at a
word. */
/* Built on the server (`app.models.excerpt`) and served as `role.excerpt`,
so the list response never carries the full description a row would
otherwise need to cut this from — see docs/decisions.md, "The pages". */
function excerpt(role) {
if (role.summary) return role.summary;
const text = (role.description || "").replace(/\s+/g, " ").trim();
if (text.length <= 160) return text;
const cut = text.slice(0, 160);
return role.excerpt || "";
}
/* The same cut, run here instead: for the one row `merge` refreshes after
a fetch or a summarise, off the full role that call answers with, which
is the only time this page ever sees a role's `summary` or
`description` directly. */
function excerptOf(role) {
const text = (role.summary || role.description || "").replace(/\s+/g, " ").trim();
if (text.length <= 200) return text;
const cut = text.slice(0, 200);
const space = cut.lastIndexOf(" ");
return `${(space > 100 ? cut.slice(0, space) : cut).replace(/[\s,.;:–-]+$/, "")}…`;
return `${(space > 120 ? cut.slice(0, space) : cut).replace(/[\s,.;:–-]+$/, "")}…`;
}
function tagChips(tags) {
@@ -584,21 +600,29 @@
sync($("#roles-list"), state.items.map((role, i) => [role.uid, { role, i }]), makeRow, fillRow);
const empty = $("#feed-empty");
empty.hidden = !(state.loaded && !state.items.length);
empty.hidden = !((state.loaded || state.feedError) && !state.items.length);
if (!empty.hidden) {
const f = state.filter;
const filtered = state.q || f.tags.size || f.period !== "all" || !f.showRead
|| f.company.trim() || f.place.trim() || f.function || f.remote || f.pay || f.judged;
empty.innerHTML = filtered
? `<h2>Nothing matches</h2>
<p>No open role fits these filters.
<button type="button" class="linky" data-clear>Clear them</button> and start again.</p>`
: `<h2>No roles yet</h2>
<p>Nothing has been pulled yet. <a href="/settings/sources#runs">Runs</a> starts one;
<a href="/settings/sources#job-boards">Job boards</a> and
<a href="/settings/sources#company-boards">Company boards</a> decide what it brings in.</p>`;
const clear = empty.querySelector("[data-clear]");
if (clear) clear.onclick = () => { state.q = ""; $("#search").value = ""; clearFilters(); };
if (state.feedError) {
empty.innerHTML = `<h2>Could not load the feed</h2>
<p>The server did not answer. <button type="button" class="linky" data-retry
>Try again</button>.</p>`;
const retry = empty.querySelector("[data-retry]");
if (retry) retry.onclick = () => loadFeed();
} else {
const f = state.filter;
const filtered = state.q || f.tags.size || f.period !== "all" || !f.showRead
|| f.company.trim() || f.place.trim() || f.function || f.remote || f.pay || f.judged;
empty.innerHTML = filtered
? `<h2>Nothing matches</h2>
<p>No open role fits these filters.
<button type="button" class="linky" data-clear>Clear them</button> and start again.</p>`
: `<h2>No roles yet</h2>
<p>Nothing has been pulled yet. <a href="/settings/sources#runs">Runs</a> starts one;
<a href="/settings/sources#job-boards">Job boards</a> and
<a href="/settings/sources#company-boards">Company boards</a> decide what it brings in.</p>`;
const clear = empty.querySelector("[data-clear]");
if (clear) clear.onclick = () => { state.q = ""; $("#search").value = ""; clearFilters(); };
}
}
// The end of the list says which end it is: a list that has run out and
@@ -755,9 +779,13 @@
}
if (!open) { el.replaceChildren(); return; }
// The list row is already in memory, and a list row is the whole role, so
// the pane paints from it at once and the fetch only brings it up to date.
// The list row is already in memory, and carries what a row draws —
// title, company, place, tags, pay — so the pane paints those at once;
// the body, the summary state and the original link wait on the fetch
// (`loaded`), since the list row no longer carries them (see
// `Store.roles_page`).
const stub = state.items.find((r) => r.uid === state.readingUid);
const loaded = Boolean(state.reading) && state.reading.uid === state.readingUid;
const r = state.reading || stub || {};
const same = el.dataset.uid === state.readingUid;
const scrolled = same ? el.querySelector(".reader-body")?.scrollTop || 0 : 0;
@@ -768,13 +796,13 @@
const text = (r.article_text || r.description || "").trim();
const body = error
? `<p class="reader-note">This role could not be loaded: ${esc(error)}</p>`
: !r.uid
: !loaded
? `<p class="reader-note">Loading…</p>`
: text ? paragraphs(text)
: `<p class="reader-note">The board gave no description for this one.</p>`;
const pay = payDisplay(r);
const waiting = state.summarising === state.readingUid;
const teaser = r.uid && !r.article_text && out && (r.description || "").length < TEASER;
const teaser = loaded && !r.article_text && out && (r.description || "").length < TEASER;
el.innerHTML = `
<div class="reader-bar">
@@ -801,7 +829,7 @@
${r.summary ? `<section class="reader-summary">
<h2 class="reader-label">Summary</h2><p>${esc(r.summary)}</p></section>` : ""}
<div class="reader-tools">
${r.uid && !r.summary && !waiting
${loaded && !r.summary && !waiting
? `<button type="button" class="secondary" data-tool="summarise">Summarise</button>` : ""}
${teaser ? `<button type="button" class="secondary" data-tool="fetch">Fetch the posting</button>` : ""}
<span class="muted small" role="status">${waiting
@@ -855,9 +883,9 @@
else state.reading = updated;
const item = state.items.find((x) => x.uid === updated.uid);
if (item) {
Object.assign(item, { summary: updated.summary, article_text: updated.article_text });
item.excerpt = excerptOf(updated);
const row = $(`#roles-list .row[data-uid="${CSS.escape(updated.uid)}"]`);
if (row) row.role = null; // drawn again from the new text
if (row) row.role = null; // drawn again from the new excerpt
renderFeed();
}
renderReader();
@@ -1116,19 +1144,41 @@
wire();
renderRail();
renderActive();
// The agent first: the companies, the feed and the counts are its.
try {
await Promise.all([loadTracked(), loadAgents()]);
chooseAgent();
await loadCompanies(state.filter.agent);
} catch (err) {
return;
}
renderRail();
renderActive();
loadFilters().catch(() => {});
// The feed is the page; agents and companies are enhancements that fill
// in when they arrive, not something it waits on — a slow or failed
// /api/agents or /api/companies must not leave it blank. Each one drawn
// here is greyed or missing until `enhance` lands, which is what "no
// agent" (renderAgent), an unjoined company (paintRow) and the tag row
// being empty already mean, so nothing here is a new state to handle.
const before = state.filter.agent;
const enhance = (async () => {
try {
await Promise.all([loadTracked(), loadAgents()]);
chooseAgent();
await loadCompanies(state.filter.agent);
} catch (err) {
return;
}
renderRail();
renderActive();
loadFilters().catch(() => {});
// The feed's first request went out with whatever agent `readUrl` had
// (often none): reload for the score and votes once the real one is
// known, and either way bring the reader's affinity control and judge
// buttons up to date, since `companies` was still empty when it first
// painted.
if (state.filter.agent !== before) reload();
else renderFeed();
if (state.readingUid) {
if (state.filter.agent !== before) refreshReader(state.readingUid);
else renderReader();
}
})();
route();
await loadFeed({ keep: was ? was.count : 0 });
if (was && !state.readingUid) window.scrollTo(0, was.y || 0);
await enhance;
});
})();
+26 -10
View File
@@ -14,7 +14,7 @@
(function () {
"use strict";
const { api, count, debounce } = window;
const { api, count, debounce, safeUrl } = window;
const $ = (sel, root = document) => root.querySelector(sel);
/** @type {{searches: object[], adzuna_key: boolean}} */
@@ -34,6 +34,14 @@
box.checked = source.on;
box.setAttribute("aria-label", `Run ${source.label}`);
box.addEventListener("change", async () => {
// Switching off closes every open role in one tap; ask first, naming
// the count, as removing a search and deleting an agent already do.
if (!box.checked && source.open_roles
&& !window.confirm(`Switch off ${source.label}? `
+ `Its ${count(source.open_roles, "open role")} close.`)) {
box.checked = true;
return;
}
box.disabled = true;
try {
const result = await api(`/api/sources/${source.id}/switch`,
@@ -41,6 +49,8 @@
Object.assign(source, result.source);
if (!box.checked && result.closed) {
window.toast.info(`${source.label}: ${count(result.closed, "open role")} closed.`);
} else if (box.checked) {
window.toast.info(`${source.label}: reading now, or with the pull right after.`);
}
} catch (err) {
box.checked = !box.checked;
@@ -158,12 +168,18 @@
const list = $("#search-sample");
for (const row of result.sample) {
const li = document.createElement("li");
const link = document.createElement("a");
link.href = row.url;
link.target = "_blank";
link.rel = "noopener";
link.textContent = row.title;
li.append(link, ` — ${[row.company, row.place].filter(Boolean).join(", ")}`);
const url = safeUrl(row.url);
if (url) {
const link = document.createElement("a");
link.href = url;
link.target = "_blank";
link.rel = "noopener";
link.textContent = row.title;
li.appendChild(link);
} else {
li.append(row.title);
}
li.append(` — ${[row.company, row.place].filter(Boolean).join(", ")}`);
list.appendChild(li);
}
} catch (err) {
@@ -184,7 +200,7 @@
renderSearches();
fillSearchForm(null);
status.textContent = `Saved ${result.source.label}. ${found(result)} `
+ "Its roles arrive with the next pull.";
+ "Reading now, or with the pull right after.";
} catch (err) {
status.textContent = "";
}
@@ -208,8 +224,8 @@
// Sources shows one section: the one the fragment names or contains, or the
// first when there is none or it names none, so `/settings/sources#runs` (a
// rail link, an old path's 301, the Search agents page's "follow it under
// Runs") opens Runs, and so does `#messages`, the log at its end. The rest
// rail link, or the Search agents page's "follow it under Runs") opens
// Runs, and so does `#messages`, the log at its end. The rest
// are hidden, not removed, so their scripts still find their roots. It runs
// as the script loads rather than on DOMContentLoaded, so the page never
// paints all three first.
+65 -2
View File
@@ -22,8 +22,8 @@ import numpy as np
from desk.models import Item
from app.models import (
AFFINITY, REMOTE, STATUSES, Agent, Application, ApplicationEvent, Candidate,
Company, Gate, Limits, Role, ScoredRole, Subscription, Weights, company_key,
country_of, place_key, posted_at, posted_host, remote_of, title_key,
Company, Gate, Limits, Role, RoleRow, ScoredRole, Subscription, Weights, company_key,
country_of, excerpt, place_key, posted_at, posted_host, remote_of, title_key,
)
from app.storage import schema
@@ -81,6 +81,17 @@ _VOTED_SCORE = ("MIN(1.0, s.score * CASE v.vote WHEN -1 THEN 0.5 "
#: nothing, so `vote` and `voted_at` are NULL: one query shape either way.
_WITH_VOTES = "LEFT JOIN role_votes v ON v.uid = roles.uid AND v.agent_id = ?"
#: What `roles_page` reads for `RoleRow.excerpt`: the summary when there is
#: one, else the description's opening. A `SUBSTR` of the source column, not
#: the column itself, so a big `description` never leaves SQLite whole for a
#: row that only ever shows `EXCERPT_LIMIT` characters of it.
_EXCERPT_SOURCE = "COALESCE(NULLIF(roles.summary, ''), roles.description)"
#: How many raw characters `roles_page` pulls before `app.models.excerpt`
#: cuts it to size: slack over `EXCERPT_LIMIT` so the word-boundary trim
#: still has somewhere to land.
_EXCERPT_RAW = 240
_COMPANY_FIELDS = ("name", "domain", "status", "careers_url", "notes", "ats", "country", "city",
"ats_slug")
@@ -539,6 +550,58 @@ class Store:
r.tags = by_uid.get(r.uid, [])
return found
def roles_page(self, limit: int = 100, company: str | None = None,
place: str | None = None, open_only: bool = True,
q: str | None = None, function: str | None = None,
remote: str | None = None, days: int | None = None,
hide_muted: bool = False, include_read: bool = True,
tags: Sequence[str] = (), tag_mode: str = "any",
agent: int | None = None, by_score: bool = True, gated: bool = False,
judged: str | None = None, pay: str | None = None,
offset: int = 0) -> list[RoleRow]:
"""What `GET /api/roles` serves: the same rows `roles` would, in the
same order, with the same filters and paging, but only the fields a
row draws (see `RoleRow`) — never `description`, `feed_text`, `raw`
or `article_text`, which a full `roles.*` select would carry whether
or not a page ever renders them. The reader still gets the whole role
by uid, see `role`.
`excerpt` is `app.models.excerpt` over a `SUBSTR` of `_EXCERPT_SOURCE`
(`_EXCERPT_RAW` characters, trimmed further in Python), so the source
column itself never crosses out of SQLite for a list."""
sql, params = self._roles_from(
company=company, place=place, open_only=open_only, q=q, function=function,
remote=remote, days=days, hide_muted=hide_muted, include_read=include_read,
tags=tags, tag_mode=tag_mode, agent=agent, by_score=by_score, gated=gated,
judged=judged, pay=pay)
select = (
"SELECT roles.uid, roles.company_key, roles.company, roles.title, roles.place, "
"roles.country, roles.remote, roles.function, roles.salary_min, "
"roles.salary_max, roles.currency, roles.salary_text, roles.original_url, "
"roles.posted_at, roles.read_at, "
"v.vote, v.voted_at, "
f"SUBSTR({_EXCERPT_SOURCE}, 1, {_EXCERPT_RAW}) AS excerpt")
order = "roles.posted_at DESC, roles.uid"
scored = agent is not None and by_score
if scored:
select += f", {_VOTED_SCORE} AS score, s.gated_reason"
order = "score DESC, " + order
elif open_only:
# Same reasoning as `roles`: the planner otherwise sorts every
# open role before applying LIMIT.
sql = sql.replace("FROM roles ", "FROM roles INDEXED BY idx_roles_posted ", 1)
rows = self._rows(f"{select} {sql} ORDER BY {order} LIMIT ? OFFSET ?",
[*params, limit, offset])
found = []
for r in rows:
row = dict(r)
row["excerpt"] = excerpt(row["excerpt"])
found.append(RoleRow.from_row(row))
by_uid = self._tags_by_uid([r.uid for r in found])
for r in found:
r.tags = by_uid.get(r.uid, [])
return found
def count_roles(self, company: str | None = None, place: str | None = None,
open_only: bool = True, q: str | None = None,
function: str | None = None, remote: str | None = None,
+2 -2
View File
@@ -7,8 +7,8 @@ from __future__ import annotations
from app.web.api import router as api_router
from app.web.pages import (
MOVED, SETTINGS, STATIC_DIR, TABS, router as pages_router, templates,
SETTINGS, STATIC_DIR, TABS, router as pages_router, templates,
)
__all__ = ["MOVED", "SETTINGS", "STATIC_DIR", "TABS", "api_router", "pages_router",
__all__ = ["SETTINGS", "STATIC_DIR", "TABS", "api_router", "pages_router",
"templates"]
+38 -13
View File
@@ -17,7 +17,7 @@ from pydantic import BaseModel, Field
from app import jobs
from app.models import (
AFFINITY, Agent, Application, Company, Gate, Limits, Role, ScoredRole, Status,
AFFINITY, Agent, Application, Company, Gate, Limits, Role, RoleRow, Status,
Subscription, Weights, company_key,
)
from app.storage import Store
@@ -112,9 +112,14 @@ def unread_role(uid: str, store: StoreDep) -> Role:
class RolesPage(BaseModel):
"""One page of roles, and how many the same filters match in all."""
"""One page of roles, and how many the same filters match in all. `items`
is `RoleRow`, not the full `Role`: the fields a feed row draws, with an
excerpt built on the server, never the big columns (`description`,
`feed_text`, `raw`, `article_text`) a full role carries — see
`Store.roles_page`. The reader fetches the rest by uid when it opens one,
`GET /api/roles/{uid}`."""
items: list[ScoredRole]
items: list[RoleRow]
total: int
@@ -165,7 +170,7 @@ def list_roles(
"hide_muted": not show_muted, "include_read": include_read, "tags": tags,
"tag_mode": tag_mode, "agent": agent_id, "by_score": by_score,
"gated": gated, "judged": judged or None, "pay": pay or None}
return RolesPage(items=store.roles(limit=limit, offset=offset, **filters),
return RolesPage(items=store.roles_page(limit=limit, offset=offset, **filters),
total=store.count_roles(**filters))
@@ -335,16 +340,21 @@ class CompanyBoardBody(BaseModel):
@router.post("/companies/{key}/board")
def set_company_board(key: str, body: CompanyBoardBody, store: StoreDep) -> dict[str, Any]:
def set_company_board(key: str, body: CompanyBoardBody, store: StoreDep,
queue: QueueDep) -> dict[str, Any]:
"""Attach a board to a company, or replace the one it has. The board is
fetched first and refused if it does not answer; replacing closes the
old board's open roles."""
old board's open roles. Queues a pull right after, so the board is read
by the one already running or the very next one rather than the
schedule, up to six hours later; a refusal because one is already
running is not an error, see `app.jobs.pull.claim_run`."""
if store.company(key) is None:
raise HTTPException(404, f"no such company: {key}")
try:
sub, found, closed = jobs.sources.set_board(store, key, body.board)
except ValueError as exc:
raise HTTPException(422, str(exc)) from exc
queue.enqueue("pull")
return {"source": _one_source(store, sub.id), "found": found, "closed": closed}
@@ -492,12 +502,18 @@ class SwitchBody(BaseModel):
@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."""
def switch_source(sub_id: int, body: SwitchBody, store: StoreDep,
queue: QueueDep) -> dict[str, Any]:
"""On or off. Off closes the open roles at once; on queues a pull right
after, so the ones it still lists reopen once the pull that is already
running reads it, or the very next one does, rather than waiting for the
schedule, up to six hours later. A refusal because one is already
running is not an error, see `app.jobs.pull.claim_run`."""
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)
if body.on:
queue.enqueue("pull")
return {"source": _one_source(store, sub_id), "closed": closed}
@@ -534,14 +550,19 @@ def try_search(body: SearchBody, config: ConfigDep) -> dict[str, Any]:
@router.post("/searches")
def save_search(body: SearchBody, store: StoreDep, config: ConfigDep) -> dict[str, Any]:
def save_search(body: SearchBody, store: StoreDep, config: ConfigDep,
queue: QueueDep) -> 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."""
once first and refused if it finds nothing. Queues a pull right after,
so its roles are read by the one already running or the very next one
rather than the schedule, up to six hours later; a refusal because one is
already running is not an error, see `app.jobs.pull.claim_run`."""
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
queue.enqueue("pull")
return {"source": _one_source(store, sub.id), "found": found, "complete": complete}
@@ -560,14 +581,18 @@ class BoardBody(BaseModel):
@router.post("/boards", status_code=201)
def add_board(body: BoardBody, store: StoreDep) -> dict[str, Any]:
def add_board(body: BoardBody, store: StoreDep, queue: QueueDep) -> dict[str, Any]:
"""Follow a company by its ATS board: `set_board` keyed by the name, so
an existing company gets it attached or replaced. The board is fetched
first and refused if it does not answer."""
first and refused if it does not answer. Queues a pull right after, so
its roles are read by the one already running or the very next one
rather than the schedule, up to six hours later; a refusal because one is
already running is not an error, see `app.jobs.pull.claim_run`."""
try:
sub, found = jobs.sources.add_board(store, body.board, body.name)
except ValueError as exc:
raise HTTPException(422, str(exc)) from exc
queue.enqueue("pull")
return {"source": _one_source(store, sub.id), "found": found}
-44
View File
@@ -23,13 +23,6 @@ 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
@@ -41,7 +34,6 @@ Jobindex areas and Adzuna countries on the Sources page come from
from __future__ import annotations
import sys
from collections.abc import Callable
from dataclasses import dataclass
from pathlib import Path
@@ -94,24 +86,6 @@ SECTIONS: dict[str, tuple[tuple[str, str], ...]] = {
),
}
#: 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]
@@ -197,21 +171,3 @@ def sources(request: Request) -> HTMLResponse:
@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)