hymnkeep 0.0.0-stage → 0.1.0

package/dist/tasks.js

@@ -0,0 +1,288 @@
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const DATE = /^\d{4}-\d{2}-\d{2}$/;
+export function today() {
+    const now = new Date();
+    return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}`;
+}
+function addDays(date, days) {
+    const at = new Date(`${date}T12:00:00Z`);
+    at.setUTCDate(at.getUTCDate() + days);
+    return at.toISOString().slice(0, 10);
+}
+const same = (a, b) => (a ?? '').toLowerCase() === b.toLowerCase();
+const has = (a, b) => (a ?? '').toLowerCase().includes(b.toLowerCase());
+/** One of several named things, by id or name: an exact name first, then the only one containing it. */
+function pick(items, wanted, name, what) {
+    const byId = items.find((item) => item.id === wanted);
+    const exact = items.filter((item) => name(item).some((n) => same(n, wanted)));
+    const partial = items.filter((item) => name(item).some((n) => has(n, wanted)));
+    const found = byId ? [byId] : exact.length > 0 ? exact : partial;
+    if (found.length === 1) {
+        return found[0];
+    }
+    const names = (found.length > 1 ? found : items).map((item) => `  ${name(item)[0]}`).join('\n');
+    throw new Error(found.length > 1 ? `More than one ${what} matches "${wanted}":\n${names}` : `No ${what} matches "${wanted}". There are:\n${names}`);
+}
+export async function whoami(api) {
+    const me = await api.get('whoami');
+    return {
+        data: me,
+        text: `${me.person.name}, ${me.role} at ${me.community.name} (${me.community.slug}). This key ${me.key.writes ? 'reads and writes' : 'only reads'}.`,
+    };
+}
+export async function occasions(api, from = today(), to = addDays(from, 41)) {
+    const { data } = await api.get('occasions', { from, to });
+    return {
+        data,
+        text: data.length === 0
+            ? `Nothing planned from ${from} to ${to}.`
+            : data.map((o) => `${o.observance_date}  ${o.name}${o.services.length ? `  (${o.services.map((s) => s.day_time).join(', ')})` : ''}`).join('\n'),
+    };
+}
+/** The occasion an id names, or the first on or after a date (today when neither is given). */
+export async function day(api, when) {
+    if (when && UUID.test(when)) {
+        return (await api.get(`occasions/${when}`)).data;
+    }
+    const from = when && DATE.test(when) ? when : today();
+    const { data } = await api.get('occasions', { from, to: addDays(from, 13) });
+    if (data.length === 0) {
+        throw new Error(`Nothing is planned in the two weeks from ${from}.`);
+    }
+    return (await api.get(`occasions/${data[0].id}`)).data;
+}
+export function services(of, wanted = []) {
+    if (wanted.length === 0) {
+        return of.services;
+    }
+    return wanted.map((each) => pick(of.services, each, (s) => [s.display, s.day_time, s.time, s.label ?? '', s.venue ?? ''], 'service'));
+}
+const title = (row) => row.title ?? 'nothing chosen yet';
+/** Every place of the day once, a place one service adds falling where it falls in that service's order. */
+export function placeOrder(of) {
+    const order = [];
+    for (const service of of.services) {
+        let after = -1;
+        for (const row of of.music.filter((r) => r.service_id === service.id).sort((a, b) => a.position - b.position)) {
+            const at = order.indexOf(row.slot);
+            if (at === -1) {
+                order.splice(after + 1, 0, row.slot);
+                after += 1;
+            }
+            else {
+                after = at;
+            }
+        }
+    }
+    return order;
+}
+/** The day as a person reads it: its music place by place, then who is on each service. */
+export function describeDay(of) {
+    const lines = [`${of.name}, ${of.observance_date}`, `Services: ${of.services.map((s) => s.display).join('; ')}`, '', 'Music'];
+    const slots = placeOrder(of);
+    for (const slot of slots) {
+        const rows = of.music.filter((row) => row.slot === slot);
+        const fills = new Set(rows.map(title));
+        const everywhere = rows.length === of.services.length && fills.size === 1;
+        if (everywhere) {
+            lines.push(`  ${slot}: ${title(rows[0])}`);
+        }
+        else {
+            lines.push(`  ${slot}:`);
+            for (const row of rows) {
+                lines.push(`    ${of.services.find((s) => s.id === row.service_id)?.day_time}: ${title(row)}`);
+            }
+        }
+    }
+    lines.push('', 'Musicians');
+    for (const service of of.services) {
+        const booked = (of.people[service.id] ?? []).filter((a) => a.status !== 'cancelled');
+        lines.push(`  ${service.display}: ${booked.length ? booked.map((a) => (a.job ? `${a.party} (${a.job})` : a.party)).join(', ') : 'nobody yet'}`);
+    }
+    return lines.join('\n');
+}
+export async function show(api, when) {
+    const found = await day(api, when);
+    return { data: found, text: describeDay(found) };
+}
+/** Music in the library and the adopted hymnals, with its page numbers for a date. */
+export async function find(api, query, date) {
+    const { data } = await api.get('music', { q: query, date });
+    return {
+        data: data.pieces,
+        text: data.pieces.length === 0
+            ? `Nothing found for "${query}".`
+            : data.pieces.map((p) => {
+                const pages = (p.pages ?? []).map((pg) => `${pg.book} ${pg.number ?? ''}`.trim()).join(', ');
+                const used = p.recent_use ? `; ${p.recent_use.is_past ? 'last sung' : 'planned'} ${p.recent_use.date}` : '';
+                return `${p.title}${p.credit || p.composer ? ` (${p.credit ?? p.composer})` : ''}${pages ? ` · ${pages}` : ''}${used}`;
+            }).join('\n'),
+    };
+}
+/** A piece by id, or by its title when one piece has it. */
+async function piece(api, wanted, date) {
+    if (UUID.test(wanted)) {
+        return { body: { piece_id: wanted }, title: wanted };
+    }
+    const { data } = await api.get('music', { q: wanted, date });
+    const chosen = pick(data.pieces, wanted, (p) => [p.title], 'piece');
+    return {
+        body: chosen.source?.kind === 'library' || !chosen.work_id ? { piece_id: chosen.id } : { work_id: chosen.work_id },
+        title: chosen.title,
+    };
+}
+/** Each named service's answer when a piece or a person spreads to it: none asked where it is free. */
+function answers(states, targets, taken, absent) {
+    const ids = targets.map((t) => t.id);
+    const out = {};
+    for (const state of states) {
+        if (!ids.includes(state.service_id)) {
+            continue;
+        }
+        if (state.state === 'free') {
+            out[state.service_id] = null;
+        }
+        else if (state.state === 'taken') {
+            out[state.service_id] = taken;
+        }
+        else if (state.state === 'absent' && absent) {
+            out[state.service_id] = absent;
+        }
+    }
+    return out;
+}
+/** A piece in a place, at every service named: those whose place holds another take this one. */
+export async function put(api, options) {
+    const found = await day(api, options.when);
+    const targets = services(found, options.services);
+    const slotName = pick(uniqueSlots(found), options.slot, (s) => [s.name], 'slot').name;
+    const first = found.music.find((row) => row.slot === slotName && targets.some((t) => t.id === row.service_id));
+    if (!first) {
+        throw new Error(`None of those services has ${slotName}. Add it first with add-slot.`);
+    }
+    const chosen = await piece(api, options.piece, found.observance_date);
+    const path = `occasions/${found.id}/services/${first.service_id}/slots/${first.id}`;
+    const { data: states } = await api.get(`${path}/spread`, chosen.body.piece_id ? { piece_id: chosen.body.piece_id } : {});
+    const spread = answers(states, targets, options.both ? 'both' : 'replace', 'add');
+    const at = [first.service_id, ...Object.keys(spread)].map((id) => found.services.find((s) => s.id === id)?.display).filter(Boolean);
+    if (options.preview) {
+        return { data: { piece: chosen, slot: slotName, services: at, states }, text: `Would put ${chosen.title} in ${slotName} at ${at.join(', ')}.` };
+    }
+    const reply = await api.patch(path, { slot_id: first.slot_id, ...chosen.body, spread });
+    return { data: reply, text: `Put ${chosen.title} in ${slotName} at ${at.join(', ')}.` };
+}
+function uniqueSlots(of) {
+    const seen = new Map();
+    for (const row of of.music) {
+        seen.set(row.slot, { id: row.slot_id, name: row.slot });
+    }
+    return [...seen.values()];
+}
+/** A slot with nothing in it yet, added to each service named. */
+export async function addSlot(api, options) {
+    const found = await day(api, options.when);
+    const targets = services(found, options.services);
+    const { data: slots } = await api.get('slots');
+    const slot = pick(slots.filter((s) => !s.hidden), options.slot, (s) => [s.name], 'slot name');
+    const reply = await api.post(`occasions/${found.id}/day/slots`, { slot_id: slot.id, service_ids: targets.map((t) => t.id) });
+    return { data: reply, text: `Added ${slot.name} at ${targets.map((t) => t.display).join(', ')}.` };
+}
+/** A slot taken off each service named, with whatever is in it. */
+export async function removeSlot(api, options) {
+    const found = await day(api, options.when);
+    const targets = services(found, options.services);
+    const slotName = pick(uniqueSlots(found), options.slot, (s) => [s.name], 'slot').name;
+    const rows = found.music.filter((row) => row.slot === slotName && targets.some((t) => t.id === row.service_id));
+    const reply = await api.post(`occasions/${found.id}/day/slots/remove`, { ids: rows.map((row) => row.id) });
+    return { data: reply, text: `Removed ${slotName} from ${rows.map((row) => found.services.find((s) => s.id === row.service_id)?.display).join(', ')}.` };
+}
+/** A person in a job, or an ensemble, at every service named: those where someone else does the job have them replaced. */
+export async function assign(api, options) {
+    const found = await day(api, options.when);
+    const targets = services(found, options.services);
+    const { data: parties } = await api.get('parties');
+    const everyone = [...parties.memberships.map((m) => ({ ...m, kind: 'membership' })), ...parties.ensembles.map((e) => ({ ...e, kind: 'ensemble' }))];
+    const who = pick(everyone, options.who, (p) => [p.name], 'person or ensemble');
+    let jobId = null;
+    let jobName = '';
+    if (who.kind === 'membership') {
+        if (!options.job) {
+            throw new Error(`Which job is ${who.name} doing? Add --job.`);
+        }
+        const { data: jobs } = await api.get('jobs');
+        const job = pick(jobs.filter((j) => !j.archived), options.job, (j) => [j.name], 'job');
+        jobId = job.id;
+        jobName = ` as ${job.name}`;
+    }
+    const party = who.kind === 'membership' ? { party_type: 'membership', membership_id: who.id } : { party_type: 'ensemble', ensemble_id: who.id };
+    const first = targets[0];
+    const path = `occasions/${found.id}/services/${first.id}/assignments`;
+    const { data: states } = await api.get(`${path}/spread`, { ...party, job_id: jobId ?? undefined, party_type: undefined });
+    const spread = answers(states, targets.slice(1), options.both ? 'both' : 'replace', null);
+    const at = [first, ...targets.slice(1).filter((t) => t.id in spread)].map((t) => t.display);
+    if (options.preview) {
+        return { data: { who: who.name, job: jobName, services: at, states }, text: `Would assign ${who.name}${jobName} at ${at.join(', ')}.` };
+    }
+    const reply = await api.post(path, { ...party, job_id: jobId, spread });
+    return { data: reply, text: `Assigned ${who.name}${jobName} at ${at.join(', ')}.` };
+}
+/** A person or an ensemble taken off each service named. */
+export async function unassign(api, options) {
+    const found = await day(api, options.when);
+    const targets = services(found, options.services);
+    const gone = [];
+    for (const service of targets) {
+        const rows = (found.people[service.id] ?? []).filter((a) => a.status !== 'cancelled' && same(a.party, options.who) && (!options.job || same(a.job, options.job)));
+        for (const row of rows) {
+            await api.delete(`occasions/${found.id}/services/${service.id}/assignments/${row.id}`);
+            gone.push(service.display);
+        }
+    }
+    if (gone.length === 0) {
+        throw new Error(`${options.who} is not on ${targets.map((t) => t.display).join(', ')}.`);
+    }
+    return { data: { removed: gone }, text: `Took ${options.who} off ${gone.join(', ')}.` };
+}
+/** One service's music onto another's, replacing it or after it. */
+export async function copy(api, options) {
+    const found = await day(api, options.when);
+    const [from] = services(found, [options.from]);
+    const [to] = services(found, [options.to]);
+    const reply = await api.post(`occasions/${found.id}/services/${to.id}/copy`, { from_service_id: from.id, replace: options.replace ?? false });
+    return { data: reply, text: `Copied ${from.display}'s music to ${to.display}${options.replace ? ', replacing what it had' : ''}.` };
+}
+/**
+ * A date planned from its templates: what they would write, and any question
+ * they raise. Nothing is written while a question has no answer.
+ */
+export async function plan(api, options) {
+    const query = { date: options.date, templates: options.templates };
+    for (const [key, value] of Object.entries(options.answers ?? {})) {
+        query[`answers[${key}]`] = value;
+    }
+    const { data: preview } = await api.get('occasions/preview', query);
+    const open = preview.collisions.filter((c) => c.answer === null || c.answer === undefined);
+    const described = [
+        `${preview.day.name}, ${options.date}`,
+        ...preview.contributors.map((c) => `  ${c.sentence}`),
+        ...preview.services.map((s) => `  ${s.time_label}${s.label ? ` · ${s.label}` : ''}: ${s.slots.length} slots`),
+    ];
+    if (open.length > 0) {
+        return {
+            data: { preview, questions: open },
+            text: [...described, '', 'Questions to answer first (--answer key=value):', ...open.map((q) => `  ${q.key}: ${q.ask} ${q.options.map((o) => `[${o.value}] ${o.label}`).join('  ')}`)].join('\n'),
+        };
+    }
+    if (options.preview) {
+        return { data: { preview }, text: [...described, '', 'Nothing written yet.'].join('\n') };
+    }
+    const reply = await api.post('occasions', {
+        observance_date: options.date,
+        name: preview.day.name,
+        kind: preview.kind,
+        is_public: true,
+        templates: options.templates ?? preview.templates,
+        answers: options.answers ?? {},
+    });
+    return { data: reply, text: `Planned ${preview.day.name} on ${options.date}.\n\n${describeDay(reply.data)}` };
+}