@omersx/bemms 0.0.0-stage → 1.0.0

package/src/lib/validators/signatures.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+
+export const signatureRequirementSchema = z.object({
+  purpose: z.enum(['accept', 'perform', 'review', 'approve', 'release', 'resolve', 'close']),
+  allowedRoles: z.array(z.string()).min(1, 'At least one role must be allowed'),
+  required: z.boolean(),
+});
+
+export const signaturePolicyActionSchema = z.enum([
+  'complete_corrective',
+  'complete_pm',
+  'complete_calibration',
+  'complete_testing',
+  'release_device',
+  'change_device_status',
+  'resolve_ticket',
+  'close_ticket',
+  'approve_exception',
+]);
+
+export const signaturePolicySchema = z.object({
+  id: z.string().uuid().optional(),
+  organizationId: z.string().uuid(),
+  hospitalId: z.string().uuid().nullable().optional(),
+  actionType: signaturePolicyActionSchema,
+  criticalityLevel: z.enum(['critical', 'high', 'medium', 'low']).nullable().optional(),
+  deviceCategoryId: z.string().uuid().nullable().optional(),
+  requiredSignatures: z.array(signatureRequirementSchema).min(1, 'At least one signature requirement is required'),
+  requireIndependentReview: z.boolean().default(false),
+  performerCanRelease: z.boolean().default(true),
+  requireReauth: z.boolean().default(true),
+  effectiveDate: z.date().or(z.string()).optional(),
+  isActive: z.boolean().default(true),
+  policyVersion: z.string().default('1.0'),
+});
+
+export const createSignaturePolicySchema = signaturePolicySchema.omit({
+  id: true,
+  organizationId: true,
+});
+
+export const updateSignaturePolicySchema = createSignaturePolicySchema.partial();
+
+export const signActionSchema = z.object({
+  signaturePurpose: z.enum(['accept', 'perform', 'review', 'approve', 'release', 'resolve', 'close', 'reject', 'amend', 'void']),
+  password: z.string().min(1, 'Password is required for signature authentication'),
+  comments: z.string().max(2000).optional(),
+});
+

package/src/lib/validators/system-settings.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+
+export const localizationSettingsSchema = z.object({
+  timezone: z.string().min(1, 'Timezone is required').default('UTC'),
+  dateFormat: z.enum(['YYYY-MM-DD', 'DD/MM/YYYY', 'MM/DD/YYYY']).default('YYYY-MM-DD'),
+  timeFormat: z.enum(['24h', '12h']).default('24h'),
+  language: z.enum(['en', 'ar']).default('en'),
+});
+
+export const securitySettingsSchema = z.object({
+  sessionTimeoutMinutes: z.coerce.number().int().min(5).max(1440).default(30),
+  passwordExpiryDays: z.coerce.number().int().min(0).max(365).default(90),
+  requireReAuthForSignatures: z.boolean().default(true),
+  maxLoginAttempts: z.coerce.number().int().min(3).max(10).default(5),
+});
+
+export const retentionSettingsSchema = z.object({
+  auditLogRetentionDays: z.coerce.number().int().min(30).max(3650).default(365), // 1 year default
+  pmAlertWindowDays: z.coerce.number().int().min(1).max(90).default(14), // 14 days lead time
+  attachmentQuotaMb: z.coerce.number().int().min(100).max(100000).default(5000), // 5GB
+});
+
+export const featuresSettingsSchema = z.object({
+  engineerRoundEnabled: z.boolean().default(false),
+});
+
+export const systemSettingsSchema = z.object({
+  localization: localizationSettingsSchema.default({
+    timezone: 'UTC',
+    dateFormat: 'YYYY-MM-DD',
+    timeFormat: '24h',
+    language: 'en',
+  }),
+  security: securitySettingsSchema.default({
+    sessionTimeoutMinutes: 30,
+    passwordExpiryDays: 90,
+    requireReAuthForSignatures: true,
+    maxLoginAttempts: 5,
+  }),
+  retention: retentionSettingsSchema.default({
+    auditLogRetentionDays: 365,
+    pmAlertWindowDays: 14,
+    attachmentQuotaMb: 5000,
+  }),
+  features: featuresSettingsSchema.default({
+    engineerRoundEnabled: false,
+  }),
+});
+
+export type SystemSettings = z.infer<typeof systemSettingsSchema>;
+export type LocalizationSettings = z.infer<typeof localizationSettingsSchema>;
+export type SecuritySettings = z.infer<typeof securitySettingsSchema>;
+export type RetentionSettings = z.infer<typeof retentionSettingsSchema>;
+export type FeaturesSettings = z.infer<typeof featuresSettingsSchema>;
+

