@omersx/bemms 0.0.0-stage → 0.1.0

package/src/lib/actions/engineers.ts

@@ -0,0 +1,285 @@
+'use server';
+
+import { db } from '@/lib/db';
+import { engineerProfiles, users, departments, devices, serviceTickets, maintenanceTasks, hospitals } from '@/lib/db/schema';
+import { requireAuth, requireRole } from '@/lib/auth/rbac';
+import { eq, and, not, sql, inArray } from 'drizzle-orm';
+import { revalidatePath } from 'next/cache';
+import { EngineerDutyStatus } from '@/lib/db/schema/engineer-profiles';
+
+export interface EngineerTeamMember {
+  id: string; // engineer profile id
+  userId: string;
+  fullName: string;
+  email: string;
+  avatarUrl: string | null;
+  jobTitle: string;
+  specialization: string | null;
+  extension: string | null;
+  mobileNumber: string | null;
+  dutyStatus: EngineerDutyStatus;
+  shiftHours: string | null;
+  workingDays: string[];
+  onCallDays: string[];
+  coveredDepartmentIds: string[];
+  coveredDepartments: { id: string; name: string; code: string }[];
+  emergencyPriority: string | null;
+  notes: string | null;
+  hospitalName: string | null;
+  activeTicketsCount: number;
+  activeMaintenanceCount: number;
+  assignedDevicesCount: number;
+}
+
+export async function getEngineersTeam(): Promise<{
+  success: boolean;
+  data?: EngineerTeamMember[];
+  stats?: {
+    totalEngineers: number;
+    onDutyToday: number;
+    onCallToday: number;
+    inMaintenanceToday: number;
+    offDutyToday: number;
+    totalActiveWorkOrders: number;
+  };
+  error?: string;
+}> {
+  await requireAuth();
+
+  try {
+    const rawProfiles = await db.query.engineerProfiles.findMany({
+      with: {
+        user: true,
+        hospital: true,
+      },
+    });
+
+    const profiles = rawProfiles.filter((p) => Boolean(p.user));
+
+    const allDepts = await db.query.departments.findMany();
+    const deptMap = new Map(allDepts.map((d) => [d.id, { id: d.id, name: d.name, code: d.code }]));
+
+    const userIds = profiles.map((p) => p.userId);
+
+    // Count active tickets per engineer
+    const activeTicketsCounts = userIds.length > 0 ? await db
+      .select({
+        engineerId: serviceTickets.assignedEngineerUserId,
+        count: sql<number>`count(*)::int`,
+      })
+      .from(serviceTickets)
+      .where(
+        and(
+          inArray(serviceTickets.assignedEngineerUserId, userIds),
+          not(inArray(serviceTickets.statusCode, ['resolved', 'closed', 'cancelled']))
+        )
+      )
+      .groupBy(serviceTickets.assignedEngineerUserId) : [];
+
+    const ticketMap = new Map(activeTicketsCounts.map((t) => [t.engineerId!, t.count]));
+
+    // Count active maintenance tasks per engineer
+    const activeMaintCounts = userIds.length > 0 ? await db
+      .select({
+        engineerId: maintenanceTasks.assignedEngineerUserId,
+        count: sql<number>`count(*)::int`,
+      })
+      .from(maintenanceTasks)
+      .where(
+        and(
+          inArray(maintenanceTasks.assignedEngineerUserId, userIds),
+          not(inArray(maintenanceTasks.statusCode, ['closed', 'cancelled']))
+        )
+      )
+      .groupBy(maintenanceTasks.assignedEngineerUserId) : [];
+
+    const maintMap = new Map(activeMaintCounts.map((m) => [m.engineerId!, m.count]));
+
+    // Count assigned devices per engineer
+    const assignedDevCounts = userIds.length > 0 ? await db
+      .select({
+        engineerId: devices.assignedEngineerUserId,
+        count: sql<number>`count(*)::int`,
+      })
+      .from(devices)
+      .where(inArray(devices.assignedEngineerUserId, userIds))
+      .groupBy(devices.assignedEngineerUserId) : [];
+
+    const devMap = new Map(assignedDevCounts.map((d) => [d.engineerId!, d.count]));
+
+    const members: EngineerTeamMember[] = profiles.map((p) => {
+      const deptIds = (p.coveredDepartmentIds as string[]) || [];
+      const coveredDepts = deptIds.map((id) => deptMap.get(id)).filter(Boolean) as { id: string; name: string; code: string }[];
+
+      return {
+        id: p.id,
+        userId: p.userId,
+        fullName: p.user?.fullName || 'Biomedical Engineer',
+        email: p.user?.email || '',
+        avatarUrl: p.user?.avatarUrl || null,
+        jobTitle: p.jobTitle,
+        specialization: p.specialization,
+        extension: p.extension,
+        mobileNumber: p.mobileNumber || p.user.phone,
+        dutyStatus: p.dutyStatus as EngineerDutyStatus,
+        shiftHours: p.shiftHours,
+        workingDays: (p.workingDays as string[]) || [],
+        onCallDays: (p.onCallDays as string[]) || [],
+        coveredDepartmentIds: deptIds,
+        coveredDepartments: coveredDepts,
+        emergencyPriority: p.emergencyPriority,
+        notes: p.notes,
+        hospitalName: p.hospital?.name || null,
+        activeTicketsCount: ticketMap.get(p.userId) || 0,
+        activeMaintenanceCount: maintMap.get(p.userId) || 0,
+        assignedDevicesCount: devMap.get(p.userId) || 0,
+      };
+    });
+
+    const totalEngineers = members.length;
+    const onDutyToday = members.filter((m) => m.dutyStatus === 'on_duty').length;
+    const onCallToday = members.filter((m) => m.dutyStatus === 'on_call').length;
+    const inMaintenanceToday = members.filter((m) => m.dutyStatus === 'in_maintenance').length;
+    const offDutyToday = members.filter((m) => m.dutyStatus === 'off_duty').length;
+    const totalActiveWorkOrders = members.reduce((sum, m) => sum + m.activeTicketsCount + m.activeMaintenanceCount, 0);
+
+    return {
+      success: true,
+      data: members,
+      stats: {
+        totalEngineers,
+        onDutyToday,
+        onCallToday,
+        inMaintenanceToday,
+        offDutyToday,
+        totalActiveWorkOrders,
+      },
+    };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+export async function updateEngineerDutyStatus(
+  profileId: string,
+  newStatus: EngineerDutyStatus
+): Promise<{ success: boolean; error?: string }> {
+  await requireAuth();
+
+  try {
+    await db
+      .update(engineerProfiles)
+      .set({
+        dutyStatus: newStatus,
+        updatedAt: new Date(),
+      })
+      .where(eq(engineerProfiles.id, profileId));
+
+    revalidatePath('/team');
+    return { success: true };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+export async function updateEngineerProfile(
+  profileId: string,
+  data: {
+    jobTitle?: string;
+    specialization?: string;
+    extension?: string;
+    mobileNumber?: string;
+    shiftHours?: string;
+    workingDays?: string[];
+    onCallDays?: string[];
+    coveredDepartmentIds?: string[];
+    notes?: string;
+  }
+): Promise<{ success: boolean; error?: string }> {
+  await requireAuth();
+  await requireRole('SYS_ADMIN', 'ORG_ADMIN', 'BIOMED_MGR', 'BIOMED_ENG');
+
+  try {
+    await db
+      .update(engineerProfiles)
+      .set({
+        ...data,
+        updatedAt: new Date(),
+      })
+      .where(eq(engineerProfiles.id, profileId));
+
+    revalidatePath('/team');
+    return { success: true };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+export async function getDepartmentCoverageMatrix(): Promise<{
+  success: boolean;
+  departments?: {
+    id: string;
+    name: string;
+    code: string;
+    deviceCount: number;
+    primaryEngineer: {
+      id: string;
+      fullName: string;
+      jobTitle: string;
+      extension: string | null;
+      mobileNumber: string | null;
+      dutyStatus: EngineerDutyStatus;
+    } | null;
+  }[];
+  error?: string;
+}> {
+  await requireAuth();
+
+  try {
+    const depts = await db.query.departments.findMany();
+    const profiles = await db.query.engineerProfiles.findMany({
+      with: { user: true },
+    });
+
+    // Count devices per department
+    const deviceCounts = await db
+      .select({
+        departmentId: devices.departmentId,
+        count: sql<number>`count(*)::int`,
+      })
+      .from(devices)
+      .groupBy(devices.departmentId);
+
+    const devCountMap = new Map(deviceCounts.map((dc) => [dc.departmentId, dc.count]));
+
+    const coverage = depts.map((d) => {
+      // Find engineer that covers this department
+      const eng = profiles.find((p) => {
+        const covered = (p.coveredDepartmentIds as string[]) || [];
+        return covered.includes(d.id);
+      });
+
+      return {
+        id: d.id,
+        name: d.name,
+        code: d.code,
+        deviceCount: devCountMap.get(d.id) || 0,
+        primaryEngineer: eng
+          ? {
+              id: eng.id,
+              fullName: eng.user?.fullName || 'Biomedical Engineer',
+              jobTitle: eng.jobTitle,
+              extension: eng.extension,
+              mobileNumber: eng.mobileNumber || eng.user?.phone || null,
+              dutyStatus: eng.dutyStatus as EngineerDutyStatus,
+            }
+          : null,
+      };
+    });
+
+    return { success: true, departments: coverage };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+

package/src/lib/actions/hospitals.ts

@@ -0,0 +1,148 @@
+'use server';
+
+import { db } from '@/lib/db';
+import { hospitals, departments } from '@/lib/db/schema';
+import { requireAuth, requireRole, requireScope } from '@/lib/auth/rbac';
+import { createAuditLog } from '@/lib/audit';
+import { createHospitalSchema, updateHospitalSchema } from '@/lib/validators/hospitals';
+import { DEFAULT_HOSPITAL_DEPARTMENTS } from '@/lib/constants/departments';
+import { eq, and } from 'drizzle-orm';
+
+export async function getHospitals(filters?: { organizationId?: string } | string) {
+  await requireAuth();
+  try {
+    const orgId = typeof filters === 'string' ? filters : filters?.organizationId;
+    const whereClause = orgId ? eq(hospitals.organizationId, orgId) : undefined;
+    const data = await db.query.hospitals.findMany({ where: whereClause });
+    return { success: true, data };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+export async function getHospitalById(id: string) {
+  await requireAuth();
+  try {
+    const data = await db.query.hospitals.findFirst({
+      where: eq(hospitals.id, id),
+    });
+    return { success: true, data };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+export async function createHospital(input: unknown) {
+  const session = await requireAuth();
+  const validated = createHospitalSchema.safeParse(input);
+  if (!validated.success) {
+    const msg = validated.error.issues?.[0]?.message || 'Validation failed';
+    return { success: false, error: msg };
+  }
+
+  await requireRole('SYS_ADMIN', 'ORG_ADMIN');
+  await requireScope({ organizationId: validated.data.organizationId });
+
+  try {
+    const payload = {
+      ...validated.data,
+      address: validated.data.address || null,
+      city: validated.data.city || null,
+      country: validated.data.country || null,
+      phone: validated.data.phone || null,
+      email: validated.data.email || null,
+      timezone: validated.data.timezone || null,
+    };
+
+    return await db.transaction(async (tx) => {
+      const [newHospital] = await tx.insert(hospitals).values(payload).returning();
+
+      // Automatically seed default clinical departments for the new hospital
+      for (const d of DEFAULT_HOSPITAL_DEPARTMENTS) {
+        await tx.insert(departments).values({
+          organizationId: newHospital.organizationId,
+          hospitalId: newHospital.id,
+          name: d.name,
+          code: d.code,
+          departmentType: d.departmentType,
+          status: 'active',
+          managerUserId: session.id,
+          createdByUserId: session.id,
+        }).onConflictDoNothing();
+      }
+
+      await createAuditLog(tx, {
+        action: 'CREATE',
+        entityType: 'hospital',
+        entityId: newHospital.id,
+        actorId: session.id,
+        details: payload,
+      });
+      return { success: true, data: newHospital };
+    });
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+export async function updateHospital(id: string, input: unknown) {
+  const session = await requireAuth();
+  const validated = updateHospitalSchema.safeParse(input);
+  if (!validated.success) return { success: false, error: validated.error.message };
+
+  await requireRole('SYS_ADMIN', 'ORG_ADMIN');
+
+  try {
+    const hospital = await db.query.hospitals.findFirst({ where: eq(hospitals.id, id) });
+    if (!hospital) return { success: false, error: 'Hospital not found' };
+    await requireScope({ organizationId: hospital.organizationId, hospitalId: id });
+
+    const payload: any = { ...validated.data };
+    if ('email' in payload) payload.email = payload.email || null;
+    if ('phone' in payload) payload.phone = payload.phone || null;
+    if ('address' in payload) payload.address = payload.address || null;
+    if ('city' in payload) payload.city = payload.city || null;
+    if ('country' in payload) payload.country = payload.country || null;
+    if ('timezone' in payload) payload.timezone = payload.timezone || null;
+
+    return await db.transaction(async (tx) => {
+      const [updated] = await tx.update(hospitals).set(payload).where(eq(hospitals.id, id)).returning();
+      await createAuditLog(tx, {
+        action: 'UPDATE',
+        entityType: 'hospital',
+        entityId: id,
+        actorId: session.id,
+        details: payload,
+      });
+      return { success: true, data: updated };
+    });
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+export async function archiveHospital(id: string) {
+  const session = await requireAuth();
+  await requireRole('SYS_ADMIN', 'ORG_ADMIN');
+  
+  try {
+    const hospital = await db.query.hospitals.findFirst({ where: eq(hospitals.id, id) });
+    if (!hospital) return { success: false, error: 'Hospital not found' };
+    await requireScope({ organizationId: hospital.organizationId, hospitalId: id });
+
+    return await db.transaction(async (tx) => {
+      const [archived] = await tx.update(hospitals).set({ status: 'archived' }).where(eq(hospitals.id, id)).returning();
+      await createAuditLog(tx, {
+        action: 'ARCHIVE',
+        entityType: 'hospital',
+        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/locations.ts

@@ -0,0 +1,115 @@
+'use server';
+
+import { db } from '@/lib/db';
+import { locations } from '@/lib/db/schema';
+import { requireAuth, requireRole, requireScope } from '@/lib/auth/rbac';
+import { createAuditLog } from '@/lib/audit';
+import { createLocationSchema, updateLocationSchema } from '@/lib/validators/locations';
+import { eq } from 'drizzle-orm';
+
+export async function getLocations(filters?: { hospitalId?: string; departmentId?: string }) {
+  await requireAuth();
+  try {
+    let whereClause = undefined;
+    if (filters?.departmentId) {
+      whereClause = eq(locations.departmentId, filters.departmentId);
+    } else if (filters?.hospitalId) {
+      whereClause = eq(locations.hospitalId, filters.hospitalId);
+    }
+    const data = await db.query.locations.findMany({ where: whereClause });
+    return { success: true, data };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+export async function getLocationTree(hospitalId: string) {
+  await requireAuth();
+  try {
+    const data = await db.query.locations.findMany({
+      where: eq(locations.hospitalId, hospitalId),
+    });
+    return { success: true, data };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+export async function createLocation(input: unknown) {
+  const session = await requireAuth();
+  const validated = createLocationSchema.safeParse(input);
+  if (!validated.success) return { success: false, error: validated.error.message };
+
+  await requireRole('SYS_ADMIN', 'ORG_ADMIN');
+  await requireScope({ organizationId: validated.data.organizationId, hospitalId: validated.data.hospitalId, departmentId: validated.data.departmentId });
+
+  try {
+    return await db.transaction(async (tx) => {
+      const [newLoc] = await tx.insert(locations).values(validated.data).returning();
+      await createAuditLog(tx, {
+        action: 'CREATE',
+        entityType: 'location',
+        entityId: newLoc.id,
+        actorId: session.id,
+        details: validated.data,
+      });
+      return { success: true, data: newLoc };
+    });
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+export async function updateLocation(id: string, input: unknown) {
+  const session = await requireAuth();
+  const validated = updateLocationSchema.safeParse(input);
+  if (!validated.success) return { success: false, error: validated.error.message };
+
+  await requireRole('SYS_ADMIN', 'ORG_ADMIN');
+
+  try {
+    const loc = await db.query.locations.findFirst({ where: eq(locations.id, id) });
+    if (!loc) return { success: false, error: 'Location not found' };
+    await requireScope({ organizationId: loc.organizationId, hospitalId: loc.hospitalId, departmentId: loc.departmentId, locationId: id });
+
+    return await db.transaction(async (tx) => {
+      const [updated] = await tx.update(locations).set(validated.data).where(eq(locations.id, id)).returning();
+      await createAuditLog(tx, {
+        action: 'UPDATE',
+        entityType: 'location',
+        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 archiveLocation(id: string) {
+  const session = await requireAuth();
+  await requireRole('SYS_ADMIN', 'ORG_ADMIN');
+  
+  try {
+    const loc = await db.query.locations.findFirst({ where: eq(locations.id, id) });
+    if (!loc) return { success: false, error: 'Location not found' };
+    await requireScope({ organizationId: loc.organizationId, hospitalId: loc.hospitalId, departmentId: loc.departmentId, locationId: id });
+
+    return await db.transaction(async (tx) => {
+      const [archived] = await tx.update(locations).set({ status: 'archived' }).where(eq(locations.id, id)).returning();
+      await createAuditLog(tx, {
+        action: 'ARCHIVE',
+        entityType: 'location',
+        entityId: id,
+        actorId: session.id,
+        details: { status: 'archived' },
+      });
+      return { success: true, data: archived };
+    });
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+