@omersx/bemms 0.0.0-stage → 1.0.0

package/src/lib/notifications/triggers.ts

@@ -0,0 +1,166 @@
+import { db } from '@/lib/db';
+import { serviceTickets, maintenanceTasks, devices, users } from '@/lib/db/schema';
+import { eq } from 'drizzle-orm';
+import { createNotification } from './create';
+
+/**
+ * Trigger notification when a ticket is assigned to an engineer.
+ */
+export async function notifyTicketAssigned(ticketId: string, engineerUserId: string) {
+  const ticket = await db.query.serviceTickets.findFirst({
+    where: eq(serviceTickets.id, ticketId),
+    with: { device: { columns: { name: true } } },
+  });
+  if (!ticket) return;
+
+  await createNotification({
+    organizationId: ticket.organizationId,
+    recipientUserId: engineerUserId,
+    notificationType: 'ticket_assigned',
+    title: `Ticket ${ticket.ticketNumber} assigned to you`,
+    body: `${ticket.title}${ticket.device ? ` — ${ticket.device.name}` : ''}`,
+    relatedEntityType: 'ticket',
+    relatedEntityId: ticketId,
+    actionUrl: `/tickets/${ticketId}`,
+  });
+}
+
+/**
+ * Trigger notification when a ticket status changes (notify reporter).
+ */
+export async function notifyTicketStatusChanged(ticketId: string, newStatus: string) {
+  const ticket = await db.query.serviceTickets.findFirst({
+    where: eq(serviceTickets.id, ticketId),
+  });
+  if (!ticket || !ticket.reportedByUserId) return;
+
+  const statusLabel = newStatus.replace(/_/g, ' ');
+
+  await createNotification({
+    organizationId: ticket.organizationId,
+    recipientUserId: ticket.reportedByUserId,
+    notificationType: 'ticket_updated',
+    title: `Ticket ${ticket.ticketNumber} is now ${statusLabel}`,
+    body: ticket.title,
+    relatedEntityType: 'ticket',
+    relatedEntityId: ticketId,
+    actionUrl: `/tickets/${ticketId}`,
+  });
+}
+
+/**
+ * Trigger notification when a comment is added to a ticket.
+ */
+export async function notifyTicketComment(ticketId: string, commenterId: string) {
+  const ticket = await db.query.serviceTickets.findFirst({
+    where: eq(serviceTickets.id, ticketId),
+  });
+  if (!ticket) return;
+
+  const commenter = await db.query.users.findFirst({
+    where: eq(users.id, commenterId),
+    columns: { fullName: true },
+  });
+
+  // Notify reporter if commenter is not the reporter
+  if (ticket.reportedByUserId && ticket.reportedByUserId !== commenterId) {
+    await createNotification({
+      organizationId: ticket.organizationId,
+      recipientUserId: ticket.reportedByUserId,
+      notificationType: 'ticket_comment',
+      title: `New comment on ${ticket.ticketNumber}`,
+      body: `${commenter?.fullName || 'Someone'} commented on your ticket`,
+      relatedEntityType: 'ticket',
+      relatedEntityId: ticketId,
+      actionUrl: `/tickets/${ticketId}`,
+    });
+  }
+
+  // Notify assigned engineer if commenter is not the engineer
+  if (ticket.assignedEngineerUserId && ticket.assignedEngineerUserId !== commenterId) {
+    await createNotification({
+      organizationId: ticket.organizationId,
+      recipientUserId: ticket.assignedEngineerUserId,
+      notificationType: 'ticket_comment',
+      title: `New comment on ${ticket.ticketNumber}`,
+      body: `${commenter?.fullName || 'Someone'} commented on the ticket`,
+      relatedEntityType: 'ticket',
+      relatedEntityId: ticketId,
+      actionUrl: `/tickets/${ticketId}`,
+    });
+  }
+}
+
+/**
+ * Trigger notification when a maintenance task needs review.
+ */
+export async function notifyTaskReviewRequired(taskId: string, reviewerUserId: string) {
+  const task = await db.query.maintenanceTasks.findFirst({
+    where: eq(maintenanceTasks.id, taskId),
+    with: { device: { columns: { name: true } } },
+  });
+  if (!task) return;
+
+  await createNotification({
+    organizationId: task.organizationId,
+    recipientUserId: reviewerUserId,
+    notificationType: 'task_review_required',
+    title: `Task ${task.taskNumber} needs review`,
+    body: `${task.title}${task.device ? ` — ${task.device.name}` : ''}`,
+    relatedEntityType: 'task',
+    relatedEntityId: taskId,
+    actionUrl: `/maintenance/tasks/${taskId}`,
+  });
+}
+
+/**
+ * Trigger notification when a PM task is due soon.
+ */
+export async function notifyPMDueSoon(taskId: string, engineerUserId: string) {
+  const task = await db.query.maintenanceTasks.findFirst({
+    where: eq(maintenanceTasks.id, taskId),
+    with: { device: { columns: { name: true } } },
+  });
+  if (!task) return;
+
+  await createNotification({
+    organizationId: task.organizationId,
+    recipientUserId: engineerUserId,
+    notificationType: 'pm_due_soon',
+    title: `PM task ${task.taskNumber} due soon`,
+    body: `${task.title}${task.device ? ` — ${task.device.name}` : ''}`,
+    relatedEntityType: 'task',
+    relatedEntityId: taskId,
+    actionUrl: `/maintenance/tasks/${taskId}`,
+  });
+}
+
+/**
+ * Trigger notification when a device status changes.
+ */
+export async function notifyDeviceStatusChanged(
+  deviceId: string,
+  newStatus: string,
+  recipientUserIds: string[]
+) {
+  const device = await db.query.devices.findFirst({
+    where: eq(devices.id, deviceId),
+  });
+  if (!device) return;
+
+  const statusLabel = newStatus.replace(/_/g, ' ');
+
+  for (const userId of recipientUserIds) {
+    await createNotification({
+      organizationId: device.organizationId,
+      recipientUserId: userId,
+      notificationType: 'device_status_changed',
+      title: `${device.name} is now ${statusLabel}`,
+      body: `Asset ${device.assetNumber || device.name} status changed`,
+      relatedEntityType: 'device',
+      relatedEntityId: deviceId,
+      actionUrl: `/devices/${deviceId}`,
+    });
+  }
+}
+