package/src/lib/validators/tickets.ts

@@ -0,0 +1,125 @@
+import { z } from 'zod';
+
+export const createTicketSchema = z.object({
+  organizationId: z.string().uuid(),
+  deviceId: z.string().uuid().optional(),
+  hospitalId: z.string().uuid(),
+  departmentId: z.string().uuid(),
+  locationId: z.string().uuid().optional(),
+  source: z.enum(['qr_scan', 'department_device_selection', 'device_profile', 'manual_entry', 'import']),
+  ticketType: z.enum([
+    'device_problem', 'urgent_equipment_concern', 'maintenance_request',
+    'inspection_request', 'calibration_request', 'pm_followup'
+  ]).default('device_problem'),
+  title: z.string().min(5).max(200),
+  description: z.string().min(10).max(2000),
+  reportedImpact: z.enum(['device_usable', 'device_not_usable', 'patient_care_affected']),
+  reportedProblemCategory: z.enum([
+    'power_issue', 'device_not_starting', 'display_interface', 'alarm_problem',
+    'sensor_accessory', 'electrical_concern', 'mechanical_damage',
+    'software_configuration', 'performance_concern', 'maintenance_request', 'other'
+  ]).optional(),
+  reportedLocationCorrection: z.string().max(200).optional(),
+  requesterContactName: z.string().max(100).optional(),
+  requesterContactPhone: z.string().max(30).optional(),
+  roundVisitId: z.string().uuid().optional(),
+});
+
+export const triageTicketSchema = z.object({
+  priorityCode: z.enum(['p1_critical', 'p2_high', 'p3_normal', 'p4_low']),
+  priorityReason: z.string().max(500).optional(),
+  selectedMaintenanceType: z.enum([
+    'preventive_maintenance', 'corrective_maintenance', 'troubleshooting',
+    'inspection', 'calibration', 'electrical_safety_testing',
+    'performance_testing', 'installation_commissioning',
+    'software_configuration', 'decommissioning'
+  ]).optional(),
+  selectedTechnicalCategory: z.enum([
+    'electrical_power', 'display_user_interface', 'alarm_safety',
+    'sensor_measurement', 'mechanical', 'software_configuration',
+    'performance_output', 'accessory_consumable', 'physical_damage',
+    'communication_network', 'no_fault_found', 'other'
+  ]).optional(),
+  assignedEngineerUserId: z.string().uuid().optional(),
+  internalTriageNote: z.string().max(1000).optional(),
+});
+
+export const assignTicketSchema = z.object({
+  assignedEngineerUserId: z.string().uuid(),
+  assignedTeamId: z.string().uuid().optional(),
+  handoffNote: z.string().max(500).optional(),
+});
+
+export const acceptTicketSchema = z.object({
+  signaturePassword: z.string().optional(),
+  signatureComments: z.string().max(500).optional(),
+  note: z.string().max(500).optional(),
+}).optional().default({});
+
+export const updateTicketDeviceStatusSchema = z.object({
+  deviceStatusCode: z.enum([
+    'operational', 'operational_with_limitations', 'under_maintenance',
+    'under_repair', 'waiting_for_parts', 'awaiting_release', 'out_of_service', 'standby'
+  ]),
+  notes: z.string().min(3, 'Please provide an update note (minimum 3 characters)').max(1000),
+  partName: z.string().max(200).optional(),
+  supplierDetails: z.string().max(500).optional(),
+  limitationsNote: z.string().max(1000).optional(),
+});
+
+export const RESOLUTION_DEVICE_STATUSES = [
+  'operational', 'operational_with_limitations', 'awaiting_release',
+  'standby', 'out_of_service', 'decommissioned'
+] as const;
+
+export const resolveTicketSchema = z.object({
+  resolutionSummary: z.string().min(10, 'Resolution summary must be at least 10 characters').max(2000),
+  finalDeviceStatusCode: z.enum(RESOLUTION_DEVICE_STATUSES),
+  limitationsNote: z.string().max(1000).optional(),
+  signaturePassword: z.string().min(1, 'Password is required to sign ticket resolution').optional(),
+  signatureComments: z.string().max(500).optional(),
+});
+
+export const closeTicketSchema = z.object({
+  closureReason: z.string().max(500).optional(),
+  signaturePassword: z.string().min(1, 'Password is required to sign ticket closure').optional(),
+  signatureComments: z.string().max(500).optional(),
+});
+
+export const cancelTicketSchema = z.object({
+  cancellationReason: z.string().min(5).max(500),
+});
+
+export const reopenTicketSchema = z.object({
+  reopenReason: z.string().min(5).max(500),
+});
+
+export const createTicketCommentSchema = z.object({
+  body: z.string().min(1).max(5000),
+  visibility: z.enum(['public', 'internal']).default('public'),
+});
+
+export const ticketStatusTransitionSchema = z.object({
+  targetStatus: z.enum([
+    'new', 'acknowledged', 'in_triage', 'in_progress',
+    'waiting_requester', 'waiting_parts_vendor',
+    'resolved', 'closed', 'cancelled'
+  ]),
+  reason: z.string().max(500).optional(),
+  waitingDependencyType: z.string().max(100).optional(),
+});
+
+export const ticketFilterSchema = z.object({
+  search: z.string().optional(),
+  organizationId: z.string().uuid().optional(),
+  hospitalId: z.string().uuid().optional(),
+  departmentId: z.string().uuid().optional(),
+  statusCode: z.string().optional(),
+  priorityCode: z.string().optional(),
+  assignedEngineerUserId: z.string().uuid().optional(),
+  reportedByUserId: z.string().uuid().optional(),
+  deviceId: z.string().uuid().optional(),
+  page: z.number().int().positive().optional(),
+  pageSize: z.number().int().positive().max(100).optional(),
+});
+

