@striae-org/striae 4.0.3 → 4.2.0

package/app/components/actions/case-import/zip-processing.ts

@@ -1,14 +1,63 @@
 import type { User } from 'firebase/auth';
 import { type CaseExportData, type CaseImportPreview } from '~/types';
+import { getCaseData } from '~/utils/data';
 import { validateCaseNumber } from '../case-manage';
 import {
-  extractForensicManifestData,
   type SignedForensicManifest,
-  validateCaseIntegritySecure as validateForensicIntegrity,
-  verifyForensicManifestSignature
+  verifyCasePackageIntegrity
 } from '~/utils/forensics';
 import { validateExporterUid, removeForensicWarning } from './validation';
 
+function isArchivedExportData(parsedData: unknown): boolean {
+  if (!parsedData || typeof parsedData !== 'object') {
+    return false;
+  }
+
+  const root = parsedData as Record<string, unknown>;
+
+  if (root.archived === true) {
+    return true;
+  }
+
+  if (typeof root.archivedAt === 'string' && root.archivedAt.trim().length > 0) {
+    return true;
+  }
+
+  const metadata = root.metadata;
+  if (!metadata || typeof metadata !== 'object') {
+    return false;
+  }
+
+  const metadataRecord = metadata as Record<string, unknown>;
+
+  if (metadataRecord.archived === true) {
+    return true;
+  }
+
+  if (typeof metadataRecord.archivedAt === 'string' && metadataRecord.archivedAt.trim().length > 0) {
+    return true;
+  }
+
+  return false;
+}
+
+async function allowSelfImportForArchivedCase(
+  currentUser: User,
+  caseNumber: string,
+  parsedData: unknown
+): Promise<boolean> {
+  if (isArchivedExportData(parsedData)) {
+    return true;
+  }
+
+  try {
+    const existingCase = await getCaseData(currentUser, caseNumber);
+    return existingCase?.archived === true;
+  } catch {
+    return false;
+  }
+}
+
 function getLeafFileName(path: string): string {
   const segments = path.split('/').filter(Boolean);
   return segments.length > 0 ? segments[segments.length - 1] : path;
@@ -54,9 +103,11 @@ async function extractVerificationPublicKeyFromZip(
  * a reasonable portion from the end.
  */
 function extractImageIdFromFilename(exportFilename: string): string | null {
+  const leafFilename = getLeafFileName(exportFilename);
+
   // Remove extension first
-  const lastDotIndex = exportFilename.lastIndexOf('.');
-  const filenameWithoutExt = lastDotIndex === -1 ? exportFilename : exportFilename.substring(0, lastDotIndex);
+  const lastDotIndex = leafFilename.lastIndexOf('.');
+  const filenameWithoutExt = lastDotIndex === -1 ? leafFilename : leafFilename.substring(0, lastDotIndex);
   
   // UUID pattern: 8-4-4-4-12 (36 chars including hyphens)
   // Look for a pattern that matches this at the end
@@ -134,79 +185,72 @@ export async function previewCaseImport(zipFile: File, currentUser: User): Promi
         forensicManifest = JSON.parse(manifestContent) as SignedForensicManifest;
         
         if (forensicManifest) {
-          const manifestForValidation = extractForensicManifestData(forensicManifest);
-          if (!manifestForValidation) {
-            hashValid = false;
-            hashError = 'Validation failed.';
-
-            validationDetails = {
-              hasForensicManifest: true,
-              dataValid: false,
-              manifestValid: false,
-              signatureValid: false,
-              validationSummary: 'Manifest schema validation failed',
-              integrityErrors: [hashError]
-            };
-          } else {
-            // Extract image files for comprehensive validation
-            const imageFiles: { [filename: string]: Blob } = {};
-            const imagesFolder = zip.folder('images');
-            if (imagesFolder) {
-              await Promise.all(Object.keys(imagesFolder.files).map(async (path) => {
-                if (path.startsWith('images/') && !path.endsWith('/')) {
-                  const filename = path.replace('images/', '');
-                  const file = zip.file(path);
-                  if (file) {
-                    const blob = await file.async('blob');
-                    imageFiles[filename] = blob;
-                  }
+          // Extract image files for comprehensive validation
+          const imageFiles: { [filename: string]: Blob } = {};
+          const imagesFolder = zip.folder('images');
+          if (imagesFolder) {
+            await Promise.all(Object.keys(imagesFolder.files).map(async (path) => {
+              if (path.startsWith('images/') && !path.endsWith('/')) {
+                const filename = path.replace('images/', '');
+                const file = zip.file(path);
+                if (file) {
+                  const blob = await file.async('blob');
+                  imageFiles[filename] = blob;
                 }
-              }));
+              }
+            }));
+          }
+
+          const casePackageResult = await verifyCasePackageIntegrity({
+            cleanedContent,
+            imageFiles,
+            forensicManifest,
+            verificationPublicKeyPem,
+            bundledAuditFiles: {
+              auditTrailContent: await zip.file('audit/case-audit-trail.json')?.async('text'),
+              auditSignatureContent: await zip.file('audit/case-audit-signature.json')?.async('text')
             }
+          });
 
-            const signatureResult = await verifyForensicManifestSignature(
-              forensicManifest,
-              verificationPublicKeyPem
-            );
-          
-            // Perform comprehensive validation
-            const validation = await validateForensicIntegrity(
-              cleanedContent, 
-              imageFiles, 
-              manifestForValidation
-            );
-          
-            hashValid = validation.isValid && signatureResult.isValid;
+          const signatureResult = casePackageResult.signatureResult;
+          const validation = casePackageResult.integrityResult;
+          const bundledAuditVerification = casePackageResult.bundledAuditVerification;
 
-            if (!hashValid) {
-              const errorParts: string[] = [];
-              if (!signatureResult.isValid) {
-                errorParts.push('Signature validation failed.');
-              }
-              if (!validation.isValid) {
-                errorParts.push('Integrity validation failed.');
-              }
-              hashError = errorParts.length > 0 ? errorParts.join(' ') : 'Validation failed.';
-            }
+          hashValid = casePackageResult.isValid;
 
-            // Capture detailed validation information
-            const integrityErrors = [...validation.errors];
+          if (!hashValid) {
+            const errorParts: string[] = [];
             if (!signatureResult.isValid) {
-              integrityErrors.push(`Signature validation failed: ${signatureResult.error || 'Unknown signature error'}`);
+              errorParts.push('Signature validation failed.');
             }
+            if (!validation.isValid) {
+              errorParts.push('Integrity validation failed.');
+            }
+            if (bundledAuditVerification) {
+              errorParts.push(bundledAuditVerification.message);
+            }
+            hashError = errorParts.length > 0 ? errorParts.join(' ') : 'Validation failed.';
+          }
 
-            validationDetails = {
-              hasForensicManifest: true,
-              dataValid: validation.dataValid,
-              imageValidation: validation.imageValidation,
-              manifestValid: validation.manifestValid,
-              signatureValid: signatureResult.isValid,
-              signatureKeyId: signatureResult.keyId,
-              signatureError: signatureResult.error,
-              validationSummary: validation.summary,
-              integrityErrors
-            };
+          const integrityErrors = [...validation.errors];
+          if (!signatureResult.isValid) {
+            integrityErrors.push(`Signature validation failed: ${signatureResult.error || 'Unknown signature error'}`);
           }
+          if (bundledAuditVerification) {
+            integrityErrors.push(bundledAuditVerification.message);
+          }
+
+          validationDetails = {
+            hasForensicManifest: true,
+            dataValid: validation.dataValid,
+            imageValidation: validation.imageValidation,
+            manifestValid: validation.manifestValid,
+            signatureValid: signatureResult.isValid,
+            signatureKeyId: signatureResult.keyId,
+            signatureError: signatureResult.error,
+            validationSummary: validation.summary,
+            integrityErrors
+          };
           
         } else {
           // No forensic manifest found - cannot validate
@@ -239,7 +283,8 @@ export async function previewCaseImport(zipFile: File, currentUser: User): Promi
       };
     }
     
-    const caseData: CaseExportData = JSON.parse(cleanedContent);
+    const parsedCaseData = JSON.parse(cleanedContent) as unknown;
+    const caseData: CaseExportData = parsedCaseData as CaseExportData;
     
     // Validate case data structure
     if (!caseData.metadata?.caseNumber) {
@@ -250,6 +295,12 @@ export async function previewCaseImport(zipFile: File, currentUser: User): Promi
       throw new Error(`Invalid case number format: ${caseData.metadata.caseNumber}`);
     }
     
+    const isArchivedExport = await allowSelfImportForArchivedCase(
+      currentUser,
+      caseData.metadata.caseNumber,
+      parsedCaseData
+    );
+
     // Validate exporter UID exists in user database and is not current user
     if (caseData.metadata.exportedByUid) {
       const validation = await validateExporterUid(caseData.metadata.exportedByUid, currentUser);
@@ -258,7 +309,7 @@ export async function previewCaseImport(zipFile: File, currentUser: User): Promi
         throw new Error(`The original exporter is not a valid Striae user. This case cannot be imported.`);
       }
       
-      if (validation.isSelf) {
+      if (validation.isSelf && !isArchivedExport) {
         throw new Error(`You cannot import a case that you originally exported. Original analysts cannot review their own cases.`);
       }
     } else {
@@ -278,9 +329,11 @@ export async function previewCaseImport(zipFile: File, currentUser: User): Promi
     
     return {
       caseNumber: caseData.metadata.caseNumber,
+      archived: isArchivedExport,
       exportedBy: caseData.metadata.exportedBy || null,
       exportedByName: caseData.metadata.exportedByName || null,
       exportedByCompany: caseData.metadata.exportedByCompany || null,
+      exportedByBadgeId: caseData.metadata.exportedByBadgeId || null,
       exportDate: caseData.metadata.exportDate,
       totalFiles,
       caseCreatedDate: caseData.metadata.caseCreatedDate,
@@ -304,6 +357,11 @@ export async function parseImportZip(zipFile: File, currentUser: User): Promise<
   caseData: CaseExportData;
   imageFiles: { [filename: string]: Blob };
   imageIdMapping: { [exportFilename: string]: string }; // exportFilename -> originalImageId
+  isArchivedExport: boolean;
+  bundledAuditFiles?: {
+    auditTrailContent?: string;
+    auditSignatureContent?: string;
+  };
   metadata?: Record<string, unknown>;
   cleanedContent?: string; // Add cleaned content for hash validation
   verificationPublicKeyPem?: string;
@@ -333,6 +391,7 @@ export async function parseImportZip(zipFile: File, currentUser: User): Promise<
     
     // Extract and parse case data
     let caseData: CaseExportData;
+    let parsedCaseData: unknown;
     let cleanedContent: string = '';
     if (isJsonFormat) {
       const dataContent = await zip.file(dataFileName)?.async('text');
@@ -342,7 +401,8 @@ export async function parseImportZip(zipFile: File, currentUser: User): Promise<
       
       // Handle forensic protection warnings in JSON
       cleanedContent = removeForensicWarning(dataContent);
-      caseData = JSON.parse(cleanedContent);
+      parsedCaseData = JSON.parse(cleanedContent) as unknown;
+      caseData = parsedCaseData as CaseExportData;
     } else {
       throw new Error('CSV import not yet supported. Please use JSON format.');
     }
@@ -356,6 +416,12 @@ export async function parseImportZip(zipFile: File, currentUser: User): Promise<
       throw new Error(`Invalid case number format: ${caseData.metadata.caseNumber}`);
     }
     
+    const isArchivedExport = await allowSelfImportForArchivedCase(
+      currentUser,
+      caseData.metadata.caseNumber,
+      parsedCaseData
+    );
+
     // Validate exporter UID exists in user database and is not current user
     if (caseData.metadata.exportedByUid) {
       const validation = await validateExporterUid(caseData.metadata.exportedByUid, currentUser);
@@ -364,7 +430,7 @@ export async function parseImportZip(zipFile: File, currentUser: User): Promise<
         throw new Error(`The original exporter is not a valid Striae user. This case cannot be imported.`);
       }
       
-      if (validation.isSelf) {
+      if (validation.isSelf && !isArchivedExport) {
         throw new Error(`You cannot import a case that you originally exported. Original analysts cannot review their own cases.`);
       }
     } else {
@@ -377,19 +443,19 @@ export async function parseImportZip(zipFile: File, currentUser: User): Promise<
     const imagesFolder = zip.folder('images');
     
     if (imagesFolder) {
-      for (const [, file] of Object.entries(imagesFolder.files)) {
-        if (!file.dir && file.name.includes('/')) {
-          const exportFilename = file.name.split('/').pop();
-          if (exportFilename) {
-            const blob = await file.async('blob');
-            imageFiles[exportFilename] = blob;
-            
-            // Extract original image ID from filename
-            const originalImageId = extractImageIdFromFilename(exportFilename);
-            if (originalImageId) {
-              imageIdMapping[exportFilename] = originalImageId;
-            }
-          }
+      for (const [path, file] of Object.entries(imagesFolder.files)) {
+        if (!path.startsWith('images/') || path.endsWith('/') || file.dir) {
+          continue;
+        }
+
+        const exportFilename = path.replace('images/', '');
+        const blob = await file.async('blob');
+        imageFiles[exportFilename] = blob;
+
+        // Extract original image ID from filename
+        const originalImageId = extractImageIdFromFilename(exportFilename);
+        if (originalImageId) {
+          imageIdMapping[exportFilename] = originalImageId;
         }
       }
     }
@@ -397,6 +463,8 @@ export async function parseImportZip(zipFile: File, currentUser: User): Promise<
     // Extract forensic manifest if present
     let metadata: Record<string, unknown> | undefined;
     const manifestFile = zip.file('FORENSIC_MANIFEST.json');
+    const auditTrailContent = await zip.file('audit/case-audit-trail.json')?.async('text');
+    const auditSignatureContent = await zip.file('audit/case-audit-signature.json')?.async('text');
     
     if (manifestFile) {
       const manifestContent = await manifestFile.async('text');
@@ -407,6 +475,11 @@ export async function parseImportZip(zipFile: File, currentUser: User): Promise<
       caseData,
       imageFiles,
       imageIdMapping,
+      isArchivedExport,
+      bundledAuditFiles: {
+        auditTrailContent,
+        auditSignatureContent
+      },
       metadata,
       cleanedContent,
       verificationPublicKeyPem