package/src/lib/utils/__tests__/crypto.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import { buildCanonicalSnapshot, computeSHA256 } from '../crypto';
+
+describe('buildCanonicalSnapshot', () => {
+  it('sorts keys deterministically regardless of input key order', () => {
+    const objA = { z: 1, a: 2, m: 3 };
+    const objB = { a: 2, m: 3, z: 1 };
+
+    const snapshotA = buildCanonicalSnapshot(objA);
+    const snapshotB = buildCanonicalSnapshot(objB);
+
+    expect(snapshotA).toBe(snapshotB);
+    expect(snapshotA).toBe('{"a":2,"m":3,"z":1}');
+  });
+});
+
+describe('computeSHA256', () => {
+  it('computes a 64-character hex hash', () => {
+    const hash = computeSHA256('hello world');
+    expect(hash).toHaveLength(64);
+    expect(hash).toBe('b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9');
+  });
+
+  it('produces identical hashes for identical canonical snapshots', () => {
+    const hash1 = computeSHA256(buildCanonicalSnapshot({ id: '1', title: 'Test' }));
+    const hash2 = computeSHA256(buildCanonicalSnapshot({ title: 'Test', id: '1' }));
+    expect(hash1).toBe(hash2);
+  });
+});
+

package/src/lib/utils/__tests__/export.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest';
+import { generateCSV, formatReportMetadata } from '../export';
+
+describe('generateCSV', () => {
+  const columns = [
+    { key: 'name', header: 'Device Name' },
+    { key: 'assetNumber', header: 'Asset #' },
+    { key: 'status', header: 'Current Status' },
+  ];
+
+  it('outputs BOM and header row when data is empty', () => {
+    const csv = generateCSV([], columns);
+    expect(csv.startsWith('\uFEFF')).toBe(true);
+    expect(csv).toContain('"Device Name","Asset #","Current Status"');
+  });
+
+  it('formats rows with quotes and escapes embedded quotes', () => {
+    const data = [
+      { name: 'Monitor "Pro"', assetNumber: 'AST-100', status: 'operational' },
+      { name: 'Pump, Syringe', assetNumber: 'AST-101', status: 'under_repair' },
+    ];
+    const csv = generateCSV(data, columns);
+    expect(csv).toContain('"Monitor ""Pro"""');
+    expect(csv).toContain('"Pump, Syringe"');
+  });
+
+  it('handles null and undefined values cleanly', () => {
+    const data = [
+      { name: 'Sensor', assetNumber: null, status: undefined },
+    ];
+    const csv = generateCSV(data, columns);
+    expect(csv).toContain('"Sensor","",""');
+  });
+});
+
+describe('formatReportMetadata', () => {
+  it('formats report transparency header lines correctly', () => {
+    const date = new Date('2026-09-01T12:00:00Z');
+    const header = formatReportMetadata({
+      reportType: 'inventory',
+      filters: { departmentId: 'dept-123' },
+      dateRange: { start: '2026-01-01', end: '2026-09-01' },
+      timezone: 'UTC',
+      generatedAt: date,
+      generatedBy: 'Admin User',
+    });
+
+    expect(header).toContain('# Report Type: inventory');
+    expect(header).toContain('# Generated By: Admin User');
+    expect(header).toContain('# Date Range Start: 2026-01-01');
+    expect(header).toContain('# Date Range End: 2026-09-01');
+    expect(header).toContain('dept-123');
+  });
+});
+

