@striae-org/striae 3.0.4

package/app/components/actions/confirm-export.ts

@@ -0,0 +1,351 @@
+import { User } from 'firebase/auth';
+import { calculateSHA256Secure } from '~/utils/SHA256';
+import { getUserData } from '~/utils/permissions';
+import { getCaseData, updateCaseData, signConfirmationData } from '~/utils/data-operations';
+import { ConfirmationData, CaseConfirmations, CaseDataWithConfirmations, ConfirmationImportData } from '~/types';
+import { auditService } from '~/services/audit.service';
+
+/**
+ * Store a confirmation for a specific image, linked to the original image ID
+ */
+export async function storeConfirmation(
+  user: User,
+  caseNumber: string,
+  currentImageId: string,
+  confirmationData: ConfirmationData,
+  originalImageFileName?: string
+): Promise<boolean> {
+  const startTime = Date.now();
+  let originalImageId: string | undefined; // Declare at function level for error handling
+  
+  try {
+    // Start workflow for confirmation creation
+    auditService.startWorkflow(caseNumber);
+    
+    // Get the current case data using centralized function
+    const caseData = await getCaseData(user, caseNumber) as CaseDataWithConfirmations;
+    if (!caseData) {
+      throw new Error('Case not found');
+    }
+
+    // Find the original image ID for the current image
+    if (caseData.originalImageIds) {
+      // Find the original ID by looking up the current image ID in the mapping
+      for (const [origId, currentId] of Object.entries(caseData.originalImageIds)) {
+        if (currentId === currentImageId) {
+          originalImageId = origId;
+          break;
+        }
+      }
+    }
+
+    if (!originalImageId) {
+      throw new Error('Could not find original image ID for current image');
+    }
+
+    // Initialize confirmations object if it doesn't exist
+    if (!caseData.confirmations) {
+      caseData.confirmations = {};
+    }
+
+    // Initialize array for this original image if it doesn't exist
+    if (!caseData.confirmations[originalImageId]) {
+      caseData.confirmations[originalImageId] = [];
+    }
+
+    // Add the confirmation data directly (already complete from modal)
+    caseData.confirmations[originalImageId].push(confirmationData);
+
+    // Store the updated case data using centralized function
+    await updateCaseData(user, caseNumber, caseData);
+
+    console.log(`Confirmation stored for original image ${originalImageId}:`, confirmationData);
+    
+    // Log successful confirmation creation
+    const endTime = Date.now();
+    await auditService.logConfirmationCreation(
+      user,
+      caseNumber,
+      confirmationData.confirmationId,
+      'success',
+      [],
+      undefined, // Original examiner UID not available in this context
+      {
+        processingTimeMs: endTime - startTime,
+        fileSizeBytes: 0 // Not applicable for confirmation creation
+      },
+      originalImageId,
+      originalImageFileName
+    );
+    
+    auditService.endWorkflow();
+    
+    return true;
+
+  } catch (error) {
+    console.error('Failed to store confirmation:', error);
+    
+    // Log failed confirmation creation
+    const endTime = Date.now();
+    await auditService.logConfirmationCreation(
+      user,
+      caseNumber,
+      confirmationData?.confirmationId || 'unknown',
+      'failure',
+      [error instanceof Error ? error.message : 'Unknown error'],
+      undefined,
+      {
+        processingTimeMs: endTime - startTime,
+        fileSizeBytes: 0
+      },
+      originalImageId || currentImageId, // Use originalImageId if available, fallback to currentImageId
+      originalImageFileName
+    );
+    
+    auditService.endWorkflow();
+    
+    return false;
+  }
+}
+
+/**
+ * Get all confirmations for a case (useful for the original analyst)
+ */
+export async function getCaseConfirmations(
+  user: User,
+  caseNumber: string
+): Promise<CaseConfirmations | null> {
+  try {
+    const caseData = await getCaseData(user, caseNumber) as CaseDataWithConfirmations;
+    if (!caseData) {
+      console.error('Case not found');
+      return null;
+    }
+
+    return caseData.confirmations || null;
+
+  } catch (error) {
+    console.error('Failed to get case confirmations:', error);
+    return null;
+  }
+}
+
+/**
+ * Get case data with forensic manifest information if available
+ */
+export async function getCaseDataWithManifest(
+  user: User,
+  caseNumber: string
+): Promise<{ confirmations: CaseConfirmations | null; forensicManifestCreatedAt?: string }> {
+  try {
+    const caseData = await getCaseData(user, caseNumber) as CaseDataWithConfirmations & { forensicManifestCreatedAt?: string };
+    if (!caseData) {
+      console.error('Case not found');
+      return { confirmations: null };
+    }
+    
+    return {
+      confirmations: caseData.confirmations || null,
+      forensicManifestCreatedAt: caseData.forensicManifestCreatedAt
+    };
+
+  } catch (error) {
+    console.error('Failed to get case data with manifest:', error);
+    return { confirmations: null };
+  }
+}
+
+/**
+ * Get confirmations for a specific original image ID
+ */
+export async function getImageConfirmations(
+  user: User,
+  caseNumber: string,
+  originalImageId: string
+): Promise<ConfirmationData[]> {
+  try {
+    const confirmations = await getCaseConfirmations(user, caseNumber);
+    return confirmations?.[originalImageId] || [];
+  } catch (error) {
+    console.error('Failed to get image confirmations:', error);
+    return [];
+  }
+}
+
+/**
+ * Exports confirmation data as a JSON file with SHA256 hash for forensic integrity
+ */
+export async function exportConfirmationData(
+  user: User, 
+  caseNumber: string
+): Promise<void> {
+  const startTime = Date.now();
+  let signatureKeyId: string | undefined;
+  let signaturePresent = false;
+  let signatureValid = false;
+  
+  try {
+    // Start audit workflow
+    auditService.startWorkflow(caseNumber);
+    
+    // Get all confirmation data and forensic manifest info for the case
+    const { confirmations: caseConfirmations, forensicManifestCreatedAt } = await getCaseDataWithManifest(user, caseNumber);
+    
+    if (!caseConfirmations || Object.keys(caseConfirmations).length === 0) {
+      throw new Error('No confirmation data found for this case');
+    }
+
+    // Get user metadata for export (same as case exports)
+    let userMetadata = {
+      exportedBy: user.email || 'Unknown User',
+      exportedByUid: user.uid,
+      exportedByName: user.displayName || 'N/A',
+      exportedByCompany: 'N/A'
+    };
+
+    try {
+      const userData = await getUserData(user);
+      if (userData) {
+        userMetadata = {
+          exportedBy: user.email || 'Unknown User',
+          exportedByUid: userData.uid,
+          exportedByName: `${userData.firstName} ${userData.lastName}`.trim(),
+          exportedByCompany: userData.company
+        };
+      }
+    } catch (error) {
+      console.warn('Failed to fetch user data for confirmation export metadata:', error);
+    }
+
+    // Try to get the forensic manifest createdAt timestamp from the original case export
+    let originalExportCreatedAt: string | undefined = forensicManifestCreatedAt;
+    
+    if (!originalExportCreatedAt) {
+      console.warn(`No forensic manifest timestamp found for case ${caseNumber}. This case may have been imported before forensic linking was implemented, or the original export did not include a forensic manifest.`);
+    }
+
+    // Create export data with metadata
+    const exportData = {
+      metadata: {
+        caseNumber,
+        exportDate: new Date().toISOString(),
+        ...userMetadata,
+        totalConfirmations: Object.keys(caseConfirmations).length,
+        version: '2.0',
+        ...(originalExportCreatedAt && { originalExportCreatedAt })
+      },
+      confirmations: caseConfirmations
+    };
+
+    // Convert to JSON string for hash calculation
+    const jsonString = JSON.stringify(exportData, null, 2);
+    
+    // Calculate SHA-256 hash for data integrity using secure version for forensic data
+    const hash = await calculateSHA256Secure(jsonString);
+    
+    // Add hash prior to signing
+    const unsignedExportData: ConfirmationImportData = {
+      ...exportData,
+      metadata: {
+        ...exportData.metadata,
+        hash: hash.toUpperCase()
+      }
+    };
+
+    // Request server-side signature to prevent tamper-by-rehash attacks
+    const signingResult = await signConfirmationData(user, caseNumber, unsignedExportData);
+    signaturePresent = true;
+    signatureValid = true;
+    signatureKeyId = signingResult.signature.keyId;
+
+    const finalExportData: ConfirmationImportData = {
+      ...unsignedExportData,
+      metadata: {
+        ...unsignedExportData.metadata,
+        signatureVersion: signingResult.signatureVersion,
+        signature: signingResult.signature
+      }
+    };
+
+    // Convert final data to JSON blob
+    const finalJsonString = JSON.stringify(finalExportData, null, 2);
+    const blob = new Blob([finalJsonString], { type: 'application/json' });
+    
+    // Create download
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    
+    // Use local timezone for filename timestamp
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, '0');
+    const day = String(now.getDate()).padStart(2, '0');
+    const hours = String(now.getHours()).padStart(2, '0');
+    const minutes = String(now.getMinutes()).padStart(2, '0');
+    const seconds = String(now.getSeconds()).padStart(2, '0');
+    const timestampString = `${year}${month}${day}-${hours}${minutes}${seconds}`;
+    
+    a.download = `confirmation-data-${caseNumber}-${timestampString}.json`;
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    URL.revokeObjectURL(url);
+    
+    console.log(`Confirmation data exported for case ${caseNumber} with hash ${hash.toUpperCase()}`);
+    
+    // Log successful confirmation export
+    const endTime = Date.now();
+    const confirmationCount = Object.keys(caseConfirmations).length;
+    await auditService.logConfirmationExport(
+      user,
+      caseNumber,
+      `confirmation-data-${caseNumber}-${timestampString}.json`,
+      confirmationCount,
+      'success',
+      [],
+      undefined, // Original examiner UID not available here
+      {
+        processingTimeMs: endTime - startTime,
+        fileSizeBytes: new Blob([jsonString]).size,
+        validationStepsCompleted: confirmationCount,
+        validationStepsFailed: 0
+      },
+      {
+        present: signaturePresent,
+        valid: signatureValid,
+        keyId: signatureKeyId
+      }
+    );
+    
+    auditService.endWorkflow();
+    
+  } catch (error) {
+    console.error('Failed to export confirmation data:', error);
+    
+    // Log failed confirmation export
+    const endTime = Date.now();
+    await auditService.logConfirmationExport(
+      user,
+      caseNumber,
+      `confirmation-data-${caseNumber}-error.json`,
+      0,
+      'failure',
+      [error instanceof Error ? error.message : 'Unknown error'],
+      undefined,
+      {
+        processingTimeMs: endTime - startTime,
+        fileSizeBytes: 0
+      },
+      {
+        present: signaturePresent,
+        valid: signatureValid,
+        keyId: signatureKeyId
+      }
+    );
+    
+    auditService.endWorkflow();
+    
+    throw error;
+  }
+}