package/src/lib/validators/users.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+
+export const inviteUserSchema = z.object({
+  fullName: z.string().min(2).max(100),
+  email: z.string().email(),
+  username: z.string().min(2).max(50).optional().nullable(),
+  jobTitle: z.string().optional(),
+  employeeIdentifier: z.string().optional(),
+  phone: z.string().optional(),
+  password: z.string().min(6).optional().nullable(),
+  organizationId: z.string().uuid(),
+  roleIds: z.array(z.string().uuid()),
+  hospitalId: z.string().uuid().optional().nullable(),
+  departmentId: z.string().uuid().optional().nullable(),
+  specialization: z.string().optional().nullable(),
+  dutyStatus: z.enum(['on_duty', 'on_call', 'in_maintenance', 'off_duty']).optional().nullable(),
+});
+
+export const addUserSchema = inviteUserSchema;
+
+export const updateUserProfileSchema = z.object({
+  fullName: z.string().min(2).max(100).optional(),
+  phone: z.string().optional(),
+  jobTitle: z.string().optional(),
+  employeeIdentifier: z.string().optional(),
+});
+
+export const assignRoleSchema = z.object({
+  userId: z.string().uuid(),
+  roleId: z.string().uuid(),
+  effectiveFrom: z.date().optional(),
+  effectiveTo: z.date().optional(),
+});
+
+export const assignScopeSchema = z.object({
+  userId: z.string().uuid(),
+  organizationId: z.string().uuid(),
+  scopeType: z.enum(['organization', 'hospital', 'department', 'location']),
+  hospitalId: z.string().uuid().optional(),
+  departmentId: z.string().uuid().optional(),
+  locationId: z.string().uuid().optional(),
+});
+

package/src/middleware.ts