package/src/lib/utils/__tests__/nav-badge.test.ts

@@ -0,0 +1,147 @@
+import { describe, it, expect } from 'vitest';
+import {
+  navBadgeVariants,
+  formatNavBadge,
+} from '@/lib/utils/nav-badge';
+
+describe('NavBadge system', () => {
+  describe('navBadgeVariants formatting & class generation', () => {
+    it('generates standard count badge classes with default options', () => {
+      const classes = navBadgeVariants({
+        variant: 'default',
+        type: 'count',
+        position: 'trailing',
+      });
+      expect(classes).toContain('bg-primary');
+      expect(classes).toContain('ml-auto');
+      expect(classes).toContain('rounded-full');
+    });
+
+    it('generates icon-corner position classes for collapsed sidebars and mobile tabs', () => {
+      const classes = navBadgeVariants({
+        variant: 'danger',
+        type: 'count',
+        position: 'icon-corner',
+      });
+      expect(classes).toContain('absolute');
+      expect(classes).toContain('-top-1');
+      expect(classes).toContain('-right-1');
+      expect(classes).toContain('bg-destructive');
+    });
+
+    it('generates dot badge classes for maintenance indicators', () => {
+      const classes = navBadgeVariants({
+        variant: 'warning',
+        type: 'dot',
+        position: 'icon-corner',
+      });
+      expect(classes).toContain('rounded-full');
+      expect(classes).toContain('w-2.5');
+      expect(classes).toContain('h-2.5');
+      expect(classes).toContain('bg-amber-500');
+    });
+
+    it('generates status badge classes for custom status text', () => {
+      const classes = navBadgeVariants({
+        variant: 'success',
+        type: 'status',
+        position: 'trailing',
+      });
+      expect(classes).toContain('bg-emerald-600');
+      expect(classes).toContain('uppercase');
+      expect(classes).toContain('truncate');
+    });
+  });
+
+  describe('formatNavBadge logic', () => {
+    it('hides count badge when value is 0 and hideWhenZero is true', () => {
+      const result = formatNavBadge({
+        type: 'count',
+        value: 0,
+        hideWhenZero: true,
+      });
+      expect(result.visible).toBe(false);
+    });
+
+    it('displays count badge when value is 0 and hideWhenZero is false', () => {
+      const result = formatNavBadge({
+        type: 'count',
+        value: 0,
+        hideWhenZero: false,
+      });
+      expect(result.visible).toBe(true);
+      expect(result.display).toBe('0');
+    });
+
+    it('displays normal count under maxCount', () => {
+      const result = formatNavBadge({
+        type: 'count',
+        value: 12,
+        maxCount: 99,
+      });
+      expect(result.visible).toBe(true);
+      expect(result.display).toBe('12');
+      expect(result.accessibleDescription).toBe('12 items');
+    });
+
+    it('formats counts exceeding maxCount with a plus suffix', () => {
+      const result = formatNavBadge({
+        type: 'count',
+        value: 150,
+        maxCount: 99,
+      });
+      expect(result.visible).toBe(true);
+      expect(result.display).toBe('99+');
+      expect(result.accessibleDescription).toBe('More than 99 items');
+    });
+
+    it('formats custom maxCount correctly (e.g. maxCount: 9)', () => {
+      const result = formatNavBadge({
+        type: 'count',
+        value: 15,
+        maxCount: 9,
+      });
+      expect(result.visible).toBe(true);
+      expect(result.display).toBe('9+');
+    });
+
+    it('uses custom aria-label when provided for accessibility', () => {
+      const result = formatNavBadge({
+        type: 'count',
+        value: 5,
+        ariaLabel: '5 unread notifications',
+      });
+      expect(result.accessibleDescription).toBe('5 unread notifications');
+    });
+
+    it('supports dot indicator without numerical value', () => {
+      const result = formatNavBadge({
+        type: 'dot',
+        ariaLabel: 'Maintenance due',
+      });
+      expect(result.visible).toBe(true);
+      expect(result.isDot).toBe(true);
+      expect(result.accessibleDescription).toBe('Maintenance due');
+    });
+
+    it('supports status labels with proper text formatting', () => {
+      const result = formatNavBadge({
+        type: 'status',
+        value: 'New',
+        ariaLabel: 'New feature',
+      });
+      expect(result.visible).toBe(true);
+      expect(result.display).toBe('New');
+      expect(result.accessibleDescription).toBe('New feature');
+    });
+
+    it('hides badge when enabled is explicitly false', () => {
+      const result = formatNavBadge({
+        enabled: false,
+        type: 'count',
+        value: 10,
+      });
+      expect(result.visible).toBe(false);
+    });
+  });
+});

