@7365admin1/layer-common 4.97.1-staging.586 → 4.97.1-staging.588

package/utils/nric-card.ts

@@ -0,0 +1,278 @@
+/**
+ * Ported verbatim from the security mobile app (isecure365
+ * `src/features/visitors/nric-card.ts`) so the web NRIC scan reads a card
+ * exactly as the app does. Keep the two in step.
+ *
+ * Reading a Singapore NRIC (or FIN card) from the text the camera saw.
+ *
+ * The visitor form's "Scan" beside the NRIC field photographs the card, runs
+ * on-device text recognition (`modules/text-recognizer`) and hands the lines
+ * here. Nothing leaves the device: the photo is deleted straight after it is
+ * read, and only the two values below reach the form.
+ *
+ * The front of the card reads, top to bottom:
+ *
+ *     REPUBLIC OF SINGAPORE
+ *     IDENTITY CARD NO.  S1234567D
+ *     Name
+ *     TAN AH KOW            <- may wrap onto a second line
+ *     (name in Chinese / Tamil / Jawi, when there is one)
+ *     Race  ...   Date of birth  ...   Sex  ...   Country/Place of birth ...
+ *
+ * The back carries the number again (with its barcode), so the number alone
+ * can also be read from the back.
+ */
+
+/** One line of recognised text and where it sits in the photo. */
+export type CardLine = {
+  text: string;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+};
+
+export type NricCardRead = {
+  nric: string | null;
+  name: string | null;
+};
+
+const WEIGHTS = [2, 7, 6, 5, 4, 3, 2];
+
+/** Check letter by remainder, per prefix family. `T` / `G` add 4 first. */
+const CHECK_LETTERS: Record<string, { letters: string; offset: number }> = {
+  S: { letters: "JZIHGFEDCBA", offset: 0 },
+  T: { letters: "JZIHGFEDCBA", offset: 4 },
+  F: { letters: "XWUTRQPNMLK", offset: 0 },
+  G: { letters: "XWUTRQPNMLK", offset: 4 },
+};
+
+/**
+ * Whether the last letter matches the number. `null` for an M-series FIN,
+ * whose check letter is not checked here: the scanner instead waits for the
+ * same M number to be read twice in a row.
+ */
+export function isNricChecksumValid(nric: string): boolean | null {
+  const value = nric.toUpperCase();
+  if (!/^[STFGM]\d{7}[A-Z]$/.test(value)) return false;
+  const rule = CHECK_LETTERS[value[0]];
+  if (!rule) return null;
+  let sum = rule.offset;
+  for (let i = 0; i < 7; i += 1) sum += Number(value[i + 1]) * WEIGHTS[i];
+  return rule.letters[sum % 11] === value[8];
+}
+
+/** Characters text recognition commonly puts where a digit is printed. */
+const AS_DIGIT: Record<string, string> = {
+  O: "0",
+  D: "0",
+  Q: "0",
+  I: "1",
+  L: "1",
+  Z: "2",
+  S: "5",
+  G: "6",
+  B: "8",
+};
+
+/** A letter, seven digit-like characters, a letter — before any fixing. */
+const NRIC_LIKE = /^[STFGM5][0-9ODQILZSGB]{7}[A-Z]$/;
+
+function fixCandidate(raw: string): string {
+  const prefix = raw[0] === "5" ? "S" : raw[0];
+  const digits = raw
+    .slice(1, 8)
+    .split("")
+    .map((ch) => AS_DIGIT[ch] ?? ch)
+    .join("");
+  return `${prefix}${digits}${raw[8]}`;
+}
+
+/**
+ * The NRIC/FIN in the text, or null. A number whose check letter matches wins
+ * over one that only has the right shape (an M-series FIN).
+ */
+export function findNric(lines: CardLine[]): string | null {
+  const texts = lines.map((line) => line.text);
+  // Each line on its own, then everything joined in case the number was split.
+  texts.push(lines.map((line) => line.text).join(""));
+
+  let shapeOnly: string | null = null;
+  for (const text of texts) {
+    const compact = text.toUpperCase().replace(/[^A-Z0-9]/g, "");
+    for (let start = 0; start + 9 <= compact.length; start += 1) {
+      const window = compact.slice(start, start + 9);
+      if (!NRIC_LIKE.test(window)) continue;
+      const candidate = fixCandidate(window);
+      const valid = isNricChecksumValid(candidate);
+      if (valid === true) return candidate;
+      if (valid === null && !shapeOnly) shapeOnly = candidate;
+    }
+  }
+  return shapeOnly;
+}
+
+/**
+ * A number with the NRIC's shape whose check letter does NOT match, or null.
+ *
+ * Never filled in on its own: the scanner only offers it ("Use anyway") once
+ * the same number has been read several times in a row, so a one-off misread
+ * never reaches the form but a worn card, or a specimen with a dummy number,
+ * does not leave the guard stuck.
+ */
+export function findUncheckedNric(lines: CardLine[]): string | null {
+  const texts = lines.map((line) => line.text);
+  texts.push(lines.map((line) => line.text).join(""));
+  for (const text of texts) {
+    const compact = text.toUpperCase().replace(/[^A-Z0-9]/g, "");
+    for (let start = 0; start + 9 <= compact.length; start += 1) {
+      const window = compact.slice(start, start + 9);
+      if (!NRIC_LIKE.test(window)) continue;
+      const candidate = fixCandidate(window);
+      if (isNricChecksumValid(candidate) === false) return candidate;
+    }
+  }
+  return null;
+}
+
+const NAME_LABEL = /^\s*name\b[\s:.]*/i;
+/** Labels that come after the name on the card: reading stops at them. */
+const AFTER_NAME = /\b(race|date|birth|sex|country|identity|republic)\b/i;
+
+/** Printed names are capitals: letters, spaces and a little punctuation. */
+function asName(text: string): string | null {
+  const value = text.replace(/\s+/g, " ").trim();
+  if (!/^[A-Za-z][A-Za-z .,'@/()-]*$/.test(value)) return null;
+  const letters = value.replace(/[^A-Za-z]/g, "");
+  if (letters.length < 2) return null;
+  const capitals = letters.replace(/[^A-Z]/g, "").length;
+  // A few lower-case misreads are fine; mostly lower case is a label, not a name.
+  if (capitals / letters.length < 0.8) return null;
+  return value.toUpperCase();
+}
+
+/**
+ * The labels printed right under the name ("Race", "Date of birth", "Sex",
+ * "Country/Place of birth"), left-aligned with it. Not "Date of issue", which
+ * is on the back.
+ */
+const UNDER_NAME = /\b(race|sex|country|date of b\w*|birth)\b/i;
+/** Capitals on the card that are not the holder's name. */
+const NOT_A_NAME = /\b(republic|singapore|identity|card|specimen)\b/i;
+
+/**
+ * Race values printed on the card, under "Race". When the name line itself is
+ * not read, the Race value is the next line in capitals and was being taken
+ * for the name.
+ */
+const RACE_VALUES = new Set([
+  "CHINESE",
+  "MALAY",
+  "INDIAN",
+  "EURASIAN",
+  "CAUCASIAN",
+  "FILIPINO",
+  "JAVANESE",
+  "BOYANESE",
+  "BUGIS",
+  "SIKH",
+  "ARAB",
+  "JAPANESE",
+  "KOREAN",
+  "THAI",
+  "VIETNAMESE",
+  "BURMESE",
+  "SINHALESE",
+  "PAKISTANI",
+  "BANGLADESHI",
+  "NEPALESE",
+  "INDONESIAN",
+  "OTHERS",
+]);
+
+function nameOf(line: CardLine): string | null {
+  const name = asName(line.text);
+  if (!name || NOT_A_NAME.test(name) || RACE_VALUES.has(name)) return null;
+  return name;
+}
+
+/**
+ * The name from its first line, plus the lines it wraps onto: a long name
+ * wraps onto a second line set tight under the first; the name in another
+ * script below it has a wider gap and is not Latin.
+ */
+function joinName(first: CardLine, following: CardLine[]): string {
+  const parts = [first];
+  for (const line of following) {
+    if (AFTER_NAME.test(line.text)) break;
+    const previous = parts[parts.length - 1];
+    const gap = line.y - (previous.y + previous.height);
+    if (nameOf(line) && gap < previous.height * 0.6 && parts.length < 3) {
+      parts.push(line);
+    } else break;
+  }
+  return parts
+    .map((line) => nameOf(line))
+    .join(" ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+/** The name under the "Name" label, starting at the label's left edge. */
+function nameUnderLabel(sorted: CardLine[]): string | null {
+  const labelIndex = sorted.findIndex((line) => NAME_LABEL.test(line.text));
+  if (labelIndex < 0) return null;
+  const label = sorted[labelIndex];
+
+  // "Name TAN AH KOW" read as one line.
+  const sameLine = asName(label.text.replace(NAME_LABEL, ""));
+  if (sameLine && !AFTER_NAME.test(sameLine) && !NOT_A_NAME.test(sameLine)) {
+    return sameLine;
+  }
+
+  const tolerance = Math.max(label.height * 1.5, label.width * 0.5);
+  const below = sorted
+    .slice(labelIndex + 1)
+    .filter(
+      (line) => line.y > label.y && Math.abs(line.x - label.x) <= tolerance,
+    );
+  // The first line under the label must be the name; anything else ends it.
+  if (!below.length || AFTER_NAME.test(below[0].text) || !nameOf(below[0])) {
+    return null;
+  }
+  return joinName(below[0], below.slice(1));
+}
+
+/**
+ * Without the "Name" label (it is printed small and is often not read): the
+ * name is the first line in capitals in the column above "Race" / "Date of
+ * birth", which are left-aligned with it.
+ */
+function nameAboveDetails(sorted: CardLine[]): string | null {
+  const details = sorted.filter((line) => UNDER_NAME.test(line.text));
+  if (!details.length) return null;
+  // The top row of those labels, its left-most: "Race" or "Date of birth",
+  // never "Sex" beside it.
+  const top = details[0];
+  const anchor = details
+    .filter((line) => Math.abs(line.y - top.y) <= top.height)
+    .reduce((left, line) => (line.x < left.x ? line : left));
+
+  const tolerance = anchor.height * 2;
+  const column = sorted.filter(
+    (line) => line.y < anchor.y && Math.abs(line.x - anchor.x) <= tolerance,
+  );
+  const firstIndex = column.findIndex((line) => nameOf(line) !== null);
+  if (firstIndex < 0) return null;
+  return joinName(column[firstIndex], column.slice(firstIndex + 1));
+}
+
+/** The holder's name off the front of the card, or null. */
+export function findName(lines: CardLine[]): string | null {
+  const sorted = [...lines].sort((a, b) => a.y - b.y || a.x - b.x);
+  return nameUnderLabel(sorted) ?? nameAboveDetails(sorted);
+}
+
+export function readNricCard(lines: CardLine[]): NricCardRead {
+  return { nric: findNric(lines), name: findName(lines) };
+}

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