@7365admin1/layer-common 4.135.0 → 4.137.0

package/utils/schedule-task.ts

@@ -176,12 +176,20 @@ export function validateSchedule(f: TScheduleForm, now: Date = new Date()): TSch
   return e;
 }
 
-/** "at 08:00 every weekday from 21 Oct until 31 Dec" - the When, as a sentence fragment. */
+/** "08:00" -> "8:00 am", "14:30" -> "2:30 pm". Anything else is returned as given. */
+export function fmtTime(time: string | null | undefined): string {
+  const m = TIME_RE.exec(time || "");
+  if (!m) return time || "";
+  const h = Number(m[1]);
+  return `${h % 12 || 12}:${m[2]} ${h < 12 ? "am" : "pm"}`;
+}
+
+/** "every weekday at 8:00 am from 21 Oct until 31 Dec" - the When, as a sentence fragment. */
 export function describeWhen(
   t: Partial<TRule> & { time?: string },
   nowYear?: string,
 ): string {
-  const time = t.time ? `at ${t.time} ` : "";
+  const at = t.time ? ` at ${fmtTime(t.time)}` : "";
   const repeat = t.repeat || "none";
   const dates = t.dates || [];
   const range =
@@ -189,23 +197,23 @@ export function describeWhen(
     (t.endDate ? ` until ${fmtDate(t.endDate, nowYear)}` : "");
   switch (repeat) {
     case "daily":
-      return `${time}every day${range}`;
+      return `every day${at}${range}`;
     case "weekdays":
-      return `${time}every weekday${range}`;
+      return `every weekday${at}${range}`;
     case "weekly": {
       const names = WEEK_DAYS.filter((d) => (t.daysOfWeek || []).includes(d.value)).map((d) => d.title);
-      return `${time}every ${names.join(", ") || "week"}${range}`;
+      return `every ${names.join(", ") || "week"}${at}${range}`;
     }
     case "monthly": {
       const day = t.startDate ? Number(t.startDate.slice(8, 10)) : null;
       const on = day === null ? "every month" : day === 31 ? "on the last day of every month" : `on day ${day} of every month`;
-      return `${time}${on}${range}`;
+      return `${on}${at}${range}`;
     }
     default: {
       const sorted = [...dates].sort();
-      if (!sorted.length) return `${time}on no date`.trim();
+      if (!sorted.length) return `on no date${at}`;
       const shown = sorted.slice(0, 3).map((d) => fmtDate(d, nowYear)).join(", ");
-      return `${time}on ${shown}${sorted.length > 3 ? ` +${sorted.length - 3} more` : ""}${
+      return `on ${shown}${sorted.length > 3 ? ` +${sorted.length - 3} more` : ""}${at}${
         t.endDate ? ` (until ${fmtDate(t.endDate, nowYear)})` : ""
       }`;
     }
@@ -226,33 +234,93 @@ export function buildSummary(
   return `Adds 1 extra visit to ${areas} (${units}) ${describeWhen(f, year)} — next: ${nextText}.`;
 }
 
-export const STATUS_LABELS: Record<string, string> = { active: "Active", paused: "Paused", ended: "Ended" };
+/** The state of an extra visit as a whole. "ended" reads "Finished": nothing is left to run. */
+export const STATUS_LABELS: Record<string, string> = { active: "Active", paused: "Paused", ended: "Finished" };
+
+/** What each word means, shown on the page so nobody has to guess. Same words as the mobile apps. */
+export const STATUS_HELP: { word: string; meaning: string }[] = [
+  { word: "Active", meaning: "It will add a visit at its next date and time." },
+  { word: "Paused", meaning: "Stopped for now. Nothing is added until you press Resume." },
+  { word: "Finished", meaning: "Its last date has passed, so nothing more is added. Press \"Extend or repeat\" to keep it going." },
+];
+export const RESULT_HELP: { word: string; meaning: string }[] = [
+  { word: "Not started", meaning: "Nothing is ticked yet." },
+  { word: "In progress", meaning: "Some units are ticked; the rest can still be done today." },
+  { word: "Done", meaning: "Staff ticked every unit of the visit." },
+  { word: "Needs redo", meaning: "A supervisor sent a unit back to be done again." },
+  { word: "Missed", meaning: "The day ended with units not done." },
+];
 
-/** "Done 20 Oct" / "Missed 20 Oct" / "Not run yet". */
+/** "Done 20 Oct" / "Missed 20 Oct" / "No visit yet". */
 export function lastRunLabel(row: { lastRun?: string | null; lastRunStatus?: string | null }): string {
-  if (!row.lastRun) return "Not run yet";
+  if (!row.lastRun) return "No visit yet";
   const m = /^(\d{4}-\d{2}-\d{2})/.exec(row.lastRun);
   const day = m ? fmtDate(m[1]) : "";
-  const word = { done: "Done", missed: "Missed", pending: "In progress" }[row.lastRunStatus || ""] || "Ran";
+  const word = { done: "Done", missed: "Missed", pending: "In progress" }[row.lastRunStatus || ""] || "Added";
   return `${word} ${day}`.trim();
 }
 
+/** Why an extra visit says Finished, in one sentence. */
+export function finishedReason(row: Partial<TRule>, nowYear?: string): string {
+  if (row.repeat && row.repeat !== "none" && row.endDate) {
+    return `Its end date (${fmtDate(row.endDate, nowYear)}) has passed.`;
+  }
+  return "All the dates it was set for have passed.";
+}
+
 /**
- * One name and one page path per trade. The names are the web menu names (M&E
- * is "Technician Schedule" - the mobile app mirrors it); the path is the folder
- * the trade app serves its daily schedule from.
+ * One sentence per list row: "Every Mon, Wed at 2:00 pm in Lobby D — next on Wed 22 Oct".
+ * Paused and finished rows say so instead of a next date.
  */
-export const SCHEDULE_NAMES: Record<string, { title: string; route: string }> = {
-  cleaning_services: { title: "Cleaning Schedule", route: "cleaning-schedule" },
-  landscaping_services: { title: "Landscape Schedule", route: "landscape-schedule" },
-  pest_control_services: { title: "Pest Schedule", route: "pest-schedule" },
-  pool_maintenance_services: { title: "Pool Schedule", route: "pool-schedule" },
-  mechanical_electrical_services: { title: "Technician Schedule", route: "technician-schedule" },
+export function describeRow(
+  row: Partial<TRule> & {
+    areas?: { name?: string }[];
+    nextRun?: string | null;
+    scheduleStatus?: string | null;
+    paused?: boolean;
+  },
+  nowYear?: string,
+): string {
+  const when = describeWhen(row, nowYear);
+  const names = (row.areas || []).map((a) => a?.name).filter(Boolean) as string[];
+  const where = names.length
+    ? ` in ${names.slice(0, 3).join(", ")}${names.length > 3 ? ` +${names.length - 3} more` : ""}`
+    : "";
+  const state = row.scheduleStatus || (row.paused ? "paused" : "active");
+  const m = /^(\d{4}-\d{2}-\d{2})/.exec(row.nextRun || "");
+  const tail =
+    state === "paused"
+      ? " — paused, nothing is added until you resume it"
+      : state === "ended"
+        ? " — finished"
+        : m
+          ? ` — next on ${DAYS[weekdayOf(m[1])]} ${fmtDate(m[1], nowYear)}`
+          : "";
+  return `${when.charAt(0).toUpperCase()}${when.slice(1)}${where}${tail}`;
+}
+
+/**
+ * One trade word and one page path per trade. Every trade's menu says "Daily
+ * Checklist" (owner 21 Oct; the mobile apps use the same name); the page title
+ * adds the trade ("Daily Checklist – Cleaning"). The path is the folder the
+ * trade app serves its daily checklist from - unchanged, so links and
+ * permissions keep working.
+ */
+export const SCHEDULE_NAMES: Record<string, { title: string; trade: string; route: string }> = {
+  cleaning_services: { title: "Daily Checklist", trade: "Cleaning", route: "cleaning-schedule" },
+  landscaping_services: { title: "Daily Checklist", trade: "Landscape", route: "landscape-schedule" },
+  pest_control_services: { title: "Daily Checklist", trade: "Pest", route: "pest-schedule" },
+  pool_maintenance_services: { title: "Daily Checklist", trade: "Pool", route: "pool-schedule" },
+  mechanical_electrical_services: { title: "Daily Checklist", trade: "Technician", route: "technician-schedule" },
 };
 
 export const scheduleNameFor = (serviceType?: string) =>
   SCHEDULE_NAMES[serviceType || ""] || SCHEDULE_NAMES.cleaning_services;
 
+/** "Daily Checklist – Cleaning" / "– Technician" / ... */
+export const dailyChecklistTitle = (serviceType?: string) =>
+  `Daily Checklist – ${scheduleNameFor(serviceType).trade}`;
+
 /** Singapore "today" as YYYY-MM-DD, for "is today's list there yet". */
 export const sgtToday = (now: Date = new Date()) => sgtParts(now).date;
 
@@ -265,13 +333,28 @@ export function hasListForToday(rows: { createdAt?: string | Date }[], now: Date
   });
 }
 
-/** One spelling for the in-flight state ("Ongoing" / "On-going" -> "In progress"); other words pass through. */
+/**
+ * The daily checklist's words, the same on web and mobile: Open -> Not started,
+ * Ongoing / On-going -> In progress, Completed -> Done. Closed stays Closed (the
+ * day ended; anything not ticked counts as Missed). Other words pass through.
+ */
 export function dailyStatusLabel(status: string | null | undefined): string {
   const s = String(status ?? "").trim();
   if (!s) return "No status";
-  return /^on-?going$/i.test(s) ? "In progress" : s;
+  if (/^on-?going$/i.test(s)) return "In progress";
+  if (/^open$/i.test(s)) return "Not started";
+  if (/^completed?$/i.test(s)) return "Done";
+  return s;
 }
 
+/** What the daily checklist's words mean, shown on the page. */
+export const DAILY_STATUS_HELP: { word: string; meaning: string }[] = [
+  { word: "Not started", meaning: "The day's list is open and nothing is ticked yet." },
+  { word: "In progress", meaning: "Staff have ticked some units; the rest can still be done." },
+  { word: "Done", meaning: "Every unit on the list was ticked." },
+  { word: "Closed", meaning: "The day ended at midnight. The list is view-only, and anything not ticked counts as Missed." },
+];
+
 /** A unit's result in the history view: Done, Needs redo (rejected by a supervisor) or Missed (never done). */
 export function historyUnitLabel(status: string | null | undefined): "Done" | "Needs redo" | "Missed" {
   const s = String(status ?? "").trim().toLowerCase();

package/utils/security-catalogue.ts

@@ -25,7 +25,7 @@ export const isSecurityV2Marked = (perms?: readonly string[] | null) =>
 
 /** Real keys = anything that is not the marker or the wildcard. */
 export const countRealPermissions = (perms?: readonly string[] | null) =>
-  (perms ?? []).filter((p) => p !== SECURITY_CATALOGUE_MARKER).length;
+  (perms ?? []).filter((p) => !p.startsWith("catalogue:")).length; // every catalogue marker (security-v2, trade-v2)
 
 /**
  * Effective grant for a v2 key. Empty list / "*" = allowed (same as

package/utils/trade-catalogue.ts

@@ -0,0 +1,43 @@
+import { holdsPermission } from "./permission-spellings.ts";
+
+/**
+ * Trade catalogue v2 (hygiene, M&E, pest control, pool, landscape), owner
+ * 2026-10-21: "Task Calendar -> See calendar" per role, and "keep access until
+ * changed". The role editor stamps the marker when it saves a trade role. A role
+ * without it was never saved with the box and keeps the calendar (it was open
+ * to every role). The marker grants nothing. Mirrors core
+ * `trade-catalogue.util.ts`; keep the two in step.
+ */
+export const TRADE_CATALOGUE_MARKER = "catalogue:trade-v2";
+export const TASK_CALENDAR_KEY = "event-mgmt:see-task-calendar";
+
+export const isTradeV2Marked = (perms?: readonly string[] | null) =>
+  !!perms?.includes(TRADE_CATALOGUE_MARKER);
+
+/** Is this editor catalogue a trade one (it offers the See calendar box)? */
+export const isTradeCatalogue = (catalogue?: Record<string, any> | null) =>
+  !!catalogue?.["event-mgmt"]?.["see-task-calendar"];
+
+/**
+ * May this role open the Task Calendar? No role = no. Empty list / "*" = yes
+ * (empty means all). Unmarked = yes (keeps today's access). Marked = the box.
+ */
+export function canSeeTaskCalendar(perms: readonly string[] | null | undefined): boolean {
+  if (!perms) return false;
+  if (!perms.length || perms.includes("*")) return true;
+  if (!isTradeV2Marked(perms)) return true;
+  return holdsPermission(perms, TASK_CALENDAR_KEY);
+}
+
+/** Marker to append on save: only when the list has a real key and no "*". */
+export function withTradeMarker(perms: readonly string[]): string[] {
+  const keys = perms.filter((p) => p !== TRADE_CATALOGUE_MARKER);
+  if (!keys.some((p) => !p.startsWith("catalogue:")) || keys.includes("*")) return keys;
+  return [...keys, TRADE_CATALOGUE_MARKER];
+}
+
+/** Box to pre-tick when opening an UNMARKED trade role in the editor. */
+export function tradeV2PreTicks(perms: readonly string[]): string[] {
+  if (!perms.length || perms.includes("*") || isTradeV2Marked(perms)) return [];
+  return perms.includes(TASK_CALENDAR_KEY) ? [] : [TASK_CALENDAR_KEY];
+}