package/src/lib/utils/__tests__/staff-status.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect } from 'vitest';
+import { getStaffStatus, getStaffStatusStyle, isStaffOnly } from '@/lib/utils/staff-status';
+
+describe('Staff Status Translations', () => {
+  it('translates internal status codes to patient/clinical-friendly labels', () => {
+    expect(getStaffStatus('new').label).toBe('Submitted');
+    expect(getStaffStatus('acknowledged').label).toBe('Reviewed');
+    expect(getStaffStatus('in_triage').label).toBe('Being reviewed');
+    expect(getStaffStatus('assigned').label).toBe('Assigned to Engineering');
+    expect(getStaffStatus('in_progress').label).toBe('Being repaired');
+    expect(getStaffStatus('waiting_parts_vendor').label).toBe('Waiting for parts');
+    expect(getStaffStatus('waiting_requester').label).toBe('Response requested');
+    expect(getStaffStatus('resolved').label).toBe('Resolved');
+    expect(getStaffStatus('closed').label).toBe('Closed');
+    expect(getStaffStatus('reopened').label).toBe('Reopened');
+  });
+
+  it('provides sensible fallback for unknown status codes', () => {
+    const unknown = getStaffStatus('custom_status_code');
+    expect(unknown.label).toBe('custom status code');
+    expect(unknown.color).toBe('gray');
+  });
+
+  it('provides theme styles for status colors', () => {
+    const inProgressStyle = getStaffStatusStyle('in_progress');
+    expect(inProgressStyle.bg).toContain('amber');
+
+    const resolvedStyle = getStaffStatusStyle('resolved');
+    expect(resolvedStyle.bg).toContain('green');
+
+    const waitingRequesterStyle = getStaffStatusStyle('waiting_requester');
+    expect(waitingRequesterStyle.bg).toContain('red');
+  });
+
+  it('correctly identifies staff-only roles without biomedical or admin privileges', () => {
+    expect(isStaffOnly(['STAFF'])).toBe(true);
+    expect(isStaffOnly(['DEPT_MGR'])).toBe(true);
+    expect(isStaffOnly(['STAFF', 'DEPT_MGR'])).toBe(true);
+
+    // Elevated roles must NOT be staff-only
+    expect(isStaffOnly(['STAFF', 'BIOMED_ENG'])).toBe(false);
+    expect(isStaffOnly(['STAFF', 'BIOMED_TECH'])).toBe(false);
+    expect(isStaffOnly(['STAFF', 'BIOMED_MGR'])).toBe(false);
+    expect(isStaffOnly(['STAFF', 'SYS_ADMIN'])).toBe(false);
+    expect(isStaffOnly(['ORG_ADMIN'])).toBe(false);
+    expect(isStaffOnly(['HOSP_ADMIN'])).toBe(false);
+    expect(isStaffOnly(['BIOMED_ENG'])).toBe(false);
+    expect(isStaffOnly([])).toBe(false);
+  });
+});

