Files
2026-10-04 21:33:31 +02:00

267 lines
12 KiB
JavaScript

/* The one way this app talks to its own API.
*
* const kinds = await api("/api/jobs/kinds");
* await api("/api/jobs", { method: "POST", body: { kind: "tick" } });
*
* Every button on every tab goes through `api`, so a failure is always one
* toast carrying the server's own sentence. That is the other half of the
* bargain the exception handler in `app/main.py` makes: it promises every
* error body is `{"detail": "<one readable sentence>"}`, and this is what
* cashes the promise. Wording a failure in the browser as well would be two
* descriptions of one thing, and the client's would be the one that was wrong.
*
* `body` may be a plain object; it is JSON-encoded with the header set, since
* 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`, `safeUrl`, and the company list with its
* affinity control (`loadCompanies`, `companies`, `affinityControl`,
* `setAffinity`) and the two fetch overrides beside it, All locations and
* All roles (`overridesControl`). 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
* none gets the server's default agent, the enabled one with the lowest id.
*/
(function () {
"use strict";
async function api(path, options) {
const o = Object.assign({}, options);
const headers = Object.assign({ Accept: "application/json" }, o.headers);
if (o.body !== undefined && typeof o.body !== "string") {
headers["Content-Type"] = "application/json";
o.body = JSON.stringify(o.body);
}
o.headers = headers;
let response;
try {
response = await fetch(path, o);
} catch (e) {
// The network, not the server: there is no `detail` to read.
window.toast.error("Could not reach the server. Is it still running?");
throw e;
}
const text = await response.text();
let data = null;
if (text) {
try { data = JSON.parse(text); } catch (e) { data = null; }
}
if (!response.ok) {
const detail = (data && data.detail)
|| `The server answered ${response.status} and said nothing about why.`;
window.toast.error(String(detail));
const error = new Error(detail);
error.status = response.status;
error.detail = detail;
throw error;
}
return data;
}
/* `window.esc` is toasts.js's — it loads first and had to have one anyway,
and two copies of an escaper is one of them being fixed. See base.html
for the load order that makes this safe. */
/* The queue's own elements do their own fetching, so their failures never
pass through `api()`. They raise an event carrying the server's `detail`
instead, and this is the same bargain kept one level out: one toast, the
server's sentence, nothing reworded here.
`desk-jobs:notice` is a notice arriving on the element's socket, which
live.js already delivers as `app:notice` — so it is deliberately not
listened for. Two toasts for one failure is the bug that listening would
buy. */
document.addEventListener("desk-schedules:error", (e) => {
const detail = (e.detail && e.detail.detail) || "That change was refused.";
window.toast.error(String(detail));
});
// ----------------------------------------------------------------- helpers
/** `count(3, "role")` is "3 roles"; `many` for an irregular plural. */
function count(n, one, many) {
return `${n} ${n === 1 ? one : many || `${one}s`}`;
}
/** A `<td>` with its column name in `data-label`, which the phone layout
prints above the value once the table's head is hidden. */
function cell(tr, label, content) {
const td = document.createElement("td");
td.dataset.label = label;
if (typeof content === "string") td.textContent = content;
else td.appendChild(content);
tr.appendChild(td);
return td;
}
function debounce(fn, ms) {
let timer;
return (...args) => {
clearTimeout(timer);
timer = setTimeout(() => fn(...args), ms);
};
}
/** 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
Map, refilled in place, so a script holding it sees every reload. */
const companies = new Map();
async function loadCompanies(agent) {
const query = agent == null ? "" : `?agent=${encodeURIComponent(agent)}`;
const rows = await api(`/api/companies${query}`);
companies.clear();
for (const c of rows) companies.set(c.key, c);
return companies;
}
/* Three icon toggles, not four: there is no button for neutral, since
pressing the one that is already pressed is how a company gets back to
it. "Hidden" is the word for -1 everywhere the UI names it, even though
the code and the API keep `mute`/`hide_muted` — a rename in the store
and CLI is a separate, larger change than this control. Low to high, as
the role's ▼ ● ▲ ★, so like and favourite sit together on the right. */
const AFFINITY_LEVELS = [
{ value: -1, icon: "⦸", label: "Hidden" }, // ⊘
{ value: 1, icon: "▲", label: "Like" }, // ▲
{ value: 2, icon: "★", label: "Favourite" }, // ★
];
/* `onChange` runs after the server accepted the change, so each page
decides what a change means for it: the role list refetches, since a
hidden company's roles come out of it, and the company list redraws.
It is given the route's answer, the company with `score_job`, the id
of the `score` that carries the change, for a page that waits on it. */
function affinityControl(companyKey, current, onChange, agent) {
const span = document.createElement("span");
span.className = "affinity";
span.setAttribute("role", "group");
span.setAttribute("aria-label", "Company affinity");
for (const level of AFFINITY_LEVELS) {
const pressed = level.value === current;
const button = document.createElement("button");
button.type = "button";
button.dataset.value = String(level.value);
button.textContent = level.icon;
button.title = level.label;
button.setAttribute("aria-label", level.label);
button.setAttribute("aria-pressed", String(pressed));
button.addEventListener("click", () =>
setAffinity(companyKey, pressed ? 0 : level.value, onChange, agent));
span.appendChild(button);
}
return span;
}
async function setAffinity(companyKey, affinity, onChange, agent) {
if (!companyKey) return;
const body = agent == null ? { affinity } : { affinity, agent };
let updated;
try {
updated = await api(`/api/companies/${encodeURIComponent(companyKey)}/affinity`, {
method: "POST", body,
});
} catch (err) {
return;
}
const company = companies.get(companyKey);
if (company) company.affinity = updated.affinity;
if (onChange) await onChange(updated);
}
/* The two fetch overrides, one more pair of toggles in the affinity
buttons' fragment beside them, in a group of their own since they are
global rather than an agent's stance (app/jobs/reach.py). The fetch gate
has four parts, world, location, role exclusion and role fetch, and a
company follows every agent's unless it is set to:
- All locations: the location gate is skipped. The company's roles are
fetched and kept from the whole world gate (Europe, say), not only the
agents' locations, for every agent. The world gate itself still holds.
- All roles: role exclusion and role fetch are skipped: no titles to
leave out and no fetch terms.
Turning either on or off queues a rescore on the server, as the other
switches that change what passes do, and a pull reads the board anew.
`company` is the shared list's row; `onChange` runs after the server
accepted a switch, with the company it answered. */
const OVERRIDES = [
{ value: "countries", field: "all_countries", path: "all-countries", text: "All locations",
on: "All locations is on: this company's roles are fetched and kept from the whole "
+ "world gate (Europe, say), not only the agents' locations, for every agent. The "
+ "world gate still holds. Turning it off puts the agents' locations back and rescores.",
off: "All locations: fetch and keep this company's roles from the whole world gate "
+ "(Europe, say) instead of only the agents' locations, for every agent. Turning it "
+ "on rescores.",
said: (on) => (on ? "all locations in the world gate" : "the agents' locations") },
{ value: "roles", field: "all_roles", path: "all-roles", text: "All roles",
on: "All roles is on: this company's roles are fetched with no fetch terms and kept "
+ "whatever their title, for every agent. Turning it off puts the agents' fetch "
+ "terms and titles to leave out back and rescores.",
off: "All roles: fetch this company's roles with no fetch terms and no titles to "
+ "leave out, for every agent. Turning it on rescores.",
said: (on) => (on ? "every role type" : "the agents' fetch terms and titles") },
];
function overridesControl(companyKey, company, onChange) {
const span = document.createElement("span");
span.className = "affinity";
span.setAttribute("role", "group");
span.setAttribute("aria-label", "Fetch overrides");
for (const o of OVERRIDES) {
const current = Boolean(company && company[o.field]);
const button = document.createElement("button");
button.type = "button";
button.dataset.value = o.value;
button.textContent = o.text;
button.title = current ? o.on : o.off;
button.setAttribute("aria-label", o.text);
button.setAttribute("aria-pressed", String(current));
button.addEventListener("click", () => setOverride(companyKey, o, !current, onChange));
span.appendChild(button);
}
return span;
}
async function setOverride(companyKey, o, on, onChange) {
if (!companyKey) return;
let updated;
try {
updated = await api(`/api/companies/${encodeURIComponent(companyKey)}/${o.path}`, {
method: "POST", body: { on },
});
} catch (err) {
return;
}
const company = companies.get(companyKey);
if (company) {
company.all_countries = Boolean(updated.all_countries);
company.all_roles = Boolean(updated.all_roles);
}
window.toast.info(on
? `${updated.name}: ${o.said(true)}. Rescoring now, and a pull reads the board right after.`
: `${updated.name}: back to ${o.said(false)}. Rescoring now, and the next pull reads the board anew.`);
if (onChange) await onChange(updated);
}
Object.assign(window, {
api, count, cell, debounce, safeUrl, companies, loadCompanies, affinityControl, setAffinity,
overridesControl,
});
})();