Serve one alpha page: filters, roles, the tracker, and Jobs

/, GET /api/roles|companies|applications, POST /api/companies/{key}/affinity
and /api/applications[/{id}/status]. The Jinja2 template renders an empty
shell; static/app.js fills it and drives Save, affinity and status changes.
<desk-jobs> from pipeline.web mounts at the bottom so Pull can be started
from the page.

Store.roles gains q, function, remote, days and hide_muted, and company/
place move from a key match to a substring on the text a board wrote.
hide_muted filters in SQL before LIMIT: filtering after it shipped first and
broke immediately on real data, since Databricks' freshly pulled 884 roles
were the newest 200-plus rows in the table and muting it left nothing to
show.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
This commit is contained in:
WolfandClaude Sonnet 5 committed 2026-09-23 11:56:10 +02:00
1 parent 867ebe6405
commit b44f78ca7e
13 files changed
+1143 -22

No files matched your search

+124
View File
@@ -0,0 +1,124 @@
"""The JSON routes the page uses: roles, companies, applications.
`/api/jobs*`, `/_jobs/jobs.js` and `/ws/jobs` are `pipeline.web`'s, mounted by
`connect` in `app.py`. This is roledesk's own API, over the same store.
"""
from __future__ import annotations
from datetime import timedelta
from typing import Annotated
from fastapi import APIRouter, HTTPException, Query
from pydantic import BaseModel
from roledesk.models import AFFINITY, Application, Company, Role, Status
from roledesk.web.deps import StoreDep
router = APIRouter(prefix="/api", tags=["roledesk"])
# ------------------------------------------------------------------- roles
@router.get("/roles")
def list_roles(
store: StoreDep,
q: str = "",
company: str = "",
place: str = "",
function: str = "",
remote: str = "",
days: int | None = None,
show_muted: bool = False,
limit: Annotated[int, Query(ge=1, le=1000)] = 200,
) -> list[Role]:
"""Open roles, newest first. See `Store.roles` for what each filter does.
A muted company's roles are left out unless `show_muted` is set."""
return store.roles(limit=limit, q=q or None, company=company or None,
place=place or None, function=function or None,
remote=remote or None, days=days, hide_muted=not show_muted)
# --------------------------------------------------------------- companies
class CompanyOut(BaseModel):
"""A company row plus the two things only the store can join in: the ats
host it is read from, and how many of its roles are still open."""
key: str
name: str
board: str
affinity: int
open_roles: int
@router.get("/companies")
def list_companies(store: StoreDep) -> list[CompanyOut]:
boards = store.company_boards()
counts = store.open_role_counts()
return [CompanyOut(key=c.key, name=c.name, board=boards.get(c.key, ""),
affinity=c.affinity, open_roles=counts.get(c.key, 0))
for c in store.companies()]
class AffinityBody(BaseModel):
affinity: int
@router.post("/companies/{key}/affinity")
def set_affinity(key: str, body: AffinityBody, store: StoreDep) -> Company:
if body.affinity not in AFFINITY:
raise HTTPException(422, "affinity is -1, 0, 1 or 2")
try:
return store.update_company(key, affinity=body.affinity)
except KeyError:
raise HTTPException(404, f"no such company: {key}") from None
# ----------------------------------------------------------- applications
class SaveBody(BaseModel):
role_uid: str
status: Status = "saved"
@router.post("/applications", status_code=201)
def save_role(body: SaveBody, store: StoreDep) -> Application:
"""Track one role. Pressing Save twice does not double-track it: the
existing row comes back rather than a second one starting at `saved`
over whatever status it has since moved to."""
existing = next((a for a in store.applications() if a.role_uid == body.role_uid), None)
if existing is not None:
return existing
role = store.role(body.role_uid)
if role is None:
raise HTTPException(404, f"no such role: {body.role_uid}")
next_date = (store.clock() + timedelta(days=2)).date().isoformat()
application = Application(
role_uid=role.uid, company_key=role.company_key, role_title=role.title,
url=role.original_url, status=body.status, source=role.source,
next_action="Read the posting and decide", next_date=next_date)
return store.save_application(application)
@router.get("/applications")
def list_applications(store: StoreDep) -> list[Application]:
"""Every tracked application, with the role title and company key it was
saved with — enough for the page to list them without a join; the
company's full name comes from `/api/companies`, already on the page."""
return store.applications()
class StatusBody(BaseModel):
status: Status
@router.post("/applications/{app_id}/status")
def set_status(app_id: str, body: StatusBody, store: StoreDep) -> Application:
try:
return store.set_application_status(app_id, body.status)
except ValueError as exc:
raise HTTPException(422, str(exc)) from exc
except KeyError:
raise HTTPException(404, f"no such application: {app_id}") from None
+11 -14
View File
@@ -1,23 +1,22 @@
"""The application factory. A stub page until the reader lands: the queue's
routes and socket from `pipeline.web.connect`, and a one-line index."""
"""The application factory: the queue's routes and socket from
`pipeline.web.connect`, roledesk's own JSON API, and the one page."""
from __future__ import annotations
from pathlib import Path
from fastapi import FastAPI
from fastapi.responses import HTMLResponse
from fastapi.staticfiles import StaticFiles
from pipeline import Jobs
from pipeline.web import connect
from roledesk import config as config_mod
from roledesk import jobs
from roledesk.storage import Store
from roledesk.web.api import router as api_router
from roledesk.web.pages import router as pages_router
INDEX = """<!doctype html>
<meta charset="utf-8"><title>roledesk</title>
<p>roledesk: no reader yet.</p>
<script type="module" src="/_jobs/jobs.js"></script>
<desk-jobs></desk-jobs>
"""
WEB = Path(__file__).resolve().parent
def create_app(config_path: str | None = None) -> FastAPI:
@@ -31,11 +30,9 @@ def create_app(config_path: str | None = None) -> FastAPI:
bootstrap=jobs.BOOTSTRAP, bootstrap_arg=config.path or "")
app.state.config = config
app.state.store = store
@app.get("/", response_class=HTMLResponse)
def index() -> str:
return INDEX
app.include_router(api_router)
app.include_router(pages_router)
app.mount("/static", StaticFiles(directory=WEB / "static"), name="static")
return app
+27
View File
@@ -0,0 +1,27 @@
"""How a route reaches the store.
Built once by the app's factory and parked on `app.state`; a route asks for
it as a dependency rather than closing over it, the same split newsdesk's
`web/deps.py` makes and for the same reason — a router module stays
importable, and testable, on its own.
Not a `yield` dependency: `Store` holds no connection between calls (see
`roledesk/storage/store.py`), so there is nothing to close, and building one
per request would take SQLite's write lock for a plain read.
"""
from __future__ import annotations
from typing import Annotated
from fastapi import Depends
from starlette.requests import HTTPConnection
from roledesk.storage import Store
def get_store(request: HTTPConnection) -> Store:
return request.app.state.store
StoreDep = Annotated[Store, Depends(get_store)]
+47
View File
@@ -0,0 +1,47 @@
"""The one page. Everything under `/api` and `/_jobs` is JSON; this route
hands the browser an empty shell — the filter bar, the section headers, the
`<select>` options a plugin's vocabulary decides — and `static/app.js` fills
it and drives every action from there.
`FUNCTIONS` is `plugins.ats`'s, not `roledesk`'s: the nine job functions are
the classifier's vocabulary, and this reaches `plugins/` the same way
`roledesk.cli` already does, since a plugin is app-agnostic and never reaches
back into `roledesk`.
"""
from __future__ import annotations
import sys
from pathlib import Path
from fastapi import APIRouter, Request
from fastapi.responses import HTMLResponse
from fastapi.templating import Jinja2Templates
from roledesk.models import REMOTE, STATUSES
_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
WEB = Path(__file__).resolve().parent
templates = Jinja2Templates(directory=WEB / "templates")
router = APIRouter(tags=["pages"])
#: `value, label` for each function 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]
@router.get("/", response_class=HTMLResponse)
def index(request: Request) -> HTMLResponse:
return templates.TemplateResponse(request, "index.html", {
"functions": FUNCTION_OPTIONS,
"remote_options": REMOTE_OPTIONS,
"status_options": STATUS_OPTIONS,
})
+193
View File
@@ -0,0 +1,193 @@
/* roledesk — an alpha to look at real ads, not the final reader. The palette
and type stack borrow newsdesk's visual language (news/newsdesk/web/static
/app.css): a quiet UI face and a teal signal colour, nothing ported beyond
that — no reader, no auth, no passkeys. */
:root {
--bg: #eceff1;
--panel: #ffffff;
--ink: #1a2027;
--muted: #505c67;
--faint: #6d7883;
--rule: #d6dbdf;
--signal: #14655b;
--signal-weak: #a9c4bf;
--mute: #96382c;
--focus: #1b4f8f;
--ui: "Segoe UI Variable Text", "Segoe UI", system-ui, -apple-system, Roboto,
"Helvetica Neue", Arial, sans-serif;
font-size: 16px;
}
@media (prefers-color-scheme: dark) {
:root {
--bg: #14181c;
--panel: #1b2126;
--ink: #e3e7ea;
--muted: #a8b2ba;
--faint: #8b959d;
--rule: #2a3238;
--signal: #4fb3a3;
--signal-weak: #35544f;
--mute: #cd6a5b;
--focus: #6ea8e8;
}
}
* { box-sizing: border-box; }
html, body { max-width: 100%; overflow-x: hidden; }
body {
margin: 0;
background: var(--bg);
color: var(--ink);
font-family: var(--ui);
line-height: 1.45;
-webkit-font-smoothing: antialiased;
}
button, input, select { font: inherit; color: inherit; }
a { color: var(--signal); }
/* ---------------------------------------------------------------- chrome */
header {
position: sticky; top: 0; z-index: 10;
display: flex; align-items: center; gap: 1rem; flex-wrap: wrap;
padding: .7rem 1rem;
background: var(--panel);
border-bottom: 1px solid var(--rule);
}
.wordmark { font-weight: 640; letter-spacing: -.01em; font-size: 1.1rem; }
.wordmark span { color: var(--signal); }
.tabs { display: flex; gap: .25rem; }
.tab {
background: none; border: 1px solid transparent; border-radius: .3rem;
padding: .35rem .75rem; cursor: pointer; color: var(--muted);
}
.tab[aria-pressed="true"] { color: var(--ink); background: var(--bg); border-color: var(--rule); }
/* --------------------------------------------------------------- filters */
.filters {
display: flex; flex-wrap: wrap; gap: .5rem;
padding: .75rem 1rem;
background: var(--panel);
border-bottom: 1px solid var(--rule);
}
.filters input[type="search"], .filters input[type="text"], .filters select {
padding: .4rem .55rem;
border: 1px solid var(--rule); border-radius: .3rem;
background: var(--bg); color: var(--ink);
min-width: 0;
}
.filters input[type="search"] { flex: 1 1 12rem; }
.filters input[type="text"] { flex: 1 1 8rem; }
.show-muted {
display: flex; align-items: center; gap: .35rem;
color: var(--muted); font-size: .9rem; white-space: nowrap;
}
button:focus-visible, a:focus-visible, input:focus-visible, select:focus-visible {
outline: 2px solid var(--focus); outline-offset: 1px;
}
/* ------------------------------------------------------------------ views */
.view { padding: 0 1rem 1.5rem; }
.count { color: var(--faint); font-size: .85rem; margin: .75rem 0 .5rem; }
/* ------------------------------------------------------------------- roles */
.roles { list-style: none; margin: 0; padding: 0; display: flex; flex-direction: column; gap: .5rem; }
.role {
background: var(--panel); border: 1px solid var(--rule); border-radius: .5rem;
padding: .6rem .8rem;
display: flex; flex-direction: column; gap: .35rem;
}
.role-main {
display: flex; flex-wrap: wrap; align-items: baseline; gap: .5rem;
}
.role-title { font-weight: 600; text-decoration: none; }
.role-title:hover { text-decoration: underline; }
.role-company { color: var(--muted); }
.role-meta {
display: flex; flex-wrap: wrap; align-items: center; gap: .5rem;
color: var(--faint); font-size: .85rem;
}
.badge {
border: 1px solid var(--rule); border-radius: 1rem;
padding: .05rem .55rem; font-size: .78rem;
}
.role-remote.badge:empty, .role-function.badge:empty { display: none; }
.role-age { margin-left: auto; }
.affinity { display: inline-flex; gap: .15rem; margin-left: auto; }
.affinity button {
background: none; border: 1px solid var(--rule); border-radius: .3rem;
padding: .1rem .4rem; cursor: pointer; color: var(--muted); font-size: .85rem;
line-height: 1.4;
}
.affinity button[aria-pressed="true"] { color: #fff; background: var(--signal); border-color: var(--signal); }
.affinity button[data-value="-1"][aria-pressed="true"] { background: var(--mute); border-color: var(--mute); }
.save {
align-self: flex-start;
background: var(--signal); color: #fff; border: 1px solid var(--signal);
border-radius: .3rem; padding: .3rem .8rem; cursor: pointer; font-weight: 600;
}
.save[disabled] {
background: var(--bg); color: var(--muted); border-color: var(--rule); cursor: default;
}
.role.muted { opacity: .55; }
/* ------------------------------------------------------------ applications */
.applications { width: 100%; border-collapse: collapse; background: var(--panel); }
.applications th, .applications td {
text-align: left; padding: .5rem .6rem; border-bottom: 1px solid var(--rule);
font-size: .9rem;
}
.applications select { padding: .25rem .4rem; }
/* Below tablet width, a table stops being a table: each row becomes a card,
its cells stacked, so nothing scrolls sideways to be read. */
@media (max-width: 640px) {
.applications thead { display: none; }
.applications, .applications tbody, .applications tr, .applications td { display: block; width: 100%; }
.applications tr { margin-bottom: .6rem; border: 1px solid var(--rule); border-radius: .4rem; }
.applications td { border-bottom: none; }
.applications td::before {
content: attr(data-label);
display: block; font-size: .72rem; color: var(--faint); margin-bottom: .1rem;
}
}
/* ------------------------------------------------------------------- jobs */
#jobs { padding: 1rem; border-top: 1px solid var(--rule); }
#jobs h2 { font-size: .95rem; color: var(--muted); margin: 0 0 .6rem; }
@media (max-width: 480px) {
.role-age { margin-left: 0; }
.affinity { margin-left: 0; }
}
+286
View File
@@ -0,0 +1,286 @@
// roledesk's page: the filter bar, the role list, the tracker, and the tab
// switch between them. The template renders an empty shell (see index.html);
// everything on screen comes from the API, and every action — Save, an
// affinity click, a status change — is a fetch from here, not a form post.
"use strict";
const ROLES_URL = "/api/roles";
/** @type {Map<string, object>} company_key -> company row from /api/companies */
let companies = new Map();
/** @type {Map<string, object>} role_uid -> application row, for roles that are already tracked */
let trackedByRole = new Map();
/** @type {object[]} the last /api/roles response, already muted-filtered by the server */
let roles = [];
const $ = (sel, root = document) => root.querySelector(sel);
const $$ = (sel, root = document) => Array.from(root.querySelectorAll(sel));
function debounce(fn, ms) {
let timer;
return (...args) => {
clearTimeout(timer);
timer = setTimeout(() => fn(...args), ms);
};
}
async function api(path, options) {
const res = await fetch(path, options);
if (!res.ok) {
const body = await res.json().catch(() => ({}));
throw new Error(body.detail || `${path}: ${res.status}`);
}
return res.status === 204 ? null : res.json();
}
// ------------------------------------------------------------------ tabs
function initTabs() {
$$(".tab").forEach((tab) => {
tab.addEventListener("click", () => {
$$(".tab").forEach((t) => t.setAttribute("aria-pressed", String(t === tab)));
const name = tab.dataset.tab;
$("#roles-view").hidden = name !== "roles";
$("#applications-view").hidden = name !== "applications";
if (name === "applications") loadApplications();
});
});
}
// ----------------------------------------------------------------- roles
function filterParams() {
const params = new URLSearchParams();
const q = $("#f-q").value.trim();
const company = $("#f-company").value.trim();
const place = $("#f-place").value.trim();
const fn = $("#f-function").value;
const remote = $("#f-remote").value;
const days = $("#f-days").value;
if (q) params.set("q", q);
if (company) params.set("company", company);
if (place) params.set("place", place);
if (fn) params.set("function", fn);
if (remote) params.set("remote", remote);
if (days) params.set("days", days);
if ($("#f-show-muted").checked) params.set("show_muted", "true");
return params;
}
async function loadRoles() {
const params = filterParams();
roles = await api(`${ROLES_URL}?${params.toString()}`);
renderRoles();
}
function relativeAge(iso) {
const then = new Date(iso);
const minutes = Math.max(0, Math.floor((Date.now() - then.getTime()) / 60000));
if (minutes < 60) return `${minutes} min ago`;
const hours = Math.floor(minutes / 60);
if (hours < 24) return `${hours} h ago`;
const days = Math.floor(hours / 24);
return `${days} d ago`;
}
function renderRoles() {
const list = $("#roles-list");
const template = $("#role-row");
list.replaceChildren();
for (const role of roles) {
const node = template.content.cloneNode(true);
const li = node.querySelector(".role");
const company = companies.get(role.company_key);
if (company && company.affinity === -1) li.classList.add("muted");
const titleLink = node.querySelector(".role-title");
titleLink.textContent = role.title || "(untitled)";
titleLink.href = role.original_url || "#";
node.querySelector(".role-company").textContent = role.company || "";
node.querySelector(".role-place").textContent = role.place || "";
node.querySelector(".role-remote").textContent = role.remote || "";
node.querySelector(".role-function").textContent = role.function || "";
node.querySelector(".role-age").textContent = relativeAge(role.first_seen);
node.querySelector(".affinity").replaceWith(
affinityControl(role.company_key, company ? company.affinity : 0));
const saveButton = node.querySelector(".save");
setSaveButton(saveButton, role.uid);
saveButton.addEventListener("click", () => saveRole(role.uid, saveButton));
list.appendChild(node);
}
$("#roles-count").textContent = `${roles.length} role${roles.length === 1 ? "" : "s"}`;
}
function setSaveButton(button, uid) {
const saved = trackedByRole.has(uid);
button.textContent = saved ? "Saved" : "Save";
button.disabled = saved;
}
async function saveRole(uid, button) {
button.disabled = true;
button.textContent = "Saving…";
try {
const application = await api("/api/applications", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ role_uid: uid, status: "saved" }),
});
trackedByRole.set(uid, application);
setSaveButton(button, uid);
} catch (err) {
button.disabled = false;
button.textContent = "Save";
console.error(err);
}
}
// -------------------------------------------------------------- affinity
const AFFINITY_LEVELS = [
{ value: -1, label: "Mute" },
{ value: 0, label: "Neutral" },
{ value: 1, label: "Like" },
{ value: 2, label: "Favourite" },
];
function affinityControl(companyKey, current) {
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));
span.appendChild(button);
}
return span;
}
async function setAffinity(companyKey, affinity) {
if (!companyKey) return;
try {
const updated = await api(`/api/companies/${encodeURIComponent(companyKey)}/affinity`, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ affinity }),
});
const company = companies.get(companyKey);
if (company) company.affinity = updated.affinity;
// Muting or unmuting changes which roles the server hands back, so the
// list is refetched rather than just re-rendered from what is on hand.
await loadRoles();
} catch (err) {
console.error(err);
}
}
// ------------------------------------------------------------ applications
// `ROLEDESK_STATUSES` is set by index.html from the same `STATUSES` tuple
// the store validates against, so this list can never drift from what a
// `POST .../status` will actually accept.
function statusSelect(current) {
const select = document.createElement("select");
for (const status of window.ROLEDESK_STATUSES) {
const option = document.createElement("option");
option.value = status;
option.textContent = status[0].toUpperCase() + status.slice(1);
option.selected = status === current;
select.appendChild(option);
}
return select;
}
async function loadApplications() {
const applications = await api("/api/applications");
trackedByRole = new Map(applications.filter((a) => a.role_uid).map((a) => [a.role_uid, a]));
renderApplications(applications);
}
function renderApplications(applications) {
const body = $("#applications-list");
body.replaceChildren();
for (const application of applications) {
const tr = document.createElement("tr");
const roleTd = document.createElement("td");
roleTd.dataset.label = "Role";
roleTd.textContent = application.role_title || "(untitled)";
tr.appendChild(roleTd);
const companyTd = document.createElement("td");
companyTd.dataset.label = "Company";
const company = companies.get(application.company_key);
companyTd.textContent = company ? company.name : application.company_key;
tr.appendChild(companyTd);
const statusTd = document.createElement("td");
statusTd.dataset.label = "Status";
const select = statusSelect(application.status);
select.addEventListener("change", () => setStatus(application.id, select.value));
statusTd.appendChild(select);
tr.appendChild(statusTd);
const nextTd = document.createElement("td");
nextTd.dataset.label = "Next";
nextTd.textContent = [application.next_action, application.next_date]
.filter(Boolean).join(" · ");
tr.appendChild(nextTd);
body.appendChild(tr);
}
$("#applications-count").textContent =
`${applications.length} tracked application${applications.length === 1 ? "" : "s"}`;
}
async function setStatus(id, status) {
try {
await api(`/api/applications/${encodeURIComponent(id)}/status`, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ status }),
});
await loadApplications();
} catch (err) {
console.error(err);
}
}
// -------------------------------------------------------------------- init
async function loadCompanies() {
const rows = await api("/api/companies");
companies = new Map(rows.map((c) => [c.key, c]));
}
async function init() {
initTabs();
await Promise.all([loadCompanies(), loadApplications()]);
await loadRoles();
const refetch = debounce(loadRoles, 300);
$("#f-q").addEventListener("input", refetch);
$("#f-company").addEventListener("input", refetch);
$("#f-place").addEventListener("input", refetch);
$("#f-function").addEventListener("change", loadRoles);
$("#f-remote").addEventListener("change", loadRoles);
$("#f-days").addEventListener("change", loadRoles);
$("#f-show-muted").addEventListener("change", loadRoles);
$("#filters").addEventListener("submit", (e) => e.preventDefault());
}
document.addEventListener("DOMContentLoaded", init);
+92
View File
@@ -0,0 +1,92 @@
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>roledesk</title>
<link rel="stylesheet" href="/static/app.css">
</head>
<body>
<header>
<span class="wordmark">role<span>desk</span></span>
<nav class="tabs" id="tabs">
<button type="button" class="tab" data-tab="roles" aria-pressed="true">Roles</button>
<button type="button" class="tab" data-tab="applications" aria-pressed="false">Applications</button>
</nav>
</header>
<section id="roles-view" class="view">
<form id="filters" class="filters" autocomplete="off">
<input type="search" id="f-q" placeholder="Search titles" aria-label="Search titles">
<input type="text" id="f-company" placeholder="Company" aria-label="Company">
<input type="text" id="f-place" placeholder="Place" aria-label="Place">
<select id="f-function" aria-label="Function">
<option value="">Any function</option>
{% for value, label in functions %}
<option value="{{ value }}">{{ label }}</option>
{% endfor %}
</select>
<select id="f-remote" aria-label="Remote">
<option value="">Any remote</option>
{% for value, label in remote_options %}
<option value="{{ value }}">{{ label }}</option>
{% endfor %}
</select>
<select id="f-days" aria-label="New in">
<option value="">Any time</option>
<option value="1">New in 1 day</option>
<option value="3">New in 3 days</option>
<option value="7">New in 7 days</option>
<option value="30">New in 30 days</option>
</select>
<label class="show-muted">
<input type="checkbox" id="f-show-muted"> Show muted
</label>
</form>
<p id="roles-count" class="count" role="status"></p>
<ul id="roles-list" class="roles"></ul>
</section>
<section id="applications-view" class="view" hidden>
<p id="applications-count" class="count" role="status"></p>
<table class="applications">
<thead>
<tr><th>Role</th><th>Company</th><th>Status</th><th>Next</th></tr>
</thead>
<tbody id="applications-list"></tbody>
</table>
</section>
<section id="jobs">
<h2>Jobs</h2>
<script type="module" src="/_jobs/jobs.js"></script>
<desk-jobs></desk-jobs>
</section>
<template id="role-row">
<li class="role">
<div class="role-main">
<a class="role-title" target="_blank" rel="noopener"></a>
<span class="role-company"></span>
<span class="affinity" role="group"></span>
</div>
<div class="role-meta">
<span class="role-place"></span>
<span class="role-remote badge"></span>
<span class="role-function badge"></span>
<span class="role-age"></span>
</div>
<button type="button" class="save"></button>
</li>
</template>
<script>
// The tracker's status vocabulary, from the same `STATUSES` tuple the
// store validates a status change against — see roledesk/web/pages.py.
window.ROLEDESK_STATUSES = {{ status_options | map(attribute=0) | list | tojson }};
</script>
<script src="/static/app.js" defer></script>
</body>
</html>