The top bar is Roles and Applications plus health's cog. Behind the cog,
/settings/{ranking,searches,companies,pulls,messages,account} share one row
of sub-tabs, an underlined row on a desktop and pills on a phone. The old
paths answer 301 with their query string.
Ranking edits the first enabled agent, or creates one, with the intent,
the weights and the gates under Advanced. The order menu on Roles reads
Newest and Best match with one enabled agent, and names them with several.
config.yaml keeps the Copenhagen starter; the other two are commented
examples in config.example.yaml.
roles.js is split into roles.js, applications.js, ranking.js and
companies.js; count, cell, debounce, the company list and the affinity
control live once in app.js. app.css gets the phone frame after health and
newsdesk: one-row bar, edge-to-edge panels, 44px targets and 16px fields on
a coarse pointer, hover only where there is one, safe areas. The app is
installable from a manifest and roledesk-coloured icons. Every lede touched
is written for the person using the app.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
164 lines
6.0 KiB
JavaScript
164 lines
6.0 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`, 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.
|
|
*/
|
|
|
|
(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);
|
|
};
|
|
}
|
|
|
|
// --------------------------------------------------------------- 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() {
|
|
const rows = await api("/api/companies");
|
|
companies.clear();
|
|
for (const c of rows) companies.set(c.key, c);
|
|
return companies;
|
|
}
|
|
|
|
const AFFINITY_LEVELS = [
|
|
{ value: -1, label: "Mute" },
|
|
{ value: 0, label: "Neutral" },
|
|
{ value: 1, label: "Like" },
|
|
{ value: 2, label: "Favourite" },
|
|
];
|
|
|
|
/* The four buttons. `onChange` runs after the server accepted the change,
|
|
so each page decides what a change means for it: the role list refetches,
|
|
since muting changes which roles come back, and the company table redraws. */
|
|
function affinityControl(companyKey, current, onChange) {
|
|
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 button = document.createElement("button");
|
|
button.type = "button";
|
|
button.dataset.value = String(level.value);
|
|
button.textContent = level.label[0];
|
|
button.title = level.label;
|
|
button.setAttribute("aria-label", level.label);
|
|
button.setAttribute("aria-pressed", String(level.value === current));
|
|
button.addEventListener("click", () => setAffinity(companyKey, level.value, onChange));
|
|
span.appendChild(button);
|
|
}
|
|
return span;
|
|
}
|
|
|
|
async function setAffinity(companyKey, affinity, onChange) {
|
|
if (!companyKey) return;
|
|
let updated;
|
|
try {
|
|
updated = await api(`/api/companies/${encodeURIComponent(companyKey)}/affinity`, {
|
|
method: "POST", body: { affinity },
|
|
});
|
|
} catch (err) {
|
|
return;
|
|
}
|
|
const company = companies.get(companyKey);
|
|
if (company) company.affinity = updated.affinity;
|
|
if (onChange) await onChange();
|
|
}
|
|
|
|
Object.assign(window, {
|
|
api, count, cell, debounce, companies, loadCompanies, affinityControl, setAffinity,
|
|
});
|
|
})();
|