shutro-erp 0.3.5 → 0.3.6

package/dist/project/routes.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Projects' routes (RFC 0026 step 3):
+ *
+ * - `GET /api/v1/projects/workload?from=YYYY-MM-DD&weeks=12`  each person's allocation week by week across the
+ *   projects they are members of (active projects only): the highest total on any day of the week, with the projects
+ *   behind it. Projects managers see everyone; others see themselves.
+ * - `POST /api/v1/projects/refresh` `{ projects? }`             Projects managers: the booked and committed costs (from
+ *   the bridges) and the health of active projects (these, or all), now; hourly too. The next of each repeating task
+ *   done is made then too.
+ * - `GET  /api/v1/projects/:id/schedule`        the project's tasks with their dates, baseline, float and the
+ *   critical path (as the caller sees them)
+ * - `POST /api/v1/projects/:id/schedule/apply`  tasks that start before what they wait for is finished move later,
+ *   their length kept (who may change the tasks)
+ */
+import { type ModuleContext } from '../server/index.js';
+import type { Env } from './.kosh/bindings.js';
+/** The Monday on or before `date` (YYYY-MM-DD). */
+export declare function mondayOf(date: string): string;
+export interface WorkloadRow {
+    readonly user: number;
+    readonly name: string;
+    /** The week's peak allocation, in %. */
+    readonly weeks: readonly number[];
+    readonly projects: readonly {
+        readonly id: number;
+        readonly name: string;
+        readonly allocation: number;
+        readonly from: string | null;
+        readonly to: string | null;
+    }[];
+}
+export declare function workload(env: Env, from: string, weeks: number): Promise<{
+    weeks: string[];
+    people: WorkloadRow[];
+}>;
+/**
+ * The booked and committed costs and the health of the active projects (`ids`, or all of the company), as the
+ * system: the bridges' figures through `moneyOf()`, then the worst of schedule, late milestones and cost against the
+ * company's thresholds. Returns how many were refreshed.
+ */
+export declare function refreshProjects(su: Env, ids?: readonly number[]): Promise<number>;
+/** `date` moved by `n` days, weeks or months. */
+export declare function shiftDate(date: string, n: number, unit: string): string;
+export declare function registerProjectRoutes(context: ModuleContext): void;

package/dist/project/routes.js

