@7365admin1/layer-common 4.144.0 → 4.147.0

package/utils/schedule-task.ts

@@ -1,5 +1,11 @@
 /**
- * EXTRA VISITS (SCHEDULE TASKS) - the rules and the wording, in one place.
+ * EXTRA CHECKS (stored as "schedule tasks") - the rules and the wording, in one place.
+ *
+ * Named "Extra Checks" (owner 22 Oct: "Extra Visits (Scheduled)" was not
+ * understood). It is one more check of an area at a set time, added to staff's
+ * Daily Checklist - "Lunch toilet check", "Pump room check", "Pool water check".
+ * "Check" is the word every trade already uses and it matches "Daily Checklist".
+ * Saved data, API paths and permission keys keep their old names.
  *
  * Mirrors the server (module-hygiene `schedule-task-rules.util.ts`) so the form
  * can say "this will never run" BEFORE the user saves, and the list and the
@@ -9,6 +15,18 @@
  * Pure: no Vue, no imports, so it is unit-tested with `node --test`.
  */
 
+export const FEATURE_NAME = "Extra Checks";
+export const FEATURE_SUBTITLE =
+  "Add a check at a set time - once, or on a repeat. At that time it appears on staff's Daily Checklist on their phone.";
+
+/** The chip on an extra round of the Daily Checklist: "Extra check: Lunch toilet check · 2:00 pm". */
+export function extraCheckLabel(set: { scheduleTaskTitle?: string | null; scheduleTaskTime?: string | null } | null | undefined): string {
+  const title = (set?.scheduleTaskTitle || "").trim();
+  const time = fmtTime(set?.scheduleTaskTime);
+  if (!title) return "Extra check";
+  return `Extra check: ${title}${time ? ` · ${time}` : ""}`;
+}
+
 export type TRepeat = "none" | "daily" | "weekdays" | "weekly" | "monthly";
 
 export const REPEAT_OPTIONS: { title: string; value: TRepeat }[] = [
@@ -119,6 +137,29 @@ function occursOn(r: TRule, date: string): boolean {
   }
 }
 
+/**
+ * Does a STORED extra check fall on `date` (YYYY-MM-DD)? For calendars (the
+ * Property Management Task Calendar overlay). Paused ones do not; fields a stored
+ * row may lack are treated as empty.
+ */
+export function scheduleOccursOn(
+  row: { repeat?: string | null; dates?: string[] | null; daysOfWeek?: number[] | null; startDate?: string | null; endDate?: string | null; paused?: boolean | null },
+  date: string,
+): boolean {
+  if (row.paused) return false;
+  return occursOn(
+    {
+      repeat: (row.repeat || "none") as TRepeat,
+      dates: row.dates ?? [],
+      daysOfWeek: row.daysOfWeek ?? [],
+      startDate: row.startDate ?? "",
+      endDate: row.endDate ?? "",
+      time: "",
+    },
+    date,
+  );
+}
+
 /**
  * The next day this would run if saved right now ("YYYY-MM-DD"), or null when it never would.
  * A day whose time has already passed does not count: a task saved after its time waits for its next day.
@@ -231,36 +272,37 @@ export function buildSummary(
   const units = `${unitCount} unit${unitCount === 1 ? "" : "s"}`;
   const next = nextRunDate(f, now);
   const nextText = next ? `${DAYS[weekdayOf(next)]} ${fmtDate(next, year)}` : "never";
-  return `Adds 1 extra visit to ${areas} (${units}) ${describeWhen(f, year)} — next: ${nextText}.`;
+  return `Adds 1 extra check to ${areas} (${units} to tick) ${describeWhen(f, year)} — next: ${nextText}.`;
 }
 
-/** The state of an extra visit as a whole. "ended" reads "Finished": nothing is left to run. */
+/** The state of an extra check 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: "Active", meaning: "It will be added to staff's checklist 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: "Done", meaning: "Staff ticked every unit of the check." },
   { 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" / "No visit yet". */
