@cyc-seattle/platform 1.36.0 → 1.37.0

package/dist/planning/activities.js

@@ -32,7 +32,7 @@ export function scheduleActivities(ctx) {
         const span = start !== null && end !== null ? end - start : 0;
         const closedFor = closed.get(activity.date);
         if (closedFor !== undefined && activity.kind !== "travel") {
-            ctx.warn("closed_date", `${offering.name} has an activity on ${activity.date}, a closed day: ${closedFor}`, activity.key);
+            ctx.warn("closed_date", `${offering.name} has an activity on ${activity.date}, a closed day: ${closedFor}`, activity.key, { version_id: activity.version_id, date: activity.date });
         }
         const usesBoats = activity.kind !== "travel" && activity.uses_boats;
         result.push({

package/dist/planning/context.d.ts

@@ -1,4 +1,9 @@
 import type { Account, AccountFunction, CostCenterType, CostType, DateString, EngineWarning, Id, PlanData, PlanOffering, Plan, PlanRates, Product, ProgramArea } from "./types.ts";
+/** Where a warning applies: a plan copy, and a date. */
+export interface WarningScope {
+    version_id?: Id;
+    date?: DateString;
+}
 /** The step that recorded an entry. Only `direct` entries count toward MTDC. */
 export type Stage = "direct" | "pool" | "bonus";
 /** One amount, in fractional cents, before lines are rounded and summed. */
@@ -45,7 +50,7 @@ export declare class Context {
     constructor(data: PlanData);
     /** The account the organization records a calculated cost type in. */
     costAccount(type: CostType): Id | undefined;
-    warn(code: string, message: string, key?: string): void;
+    warn(code: string, message: string, key?: string, scope?: WarningScope): void;
     book(entry: EntryInput): void;
     /**
      * An entry's function: the line's if set. Otherwise a cost charged to a program is `program`

package/dist/planning/context.js

@@ -1,4 +1,13 @@
 import { fiscalYearDates, within } from "./dates.js";
+/** The warnings about what the blocks are given, or when they run. The rest are about the data. */
+const ALLOCATION_WARNINGS = new Set([
+    "over_inventory_boats",
+    "over_inventory_resource",
+    "over_capacity",
+    "unallocated_activity",
+    "closed_date",
+    "position_double_booked",
+]);
 /** Lookups over the input, and the entries recorded so far, shared by every step. */
 export class Context {
     /** The plan year's first and last days. */
@@ -47,10 +56,19 @@ export class Context {
         }
         return account;
     }
-    warn(code, message, key) {
-        if (this.warnings.some((w) => w.code === code && w.message === message))
+    warn(code, message, key, scope = {}) {
+        const same = (w) => w.code === code && w.message === message && w.version_id === scope.version_id;
+        if (this.warnings.some(same))
             return;
-        this.warnings.push(key === undefined ? { code, message } : { code, message, key });
+        const category = ALLOCATION_WARNINGS.has(code) ? "allocation" : "data";
+        this.warnings.push({
+            code,
+            message,
+            category,
+            ...(key !== undefined && { key }),
+            ...(scope.version_id !== undefined && { version_id: scope.version_id }),
+            ...(scope.date !== undefined && { date: scope.date }),
+        });
     }
     book(entry) {
         if (entry.amount === 0 || !Number.isFinite(entry.amount))

package/dist/planning/engine.js

@@ -77,7 +77,7 @@ function summarizePositions(ctx, coaching, charged, bonuses, doubleBooked) {
     ];
     for (const key of new Set(named)) {
         if (!known.has(key)) {
-            ctx.warn("unknown_position", `A block, offering or bonus names missing salaried position ${key}`, key);
+            ctx.warn("unknown_position", `A block or bonus names missing salaried position ${key}`, key);
         }
     }
     return ctx.data.plan_salaried_positions.map((position) => {

package/dist/planning/staffing.d.ts

@@ -11,61 +11,61 @@ export interface SalariedCoaching {
     /** The wages for `hourly` hours. */
     wages: number;
 }
-/** A salaried position's year of coaching two groups at once. */
+/** A salaried position's year of coaching two blocks at once. */
 export interface DoubleBooked {
-    /** Hours another coach would need: n − 1 for each hour it's on n groups at once. */
+    /** Hours another coach would need: n − 1 for each hour it's on n blocks at once. */
     hours: number;
-    /** Dates it's on two groups at once. */
+    /** Dates it's on two blocks at once. */
     dates: number;
 }
 /** Whole kids: `target_enrollment` if set, otherwise `capacity × fill_rate` rounded. */
 export declare function enrollmentOf(offering: PlanOffering): number;
 export declare class Staffing {
     private readonly ctx;
-    private readonly boatClasses;
-    private readonly offeringBoatClasses;
     private readonly covers;
     private readonly warned;
     constructor(ctx: Context);
+    /** Warns once for each row and plan copy, about the first date it's seen on. */
     private warnOnce;
     /** Whether holding `held` qualifies for `required`, through `qualification_covers`. */
     qualifies(held: Id[], required: Id): boolean;
-    private levelFor;
-    private sailorsByClass;
-    private boatsFor;
-    private initial;
-    private blockFor;
     /**
-     * Staffs a block's activities on one date as one group, then gives each activity its share. A
-     * count an activity fixes keeps it out of that part of the group.
+     * Gathers each block's activities, times and allocations. A block's paid time runs from its first
+     * activity's start to its last one's end, plus the longest setup and put-away. Its time on the
+     * water is the longest `on_water_minutes` its activities set, or else the span of those that sail.
      */
-    private staffBlock;
-    /** An offering's named coach, on an activity outside any block: one of its coaches. */
-    private staffNamedCoach;
+    private blocks;
+    /** Warns about each activity, other than travel, that's in no block, or in one with no staff. */
+    private checkUnallocated;
+    /** Each program's settings, by its product. */
+    private programs;
+    /** Whether a staff member holding `held`, at level `levelKey` if any, may coach a program coached at `required`. */
+    private qualifiedFor;
     /**
-     * Splits a block's activities on one date into groups whose times overlap. An activity with no
-     * times overlaps every other.
+     * Warns when a block's sailors are more than its staff or its boats can safely take. Each program's
+     * sailors count against its own sailors per coach, and a coach counts if they're at the staff
+     * level of one of the block's programs, or qualified for it. Boats count the ones sailors bring.
      */
-    private overlapping;
+    private checkCapacity;
     /**
-     * Warns when a salaried position coaches two activities at once that aren't staffed as one block
-     * group. It's still charged to both. Returns each position's double-booked hours and dates.
+     * Warns when the organization's boats of one class, or a resource such as RIBs, are given to more
+     * blocks at once on a date than it has. Boats sailors bring don't count.
      */
-    private checkDoubleBooked;
+    private checkInventory;
     /**
-     * One RIB's hourly and daily cost, averaged over the RIB resources by `quantity`, and the part of
-     * it from resources excluded from MTDC, such as rentals.
+     * Warns when a salaried position coaches two blocks whose times overlap. It's still charged to
+     * both. Returns each position's double-booked hours and dates.
      */
-    private ribRate;
-    /** Staffs every activity, and records what its coaches, RIBs, boats and resources cost. */
+    private checkDoubleBooked;
+    /** Costs every block's staff, RIBs, boats and resources, and checks them against the limits. */
     run(scheduled: ScheduledActivity[]): {
         activities: ComputedActivity[];
         coaching: SalariedCoaching[];
         doubleBooked: Map<Id, DoubleBooked>;
     };
     /**
-     * A trip's coaches each fly and stay; the miles are driven once. Its coaches are those of its
-     * travel days; with none, the offering's coaching ratio sets them.
+     * A trip's coaches each fly and stay; the miles are driven once. Its coaches are the staff on the
+     * block of its busiest travel day.
      */
     private bookTrips;
 }