@7365admin1/layer-common 4.146.0 → 4.147.0

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(/[.,;:]+$/, "") ?? "";
+}