@@ -0,0 +1,45 @@
+import { NextResponse, type NextRequest } from 'next/server';
+
+export function middleware(req: NextRequest) {
+  // Check for NextAuth / Auth.js session cookies (Edge-compatible, no pg/crypto imports)
+  const sessionToken =
+    req.cookies.get('authjs.session-token')?.value ||
+    req.cookies.get('__Secure-authjs.session-token')?.value ||
+    req.cookies.get('next-auth.session-token')?.value ||
+    req.cookies.get('__Secure-next-auth.session-token')?.value;
+
+  const isLoggedIn = !!sessionToken;
+  const { nextUrl } = req;
+
+  const isApiAuthRoute = nextUrl.pathname.startsWith('/api/auth');
+  const isPublicRoute = nextUrl.pathname === '/login' || nextUrl.pathname.startsWith('/scan');
+
+  if (isApiAuthRoute) {
+    return NextResponse.next();
+  }
+
+  if (isPublicRoute) {
+    if (isLoggedIn && nextUrl.pathname === '/login') {
+      return NextResponse.redirect(new URL('/dashboard', nextUrl));
+    }
+    return NextResponse.next();
+  }
+
+  if (!isLoggedIn) {
+    let callbackUrl = nextUrl.pathname;
+    if (nextUrl.search) {
+      callbackUrl += nextUrl.search;
+    }
+    const encodedCallbackUrl = encodeURIComponent(callbackUrl);
+    return NextResponse.redirect(new URL(`/login?callbackUrl=${encodedCallbackUrl}`, nextUrl));
+  }
+
+  return NextResponse.next();
+}
+
+export const config = {
+  matcher: [
+    '/((?!api|_next/static|_next/image|favicon.ico|manifest.webmanifest|sw.js|icons).*)',
+  ],
+};
+

package/tailwind.config.ts

@@ -0,0 +1,76 @@
+import type { Config } from "tailwindcss";
+import tailwindcssAnimate from "tailwindcss-animate";
+
+const config: Config = {
+    darkMode: ["class"],
+    content: [
+    "./src/pages/**/*.{js,ts,jsx,tsx,mdx}",
+    "./src/components/**/*.{js,ts,jsx,tsx,mdx}",
+    "./src/app/**/*.{js,ts,jsx,tsx,mdx}",
+    "./src/**/*.{js,ts,jsx,tsx,mdx}",
+  ],
+  theme: {
+  	extend: {
+  		colors: {
+  			background: 'hsl(var(--background))',
+  			foreground: 'hsl(var(--foreground))',
+  			card: {
+  				DEFAULT: 'hsl(var(--card))',
+  				foreground: 'hsl(var(--card-foreground))'
+  			},
+  			popover: {
+  				DEFAULT: 'hsl(var(--popover))',
+  				foreground: 'hsl(var(--popover-foreground))'
+  			},
+  			primary: {
+  				DEFAULT: 'hsl(var(--primary))',
+  				foreground: 'hsl(var(--primary-foreground))'
+  			},
+  			secondary: {
+  				DEFAULT: 'hsl(var(--secondary))',
+  				foreground: 'hsl(var(--secondary-foreground))'
+  			},
+  			muted: {
+  				DEFAULT: 'hsl(var(--muted))',
+  				foreground: 'hsl(var(--muted-foreground))'
+  			},
+  			accent: {
+  				DEFAULT: 'hsl(var(--accent))',
+  				foreground: 'hsl(var(--accent-foreground))'
+  			},
+  			destructive: {
+  				DEFAULT: 'hsl(var(--destructive))',
+  				foreground: 'hsl(var(--destructive-foreground))'
+  			},
+  			border: 'hsl(var(--border))',
+  			input: 'hsl(var(--input))',
+  			ring: 'hsl(var(--ring))',
+  			chart: {
+  				'1': 'hsl(var(--chart-1))',
+  				'2': 'hsl(var(--chart-2))',
+  				'3': 'hsl(var(--chart-3))',
+  				'4': 'hsl(var(--chart-4))',
+  				'5': 'hsl(var(--chart-5))'
+  			},
+  			sidebar: {
+  				DEFAULT: 'hsl(var(--sidebar-background))',
+  				foreground: 'hsl(var(--sidebar-foreground))',
+  				primary: 'hsl(var(--sidebar-primary))',
+  				'primary-foreground': 'hsl(var(--sidebar-primary-foreground))',
+  				accent: 'hsl(var(--sidebar-accent))',
+  				'accent-foreground': 'hsl(var(--sidebar-accent-foreground))',
+  				border: 'hsl(var(--sidebar-border))',
+  				ring: 'hsl(var(--sidebar-ring))'
+  			}
+  		},
+  		borderRadius: {
+  			lg: 'var(--radius)',
+  			md: 'calc(var(--radius) - 2px)',
+  			sm: 'calc(var(--radius) - 4px)'
+  		}
+  	}
+  },
+  plugins: [tailwindcssAnimate],
+};
+export default config;
+

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts", "src"],
+  "exclude": ["node_modules"]
+}
+