-export function lastRunLabel(row: { lastRun?: string | null; lastRunStatus?: string | null }): string {
-  if (!row.lastRun) return "No visit yet";
+/** "Done 20 Oct" / "Missed 20 Oct" / "Not done yet". */
+export function lastRunLabel(row: { lastRun?: string | null; lastRunStatus?: string | null; scheduleStatus?: string | null }): string {
+  // Finished rows from before run records existed (20 Oct) may well have run: say we do not know.
+  if (!row.lastRun) return row.scheduleStatus === "ended" ? "No record" : "Not added 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 || ""] || "Added";
   return `${word} ${day}`.trim();
 }
 
-/** Why an extra visit says Finished, in one sentence. */
+/** Why an extra check 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.`;

package/utils/visitor-people.ts

@@ -0,0 +1,262 @@
+/*
+ * People lookup helpers for the visitor form's autofill, ported as is from the
+ * security mobile app (isecure365 `src/features/people/people.service.ts` and
+ * `src/features/visitors/delivery-company.ts`), so the web and the app fill a
+ * visitor in the same way.
+ *
+ * People records are kept per visitor type (guest, contractor, delivery, with
+ * walk-in kept as guest). The form looks a person up across EVERY visitor type
+ * - a past contractor is offered when adding a Guest, and so on - with the type
+ * being registered listed first, and the same person on file under several
+ * types shown once.
+ */
+
+/** The person types a visitor registration keeps a People record for. */
+export const VISITOR_PERSON_TYPES = ["guest", "contractor", "delivery"] as const;
+
+export type VisitorPerson = {
+  _id?: string;
+  name?: string;
+  nric?: string;
+  contact?: string | string[];
+  plateNumber?: string | string[];
+  company?: string;
+  companyName?: string | string[];
+  type?: string;
+  /** Every record behind one result (a merged result is several). */
+  ids?: string[];
+  /** The companies of each record by its person type. */
+  companiesByType?: Record<string, string[]>;
+  contacts?: string[];
+  plateNumbers?: string[];
+  plates?: { plateNumber?: string }[];
+  firstName?: string;
+  lastName?: string;
+  phoneNumber?: string;
+  contactNumbers?: unknown[];
+  phoneNumbers?: unknown[];
+  [key: string]: unknown;
+};
+
+const listOf = (value: unknown): unknown[] =>
+  Array.isArray(value) ? value : value === undefined || value === null ? [] : [value];
+
+function uniqueOf(
+  values: unknown[],
+  pick: (value: Record<string, unknown>) => unknown
+): string[] {
+  return Array.from(
+    new Set(
+      values
+        .map((value) =>
+          typeof value === "string"
+            ? value
+            : value && typeof value === "object"
+              ? pick(value as Record<string, unknown>)
+              : undefined
+        )
+        .filter(
+          (value): value is string => typeof value === "string" && Boolean(value.trim())
+        )
+        .map((value) => value.trim())
+    )
+  );
+}
+
+export function summaryName(person: VisitorPerson): string {
+  return (
+    person.name ||
+    [person.firstName, person.lastName].filter(Boolean).join(" ") ||
+    "Unknown"
+  );
+}
+
+export function summaryContacts(person: VisitorPerson): string[] {
+  return uniqueOf(
+    [
+      ...listOf(person.contact),
+      person.phoneNumber,
+      ...listOf(person.contacts),
+      ...listOf(person.contactNumbers),
+      ...listOf(person.phoneNumbers),
+    ],
+    (value) => value.contact || value.phoneNumber || value.number
+  );
+}
+
+export function summaryPlates(person: VisitorPerson): string[] {
+  return uniqueOf(
+    [...listOf(person.plateNumber), ...listOf(person.plates), ...listOf(person.plateNumbers)],
+    (value) => value.plateNumber || value.number || value.value
+  );
+}
+
+/** The companies on one record (`companyName`, or a single `company`). */
+function companiesOf(person: VisitorPerson): string[] {
+  return [
+    ...new Set(
+      [...listOf(person.companyName), person.company]
+        .filter((name): name is string => typeof name === "string" && Boolean(name.trim()))
+        .map((name) => name.trim())
+    ),
+  ];
+}
+
+/**
+ * The companies saved for the person from registrations of `type` only:
+ * contractor companies on the Contractor form, delivery companies on the
+ * Delivery form. Walk-in is kept as guest.
+ */
+export function companiesForType(person: VisitorPerson, type?: string): string[] {
+  const personType = type === "walk-in" ? "guest" : type;
+  if (!personType) return [];
+  if (person.companiesByType) return person.companiesByType[personType] ?? [];
+  return person.type === personType ? companiesOf(person) : [];
+}
+
+const sameText = (a?: string, b?: string) =>
+  Boolean(a?.trim()) && a!.trim().toLowerCase() === b?.trim().toLowerCase();
+
+/**
+ * Records with the same name and the same NRIC (or, with no NRIC on either,
+ * the same name and a shared phone number) are one person: shown once, with
+ * every number, plate and company of both.
+ */
+export function mergePeople(people: VisitorPerson[]): VisitorPerson[] {
+  const merged: VisitorPerson[] = [];
+  const seenIds = new Set<string>();
+  for (const person of people) {
+    if (person._id) {
+      if (seenIds.has(person._id)) continue;
+      seenIds.add(person._id);
+    }
+    const contacts = summaryContacts(person);
+    const same = merged.find((other) => {
+      if (!sameText(summaryName(other), summaryName(person))) return false;
+      if (other.nric || person.nric) return sameText(other.nric, person.nric);
+      const otherContacts = other.contacts ?? [];
+      return contacts.some((contact) => otherContacts.includes(contact));
+    });
+    if (!same) {
+      merged.push({
+        ...person,
+        ids: person._id ? [person._id] : [],
+        companiesByType: person.type ? { [person.type]: companiesOf(person) } : {},
+        contacts,
+        plateNumbers: summaryPlates(person),
+      });
+      continue;
+    }
+    if (person.type) {
+      const byType = { ...(same.companiesByType ?? {}) };
+      byType[person.type] = [
+        ...new Set([...(byType[person.type] ?? []), ...companiesOf(person)]),
+      ];
+      same.companiesByType = byType;
+    }
+    if (person._id) same.ids = [...(same.ids ?? []), person._id];
+    same.contacts = [...new Set([...(same.contacts ?? []), ...contacts])];
+    same.plateNumbers = [
+      ...new Set([...(same.plateNumbers ?? []), ...summaryPlates(person)]),
+    ];
+    same.companyName = [
+      ...new Set(
+        [...listOf(same.companyName), ...listOf(person.companyName)].filter(
+          (name): name is string => typeof name === "string" && Boolean(name.trim())
+        )
+      ),
+    ];
+  }
+  return merged;
+}
+
+/** People of the visitor types only, the type being registered first, merged. */
+export function visitorPeopleResults(
+  found: VisitorPerson[],
+  preferType?: string
+): VisitorPerson[] {
+  const visitorTypes: readonly string[] = VISITOR_PERSON_TYPES;
+  return mergePeople(
+    found
+      // A server without the several-types filter returns every type.
+      .filter((person) => !person.type || visitorTypes.includes(person.type))
+      .sort((a, b) => Number(b.type === preferType) - Number(a.type === preferType))
+  );
+}
+
+/** Every record behind a result (a merged one is several). */
+export function recordIdsOf(person: VisitorPerson): string[] {
+  return [...new Set([...(person.ids ?? []), ...(person._id ? [person._id] : [])])];
+}
+
+/** A stable key for "this person was already filled in from this field". */
+export function personKey(person: VisitorPerson): string {
+  const ids = recordIdsOf(person);
+  if (ids.length) return ids.join(",");
+  return `${summaryName(person)}|${person.nric ?? ""}`;
+}
+
+export const DELETE_PERSON_TITLE = "Delete saved details?";
+export const deletePersonMessage = (name: string) =>
+  `${name}'s saved details will no longer be offered when filling in the form. Use this when the NRIC saved for them is wrong. Their past visits are not changed, and their details are saved again on their next visit.`;
+export const PERSON_DELETED_MESSAGE = "Saved details deleted.";
+
+/*
+ * The delivery company list (isecure365 `delivery-company.ts`): names are
+ * compared ignoring case and surrounding spaces, so "grabfood" is the listed
+ * "GrabFood".
+ */
+export const normalizeCompany = (value: unknown): string =>
+  typeof value === "string" ? value.trim() : "";
+
+export const sameCompany = (a: string, b: string): boolean =>
+  a.trim().toLowerCase() === b.trim().toLowerCase();
+
+export const isListedCompany = (list: readonly string[], name: string): boolean =>
+  list.some((company) => sameCompany(company, name));
+
+/** A typed name that matches a listed company apart from case / spaces becomes the listed one. */
+export function listedName(list: readonly string[], typed: unknown): string {
+  const name = normalizeCompany(typed);
+  if (!name) return "";
+  return list.find((company) => sameCompany(company, name)) ?? name;
+}
+
+export const withCompany = (list: readonly string[], name: string): string[] =>
+  isListedCompany(list, name) ? [...list] : [...list, name];
+
+export function renamedCompany(
+  list: readonly string[],
+  original: string,
+  name: string
+): string[] {
+  const index = list.findIndex((company) => sameCompany(company, original));
+  if (index === -1) return [...list, name];
+  const next = [...list];
+  next[index] = name;
+  return next;
+}
+
+export const withoutCompany = (list: readonly string[], name: string): string[] =>
+  list.filter((company) => !sameCompany(company, name));
+
+export const COMPANY_NAME_REQUIRED = "Company name is required.";
+export const COMPANY_ALREADY_LISTED = "This company is already in the list.";
+
+export function renameProblem(
+  list: readonly string[],
+  original: string,
+  value: unknown
+): string | null {
+  const name = normalizeCompany(value);
+  if (!name) return COMPANY_NAME_REQUIRED;
+  if (!sameCompany(name, original) && isListedCompany(list, name))
+    return COMPANY_ALREADY_LISTED;
+  return null;
+}
+
+/** "Pass VP01 is In Use" -> "VP01" (the pass / key the server refused). */
+export function refusedPassKeyName(message: string | undefined | null): string {
+  const match = /\b(?:Pass|Key)\s+(\S+)\s+is\s+/i.exec(String(message ?? ""));
+  return match?.[1]?.replace(/[.,;:]+$/, "") ?? "";
+}