@striae-org/striae 3.0.4

package/app/components/actions/case-export/core-export.ts

@@ -0,0 +1,328 @@
+import { User } from 'firebase/auth';
+import { AnnotationData, CaseExportData, AllCasesExportData, ExportOptions } from '~/types';
+import { fetchFiles } from '../image-manage';
+import { getNotes } from '../notes-manage';
+import { checkExistingCase, validateCaseNumber, listCases } from '../case-manage';
+import { getUserExportMetadata } from './metadata-helpers';
+
+/**
+ * Export all cases for a user
+ */
+export async function exportAllCases(
+  user: User,
+  options: ExportOptions = {},
+  onProgress?: (current: number, total: number, caseName: string) => void
+): Promise<AllCasesExportData> {
+  // NOTE: startTime tracking moved to download handlers
+  
+  try {
+    // NOTE: Audit workflow management moved to download handlers
+    
+    const {
+      includeMetadata = true
+    } = options;
+
+    // Get user export metadata
+    const userMetadata = await getUserExportMetadata(user);
+    
+    // Get list of all cases for the user
+    const caseNumbers = await listCases(user);
+    
+    if (!caseNumbers || caseNumbers.length === 0) {
+      throw new Error('No cases found for user');
+    }
+
+    const exportedCases: CaseExportData[] = [];
+    let totalFiles = 0;
+    let totalAnnotations = 0;
+    let totalConfirmations = 0;
+    let totalConfirmationsRequested = 0;
+    let casesWithFiles = 0;
+    let casesWithAnnotations = 0;
+    let casesWithoutFiles = 0;
+    let lastModified: string | undefined;
+    let earliestAnnotationDate: string | undefined;
+    let latestAnnotationDate: string | undefined;
+
+    // Export each case
+    for (let i = 0; i < caseNumbers.length; i++) {
+      const caseNumber = caseNumbers[i];
+      
+      // Report progress
+      if (onProgress) {
+        onProgress(i + 1, caseNumbers.length, caseNumber);
+      }
+
+      try {
+        const caseExport = await exportCaseData(user, caseNumber, options);
+        exportedCases.push(caseExport);
+
+        // Update totals
+        totalFiles += caseExport.metadata.totalFiles;
+        
+        if (caseExport.metadata.totalFiles > 0) {
+          casesWithFiles++;
+        } else {
+          casesWithoutFiles++;
+        }
+
+        // Count annotations and confirmations
+        const caseAnnotations = caseExport.files.filter(f => f.hasAnnotations).length;
+        if (caseAnnotations > 0) {
+          casesWithAnnotations++;
+          totalAnnotations += caseAnnotations;
+        }
+
+        // Count confirmations
+        if (caseExport.summary?.filesWithConfirmations) {
+          totalConfirmations += caseExport.summary.filesWithConfirmations;
+        }
+        if (caseExport.summary?.filesWithConfirmationsRequested) {
+          totalConfirmationsRequested += caseExport.summary.filesWithConfirmationsRequested;
+        }
+
+        // Track latest modification
+        if (caseExport.summary?.lastModified) {
+          if (!lastModified || caseExport.summary.lastModified > lastModified) {
+            lastModified = caseExport.summary.lastModified;
+          }
+        }
+
+        // Track annotation date range across all cases
+        if (caseExport.summary?.earliestAnnotationDate) {
+          if (!earliestAnnotationDate || caseExport.summary.earliestAnnotationDate < earliestAnnotationDate) {
+            earliestAnnotationDate = caseExport.summary.earliestAnnotationDate;
+          }
+        }
+        if (caseExport.summary?.latestAnnotationDate) {
+          if (!latestAnnotationDate || caseExport.summary.latestAnnotationDate > latestAnnotationDate) {
+            latestAnnotationDate = caseExport.summary.latestAnnotationDate;
+          }
+        }
+
+      } catch (error) {
+        // Get case creation date even for failed exports
+        let caseCreatedDate = new Date().toISOString(); // fallback
+        try {
+          const existingCase = await checkExistingCase(user, caseNumber);
+          if (existingCase?.createdAt) {
+            caseCreatedDate = existingCase.createdAt;
+          }
+        } catch {
+          // Use fallback date if case lookup fails
+        }
+
+        // Create a placeholder entry for failed exports
+        exportedCases.push({
+          metadata: {
+            caseNumber,
+            caseCreatedDate,
+            exportDate: new Date().toISOString(),
+            ...userMetadata,
+            striaeExportSchemaVersion: '1.0',
+            totalFiles: 0
+          },
+          files: [],
+          summary: {
+            filesWithAnnotations: 0,
+            filesWithoutAnnotations: 0,
+            totalBoxAnnotations: 0,
+            exportError: error instanceof Error ? error.message : 'Unknown error'
+          }
+        });
+        casesWithoutFiles++;
+      }
+    }
+
+    const allCasesExport: AllCasesExportData = {
+      metadata: {
+        exportDate: new Date().toISOString(),
+        ...userMetadata,
+        striaeExportSchemaVersion: '1.0',
+        totalCases: caseNumbers.length,
+        totalFiles,
+        totalAnnotations,
+        totalConfirmations,
+        totalConfirmationsRequested
+      },
+      cases: exportedCases
+    };
+
+    if (includeMetadata) {
+      allCasesExport.summary = {
+        casesWithFiles,
+        casesWithAnnotations,
+        casesWithoutFiles,
+        lastModified,
+        earliestAnnotationDate,
+        latestAnnotationDate
+      };
+    }
+
+    // Report completion
+    if (onProgress) {
+      onProgress(caseNumbers.length, caseNumbers.length, 'Export completed!');
+    }
+    
+    // NOTE: Audit logging moved to download handlers where actual filename and format are known
+    
+    return allCasesExport;
+
+  } catch (error) {
+    console.error('Export all cases failed:', error);
+    
+    // NOTE: Audit logging for failures moved to download handlers
+    
+    throw error;
+  }
+}
+
+/**
+ * Export case data with files and annotations
+ */
+export async function exportCaseData(
+  user: User,
+  caseNumber: string,
+  options: ExportOptions = {}
+): Promise<CaseExportData> {
+  // NOTE: startTime and fileName tracking moved to download handlers
+  
+  const {
+    includeMetadata = true
+  } = options;
+
+  // Get user export metadata
+  const userMetadata = await getUserExportMetadata(user);
+
+  // Validate case number format
+  if (!validateCaseNumber(caseNumber)) {
+    throw new Error('Invalid case number format');
+  }
+
+  // Check if case exists
+  const existingCase = await checkExistingCase(user, caseNumber);
+  if (!existingCase) {
+    throw new Error(`Case "${caseNumber}" does not exist`);
+  }
+
+  try {
+    // NOTE: Audit workflow management moved to download handlers
+    
+    // Fetch all files for the case
+    const files = await fetchFiles(user, caseNumber);
+    
+    if (!files || files.length === 0) {
+      throw new Error(`No files found for case: ${caseNumber}`);
+    }
+
+    // Collect file data with annotations
+    const filesWithAnnotations: CaseExportData['files'] = [];
+    let filesWithAnnotationsCount = 0;
+    let totalBoxAnnotations = 0;
+    let filesWithConfirmationsCount = 0;
+    let filesWithConfirmationsRequestedCount = 0;
+    let lastModified: string | undefined;
+    let earliestAnnotationDate: string | undefined;
+    let latestAnnotationDate: string | undefined;
+
+    for (const file of files) {
+      let annotations: AnnotationData | undefined;
+      let hasAnnotations = false;
+
+      try {
+        annotations = await getNotes(user, caseNumber, file.id) || undefined;
+        
+        // Check if file has any annotation data beyond just defaults
+        hasAnnotations = !!(annotations && (
+          annotations.additionalNotes ||
+          annotations.classNote ||
+          annotations.customClass ||
+          annotations.leftCase ||
+          annotations.rightCase ||
+          annotations.leftItem ||
+          annotations.rightItem ||
+          annotations.supportLevel ||
+          annotations.classType ||
+          (annotations.boxAnnotations && annotations.boxAnnotations.length > 0)
+        ));
+
+        if (hasAnnotations) {
+          filesWithAnnotationsCount++;
+          if (annotations?.boxAnnotations) {
+            totalBoxAnnotations += annotations.boxAnnotations.length;
+          }
+          
+          // Track confirmation data
+          if (annotations?.confirmationData) {
+            filesWithConfirmationsCount++;
+          }
+        }
+        
+        // Track confirmation requests separately (regardless of other annotations)
+        if (annotations?.includeConfirmation) {
+          filesWithConfirmationsRequestedCount++;
+        }
+          
+        // Track last modified (only for files with annotations)
+        if (hasAnnotations && annotations?.updatedAt) {
+          if (!lastModified || annotations.updatedAt > lastModified) {
+            lastModified = annotations.updatedAt;
+          }
+          
+          // Track annotation date range using earliest timestamp for first annotation
+          const annotationDateToCheck = annotations.earliestAnnotationTimestamp || annotations.updatedAt;
+          if (!earliestAnnotationDate || annotationDateToCheck < earliestAnnotationDate) {
+            earliestAnnotationDate = annotationDateToCheck;
+          }
+          if (!latestAnnotationDate || annotations.updatedAt > latestAnnotationDate) {
+            latestAnnotationDate = annotations.updatedAt;
+          }
+        }
+      } catch (error) {
+        // Continue without annotations for this file
+      }
+
+      filesWithAnnotations.push({
+        fileData: file,
+        annotations,
+        hasAnnotations
+      });
+    }
+
+    // Build export data
+    const exportData: CaseExportData = {
+      metadata: {
+        caseNumber,
+        caseCreatedDate: existingCase.createdAt,
+        exportDate: new Date().toISOString(),
+        ...userMetadata,
+        striaeExportSchemaVersion: '1.0',
+        totalFiles: files.length
+      },
+      files: filesWithAnnotations,
+      ...(includeMetadata && {
+        summary: {
+          filesWithAnnotations: filesWithAnnotationsCount,
+          filesWithoutAnnotations: files.length - filesWithAnnotationsCount,
+          totalBoxAnnotations,
+          filesWithConfirmations: filesWithConfirmationsCount,
+          filesWithConfirmationsRequested: filesWithConfirmationsRequestedCount,
+          lastModified,
+          earliestAnnotationDate,
+          latestAnnotationDate
+        }
+      })
+    };
+
+    // NOTE: Audit logging moved to download handlers where actual filename and format are known
+
+    return exportData;
+
+  } catch (error) {
+    console.error('Case export failed:', error);
+    
+    // NOTE: Audit logging for failures moved to download handlers
+    
+    throw error;
+  }
+}

