@cyc-seattle/platform 1.39.2 → 1.39.4

package/dist/planning/staffing.d.ts

@@ -22,13 +22,10 @@ export interface DoubleBooked {
 export declare function enrollmentOf(offering: PlanOffering): number;
 export declare class Staffing {
     private readonly ctx;
-    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;
     /**
      * 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
@@ -39,12 +36,11 @@ export declare class Staffing {
     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;
     /**
      * 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.
+     * sailors count against its own sailors per coach, and need coaches at its own staff level. A
+     * salaried position on the block counts as a coach for any of its programs, since the plan trusts
+     * the planner's allocation (#208). Boats count the ones sailors bring.
      */
     private checkCapacity;
     /**

package/dist/planning/staffing.js

@@ -41,13 +41,9 @@ function groupBy(rows, key) {
 }
 export class Staffing {
     ctx;
-    covers = new Map();
     warned = new Set();
     constructor(ctx) {
         this.ctx = ctx;
-        for (const c of ctx.data.qualification_covers) {
-            this.covers.set(c.qualification_id, new Set([...(this.covers.get(c.qualification_id) ?? []), c.covers_id]));
-        }
     }
     /** Warns once for each row and plan copy, about the first date it's seen on. */
     warnOnce(code, message, key, scope = {}) {
@@ -57,21 +53,6 @@ export class Staffing {
         this.warned.add(id);
         this.ctx.warn(code, message, key, scope);
     }
-    /** Whether holding `held` qualifies for `required`, through `qualification_covers`. */
-    qualifies(held, required) {
-        const seen = new Set();
-        const stack = [...held];
-        while (stack.length > 0) {
-            const q = stack.pop();
-            if (q === required)
-                return true;
-            if (seen.has(q))
-                continue;
-            seen.add(q);
-            stack.push(...(this.covers.get(q) ?? []));
-        }
-        return false;
-    }
     /**
      * 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
@@ -147,18 +128,11 @@ export class Staffing {
     programs() {
         return new Map(this.ctx.data.plan_programs.map((p) => [p.product_id, p]));
     }
-    /** Whether a staff member holding `held`, at level `levelKey` if any, may coach a program coached at `required`. */
-    qualifiedFor(held, levelKey, required) {
-        if (levelKey === required)
-            return true;
-        const level = this.ctx.data.plan_staff_levels.find((l) => l.key === required);
-        const needed = level?.qualifications ?? [];
-        return needed.length > 0 && needed.every((q) => this.qualifies(held, q));
-    }
     /**
      * 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.
+     * sailors count against its own sailors per coach, and need coaches at its own staff level. A
+     * salaried position on the block counts as a coach for any of its programs, since the plan trusts
+     * the planner's allocation (#208). Boats count the ones sailors bring.
      */
     checkCapacity(block, programs) {
         const { ctx } = this;
@@ -171,9 +145,9 @@ export class Staffing {
         const scope = { version_id: block.row.version_id, date: block.row.date };
         // The block's offerings, with the verb that agrees with them: "Guppies Week 2 has".
         const has = `${offeringsOf(block)} ${new Set(block.members.map((a) => a.offering.id)).size > 1 ? "have" : "has"}`;
-        let load = 0;
+        // Coaches each level needs, from the sailors of the programs coached at it.
+        const needed = new Map();
         let counted = 0;
-        const required = [];
         for (const o of offerings) {
             const settings = programs.get(o.product_id);
             if (settings?.staff_level_key == null || settings.sailors_per_coach == null || settings.sailors_per_coach <= 0) {
@@ -181,24 +155,25 @@ export class Staffing {
                 continue;
             }
             const n = ctx.enrollment.get(o.id) ?? 0;
-            load += n / settings.sailors_per_coach;
+            needed.set(settings.staff_level_key, (needed.get(settings.staff_level_key) ?? 0) + n / settings.sailors_per_coach);
             counted += n;
-            required.push(settings.staff_level_key);
         }
         if (counted > 0) {
-            const levels = new Map(ctx.data.plan_staff_levels.map((l) => [l.key, l]));
-            const positions = new Map(ctx.data.plan_salaried_positions.map((p) => [p.key, p]));
-            const qualified = sum(block.staff.map((s) => {
-                const held = s.position_key != null
-                    ? (positions.get(s.position_key)?.qualifications ?? [])
-                    : (levels.get(s.staff_level_key ?? "")?.qualifications ?? []);
-                const level = s.position_key != null ? null : s.staff_level_key;
-                return required.some((r) => this.qualifiedFor(held, level, r)) ? s.count : 0;
-            }));
-            if (load > qualified + 1e-9) {
-                ctx.warn("over_capacity", qualified === 0
-                    ? `${has} ${countOf(counted, "sailor")} and no qualified coach`
-                    : `${has} ${countOf(counted, "sailor")}, but enough qualified coaches for only ${Math.floor((qualified * counted) / load + 1e-9)}`, block.row.key, scope);
+            const load = sum(needed.values());
+            // Each level's staff cover only its own programs; salaried positions cover what's left.
+            let short = 0;
+            let covered = 0;
+            for (const [level, need] of needed) {
+                const have = sum(block.staff.filter((s) => s.position_key == null && s.staff_level_key === level).map((s) => s.count));
+                covered += Math.min(need, have);
+                short += Math.max(0, need - have);
+            }
+            const salaried = sum(block.staff.filter((s) => s.position_key != null).map((s) => s.count));
+            covered += Math.min(short, salaried);
+            if (load > covered + 1e-9) {
+                ctx.warn("over_capacity", covered === 0
+                    ? `${has} ${countOf(counted, "sailor")} and no coach`
+                    : `${has} ${countOf(counted, "sailor")}, but enough coaches for only ${Math.floor((covered * counted) / load + 1e-9)}`, block.row.key, scope);
             }
         }
         if (!block.members.some((a) => a.uses_boats))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cyc-seattle/platform",
-  "version": "1.39.2",
+  "version": "1.39.4",
   "description": "Pulumi components for CYC's shared Google Cloud platform: WebService, the platform outputs reader, and the stacks that build the platform",
   "author": "CYC Community Sailing Center",
   "license": "Apache-2.0",