@omersx/bemms 0.0.0-stage → 1.0.0

package/src/app/api/notifications/subscribe/route.ts

@@ -0,0 +1,54 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { savePushSubscription } from '@/lib/actions/notifications';
+import { getLogger } from '@/lib/logger';
+
+const log = getLogger('push-subscribe');
+
+const MAX_ENDPOINT_LENGTH = 2048;
+const MAX_KEY_LENGTH = 512;
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json();
+
+    if (!body.endpoint || !body.keys?.p256dh || !body.keys?.auth) {
+      return NextResponse.json(
+        { error: 'Invalid push subscription' },
+        { status: 400 }
+      );
+    }
+
+    // Validate input lengths to prevent abuse
+    if (
+      typeof body.endpoint !== 'string' ||
+      body.endpoint.length > MAX_ENDPOINT_LENGTH ||
+      typeof body.keys.p256dh !== 'string' ||
+      body.keys.p256dh.length > MAX_KEY_LENGTH ||
+      typeof body.keys.auth !== 'string' ||
+      body.keys.auth.length > MAX_KEY_LENGTH
+    ) {
+      return NextResponse.json(
+        { error: 'Invalid push subscription data' },
+        { status: 400 }
+      );
+    }
+
+    const subscription = await savePushSubscription({
+      endpoint: body.endpoint,
+      keys: {
+        p256dh: body.keys.p256dh,
+        auth: body.keys.auth,
+      },
+      userAgent: req.headers.get('user-agent') || undefined,
+    });
+
+    return NextResponse.json({ success: true, id: subscription.id });
+  } catch (error: unknown) {
+    // Log the real error server-side; return a generic message to the client
+    log.error('Push subscription error', error instanceof Error ? error : { message: String(error) });
+    return NextResponse.json(
+      { error: 'Failed to save push subscription' },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/notifications/vapid-key/route.ts

@@ -0,0 +1,7 @@
+import { NextResponse } from 'next/server';
+
+export async function GET() {
+  const publicKey = process.env.NEXT_PUBLIC_VAPID_PUBLIC_KEY || '';
+  return NextResponse.json({ publicKey });
+}
+

package/src/app/api/reports/export/route.ts

@@ -0,0 +1,102 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { requireAuth, requirePermission } from '@/lib/auth/rbac';
+import { getInventoryReport, getTicketPerformanceReport, getCostReport, getWorkloadReport } from '@/lib/actions/reports';
+import { generateCSV, formatReportMetadata } from '@/lib/utils/export';
+import { saveReportToHistory } from '@/lib/actions/report-history';
+
+export async function GET(req: NextRequest) {
+  try {
+    const user = await requireAuth();
+    await requirePermission('REPORTS', 'VIEW');
+
+    const searchParams = req.nextUrl.searchParams;
+    const reportType = searchParams.get('type') || searchParams.get('reportType');
+    
+    // Parse filters
+    const filters = Object.fromEntries(searchParams.entries());
+
+    let data: any[] = [];
+    let columns: { key: string; header: string }[] = [];
+
+    if (reportType === 'inventory') {
+      const results = await getInventoryReport(filters as any);
+      data = results;
+      columns = [
+        { key: 'groupId', header: 'Group' },
+        { key: 'totalCount', header: 'Total Devices' },
+        { key: 'operationalCount', header: 'Operational' },
+        { key: 'maintenanceCount', header: 'Under Maintenance' },
+        { key: 'outOfServiceCount', header: 'Out of Service' },
+        { key: 'decommissionedCount', header: 'Decommissioned' }
+      ];
+    } else if (reportType === 'tickets') {
+      const results = await getTicketPerformanceReport(filters as any);
+      data = [results];
+      columns = [
+        { key: 'total', header: 'Total Tickets' },
+        { key: 'openCount', header: 'Open Tickets' },
+        { key: 'closedCount', header: 'Closed Tickets' },
+        { key: 'avgResponseTime', header: 'Avg Response Time (hrs)' },
+        { key: 'avgResolutionTime', header: 'Avg Resolution Time (hrs)' },
+        { key: 'priorityP1', header: 'P1 Critical' },
+        { key: 'priorityP2', header: 'P2 High' },
+        { key: 'priorityP3', header: 'P3 Normal' },
+        { key: 'priorityP4', header: 'P4 Low' }
+      ];
+    } else if (reportType === 'costs') {
+      const results = await getCostReport(filters as any);
+      data = results.byCostType;
+      columns = [
+        { key: 'costType', header: 'Cost Type' },
+        { key: 'totalAmount', header: 'Total Amount' },
+        { key: 'count', header: 'Record Count' }
+      ];
+    } else if (reportType === 'workload') {
+      const results = await getWorkloadReport(filters as any);
+      data = results;
+      columns = [
+        { key: 'engineerId', header: 'Engineer ID' },
+        { key: 'assignedCount', header: 'Total Tasks' },
+        { key: 'completedCount', header: 'Completed Tasks' },
+        { key: 'inProgressCount', header: 'In Progress Tasks' },
+        { key: 'priorityP1Count', header: 'P1 Critical Tasks' },
+        { key: 'pmCount', header: 'Preventive Tasks' }
+      ];
+    } else {
+      return NextResponse.json({ error: 'Unsupported report type' }, { status: 400 });
+    }
+
+    const csvData = generateCSV(data, columns);
+    const metadata = formatReportMetadata({
+      reportType,
+      filters,
+      timezone: filters.timezone || 'UTC',
+      generatedAt: new Date(),
+      generatedBy: user.fullName || user.email,
+    });
+
+    const finalCsv = metadata + csvData;
+    const fileName = `${reportType}_report_${new Date().toISOString().split('T')[0]}.csv`;
+
+    await saveReportToHistory({
+      reportType,
+      title: `${reportType} Report`,
+      filters,
+      rowCount: data.length,
+      fileFormat: 'csv',
+      fileName
+    });
+
+    return new NextResponse(finalCsv, {
+      headers: {
+        'Content-Type': 'text/csv; charset=utf-8',
+        'Content-Disposition': `attachment; filename="${fileName}"`,
+      },
+    });
+
+  } catch (error: any) {
+    console.error('Export error:', error);
+    return NextResponse.json({ error: error.message || 'Internal Server Error' }, { status: 500 });
+  }
+}
+

package/src/app/api/tickets/[id]/attachments/route.ts

@@ -0,0 +1,129 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { db } from '@/lib/db';
+import { serviceTicketAttachments, serviceTickets } from '@/lib/db/schema';
+import { eq } from 'drizzle-orm';
+import { writeFile, mkdir } from 'fs/promises';
+import path from 'path';
+
+export const dynamic = 'force-dynamic';
+
+const MAX_FILE_SIZE = 20 * 1024 * 1024; // 20MB
+
+export async function POST(
+  req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const session = await auth();
+  if (!session?.user?.id) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+  }
+
+  const { id: ticketId } = await params;
+
+  try {
+    const ticket = await db.query.serviceTickets.findFirst({
+      where: eq(serviceTickets.id, ticketId),
+    });
+
+    if (!ticket) {
+      return NextResponse.json({ error: 'Ticket not found' }, { status: 404 });
+    }
+
+    const formData = await req.formData();
+    const file = formData.get('file') as File | null;
+    const visibility = (formData.get('visibility') as string) || 'public';
+
+    if (!file) {
+      return NextResponse.json({ error: 'No file provided' }, { status: 400 });
+    }
+
+    if (file.size > MAX_FILE_SIZE) {
+      return NextResponse.json(
+        { error: 'File exceeds maximum size of 20MB' },
+        { status: 400 }
+      );
+    }
+
+    // Sanitize filename and create unique storage name
+    const originalName = file.name || 'attachment';
+    const ext = path.extname(originalName) || '';
+    const baseName = path.basename(originalName, ext).replace(/[^a-zA-Z0-9_-]/g, '_');
+    const uniqueSuffix = `${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+    const savedFileName = `${baseName}-${uniqueSuffix}${ext}`;
+
+    const uploadDir = path.join(process.cwd(), 'public', 'uploads', 'tickets');
+    await mkdir(uploadDir, { recursive: true });
+
+    const filePath = path.join(uploadDir, savedFileName);
+    const buffer = Buffer.from(await file.arrayBuffer());
+    await writeFile(filePath, buffer);
+
+    const storageKey = `/uploads/tickets/${savedFileName}`;
+
+    const [attachment] = await db
+      .insert(serviceTicketAttachments)
+      .values({
+        serviceTicketId: ticketId,
+        fileName: originalName,
+        fileSize: file.size,
+        mimeType: file.type || 'application/octet-stream',
+        storageKey,
+        visibility: visibility as any,
+        uploadedByUserId: (session.user as any).id,
+      })
+      .returning();
+
+    return NextResponse.json({
+      success: true,
+      attachment: {
+        id: attachment.id,
+        fileName: attachment.fileName,
+        fileSize: attachment.fileSize,
+        mimeType: attachment.mimeType,
+        url: attachment.storageKey,
+        createdAt: attachment.createdAt,
+      },
+    });
+  } catch (error: any) {
+    console.error('[Attachment Upload] Error:', error);
+    return NextResponse.json(
+      { error: error.message || 'File upload failed' },
+      { status: 500 }
+    );
+  }
+}
+
+export async function GET(
+  req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const session = await auth();
+  if (!session?.user?.id) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+  }
+
+  const { id: ticketId } = await params;
+
+  try {
+    const attachments = await db.query.serviceTicketAttachments.findMany({
+      where: eq(serviceTicketAttachments.serviceTicketId, ticketId),
+      with: {
+        uploadedByUser: {
+          columns: {
+            id: true,
+            fullName: true,
+          },
+        },
+      },
+      orderBy: (t, { desc }) => [desc(t.createdAt)],
+    });
+
+    return NextResponse.json({ success: true, attachments });
+  } catch (error: any) {
+    return NextResponse.json(
+      { error: error.message || 'Failed to fetch attachments' },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/tickets/[id]/live-sync/route.ts

@@ -0,0 +1,52 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { db } from '@/lib/db';
+import { serviceTickets, serviceTicketComments } from '@/lib/db/schema';
+import { eq, sql } from 'drizzle-orm';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(
+  req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const session = await auth();
+  if (!session?.user?.id) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+  }
+
+  const { id: ticketId } = await params;
+
+  try {
+    const [ticket, commentResult] = await Promise.all([
+      db.query.serviceTickets.findFirst({
+        where: eq(serviceTickets.id, ticketId),
+        columns: {
+          id: true,
+          statusCode: true,
+          assignedEngineerUserId: true,
+          updatedAt: true,
+        },
+      }),
+      db.select({
+        count: sql<number>`count(*)::int`,
+      })
+      .from(serviceTicketComments)
+      .where(eq(serviceTicketComments.serviceTicketId, ticketId)),
+    ]);
+
+    if (!ticket) {
+      return NextResponse.json({ error: 'Not found' }, { status: 404 });
+    }
+
+    return NextResponse.json({
+      id: ticket.id,
+      statusCode: ticket.statusCode,
+      assignedEngineerUserId: ticket.assignedEngineerUserId,
+      updatedAt: ticket.updatedAt ? new Date(ticket.updatedAt).toISOString() : null,
+      commentCount: commentResult[0]?.count || 0,
+    });
+  } catch (error: any) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}

package/src/app/error.tsx

@@ -0,0 +1,54 @@
+'use client';
+
+import { useEffect } from 'react';
+import { Button } from '@/components/ui/button';
+import { Card, CardContent } from '@/components/ui/card';
+import { AlertTriangle, RotateCcw } from 'lucide-react';
+import Link from 'next/link';
+
+export default function GlobalError({
+  error,
+  reset,
+}: {
+  error: Error & { digest?: string };
+  reset: () => void;
+}) {
+  useEffect(() => {
+    // Only log full error details in development; production errors are
+    // captured server-side and identified by their digest hash.
+    if (process.env.NODE_ENV !== 'production') {
+      console.error('Unhandled application error:', error);
+    }
+  }, [error]);
+
+  return (
+    <div className="min-h-screen flex items-center justify-center p-4 bg-background">
+      <Card className="max-w-md w-full text-center">
+        <CardContent className="pt-8 pb-8 space-y-4">
+          <div className="h-12 w-12 rounded-full bg-destructive/10 text-destructive flex items-center justify-center mx-auto">
+            <AlertTriangle className="h-6 w-6" />
+          </div>
+          <h1 className="text-2xl font-bold tracking-tight">Something went wrong</h1>
+          <p className="text-sm text-muted-foreground">
+            An unexpected error occurred. Our engineering team has been notified.
+          </p>
+          {error.digest && (
+            <p className="text-xs font-mono text-muted-foreground bg-muted p-2 rounded">
+              Error ID: {error.digest}
+            </p>
+          )}
+          <div className="flex items-center justify-center gap-2 pt-2">
+            <Button onClick={reset} variant="default" className="min-h-[44px] gap-2">
+              <RotateCcw className="h-4 w-4" />
+              Try Again
+            </Button>
+            <Button asChild variant="outline" className="min-h-[44px]">
+              <Link href="/dashboard">Dashboard</Link>
+            </Button>
+          </div>
+        </CardContent>
+      </Card>
+    </div>
+  );
+}
+

package/src/app/globals.css

@@ -0,0 +1,89 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+@layer base {
+  :root {
+    --background: 0 0% 100%;
+    --foreground: 222.2 84% 4.9%;
+    --card: 0 0% 100%;
+    --card-foreground: 222.2 84% 4.9%;
+    --popover: 0 0% 100%;
+    --popover-foreground: 222.2 84% 4.9%;
+    --primary: 221.2 83.2% 53.3%;
+    --primary-foreground: 210 40% 98%;
+    --secondary: 210 40% 96.1%;
+    --secondary-foreground: 222.2 47.4% 11.2%;
+    --muted: 210 40% 96.1%;
+    --muted-foreground: 215.4 16.3% 46.9%;
+    --accent: 210 40% 96.1%;
+    --accent-foreground: 222.2 47.4% 11.2%;
+    --destructive: 0 84.2% 60.2%;
+    --destructive-foreground: 210 40% 98%;
+    --border: 214.3 31.8% 91.4%;
+    --input: 214.3 31.8% 91.4%;
+    --ring: 221.2 83.2% 53.3%;
+    --radius: 0.5rem;
+    --warning: 38 92% 50%;
+    --warning-foreground: 48 96% 89%;
+    --success: 142 76% 36%;
+    --success-foreground: 355.7 100% 97.3%;
+    --chart-1: 221 83% 53%;
+    --chart-2: 160 60% 45%;
+    --chart-3: 30 80% 55%;
+    --chart-4: 280 65% 60%;
+    --chart-5: 340 75% 55%;
+    --sidebar-background: 0 0% 100%;
+    --sidebar-foreground: 222.2 84% 4.9%;
+    --sidebar-primary: 221.2 83.2% 53.3%;
+    --sidebar-primary-foreground: 210 40% 98%;
+    --sidebar-accent: 210 40% 96.1%;
+    --sidebar-accent-foreground: 222.2 47.4% 11.2%;
+    --sidebar-border: 214.3 31.8% 91.4%;
+    --sidebar-ring: 221.2 83.2% 53.3%;
+  }
+
+  .dark {
+    --background: 224 71.4% 4.1%;
+    --foreground: 210 20% 98%;
+    --card: 224 71.4% 4.1%;
+    --card-foreground: 210 20% 98%;
+    --popover: 224 71.4% 4.1%;
+    --popover-foreground: 210 20% 98%;
+    --primary: 217.2 91.2% 59.8%;
+    --primary-foreground: 222.2 47.4% 11.2%;
+    --secondary: 215 27.9% 16.9%;
+    --secondary-foreground: 210 20% 98%;
+    --muted: 215 27.9% 16.9%;
+    --muted-foreground: 217.9 10.6% 64.9%;
+    --accent: 215 27.9% 16.9%;
+    --accent-foreground: 210 20% 98%;
+    --destructive: 0 62.8% 30.6%;
+    --destructive-foreground: 210 20% 98%;
+    --border: 215 27.9% 16.9%;
+    --input: 215 27.9% 16.9%;
+    --ring: 216 12.2% 83.9%;
+    --warning: 38 92% 50%;
+    --warning-foreground: 48 96% 89%;
+    --success: 142 71% 45%;
+    --success-foreground: 144 80% 95%;
+    --chart-1: 217 91% 60%;
+    --chart-2: 160 60% 45%;
+    --chart-3: 30 80% 55%;
+    --chart-4: 280 65% 60%;
+    --chart-5: 340 75% 55%;
+    --sidebar-background: 224 71.4% 4.1%;
+    --sidebar-foreground: 210 20% 98%;
+    --sidebar-primary: 217.2 91.2% 59.8%;
+    --sidebar-primary-foreground: 222.2 47.4% 11.2%;
+    --sidebar-accent: 215 27.9% 16.9%;
+    --sidebar-accent-foreground: 210 20% 98%;
+    --sidebar-border: 215 27.9% 16.9%;
+    --sidebar-ring: 216 12.2% 83.9%;
+  }
+}
+
+@layer base {
+  * { @apply border-border; }
+  body { @apply bg-background text-foreground; }
+}

package/src/app/layout.tsx

@@ -0,0 +1,59 @@
+import type { Metadata, Viewport } from 'next'
+import { Inter } from 'next/font/google'
+import './globals.css'
+import { Toaster } from 'sonner'
+import AuthProvider from '@/components/providers/session-provider'
+import { ThemeProvider } from '@/components/providers/theme-provider'
+import { ServiceWorkerRegister } from '@/components/pwa/sw-register'
+import { InstallPrompt } from '@/components/pwa/install-prompt'
+
+const inter = Inter({ subsets: ['latin'] })
+
+export const metadata: Metadata = {
+  title: 'BEMMS',
+  description: 'Biomedical Equipment Management and Maintenance System',
+  manifest: '/manifest.webmanifest',
+  appleWebApp: {
+    capable: true,
+    statusBarStyle: 'default',
+    title: 'BEMMS',
+  },
+  icons: {
+    icon: '/icons/icon-192.png',
+    apple: '/icons/icon-192.png',
+  },
+}
+
+export const viewport: Viewport = {
+  width: 'device-width',
+  initialScale: 1,
+  maximumScale: 1,
+  viewportFit: 'cover',
+  themeColor: '#2563eb',
+}
+
+export default function RootLayout({
+  children,
+}: {
+  children: React.ReactNode
+}) {
+  return (
+    <html lang="en" suppressHydrationWarning>
+      <body className={inter.className} suppressHydrationWarning>
+        <ThemeProvider
+          attribute="class"
+          defaultTheme="system"
+          enableSystem
+          disableTransitionOnChange
+        >
+          <AuthProvider>
+            {children}
+            <Toaster richColors closeButton />
+            <ServiceWorkerRegister />
+            <InstallPrompt />
+          </AuthProvider>
+        </ThemeProvider>
+      </body>
+    </html>
+  )
+}

package/src/app/not-found.tsx

@@ -0,0 +1,32 @@
+import Link from 'next/link';
+import { Button } from '@/components/ui/button';
+import { Card, CardContent } from '@/components/ui/card';
+import { Activity, ArrowLeft } from 'lucide-react';
+
+export default function NotFound() {
+  return (
+    <div className="min-h-screen flex items-center justify-center p-4 bg-background">
+      <Card className="max-w-md w-full text-center">
+        <CardContent className="pt-8 pb-8 space-y-4">
+          <div className="h-12 w-12 rounded-full bg-primary/10 text-primary flex items-center justify-center mx-auto">
+            <Activity className="h-6 w-6" />
+          </div>
+          <h1 className="text-3xl font-bold tracking-tight">404</h1>
+          <h2 className="text-lg font-semibold">Page Not Found</h2>
+          <p className="text-sm text-muted-foreground">
+            The requested page does not exist or has been moved.
+          </p>
+          <div className="pt-2">
+            <Button asChild className="min-h-[44px]">
+              <Link href="/dashboard" className="gap-2">
+                <ArrowLeft className="h-4 w-4" />
+                Back to Dashboard
+              </Link>
+            </Button>
+          </div>
+        </CardContent>
+      </Card>
+    </div>
+  );
+}
+

package/src/app/page.tsx

@@ -0,0 +1,5 @@
+import { redirect } from 'next/navigation'
+
+export default function Home() {
+  redirect('/dashboard')
+}