package/app/components/actions/case-export/data-processing.ts

@@ -0,0 +1,167 @@
+import { CaseExportData } from '~/types';
+import { calculateSHA256Secure } from '~/utils/SHA256';
+import { CSV_HEADERS } from './types-constants';
+import { addForensicDataWarning } from './metadata-helpers';
+
+/**
+ * Generate metadata rows for tabular format
+ */
+export function generateMetadataRows(exportData: CaseExportData): string[][] {
+  return [
+    ['Case Export Report'],
+    [''],
+    ['Case Number', exportData.metadata.caseNumber],
+    ['Case Created Date', exportData.metadata.caseCreatedDate],
+    ['Export Date', exportData.metadata.exportDate],
+    ['Exported By (Email)', exportData.metadata.exportedBy || 'N/A'],
+    ['Exported By (UID)', exportData.metadata.exportedByUid || 'N/A'],
+    ['Exported By (Name)', exportData.metadata.exportedByName || 'N/A'],
+    ['Exported By (Company)', exportData.metadata.exportedByCompany || 'N/A'],
+    ['Striae Export Schema Version', exportData.metadata.striaeExportSchemaVersion],
+    ['Total Files', exportData.metadata.totalFiles.toString()],
+    [''],
+    ['Summary'],
+    ['Files with Annotations', (exportData.summary?.filesWithAnnotations || 0).toString()],
+    ['Files without Annotations', (exportData.summary?.filesWithoutAnnotations || 0).toString()],
+    ['Total Box Annotations', (exportData.summary?.totalBoxAnnotations || 0).toString()],
+    ['Files with Confirmations', (exportData.summary?.filesWithConfirmations || 0).toString()],
+    ['Files with Confirmations Requested', (exportData.summary?.filesWithConfirmationsRequested || 0).toString()],
+    ['Last Modified', exportData.summary?.lastModified || 'N/A'],
+    ['Earliest Annotation Date', exportData.summary?.earliestAnnotationDate || 'N/A'],
+    ['Latest Annotation Date', exportData.summary?.latestAnnotationDate || 'N/A'],
+    [''],
+    ['File Details']
+  ];
+}
+
+/**
+ * Process file data for tabular format (CSV/Excel)
+ */
+export function processFileDataForTabular(fileEntry: CaseExportData['files'][0]): string[][] {
+  // Full file data for the first row (excluding Additional Notes and Last Updated)
+  const fullFileData = [
+    fileEntry.fileData.id,
+    fileEntry.fileData.originalFilename,
+    fileEntry.fileData.uploadedAt,
+    fileEntry.hasAnnotations ? 'Yes' : 'No',
+    fileEntry.annotations?.leftCase || '',
+    fileEntry.annotations?.rightCase || '',
+    fileEntry.annotations?.leftItem || '',
+    fileEntry.annotations?.rightItem || '',
+    fileEntry.annotations?.caseFontColor || '',
+    fileEntry.annotations?.classType || '',
+    fileEntry.annotations?.customClass || '',
+    fileEntry.annotations?.classNote || '',
+    fileEntry.annotations?.indexType || '',
+    fileEntry.annotations?.indexNumber || '',
+    fileEntry.annotations?.indexColor || '',
+    fileEntry.annotations?.supportLevel || '',
+    fileEntry.annotations?.hasSubclass ? 'Yes' : 'No',
+    fileEntry.annotations?.includeConfirmation ? 'Yes' : 'No',
+    fileEntry.annotations?.confirmationData ? 'Confirmed' : (fileEntry.annotations?.includeConfirmation ? 'Requested' : 'Not Requested'),
+    fileEntry.annotations?.confirmationData?.fullName || '',
+    fileEntry.annotations?.confirmationData?.badgeId || '',
+    fileEntry.annotations?.confirmationData?.confirmedByEmail || '',
+    fileEntry.annotations?.confirmationData?.confirmedByCompany || '',
+    fileEntry.annotations?.confirmationData?.confirmationId || '',
+    fileEntry.annotations?.confirmationData?.timestamp || '',
+    fileEntry.annotations?.confirmationData?.confirmedAt || '',
+    (fileEntry.annotations?.boxAnnotations?.length || 0).toString()
+  ];
+
+  // Additional Notes and Last Updated (at the end)
+  const additionalFileData = [
+    fileEntry.annotations?.additionalNotes || '',
+    fileEntry.annotations?.updatedAt || ''
+  ];
+
+  // Calculate array sizes programmatically from CSV_HEADERS
+  const fileDataColumnCount = fullFileData.length; // Dynamic count based on actual data
+  const additionalDataColumnCount = additionalFileData.length; // Dynamic count based on actual data
+
+  // Empty row template for subsequent box annotations (file info columns empty)
+  const emptyFileData = Array(fileDataColumnCount).fill('');
+  const emptyAdditionalData = Array(additionalDataColumnCount).fill('');
+
+  const rows: string[][] = [];
+
+  // If there are box annotations, create a row for each one
+  if (fileEntry.annotations?.boxAnnotations && fileEntry.annotations.boxAnnotations.length > 0) {
+    fileEntry.annotations.boxAnnotations.forEach((box, index) => {
+      const rowData = index === 0 ? fullFileData : emptyFileData;
+      const additionalData = index === 0 ? additionalFileData : emptyAdditionalData;
+      
+      rows.push([
+        ...rowData,
+        box.id,
+        box.x.toString(),
+        box.y.toString(),
+        box.width.toString(),
+        box.height.toString(),
+        box.color || '',
+        box.label || '',
+        box.timestamp || '',
+        ...additionalData
+      ]);
+    });
+  } else {
+    // If no box annotations, still include one row with empty box data
+    rows.push([
+      ...fullFileData,
+      '', // Box ID
+      '', // Box X
+      '', // Box Y
+      '', // Box Width
+      '', // Box Height
+      '', // Box Color
+      '', // Box Label
+      '', // Box Timestamp
+      ...additionalFileData
+    ]);
+  }
+
+  return rows;
+}
+
+/**
+ * Generate CSV content from export data
+ */
+export async function generateCSVContent(exportData: CaseExportData, protectForensicData: boolean = true): Promise<string> {
+  // Case metadata section
+  const metadataRows = generateMetadataRows(exportData);
+
+  // File data rows
+  const fileRows: string[][] = [];
+  exportData.files.forEach(fileEntry => {
+    const processedRows = processFileDataForTabular(fileEntry);
+    fileRows.push(...processedRows);
+  });
+
+  // Combine data rows for hash calculation (excluding header comments)
+  const dataRows = [
+    ...metadataRows,
+    CSV_HEADERS,
+    ...fileRows
+  ];
+
+  const csvDataContent = dataRows.map(row => 
+    row.map(field => `"${String(field).replace(/"/g, '""')}"`).join(',')
+  ).join('\n');
+  
+  // Calculate hash for integrity verification
+  const hash = await calculateSHA256Secure(csvDataContent);
+  
+  // Create final CSV with hash header
+  const csvWithHash = [
+    `# Striae Case Export - Generated: ${new Date().toISOString()}`,
+    `# Case: ${exportData.metadata.caseNumber}`,
+    `# Total Files: ${exportData.metadata.totalFiles}`,
+    `# SHA-256 Hash: ${hash.toUpperCase()}`,
+    '# Verification: Recalculate SHA-256 of data rows only (excluding these comment lines)',
+    '',
+    csvDataContent
+  ].join('\n');
+
+  // Add forensic protection warning if enabled
+  return protectForensicData ? addForensicDataWarning(csvWithHash, 'csv') : csvWithHash;
+}