@@ -0,0 +1,314 @@
+/**
+ * Projects' routes (RFC 0026 step 3):
+ *
+ * - `GET /api/v1/projects/workload?from=YYYY-MM-DD&weeks=12`  each person's allocation week by week across the
+ *   projects they are members of (active projects only): the highest total on any day of the week, with the projects
+ *   behind it. Projects managers see everyone; others see themselves.
+ * - `POST /api/v1/projects/refresh` `{ projects? }`             Projects managers: the booked and committed costs (from
+ *   the bridges) and the health of active projects (these, or all), now; hourly too. The next of each repeating task
+ *   done is made then too.
+ * - `GET  /api/v1/projects/:id/schedule`        the project's tasks with their dates, baseline, float and the
+ *   critical path (as the caller sees them)
+ * - `POST /api/v1/projects/:id/schedule/apply`  tasks that start before what they wait for is finished move later,
+ *   their length kept (who may change the tasks)
+ */
+import { chatterContext } from '../messaging/index.js';
+import { HttpProblem } from '../server/index.js';
+import { configureProjectChatter, judgeHealth, peakAllocation, } from './module.js';
+import { applySlips, scheduleOf } from './schedule.js';
+const DAY = 86_400_000;
+const iso = (t) => new Date(t).toISOString().slice(0, 10);
+/** The Monday on or before `date` (YYYY-MM-DD). */
+export function mondayOf(date) {
+    const t = Date.parse(`${date}T00:00:00Z`);
+    const weekday = (new Date(t).getUTCDay() + 6) % 7; // Monday 0
+    return iso(t - weekday * DAY);
+}
+export async function workload(env, from, weeks) {
+    const start = Date.parse(`${mondayOf(from)}T00:00:00Z`);
+    const mondays = Array.from({ length: weeks }, (_, i) => iso(start + i * 7 * DAY));
+    const last = iso(start + weeks * 7 * DAY - DAY);
+    const everyone = env.administrator || env.groups.has('project.manager');
+    const first = mondays[0] ?? last;
+    const where = {
+        'project.active': true,
+        ...(everyone ? {} : { user: env.userId }),
+    };
+    const all = await env.asSuperuser({ reason: 'workload' }, async (su) => (await su
+        .model('project.member')
+        .search({ where: where })
+        .then((r) => r.load({ user: ['name'], project: ['name'] }))).map((m) => ({
+        user: m.user.id,
+        name: String(m.user.name),
+        project: m.project.id,
+        projectName: String(m.project.name),
+        allocation: m.allocation,
+        from: m.dateFrom === null ? null : String(m.dateFrom),
+        to: m.dateTo === null ? null : String(m.dateTo),
+    })));
+    // Memberships that touch the weeks shown.
+    const members = all.filter((m) => (m.from === null || m.from <= last) && (m.to === null || m.to >= first));
+    const byUser = new Map();
+    for (const m of members)
+        byUser.set(m.user, [...(byUser.get(m.user) ?? []), m]);
+    const people = [...byUser.values()]
+        .map((rows) => ({
+        user: rows[0]?.user ?? 0,
+        name: rows[0]?.name ?? '',
+        weeks: mondays.map((monday) => peakAllocation(rows, monday, iso(Date.parse(`${monday}T00:00:00Z`) + 6 * DAY))),
+        projects: rows.map((r) => ({
+            id: r.project,
+            name: r.projectName,
+            allocation: r.allocation,
+            from: r.from,
+            to: r.to,
+        })),
+    }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+    return { weeks: mondays, people };
+}
+/** A date-only value as `YYYY-MM-DD` (PostgreSQL dates may read as local midnights). */
+function isoDate(v) {
+    if (v === null || v === undefined || v === '')
+        return null;
+    if (!(v instanceof Date))
+        return String(v).slice(0, 10);
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${v.getFullYear()}-${pad(v.getMonth() + 1)}-${pad(v.getDate())}`;
+}
+/**
+ * The booked and committed costs and the health of the active projects (`ids`, or all of the company), as the
+ * system: the bridges' figures through `moneyOf()`, then the worst of schedule, late milestones and cost against the
+ * company's thresholds. Returns how many were refreshed.
+ */
+export async function refreshProjects(su, ids) {
+    const found = await su.model('project.project').search({
+        where: { active: true, ...(ids === undefined ? {} : { id: { in: ids } }) },
+    });
+    if (found.ids.length === 0)
+        return 0;
+    const projects = await found.load({ company: true });
+    const money = await su.model('project.project').browse(found.ids).moneyOf();
+    const today = isoDate(su.today()) ?? new Date().toISOString().slice(0, 10);
+    const late = new Map();
+    for (const t of await su
+        .model('project.task')
+        .search({
+        where: {
+            project: { in: found.ids },
+            milestone: true,
+            done: false,
+            deadline: { lt: today },
+        },
+    })
+        .then((r) => r.load(['project'])))
+        late.set(t.project.id, (late.get(t.project.id) ?? 0) + 1);
+    const rules = new Map();
+    for (const p of projects) {
+        const company = p.company.id;
+        let r = rules.get(company);
+        if (r === undefined) {
+            const [c] = (await su
+                .model('res.company')
+                .browse([company])
+                .load(['projectHealthBehindRisk', 'projectHealthBehindOff', 'projectHealthCostRisk'])).read(['projectHealthBehindRisk', 'projectHealthBehindOff', 'projectHealthCostRisk']);
+            r = {
+                behindRisk: Number(c?.['projectHealthBehindRisk'] ?? 10),
+                behindOff: Number(c?.['projectHealthBehindOff'] ?? 25),
+                costRisk: Number(c?.['projectHealthCostRisk'] ?? 90),
+            };
+            rules.set(company, r);
+        }
+        const figures = money.get(p.id) ?? { booked: '0', committed: '0' };
+        const spent = Number(p.labourCost ?? 0) + Number(figures.booked) + Number(figures.committed);
+        const judged = judgeHealth({
+            today,
+            dateStart: isoDate(p.dateStart),
+            dateEnd: isoDate(p.dateEnd),
+            progress: Number(p.progress ?? 0),
+            milestonesLate: late.get(p.id) ?? 0,
+            budget: Number(p.budget ?? 0),
+            spent,
+        }, r);
+        await su
+            .model('project.project')
+            .browse([p.id])
+            .write({
+            bookedCost: figures.booked,
+            committedCost: figures.committed,
+            healthComputed: judged.health,
+            healthNotes: judged.reasons.join(' '),
+            healthCheckedAt: new Date(),
+        });
+    }
+    await repeatTasks(su, found.ids, today);
+    // Phases past their end and not finished: late (what the overview and the Late filter read).
+    const phases = await su
+        .model('project.phase')
+        .search({ where: { project: { in: found.ids } } })
+        .then((r) => r.load(['dateEnd', 'status', 'late']));
+    for (const ph of phases) {
+        const end = isoDate(ph.dateEnd);
+        const late = end !== null && end < today && !['done', 'cancelled'].includes(ph.status);
+        if (late !== ph.late)
+            await su
+                .model('project.phase')
+                .browse([ph.id])
+                .write({ late });
+    }
+    await su.flush();
+    return projects.length;
+}
+/** `date` moved by `n` days, weeks or months. */
+export function shiftDate(date, n, unit) {
+    const d = new Date(`${date}T00:00:00Z`);
+    if (unit === 'month')
+        d.setUTCMonth(d.getUTCMonth() + n);
+    else
+        d.setUTCDate(d.getUTCDate() + n * (unit === 'week' ? 7 : 1));
+    return d.toISOString().slice(0, 10);
+}
+/** For each repeating task done in `projects` with no next one yet: the next one, its dates moved, until its end. */
+async function repeatTasks(su, projects, today) {
+    const done = await su
+        .model('project.task')
+        .search({
+        where: {
+            project: { in: projects },
+            done: true,
+            repeatEvery: { gt: 0 },
+            nextTask: { isNull: true },
+        },
+    })
+        .then((r) => r.load({ assignees: ['id'], tags: ['id'] }));
+    if (done.length === 0)
+        return 0;
+    const [open] = await su
+        .model('project.task.stage')
+        .search({ where: { done: false }, order: ['sequence asc'], limit: 1 })
+        .then((r) => r.load(['id']));
+    let made = 0;
+    for (const t of done) {
+        const every = Number(t.repeatEvery ?? 0);
+        const unit = String(t.repeatUnit ?? 'week');
+        const start = isoDate(t.dateStart);
+        const end = isoDate(t.deadline);
+        const nextEnd = end === null ? null : shiftDate(end, every, unit);
+        const nextStart = start === null ? null : shiftDate(start, every, unit);
+        const until = isoDate(t.repeatUntil);
+        const first = nextStart ?? nextEnd ?? shiftDate(today, every, unit);
+        if (until !== null && first > until)
+            continue;
+        const created = await su.model('project.task').create([
+            {
+                name: t.name,
+                project: t.project.id,
+                phase: t.phase?.id ?? null,
+                workPackage: t.workPackage?.id ?? null,
+                category: t.category?.id ?? null,
+                partner: t.partner?.id ?? null,
+                assignee: t.assignee?.id ?? null,
+                assignees: { set: [...t.assignees].map((a) => a.id) },
+                tags: { set: [...t.tags].map((x) => x.id) },
+                priority: t.priority,
+                milestone: t.milestone,
+                plannedHours: t.plannedHours,
+                description: t.description,
+                dateStart: nextStart,
+                deadline: nextEnd,
+                repeatEvery: t.repeatEvery,
+                repeatUnit: t.repeatUnit,
+                repeatUntil: t.repeatUntil,
+                ...(open === undefined ? {} : { stage: open.id }),
+            },
+        ]);
+        await su
+            .model('project.task')
+            .browse([t.id])
+            .write({ nextTask: created.ids[0] });
+        made += 1;
+    }
+    return made;
+}
+export function registerProjectRoutes(context) {
+    const { app, shutro } = context;
+    configureProjectChatter(chatterContext(context));
+    app.post('/api/v1/projects/refresh', async (request) => {
+        const body = (request.body ?? {});
+        const ids = Array.isArray(body.projects)
+            ? body.projects.filter((x) => Number.isSafeInteger(x))
+            : undefined;
+        return request.env(async (raw) => {
+            const env = raw;
+            if (!env.administrator && !env.groups.has('project.manager'))
+                throw new HttpProblem(403, 'access', 'Projects managers', 'This needs the Projects manager role.');
+            // The projects as the manager sees them, refreshed as the system.
+            const visible = ids === undefined
+                ? undefined
+                : (await env.model('project.project').search({ where: { id: { in: ids } } }))
+                    .ids;
+            return env.asSuperuser({ reason: 'project figures' }, async (su) => ({
+                refreshed: await refreshProjects(su, visible),
+            }));
+        }, { write: true });
+    });
+    app.get('/api/v1/projects/workload', async (request) => {
+        const query = request.query;
+        const from = query.from ?? new Date().toISOString().slice(0, 10);
+        const weeks = query.weeks === undefined ? 12 : Number(query.weeks);
+        if (!/^\d{4}-\d{2}-\d{2}$/.test(from) || Number.isNaN(Date.parse(from)))
+            throw new HttpProblem(422, 'invalid-date', 'Which week?', 'Give `from` as YYYY-MM-DD.');
+        if (!Number.isInteger(weeks) || weeks < 1 || weeks > 52)
+            throw new HttpProblem(422, 'invalid-weeks', 'How many weeks?', '`weeks` is from 1 to 52.');
+        // asSuperuser writes an audit row: the request runs in a write scope.
+        return request.env(async (raw) => {
+            const env = raw;
+            if (!env.administrator && !env.groups.has('project.user'))
+                throw new HttpProblem(403, 'access', 'Projects users', 'This needs a Projects role.');
+            return workload(env, from, weeks);
+        }, { write: true });
+    });
+    const projectId = (request) => {
+        const id = Number(request.params.id);
+        if (!Number.isSafeInteger(id) || id <= 0)
+            throw new HttpProblem(404, 'missing-record', 'Not found', 'No such project.');
+        return id;
+    };
+    const seenProject = async (env, id) => {
+        const seen = await env.model('project.project').search({ where: { id: id } });
+        if (seen.ids.length === 0)
+            throw new HttpProblem(404, 'missing-record', 'Not found', 'No such project of yours.');
+    };
+    app.get('/api/v1/projects/:id/schedule', async (request) => {
+        const id = projectId(request);
+        return request.env(async (raw) => {
+            const env = raw;
+            await seenProject(env, id);
+            return scheduleOf(env, id);
+        });
+    });
+    app.post('/api/v1/projects/:id/schedule/apply', async (request) => {
+        const id = projectId(request);
+        return request.env(async (raw) => {
+            const env = raw;
+            await seenProject(env, id);
+            return { moved: await applySlips(env, id) };
+        }, { write: true });
+    });
+    if (process.env['KOSH_SCHEDULES'] === 'off')
+        return;
+    const run = async () => {
+        try {
+            const companies = await shutro.bootstrap({ reason: 'project figures' }, async (env) => (await env.model('res.company').search({}))
+                .ids);
+            for (const company of companies)
+                await shutro.bootstrap({ reason: 'project figures', company }, (env) => env.asSuperuser({ reason: 'project figures' }, (su) => refreshProjects(su)));
+        }
+        catch (error) {
+            app.log.error({ err: error }, 'project figures');
+        }
+    };
+    const timer = setInterval(() => void run(), 3_600_000);
+    timer.unref();
+    app.addHook('onClose', async () => clearInterval(timer));
+}

package/dist/project/schedule.d.ts

@@ -0,0 +1,72 @@
+/**
+ * A project's schedule (RFC 0026 step 5): finish-to-start dependencies with a lag in days, the critical path by the
+ * critical path method, and moving tasks that start before what they wait for is finished (keeping their length).
+ * Dates are `YYYY-MM-DD`; a task's end is its deadline (inclusive). The pure functions are unit-tested; the database
+ * ones run as the caller, so record rules decide what is scheduled.
+ */
+import type { Env } from './.kosh/bindings.js';
+export interface PlanTask {
+    readonly id: number;
+    readonly start: string | null;
+    readonly end: string | null;
+    /** Planned hours: the length in days (8 hours a day) of a task without both dates. */
+    readonly hours: number;
+    readonly predecessors: readonly {
+        readonly id: number;
+        readonly lag: number;
+    }[];
+}
+export interface Scheduled {
+    readonly id: number;
+    /** Earliest start and finish (inclusive), latest start and finish, as dates. */
+    readonly earlyStart: string;
+    readonly earlyFinish: string;
+    readonly lateStart: string;
+    readonly lateFinish: string;
+    /** Days it may slip without moving the project's end. */
+    readonly float: number;
+    readonly critical: boolean;
+}
+/**
+ * The critical path method over `tasks` from `projectStart`: each task starts no earlier than its own start (when set)
+ * and the day after each predecessor finishes plus the lag; the project ends with the last finish; working back,
+ * each task's latest dates and its float. Tasks with no float are critical.
+ */
+export declare function criticalPath(tasks: readonly PlanTask[], projectStart: string): Scheduled[];
+/**
+ * The moves that put every dated task after what it waits for: a task starting before the day after a predecessor's
+ * end plus the lag moves later, its end with it (its length kept); what waits for it follows in turn.
+ */
+export declare function slipMoves(tasks: readonly PlanTask[]): {
+    id: number;
+    start: string;
+    end: string;
+    days: number;
+}[];
+export interface ScheduleRow extends Scheduled {
+    readonly name: string;
+    readonly start: string | null;
+    readonly end: string | null;
+    readonly baselineStart: string | null;
+    readonly baselineEnd: string | null;
+    readonly done: boolean;
+    readonly milestone: boolean;
+    readonly progress: number;
+    readonly predecessors: readonly {
+        readonly id: number;
+        readonly lag: number;
+    }[];
+}
+/** The schedule of a project: each task's dates, baseline, float and whether it is critical. */
+export declare function scheduleOf(env: Env, project: number): Promise<{
+    start: string;
+    end: string;
+    tasks: ScheduleRow[];
+}>;
+/** Moves the project's tasks that start before what they wait for is finished; returns the moves. */
+export declare function applySlips(env: Env, project: number): Promise<{
+    id: number;
+    start: string;
+    end: string;
+    days: number;
+}[]>;

package/dist/project/schedule.js

@@ -0,0 +1,192 @@
+const DAY = 86_400_000;
+const toDay = (iso) => Math.round(Date.parse(`${iso}T00:00:00Z`) / DAY);
+const toIso = (day) => new Date(day * DAY).toISOString().slice(0, 10);
+/** The tasks in an order where each comes after what it waits for (links are acyclic: a constraint keeps them so). */
+function ordered(tasks) {
+    const byId = new Map(tasks.map((t) => [t.id, t]));
+    const out = [];
+    const seen = new Set();
+    const visit = (t, path) => {
+        if (seen.has(t.id) || path.has(t.id))
+            return;
+        path.add(t.id);
+        for (const p of t.predecessors) {
+            const pred = byId.get(p.id);
+            if (pred !== undefined)
+                visit(pred, path);
+        }
+        seen.add(t.id);
+        out.push(t);
+    };
+    for (const t of tasks)
+        visit(t, new Set());
+    return out;
+}
+/** The length of a task in days (at least one). */
+function lengthOf(t) {
+    if (t.start !== null && t.end !== null)
+        return Math.max(toDay(t.end) - toDay(t.start) + 1, 1);
+    return Math.max(Math.ceil(t.hours / 8), 1);
+}
+/**
+ * The critical path method over `tasks` from `projectStart`: each task starts no earlier than its own start (when set)
+ * and the day after each predecessor finishes plus the lag; the project ends with the last finish; working back,
+ * each task's latest dates and its float. Tasks with no float are critical.
+ */
+export function criticalPath(tasks, projectStart) {
+    const order = ordered(tasks);
+    const ids = new Set(tasks.map((t) => t.id));
+    const es = new Map();
+    const ef = new Map();
+    const base = toDay(projectStart);
+    for (const t of order) {
+        let start = t.start === null ? base : toDay(t.start);
+        for (const p of t.predecessors) {
+            const finish = ef.get(p.id);
+            if (finish !== undefined)
+                start = Math.max(start, finish + 1 + p.lag);
+        }
+        es.set(t.id, start);
+        ef.set(t.id, start + lengthOf(t) - 1);
+    }
+    const end = Math.max(...[...ef.values()], base);
+    const successors = new Map();
+    for (const t of tasks)
+        for (const p of t.predecessors)
+            if (ids.has(p.id))
+                successors.set(p.id, [...(successors.get(p.id) ?? []), { id: t.id, lag: p.lag }]);
+    const ls = new Map();
+    const lf = new Map();
+    for (const t of [...order].reverse()) {
+        let finish = end;
+        for (const s of successors.get(t.id) ?? []) {
+            const start = ls.get(s.id);
+            if (start !== undefined)
+                finish = Math.min(finish, start - 1 - s.lag);
+        }
+        lf.set(t.id, finish);
+        ls.set(t.id, finish - lengthOf(t) + 1);
+    }
+    return tasks.map((t) => {
+        const float = (ls.get(t.id) ?? 0) - (es.get(t.id) ?? 0);
+        return {
+            id: t.id,
+            earlyStart: toIso(es.get(t.id) ?? base),
+            earlyFinish: toIso(ef.get(t.id) ?? base),
+            lateStart: toIso(ls.get(t.id) ?? base),
+            lateFinish: toIso(lf.get(t.id) ?? base),
+            float,
+            critical: float <= 0,
+        };
+    });
+}
+/**
+ * The moves that put every dated task after what it waits for: a task starting before the day after a predecessor's
+ * end plus the lag moves later, its end with it (its length kept); what waits for it follows in turn.
+ */
+export function slipMoves(tasks) {
+    const order = ordered(tasks);
+    const start = new Map();
+    const end = new Map();
+    for (const t of tasks) {
+        start.set(t.id, t.start === null ? null : toDay(t.start));
+        end.set(t.id, t.end === null ? null : toDay(t.end));
+    }
+    const moves = [];
+    for (const t of order) {
+        const s = start.get(t.id) ?? null;
+        if (s === null)
+            continue;
+        let required = s;
+        for (const p of t.predecessors) {
+            const finish = end.get(p.id);
+            if (finish !== undefined && finish !== null)
+                required = Math.max(required, finish + 1 + p.lag);
+        }
+        if (required === s)
+            continue;
+        const days = required - s;
+        const e = end.get(t.id) ?? null;
+        const newEnd = e === null ? required + lengthOf(t) - 1 : e + days;
+        start.set(t.id, required);
+        end.set(t.id, newEnd);
+        moves.push({ id: t.id, start: toIso(required), end: toIso(newEnd), days });
+    }
+    return moves;
+}
+/** A date-only value as `YYYY-MM-DD`. */
+function isoDate(v) {
+    if (v === null || v === undefined || v === '')
+        return null;
+    if (!(v instanceof Date))
+        return String(v).slice(0, 10);
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${v.getFullYear()}-${pad(v.getMonth() + 1)}-${pad(v.getDate())}`;
+}
+/** A project's top-level tasks as the caller sees them, for the schedule. */
+async function planOf(env, project) {
+    const [p] = await env
+        .model('project.project')
+        .browse([project])
+        .load(['dateStart']);
+    const found = await env
+        .model('project.task')
+        .search({ where: { project, parentTask: { isNull: true } } })
+        .then((r) => r.load({
+        predecessors: ['predecessor', 'lag'],
+    }));
+    const rows = new Map();
+    const tasks = [];
+    for (const t of found) {
+        const predecessors = [...t.predecessors].map((l) => ({
+            id: l.predecessor.id,
+            lag: Number(l.lag ?? 0),
+        }));
+        const start = isoDate(t.dateStart);
+        const end = isoDate(t.deadline);
+        tasks.push({
+            id: t.id,
+            start,
+            end,
+            hours: Number(t.plannedHours ?? 0),
+            predecessors,
+        });
+        rows.set(t.id, {
+            name: String(t.name),
+            start,
+            end,
+            baselineStart: isoDate(t.baselineStart),
+            baselineEnd: isoDate(t.baselineEnd),
+            done: t.done === true,
+            milestone: t.milestone === true,
+            progress: Number(t.progress ?? 0),
+            predecessors,
+        });
+    }
+    const starts = tasks.flatMap((t) => (t.start === null ? [] : [t.start])).sort();
+    const start = isoDate(p?.dateStart) ?? starts[0] ?? new Date().toISOString().slice(0, 10);
+    return { tasks, rows, start };
+}
+/** The schedule of a project: each task's dates, baseline, float and whether it is critical. */
+export async function scheduleOf(env, project) {
+    const { tasks, rows, start } = await planOf(env, project);
+    const scheduled = criticalPath(tasks, start);
+    const out = scheduled.map((s) => ({
+        ...rows.get(s.id),
+        ...s,
+    }));
+    out.sort((a, b) => a.earlyStart.localeCompare(b.earlyStart) || a.id - b.id);
+    const end = out.reduce((m, r) => (r.earlyFinish > m ? r.earlyFinish : m), start);
+    return { start, end, tasks: out };
+}
+/** Moves the project's tasks that start before what they wait for is finished; returns the moves. */
+export async function applySlips(env, project) {
+    const { tasks } = await planOf(env, project);
+    const moves = slipMoves(tasks);
+    for (const m of moves)
+        await env
+            .model('project.task')
+            .browse([m.id])
+            .write({ dateStart: m.start, deadline: m.end });
+    return moves;
+}

package/dist/project/web/Refresh.d.ts

@@ -0,0 +1,8 @@
+/**
+ * "Refresh the figures" on a project (RFC 0026 step 4), a node component of the project form: the booked and
+ * committed costs from the bridges and the health, now, through `POST /api/v1/projects/refresh`; the form reloads.
+ * Shown to Projects managers (the money fields are theirs to see); the server decides.
+ */
+import { type NodeComponentProps } from '../../ui/index.js';
+import { type ReactElement } from 'react';
+export declare function Refresh({ api, record, model, served, reload, }: NodeComponentProps): ReactElement | null;

package/dist/project/web/Refresh.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * "Refresh the figures" on a project (RFC 0026 step 4), a node component of the project form: the booked and
+ * committed costs from the bridges and the health, now, through `POST /api/v1/projects/refresh`; the form reloads.
+ * Shown to Projects managers (the money fields are theirs to see); the server decides.
+ */
+import { Alert, Button } from '../../ui/index.js';
+import { useMutation } from '@tanstack/react-query';
+import { useState } from 'react';
+import { useTranslation } from 'react-i18next';
+export function Refresh({ api, record, model, served, reload, }) {
+    const { t } = useTranslation('project');
+    const [error, setError] = useState(null);
+    const refresh = useMutation({
+        mutationFn: () => api.call('POST', '/api/v1/projects/refresh', {
+            projects: [record?.id],
+        }),
+        onSuccess: () => {
+            setError(null);
+            reload();
+        },
+        onError: (e) => setError(e.message),
+    });
+    if (record === null || typeof record.id !== 'number')
+        return null;
+    if (served.fields[model]?.['budget'] === undefined)
+        return null;
+    return (_jsxs("div", { className: "grid gap-2", children: [error === null ? null : _jsx(Alert, { tone: "danger", children: error }), _jsx("div", { children: _jsx(Button, { busy: refresh.isPending, onClick: () => refresh.mutate(), children: t('refresh.button') }) })] }));
+}

package/dist/project/web/Schedule.d.ts

@@ -0,0 +1,9 @@
+/**
+ * A project's schedule (RFC 0026 step 5), a node component of the project form: its tasks as bars over the weeks from
+ * the project's start to its end, the baseline as a thin bar beneath each, the critical path in red, arrows from each
+ * task to what waits for it, milestones as diamonds. "Move waiting tasks" puts tasks that start before what they wait
+ * for is finished after it, keeping their length (`POST /api/v1/projects/:id/schedule/apply`). Read as the user.
+ */
+import { type NodeComponentProps } from '../../ui/index.js';
+import { type ReactElement } from 'react';
+export declare function Schedule({ api, record, version, reload, }: NodeComponentProps): ReactElement | null;