@omersx/bemms 0.0.0-stage → 1.0.0

package/src/lib/actions/maintenance-tasks.ts

@@ -0,0 +1,415 @@
+'use server';
+
+import { db } from '@/lib/db';
+import { 
+  maintenanceTasks, 
+  serviceTickets, 
+  devices,
+  checklistTemplateVersions,
+  maintenanceChecklistResults,
+  users
+} from '@/lib/db/schema';
+import { requireAuth, requireRole, requireScope } from '@/lib/auth/rbac';
+import { createAuditLog } from '@/lib/audit';
+import { eq, and, desc, inArray, ilike, or, count, getTableColumns, sql } from 'drizzle-orm';
+import {
+  createMaintenanceTaskSchema,
+  assignMaintenanceTaskSchema,
+  updateMaintenanceTaskStageSchema,
+  completeMaintenanceTaskSchema,
+  cancelMaintenanceTaskSchema,
+  maintenanceTaskFilterSchema
+} from '@/lib/validators/maintenance';
+import { z } from 'zod';
+import crypto from 'crypto';
+
+function generateTaskNumber() {
+  const date = new Date();
+  const yearMonth = `${date.getFullYear()}${String(date.getMonth() + 1).padStart(2, '0')}`;
+  const randomStr = crypto.randomBytes(3).toString('hex').toUpperCase();
+  return `TSK-${yearMonth}-${randomStr}`;
+}
+
+export async function createMaintenanceTask(input: z.infer<typeof createMaintenanceTaskSchema>) {
+  const user = await requireAuth();
+  
+  try {
+    const data = createMaintenanceTaskSchema.parse(input);
+    await requireScope({ organizationId: data.organizationId, hospitalId: data.hospitalId });
+
+    const taskNumber = generateTaskNumber();
+
+    const [newTask] = await db.insert(maintenanceTasks).values({
+      taskNumber,
+      organizationId: data.organizationId,
+      hospitalId: data.hospitalId,
+      departmentId: data.departmentId,
+      locationId: data.locationId,
+      deviceId: data.deviceId,
+      serviceTicketId: data.serviceTicketId,
+      maintenanceScheduleOccurrenceId: data.maintenanceScheduleOccurrenceId,
+      maintenanceType: data.maintenanceType,
+      technicalProblemCategory: data.technicalProblemCategory,
+      title: data.title,
+      description: data.description,
+      assignedEngineerUserId: data.assignedEngineerUserId,
+      priorityCode: data.priorityCode,
+      dueDate: data.dueDate ? new Date(data.dueDate) : undefined,
+      checklistTemplateVersionId: data.checklistTemplateVersionId,
+      statusCode: data.assignedEngineerUserId ? 'assigned' : 'draft',
+      createdByUserId: user.id,
+      updatedByUserId: user.id,
+    }).returning();
+
+    await createAuditLog({
+      actionType: 'CREATE',
+      entityType: 'MAINTENANCE_TASK',
+      entityId: newTask.id,
+      organizationId: newTask.organizationId,
+      hospitalId: newTask.hospitalId,
+      departmentId: newTask.departmentId,
+      userId: user.id,
+      details: { taskNumber, maintenanceType: data.maintenanceType }
+    });
+
+    return { success: true, data: newTask };
+  } catch (error: any) {
+    console.error('Failed to create maintenance task:', error);
+    return { success: false, error: error.message };
+  }
+}
+
+export async function getMaintenanceTaskById(id: string) {
+  const user = await requireAuth();
+
+  try {
+    const task = await db.query.maintenanceTasks.findFirst({
+      where: eq(maintenanceTasks.id, id),
+      with: {
+        device: true,
+        hospital: true,
+        department: true,
+        assignedEngineer: true,
+        serviceTicket: true,
+        checklistTemplateVersion: true,
+        checklistResults: true,
+        createdByUser: true,
+      }
+    });
+
+    if (!task) return { success: false, error: 'Maintenance task not found' };
+
+    await requireScope({ organizationId: task.organizationId, hospitalId: task.hospitalId });
+
+    return { success: true, data: task };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+export async function listMaintenanceTasks(input?: z.infer<typeof maintenanceTaskFilterSchema>) {
+  const user = await requireAuth();
+
+  try {
+    const filters = maintenanceTaskFilterSchema.parse(input || { page: 1, pageSize: 20 });
+    const conditions = [];
+
+    // Basic role scoping - users should only see tasks in their org/hospital
+    if (!user.roles.includes('SYS_ADMIN')) {
+      if (user.organizationId) {
+        conditions.push(eq(maintenanceTasks.organizationId, user.organizationId));
+      }
+    }
+
+    if (filters.hospitalId) conditions.push(eq(maintenanceTasks.hospitalId, filters.hospitalId));
+    if (filters.departmentId) conditions.push(eq(maintenanceTasks.departmentId, filters.departmentId));
+    if (filters.deviceId) conditions.push(eq(maintenanceTasks.deviceId, filters.deviceId));
+    if (filters.statusCode) conditions.push(eq(maintenanceTasks.statusCode, filters.statusCode as any));
+    if (filters.maintenanceType) conditions.push(eq(maintenanceTasks.maintenanceType, filters.maintenanceType as any));
+    if (filters.assignedEngineerUserId) conditions.push(eq(maintenanceTasks.assignedEngineerUserId, filters.assignedEngineerUserId));
+
+    if (filters.search) {
+      conditions.push(
+        or(
+          ilike(maintenanceTasks.taskNumber, `%${filters.search}%`),
+          ilike(maintenanceTasks.title, `%${filters.search}%`)
+        )
+      );
+    }
+
+    const whereClause = conditions.length > 0 ? and(...conditions) : undefined;
+
+    const offset = (filters.page - 1) * filters.pageSize;
+    
+    const [totalCount, data] = await Promise.all([
+      db.select({ count: count() }).from(maintenanceTasks).where(whereClause),
+      db.query.maintenanceTasks.findMany({
+        where: whereClause,
+        orderBy: [desc(maintenanceTasks.createdAt)],
+        limit: filters.pageSize,
+        offset: offset,
+        with: {
+          device: { columns: { name: true, assetNumber: true } },
+          assignedEngineer: { columns: { fullName: true } }
+        }
+      })
+    ]);
+
+    return { 
+      success: true, 
+      data, 
+      meta: {
+        total: totalCount[0].count,
+        page: filters.page,
+        pageSize: filters.pageSize,
+        totalPages: Math.ceil(totalCount[0].count / filters.pageSize)
+      }
+    };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+export async function assignMaintenanceTask(id: string, input: z.infer<typeof assignMaintenanceTaskSchema>) {
+  const user = await requireAuth();
+
+  try {
+    const data = assignMaintenanceTaskSchema.parse(input);
+    
+    const task = await db.query.maintenanceTasks.findFirst({
+      where: eq(maintenanceTasks.id, id),
+    });
+
+    if (!task) return { success: false, error: 'Task not found' };
+    await requireScope({ organizationId: task.organizationId, hospitalId: task.hospitalId });
+
+    const validStates = ['draft', 'assigned'];
+    if (!validStates.includes(task.statusCode)) {
+      return { success: false, error: `Cannot assign task in ${task.statusCode} state` };
+    }
+
+    const [updated] = await db.update(maintenanceTasks).set({
+      assignedEngineerUserId: data.assignedEngineerUserId,
+      statusCode: 'assigned',
+      updatedAt: new Date(),
+      updatedByUserId: user.id
+    }).where(eq(maintenanceTasks.id, id)).returning();
+
+    await createAuditLog({
+      actionType: 'ASSIGN',
+      entityType: 'MAINTENANCE_TASK',
+      entityId: id,
+      organizationId: task.organizationId,
+      userId: user.id,
+      details: { assignedTo: data.assignedEngineerUserId, handoffNote: data.handoffNote }
+    });
+
+    return { success: true, data: updated };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+export async function startMaintenanceTask(id: string) {
+  const user = await requireAuth();
+
+  try {
+    const task = await db.query.maintenanceTasks.findFirst({
+      where: eq(maintenanceTasks.id, id),
+    });
+
+    if (!task) return { success: false, error: 'Task not found' };
+    await requireScope({ organizationId: task.organizationId, hospitalId: task.hospitalId });
+
+    const validStates = ['assigned', 'waiting_dependency'];
+    if (!validStates.includes(task.statusCode)) {
+      return { success: false, error: `Cannot start task from ${task.statusCode} state` };
+    }
+
+    const updates: any = {
+      statusCode: 'in_progress',
+      updatedAt: new Date(),
+      updatedByUserId: user.id
+    };
+
+    if (!task.startedAt) {
+      updates.startedAt = new Date();
+    }
+
+    const [updated] = await db.update(maintenanceTasks)
+      .set(updates)
+      .where(eq(maintenanceTasks.id, id))
+      .returning();
+
+    await createAuditLog({
+      actionType: 'UPDATE',
+      entityType: 'MAINTENANCE_TASK',
+      entityId: id,
+      organizationId: task.organizationId,
+      userId: user.id,
+      details: { action: 'start_work', previousState: task.statusCode }
+    });
+
+    return { success: true, data: updated };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+export async function markTaskWaiting(id: string, input: z.infer<typeof updateMaintenanceTaskStageSchema>) {
+  const user = await requireAuth();
+
+  try {
+    const data = updateMaintenanceTaskStageSchema.parse(input);
+    const task = await db.query.maintenanceTasks.findFirst({
+      where: eq(maintenanceTasks.id, id),
+    });
+
+    if (!task) return { success: false, error: 'Task not found' };
+    await requireScope({ organizationId: task.organizationId, hospitalId: task.hospitalId });
+
+    if (task.statusCode !== 'in_progress') {
+      return { success: false, error: `Cannot pause task from ${task.statusCode} state` };
+    }
+
+    const [updated] = await db.update(maintenanceTasks).set({
+      statusCode: 'waiting_dependency',
+      waitingDependencyType: data.waitingDependencyType,
+      waitingReason: data.waitingReason,
+      updatedAt: new Date(),
+      updatedByUserId: user.id
+    }).where(eq(maintenanceTasks.id, id)).returning();
+
+    await createAuditLog({
+      actionType: 'UPDATE',
+      entityType: 'MAINTENANCE_TASK',
+      entityId: id,
+      organizationId: task.organizationId,
+      userId: user.id,
+      details: { action: 'mark_waiting', reason: data.waitingReason, type: data.waitingDependencyType }
+    });
+
+    return { success: true, data: updated };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+export async function completeTaskWork(id: string, input: z.infer<typeof completeMaintenanceTaskSchema>) {
+  const user = await requireAuth();
+
+  try {
+    const data = completeMaintenanceTaskSchema.parse(input);
+    const task = await db.query.maintenanceTasks.findFirst({
+      where: eq(maintenanceTasks.id, id),
+      with: { checklistResults: true }
+    });
+
+    if (!task) return { success: false, error: 'Task not found' };
+    await requireScope({ organizationId: task.organizationId, hospitalId: task.hospitalId });
+
+    const validStates = ['in_progress', 'returned_for_rework'];
+    if (!validStates.includes(task.statusCode)) {
+      return { success: false, error: `Cannot complete work from ${task.statusCode} state` };
+    }
+
+    // TODO: Verify checklist completion logic here (if checklist is attached, verify all required are answered)
+
+    const [updated] = await db.update(maintenanceTasks).set({
+      statusCode: 'work_complete',
+      completedAt: new Date(),
+      updatedAt: new Date(),
+      updatedByUserId: user.id
+    }).where(eq(maintenanceTasks.id, id)).returning();
+
+    await createAuditLog({
+      actionType: 'UPDATE',
+      entityType: 'MAINTENANCE_TASK',
+      entityId: id,
+      organizationId: task.organizationId,
+      userId: user.id,
+      details: { action: 'work_complete', finalResultCode: data.finalResultCode }
+    });
+
+    return { success: true, data: updated };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+export async function cancelMaintenanceTask(id: string, input: z.infer<typeof cancelMaintenanceTaskSchema>) {
+  const user = await requireAuth();
+
+  try {
+    const data = cancelMaintenanceTaskSchema.parse(input);
+    const task = await db.query.maintenanceTasks.findFirst({
+      where: eq(maintenanceTasks.id, id),
+    });
+
+    if (!task) return { success: false, error: 'Task not found' };
+    await requireScope({ organizationId: task.organizationId, hospitalId: task.hospitalId });
+
+    const activeStates = ['draft', 'assigned', 'in_progress', 'waiting_dependency'];
+    if (!activeStates.includes(task.statusCode)) {
+      return { success: false, error: `Cannot cancel task in ${task.statusCode} state` };
+    }
+
+    const [updated] = await db.update(maintenanceTasks).set({
+      statusCode: 'cancelled',
+      updatedAt: new Date(),
+      updatedByUserId: user.id
+    }).where(eq(maintenanceTasks.id, id)).returning();
+
+    await createAuditLog({
+      actionType: 'UPDATE',
+      entityType: 'MAINTENANCE_TASK',
+      entityId: id,
+      organizationId: task.organizationId,
+      userId: user.id,
+      details: { action: 'cancel', reason: data.cancellationReason }
+    });
+
+    return { success: true, data: updated };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+export async function createMaintenanceTaskFromTicket(ticketId: string, input: z.infer<typeof createMaintenanceTaskSchema>) {
+  const user = await requireAuth();
+
+  try {
+    const ticket = await db.query.serviceTickets.findFirst({
+      where: eq(serviceTickets.id, ticketId)
+    });
+
+    if (!ticket) return { success: false, error: 'Service ticket not found' };
+    await requireScope({ organizationId: ticket.organizationId, hospitalId: ticket.hospitalId });
+
+    // Override some fields with ticket context
+    const dataToCreate = {
+      ...input,
+      organizationId: ticket.organizationId,
+      hospitalId: ticket.hospitalId,
+      departmentId: ticket.departmentId || undefined,
+      deviceId: ticket.deviceId!,
+      serviceTicketId: ticket.id,
+    };
+
+    const result = await createMaintenanceTask(dataToCreate);
+
+    if (result.success) {
+      // Transition ticket to in_progress if it isn't already closed/resolved
+      if (!['resolved', 'closed', 'cancelled'].includes(ticket.statusCode)) {
+         await db.update(serviceTickets)
+           .set({ statusCode: 'in_progress', updatedAt: new Date() })
+           .where(eq(serviceTickets.id, ticket.id));
+      }
+    }
+
+    return result;
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+

package/src/lib/actions/manufacturers.ts

@@ -0,0 +1,132 @@
+'use server';
+
+import { db } from '@/lib/db';
+import { manufacturers } from '@/lib/db/schema';
+import { requireAuth, requireRole } from '@/lib/auth/rbac';
+import { createAuditLog } from '@/lib/audit';
+import { createManufacturerSchema, updateManufacturerSchema } from '@/lib/validators/devices';
+import { DEFAULT_MANUFACTURERS } from '@/lib/constants/manufacturers';
+import { eq, desc, asc } from 'drizzle-orm';
+
+export async function getManufacturers(organizationId?: string) {
+  const session = await requireAuth();
+  try {
+    const orgId = organizationId || session.organizationId;
+    let data = await db.query.manufacturers.findMany({
+      where: orgId ? eq(manufacturers.organizationId, orgId) : undefined,
+      orderBy: [asc(manufacturers.name)],
+    });
+
+    // Auto-seed default global manufacturers if empty for this organization
+    if (data.length === 0 && orgId) {
+      for (const mfr of DEFAULT_MANUFACTURERS) {
+        await db.insert(manufacturers).values({
+          organizationId: orgId,
+          name: mfr.name,
+          code: mfr.code,
+          country: mfr.country,
+          website: mfr.website,
+          createdByUserId: session.id,
+        });
+      }
+      data = await db.query.manufacturers.findMany({
+        where: eq(manufacturers.organizationId, orgId),
+        orderBy: [asc(manufacturers.name)],
+      });
+    }
+
+    return { success: true, data };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+export async function getManufacturerById(id: string) {
+  await requireAuth();
+  try {
+    const data = await db.query.manufacturers.findFirst({
+      where: eq(manufacturers.id, id),
+    });
+    return { success: true, data };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+export async function createManufacturer(input: unknown) {
+  const session = await requireAuth();
+  await requireRole('SYS_ADMIN', 'ORG_ADMIN', 'BIOMED_MGR', 'BIOMED_ENG');
+
+  let orgId = (input as any)?.organizationId || session.organizationId;
+  if (!orgId) {
+    const firstOrg = await db.query.organizations.findFirst();
+    orgId = firstOrg?.id;
+  }
+
+  const payload = typeof input === 'object' && input !== null
+    ? { organizationId: orgId, ...input }
+    : input;
+
+  const validated = createManufacturerSchema.safeParse(payload);
+  if (!validated.success) return { success: false, error: validated.error.message };
+
+  try {
+    return await db.transaction(async (tx) => {
+      const [newMfr] = await tx.insert(manufacturers).values({
+        ...validated.data,
+        createdByUserId: session.id,
+      }).returning();
+      await createAuditLog(tx, {
+        action: 'CREATE', entityType: 'manufacturer', entityId: newMfr.id,
+        actorId: session.id, details: validated.data,
+      });
+      return { success: true, data: newMfr };
+    });
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+export async function updateManufacturer(id: string, input: unknown) {
+  const session = await requireAuth();
+  await requireRole('SYS_ADMIN', 'ORG_ADMIN', 'BIOMED_MGR');
+  const validated = updateManufacturerSchema.safeParse(input);
+  if (!validated.success) return { success: false, error: validated.error.message };
+
+  try {
+    return await db.transaction(async (tx) => {
+      const [updated] = await tx.update(manufacturers)
+        .set(validated.data)
+        .where(eq(manufacturers.id, id))
+        .returning();
+      await createAuditLog(tx, {
+        action: 'UPDATE', entityType: 'manufacturer', entityId: id,
+        actorId: session.id, details: validated.data,
+      });
+      return { success: true, data: updated };
+    });
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+export async function archiveManufacturer(id: string) {
+  const session = await requireAuth();
+  await requireRole('SYS_ADMIN', 'ORG_ADMIN', 'BIOMED_MGR');
+  try {
+    return await db.transaction(async (tx) => {
+      const [archived] = await tx.update(manufacturers)
+        .set({ status: 'archived', archivedAt: new Date() })
+        .where(eq(manufacturers.id, id))
+        .returning();
+      await createAuditLog(tx, {
+        action: 'ARCHIVE', entityType: 'manufacturer', entityId: id,
+        actorId: session.id, details: { status: 'archived' },
+      });
+      return { success: true, data: archived };
+    });
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+

package/src/lib/actions/nav-counts.ts

@@ -0,0 +1,144 @@
+'use server';
+
+import { db } from '@/lib/db';
+import { requireAuth } from '@/lib/auth/rbac';
+import {
+  notifications,
+  serviceTickets,
+  maintenanceTasks,
+  maintenanceScheduleOccurrences,
+  maintenancePlans,
+} from '@/lib/db/schema';
+import { eq, and, isNull, inArray, notInArray, sql } from 'drizzle-orm';
+
+export interface NavBadgeCounts {
+  notifications: number;
+  triage: number;
+  tickets: number;
+  maintenance: number;
+  workOrders: number;
+  pmPlans: number;
+  hasMaintenanceDue: boolean;
+}
+
+const DEFAULT_COUNTS: NavBadgeCounts = {
+  notifications: 0,
+  triage: 0,
+  tickets: 0,
+  maintenance: 0,
+  workOrders: 0,
+  pmPlans: 0,
+  hasMaintenanceDue: false,
+};
+
+/**
+ * Fetch dynamic navigation badge counts for the current user and their scope.
+ */
+export async function getNavBadgeCounts(): Promise<NavBadgeCounts> {
+  try {
+    const user = await requireAuth();
+    const userId = user.id;
+    const orgId = user.organizationId;
+    const roles = user.roles || [];
+
+    const isStaffOnly =
+      roles.some((r) => ['STAFF', 'DEPT_MGR'].includes(r)) &&
+      !roles.some((r) =>
+        ['BIOMED_ENG', 'BIOMED_TECH', 'BIOMED_MGR', 'SYS_ADMIN', 'ORG_ADMIN', 'HOSP_ADMIN'].includes(r)
+      );
+
+    const isBmeOrAdmin = roles.some((r) =>
+      ['BIOMED_ENG', 'BIOMED_TECH', 'BIOMED_MGR', 'SYS_ADMIN', 'ORG_ADMIN', 'HOSP_ADMIN'].includes(r)
+    );
+
+    // 1. Unread notifications for this user
+    const [unreadNotifResult] = await db
+      .select({ count: sql<number>`count(*)::int` })
+      .from(notifications)
+      .where(and(eq(notifications.recipientUserId, userId), isNull(notifications.readAt)));
+
+    const notificationsCount = unreadNotifResult?.count || 0;
+
+    let triageCount = 0;
+    let ticketsCount = 0;
+    let workOrdersCount = 0;
+    let pmDueCount = 0;
+
+    if (isStaffOnly) {
+      // Staff: open tickets reported by this user
+      const [staffTicketsResult] = await db
+        .select({ count: sql<number>`count(*)::int` })
+        .from(serviceTickets)
+        .where(
+          and(
+            eq(serviceTickets.reportedByUserId, userId),
+            notInArray(serviceTickets.statusCode, ['resolved', 'closed', 'cancelled'])
+          )
+        );
+      ticketsCount = staffTicketsResult?.count || 0;
+    } else if (isBmeOrAdmin && orgId) {
+      // BME / Admin: Triage queue tickets (new, acknowledged, in_triage)
+      const [triageResult] = await db
+        .select({ count: sql<number>`count(*)::int` })
+        .from(serviceTickets)
+        .where(
+          and(
+            eq(serviceTickets.organizationId, orgId),
+            inArray(serviceTickets.statusCode, ['new', 'acknowledged', 'in_triage'])
+          )
+        );
+      triageCount = triageResult?.count || 0;
+
+      // Active helpdesk tickets in the organization
+      const [orgTicketsResult] = await db
+        .select({ count: sql<number>`count(*)::int` })
+        .from(serviceTickets)
+        .where(
+          and(
+            eq(serviceTickets.organizationId, orgId),
+            notInArray(serviceTickets.statusCode, ['resolved', 'closed', 'cancelled'])
+          )
+        );
+      ticketsCount = orgTicketsResult?.count || 0;
+
+      // Maintenance Work orders active / pending
+      const [tasksResult] = await db
+        .select({ count: sql<number>`count(*)::int` })
+        .from(maintenanceTasks)
+        .where(
+          and(
+            eq(maintenanceTasks.organizationId, orgId),
+            inArray(maintenanceTasks.statusCode, [
+              'assigned',
+              'in_progress',
+              'waiting_dependency',
+            ])
+          )
+        );
+      workOrdersCount = tasksResult?.count || 0;
+
+      // PM schedule occurrences overdue or due today
+      const pmResult = await db.execute(sql`
+        SELECT COUNT(*)::int as count
+        FROM maintenance_schedule_occurrences mso
+        JOIN maintenance_plans mp ON mso.maintenance_plan_id = mp.id
+        WHERE mp.organization_id = ${orgId}
+          AND mso.due_state IN ('due_today', 'overdue')
+      `);
+      pmDueCount = Number((pmResult.rows[0] as any)?.count) || 0;
+    }
+
+    return {
+      notifications: notificationsCount,
+      triage: triageCount,
+      tickets: ticketsCount,
+      maintenance: pmDueCount + workOrdersCount,
+      workOrders: workOrdersCount,
+      pmPlans: pmDueCount,
+      hasMaintenanceDue: pmDueCount > 0 || workOrdersCount > 0,
+    };
+  } catch (error) {
+    console.error('[getNavBadgeCounts] Failed to fetch badge counts:', error);
+    return DEFAULT_COUNTS;
+  }
+}