@7365admin1/layer-common 4.118.10 → 4.120.0

package/utils/inventory-presets.ts

@@ -143,3 +143,67 @@ export function inventoryControls(a?: Partial<TInventoryAccess> | null) {
     unitPrice: c.canManage || c.canApprove || c.canHandle || c.canReports,
   };
 }
+
+/**
+ * Whole-role starting points (TLR A7), offered in the create-role dialog when
+ * the catalogue has every module they use. Keys are the security catalogue's
+ * own (`composables/useSecurityPermission.ts`). Applying one REPLACES the
+ * ticks in the dialog and saves nothing; the admin adjusts and saves.
+ */
+export type TRolePreset = {
+  key: string;
+  label: string;
+  description: string;
+  permissions: string[];
+};
+
+/**
+ * The Guardhouse officer's grants, by module, in the same nested form as the
+ * security catalogue that offers them (`useSecurityPermission.ts`). A grant
+ * list, not a check: `constants/permissions.ts` (what this package CHECKS)
+ * deliberately has no Passes & Keys entry, so the role editors there gain no
+ * extra checkbox.
+ */
+const GUARDHOUSE_OFFICER: Record<string, string[]> = {
+  // check-out is a visitor update on the server
+  "visitor-mgmt": ["add-visitor", "see-all-visitor", "see-visitor-details", "update-visitor"],
+  "daily-occurrence-books": ["see-all-daily-occurrence", "see-daily-occurrence-details"],
+  "daily-occurrence-entries": ["add-daily-occurrence-entries", "see-daily-occurrence-entries-details"],
+  "incident-reports": ["add-incident-report", "see-incident-reports", "see-incident-report-details"],
+  feedbacks: ["add-feedback", "see-all-feedback", "see-feedback-details"],
+  // issuing and taking back a key is a pass/key update on the server
+  "passes-and-keys-mgmt": ["see-all-passes-and-keys", "update-passes-and-keys"],
+};
+
+const grants = (byModule: Record<string, string[]>) =>
+  Object.entries(byModule).flatMap(([resource, actions]) => actions.map((action) => [resource, action].join(":")));
+
+export const ROLE_PRESETS: TRolePreset[] = [
+  {
+    key: "guardhouse-officer",
+    label: "Guardhouse officer",
+    description:
+      "Register, see and check out visitors; fill in the daily occurrence book; raise and view incident reports and feedback; issue and take back passes and keys. No delete rights.",
+    permissions: grants(GUARDHOUSE_OFFICER),
+  },
+];
+
+/**
+ * The dialog state for `preset` against the offered catalogue, or null when
+ * the catalogue lacks any of it. Never returns an empty list: an empty
+ * permission list means "everything" on the server.
+ */
+export function applyRolePreset(
+  catalogue: Record<string, Record<string, unknown> | undefined>,
+  preset: TRolePreset,
+): { selected: string[]; enabled: string[] } | null {
+  const offered = preset.permissions.every((p) => {
+    const [resource, action] = p.split(":");
+    return Boolean(catalogue?.[resource]?.[action]);
+  });
+  if (!offered || !preset.permissions.length) return null;
+  return {
+    selected: [...preset.permissions],
+    enabled: [...new Set(preset.permissions.map((p) => p.split(":")[0]))],
+  };
+}

package/utils/key-presses.ts

@@ -0,0 +1,55 @@
+/**
+ * Key presses (cabinets) and the Passes & keys site switches (TLR B8 / D2).
+ * Stored on the site as `metadata.keySettings`; read with the same defaults
+ * as core's `getKeySettings`, so a site that never saved anything reads as
+ * today: no presses, no daily list, check-out never blocked by the server.
+ */
+export type TKeyPress = { id: string; name: string };
+
+export type TKeySettings = {
+  cabinets: TKeyPress[];
+  dailyUnreturnedAlert: boolean;
+  alertTime: string;
+  blockCheckoutWithKeys: boolean;
+};
+
+export function readKeySettings(site: any): TKeySettings {
+  const k = site?.metadata?.keySettings ?? {};
+  return {
+    cabinets: Array.isArray(k.cabinets)
+      ? k.cabinets.filter((c: any) => c && typeof c.id === "string" && typeof c.name === "string")
+      : [],
+    dailyUnreturnedAlert: k.dailyUnreturnedAlert === true,
+    alertTime: typeof k.alertTime === "string" && /^([01]\d|2[0-3]):[0-5]\d$/.test(k.alertTime) ? k.alertTime : "18:00",
+    blockCheckoutWithKeys: k.blockCheckoutWithKeys === true,
+  };
+}
+
+/** The press's name, or "" when the key has none (or one since removed). */
+export function keyPressName(cabinets: TKeyPress[], id?: string | null): string {
+  if (!id) return "";
+  return cabinets.find((c) => c.id === id)?.name ?? "";
+}
+
+/**
+ * The list as saved: names trimmed, empty rows dropped, and an id for each new
+ * row made from its name (lowercase letters, digits and dashes, unique). An
+ * existing row keeps its id, so renaming a press keeps every key in it.
+ */
+export function cleanKeyPresses(rows: Array<{ id?: string; name?: string }>): TKeyPress[] {
+  const out: TKeyPress[] = [];
+  const taken = new Set(rows.map((r) => r.id).filter(Boolean) as string[]);
+  for (const row of rows) {
+    const name = String(row.name ?? "").trim().slice(0, 60);
+    if (!name) continue;
+    let id = row.id;
+    if (!id) {
+      const base = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 34) || "press";
+      id = base;
+      for (let n = 2; taken.has(id); n++) id = `${base}-${n}`;
+      taken.add(id);
+    }
+    out.push({ id, name });
+  }
+  return out;
+}

package/utils/list-export.ts

@@ -0,0 +1,39 @@
+/**
+ * CSV download of a list screen (TLR B6): the rows the list itself can read,
+ * through the same list API and filters, paged through to the end. Browser-safe.
+ */
+import { toCsv } from "./attendance-proxy.ts";
+
+export type TExportColumn = { title: string; value: (row: any) => unknown };
+
+/** Largest page the list APIs accept (core feedback / work-order: max 100). */
+export const EXPORT_PAGE_SIZE = 100;
+/** ponytail: hard cap, so one click never pulls an estate's whole history; raise or add a server export if hit. */
+export const EXPORT_MAX_ROWS = 5000;
+
+/**
+ * Every row from `fetchPage(1..n)`, stopping at the last page, an empty page,
+ * or `maxRows`. `fetchPage` returns the list API's `{ items, pages }`.
+ */
+export async function collectAllPages(
+  fetchPage: (page: number, limit: number) => Promise<{ items?: any[]; pages?: number } | null | undefined>,
+  maxRows = EXPORT_MAX_ROWS,
+  limit = EXPORT_PAGE_SIZE,
+): Promise<{ rows: any[]; truncated: boolean }> {
+  const rows: any[] = [];
+  for (let page = 1; rows.length < maxRows; page++) {
+    const res = await fetchPage(page, limit);
+    const items = Array.isArray(res?.items) ? res!.items : [];
+    rows.push(...items);
+    const last = Number(res?.pages) || 0;
+    if (!items.length || page >= last) return { rows: rows.slice(0, maxRows), truncated: rows.length > maxRows };
+  }
+  return { rows: rows.slice(0, maxRows), truncated: true };
+}
+
+export function listCsv(columns: TExportColumn[], rows: any[]): string {
+  return toCsv(
+    columns.map((c) => c.title),
+    rows.map((row) => columns.map((c) => c.value(row))),
+  );
+}