Files
jobboard/app/static/app.js
T

267 lines
11 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 countries 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 three parts, region, place and role, and a company follows every
agent's on all three unless it is set to:
- All countries: the place part is skipped. The company's roles are
fetched and kept from the whole region (Europe), not only the agents'
places, for every agent. The region itself still holds.
- All roles: the role part is skipped: no fetch terms and no titles to
leave out.
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 countries",
on: "All countries is on: this company's roles are fetched and kept from the whole "
+ "region (Europe), not only the agents' places, for every agent. The region still "
+ "holds. Turning it off puts the agents' places back and rescores.",
off: "All countries: fetch and keep this company's roles from the whole region "
+ "(Europe) instead of only the agents' places, for every agent. Turning it on "
+ "rescores.",
said: (on) => (on ? "all countries in the region" : "the agents' places") },
{ 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,
});
})();