package/src/lib/utils/attestations.ts

@@ -0,0 +1,19 @@
+// ── Attestation Templates ───────────────────────────────────────────────────
+
+export const ATTESTATION_TEMPLATES: Record<string, string> = {
+  perform: 'I confirm that I performed the recorded maintenance/inspection and that the information entered is accurate to the best of my knowledge.',
+  review: 'I have reviewed the performed work, findings, evidence, and test results, and confirm technical completeness and accuracy.',
+  approve: 'I approve the recorded work, findings, and recommendations in accordance with the applicable policy.',
+  release: 'I authorize the release of this medical device for clinical use with the specified operational status.',
+  accept: 'I accept responsibility for the assigned work and confirm I will perform it in accordance with applicable procedures.',
+  resolve: 'I confirm that the issue has been resolved and the resolution summary accurately describes the work performed.',
+  close: 'I confirm that the ticket resolution is sufficiently documented and complete under the applicable policy.',
+  reject: 'I am returning this work for correction. The stated reason identifies the issues that must be addressed.',
+  amend: 'I am submitting a correction to the previously signed record. The amendment reason describes the changes made.',
+  void: 'I am voiding this signature/record. The stated reason documents why this action is necessary.',
+};
+
+export function getAttestationText(purpose: string): string {
+  return ATTESTATION_TEMPLATES[purpose] || `I confirm this ${purpose} action and that the information is accurate.`;
+}
+

package/src/lib/utils/crypto.ts

@@ -0,0 +1,18 @@
+import { createHash } from 'crypto';
+
+/**
+ * Build a canonical JSON snapshot for cryptographic hashing.
+ * Keys are sorted deterministically to ensure the same content
+ * always produces the same hash regardless of insertion order.
+ */
+export function buildCanonicalSnapshot(data: Record<string, unknown>): string {
+  return JSON.stringify(data, Object.keys(data).sort(), 0);
+}
+
+/**
+ * Compute SHA-256 hash of a canonical JSON snapshot string.
+ */
+export function computeSHA256(content: string): string {
+  return createHash('sha256').update(content, 'utf8').digest('hex');
+}
+

package/src/lib/utils/csv-parser.ts