package/app/components/actions/generate-pdf.ts

@@ -0,0 +1,210 @@
+import paths from '~/config/config.json';
+import { AnnotationData } from '~/types/annotations';
+import { auditService } from '~/services/audit.service';
+import { User } from 'firebase/auth';
+
+interface GeneratePDFParams {
+  user: User;
+  selectedImage: string | undefined;
+  selectedFilename: string | undefined;
+  userCompany: string;
+  userFirstName: string;
+  currentCase: string;
+  annotationData: AnnotationData | null;
+  activeAnnotations: Set<string>;
+  setIsGeneratingPDF: (isGenerating: boolean) => void;
+  setToastType: (type: 'success' | 'error') => void;
+  setToastMessage: (message: string) => void;
+  setShowToast: (show: boolean) => void;
+  setToastDuration?: (duration: number) => void;
+}
+
+export const generatePDF = async ({
+  user,
+  selectedImage,
+  selectedFilename,
+  userCompany,
+  userFirstName,
+  currentCase,
+  annotationData,
+  activeAnnotations,
+  setIsGeneratingPDF,
+  setToastType,
+  setToastMessage,
+  setShowToast,
+  setToastDuration
+}: GeneratePDFParams) => {
+  setIsGeneratingPDF(true);
+  
+  // Track processing time for audit logging
+  const startTime = Date.now();
+  
+  // Show generating toast immediately with duration 0 (stays until manually closed or completion)
+  setToastType('success');
+  setToastMessage('Generating PDF report... This may take up to a minute.');
+  if (setToastDuration) setToastDuration(0);
+  setShowToast(true);
+  
+  try {
+    // Format current date in user's timezone
+    const now = new Date();
+    const currentDate = `${(now.getMonth() + 1).toString().padStart(2, '0')}/${now.getDate().toString().padStart(2, '0')}/${now.getFullYear()}`;
+    
+    // Format notes updated date in user's timezone if it exists
+    let notesUpdatedFormatted = '';
+    if (annotationData?.updatedAt) {
+      const updatedDate = new Date(annotationData.updatedAt);
+      notesUpdatedFormatted = `${(updatedDate.getMonth() + 1).toString().padStart(2, '0')}/${updatedDate.getDate().toString().padStart(2, '0')}/${updatedDate.getFullYear()}`;
+    }
+
+    const pdfData = {
+      imageUrl: selectedImage,
+      filename: selectedFilename,
+      userCompany: userCompany,
+      firstName: userFirstName,
+      caseNumber: currentCase,
+      annotationData,
+      activeAnnotations: Array.from(activeAnnotations), // Convert Set to Array
+      currentDate, // Pass formatted current date
+      notesUpdatedFormatted // Pass formatted notes updated date
+    };
+
+    const pdfRequest = {
+      reportFormat: 'striae',
+      data: pdfData,
+    };
+
+    const response = await fetch(paths.pdf_worker_url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(pdfRequest)
+    });
+
+    if (response.ok) {
+      const blob = await response.blob();
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement('a');
+      a.href = url;
+      
+      // Generate filename based on annotation data
+      let filename = 'striae-report';
+      
+      if (annotationData) {
+        const { leftCase, leftItem, rightCase, rightItem } = annotationData;
+        
+        // Build left and right parts
+        const leftPart = [leftCase, leftItem].filter(Boolean).join('-');
+        const rightPart = [rightCase, rightItem].filter(Boolean).join('-');
+        
+        if (leftPart && rightPart) {
+          filename = `striae-report-${leftPart}--${rightPart}`;
+        } else if (leftPart) {
+          filename = `striae-report-${leftPart}`;
+        } else if (rightPart) {
+          filename = `striae-report-${rightPart}`;
+        }
+      }
+      
+      // Fallback to case number if no annotation data
+      if (filename === 'striae-report' && currentCase) {
+        filename = `striae-report-${currentCase}`;
+      }
+      
+      // Final fallback to timestamp
+      if (filename === 'striae-report') {
+        filename = `striae-report-${Date.now()}`;
+      }
+      
+      // Sanitize filename and ensure .pdf extension
+      filename = filename.replace(/[<>:"/\\|?*]/g, '-') + '.pdf';
+      
+      a.download = filename;
+      document.body.appendChild(a);
+      a.click();
+      document.body.removeChild(a);
+      URL.revokeObjectURL(url);
+      
+      // Log successful PDF generation audit
+      try {
+        const processingTime = Date.now() - startTime;
+        await auditService.logPDFGeneration(
+          user,
+          filename,
+          currentCase || 'unknown-case',
+          'success',
+          processingTime,
+          blob.size,
+          [],
+          selectedImage, // Source file ID
+          selectedFilename // Source original filename
+        );
+      } catch (auditError) {
+        console.error('Failed to log PDF generation audit:', auditError);
+        // Continue with success flow even if audit logging fails
+      }
+      
+      // Show success toast
+      setToastType('success');
+      setToastMessage('PDF generated successfully!');
+      if (setToastDuration) setToastDuration(4000); // Reset to default duration for success message
+      setShowToast(true);
+    } else {
+      const errorText = await response.text();
+      console.error('PDF generation failed:', errorText);
+      
+      // Log failed PDF generation audit
+      try {
+        const processingTime = Date.now() - startTime;
+        await auditService.logPDFGeneration(
+          user,
+          `failed-pdf-${Date.now()}.pdf`,
+          currentCase || 'unknown-case',
+          'failure',
+          processingTime,
+          0, // No file size for failed generation
+          [errorText || 'PDF generation failed'],
+          selectedImage, // Source file ID
+          selectedFilename // Source original filename
+        );
+      } catch (auditError) {
+        console.error('Failed to log PDF generation failure audit:', auditError);
+        // Continue with error flow even if audit logging fails
+      }
+      
+      setToastType('error');
+      setToastMessage('Failed to generate PDF report');
+      if (setToastDuration) setToastDuration(4000); // Reset to default duration for error message
+      setShowToast(true);
+    }
+  } catch (error) {
+    console.error('Error generating PDF:', error);
+    
+    // Log error PDF generation audit
+    try {
+      const processingTime = Date.now() - startTime;
+      await auditService.logPDFGeneration(
+        user,
+        `error-pdf-${Date.now()}.pdf`,
+        currentCase || 'unknown-case',
+        'failure',
+        processingTime,
+        0, // No file size for failed generation
+        [error instanceof Error ? error.message : 'Unknown error generating PDF'],
+        selectedImage, // Source file ID
+        selectedFilename // Source original filename
+      );
+    } catch (auditError) {
+      console.error('Failed to log PDF generation error audit:', auditError);
+      // Continue with error flow even if audit logging fails
+    }
+    
+    setToastType('error');
+    setToastMessage('Error generating PDF report');
+    if (setToastDuration) setToastDuration(4000); // Reset to default duration for error message
+    setShowToast(true);
+  } finally {
+    setIsGeneratingPDF(false);
+  }
+};