@@ -0,0 +1,181 @@
+/**
+ * Robust CSV parser that handles quotes, escaped quotes, and newlines.
+ */
+export function parseCSV(text: string): Record<string, string>[] {
+  const cleanText = text.replace(/^\uFEFF/, '').trim(); // Remove BOM if present
+  if (!cleanText) return [];
+
+  const rows: string[][] = [];
+  let currentRow: string[] = [];
+  let currentField = '';
+  let inQuotes = false;
+
+  for (let i = 0; i < cleanText.length; i++) {
+    const char = cleanText[i];
+    const nextChar = cleanText[i + 1];
+
+    if (inQuotes) {
+      if (char === '"' && nextChar === '"') {
+        currentField += '"';
+        i++; // Skip escaped quote
+      } else if (char === '"') {
+        inQuotes = false;
+      } else {
+        currentField += char;
+      }
+    } else {
+      if (char === '"') {
+        inQuotes = true;
+      } else if (char === ',') {
+        currentRow.push(currentField.trim());
+        currentField = '';
+      } else if (char === '\r') {
+        // Skip CR in CRLF
+        continue;
+      } else if (char === '\n') {
+        currentRow.push(currentField.trim());
+        if (currentRow.some((field) => field.length > 0)) {
+          rows.push(currentRow);
+        }
+        currentRow = [];
+        currentField = '';
+      } else {
+        currentField += char;
+      }
+    }
+  }
+
+  // Flush remaining field/row
+  if (currentField || currentRow.length > 0) {
+    currentRow.push(currentField.trim());
+    if (currentRow.some((field) => field.length > 0)) {
+      rows.push(currentRow);
+    }
+  }
+
+  if (rows.length < 2) return [];
+
+  // Normalize header keys: lowercase, remove non-alphanumeric except underscore
+  const rawHeaders = rows[0];
+  const headers = rawHeaders.map((h) =>
+    h
+      .toLowerCase()
+      .replace(/[\s\-_]+/g, '_')
+      .replace(/[^a-z0-9_]/g, '')
+  );
+
+  const records: Record<string, string>[] = [];
+
+  for (let i = 1; i < rows.length; i++) {
+    const row = rows[i];
+    const record: Record<string, string> = {};
+    headers.forEach((header, idx) => {
+      record[header] = row[idx] !== undefined ? row[idx].trim() : '';
+    });
+    records.push(record);
+  }
+
+  return records;
+}
+
+/**
+ * Returns a ready-to-use CSV template string with BOM and sample rows.
+ */
+export function getDeviceImportTemplateCSV(): string {
+  const BOM = '\uFEFF';
+  const headers = [
+    'asset_number',
+    'name',
+    'model',
+    'serial_number',
+    'category',
+    'manufacturer',
+    'department',
+    'location',
+    'risk_classification',
+    'criticality',
+    'purchase_date',
+    'purchase_cost',
+    'installation_date',
+    'warranty_start_date',
+    'warranty_end_date',
+  ].join(',');
+
+  const samples = [
+    [
+      'BEMMS-DEV-001',
+      'Infusion Pump IV-300',
+      'IV-3000',
+      'SN-8492014',
+      'Infusion Pump',
+      'Baxter',
+      'Emergency Department',
+      'Room 102 - Trauma Bay',
+      'class_iib',
+      'high',
+      '2023-01-15',
+      '3500.00',
+      '2023-02-01',
+      '2023-02-01',
+      '2025-02-01',
+    ].join(','),
+    [
+      'BEMMS-DEV-002',
+      'Patient Monitor IntelliVue',
+      'MX450',
+      'SN-9921443',
+      'Patient Monitor',
+      'Philips Healthcare',
+      'Intensive Care Unit (ICU)',
+      'Bed 04',
+      'class_iib',
+      'high',
+      '2023-03-10',
+      '12500.00',
+      '2023-03-25',
+      '2023-03-25',
+      '2026-03-25',
+    ].join(','),
+    [
+      'BEMMS-DEV-003',
+      'Centrifuge 5424 R',
+      '5424 R',
+      'SN-1029481',
+      'Laboratory Centrifuge',
+      'Eppendorf',
+      'Central Laboratory',
+      'Bench 3',
+      'class_i',
+      'low',
+      '2023-05-20',
+      '4800.00',
+      '2023-06-01',
+      '2023-06-01',
+      '2025-06-01',
+    ].join(','),
+  ].join('\n');
+
+  return `${BOM}${headers}\n${samples}\n`;
+}
+
+/**
+ * Returns a ready-to-use CSV template string with BOM and sample rows for departments.
+ */
+export function getDepartmentImportTemplateCSV(): string {
+  const BOM = '\uFEFF';
+  const headers = [
+    'name',
+    'code',
+    'department_type',
+    'hospital_name',
+  ].join(',');
+
+  const samples = [
+    ['Emergency Department', 'ED', 'emergency', 'Central Teaching Hospital'].join(','),
+    ['Intensive Care Unit', 'ICU', 'critical_care', 'Central Teaching Hospital'].join(','),
+    ['Radiology Department', 'RAD', 'diagnostic', 'Central Teaching Hospital'].join(','),
+  ].join('\n');
+
+  return `${BOM}${headers}\n${samples}\n`;
+}
+