@striae-org/striae 4.0.3 → 4.2.0

package/app/components/audit/viewer/audit-viewer-header.tsx

@@ -0,0 +1,55 @@
+import styles from '../user-audit.module.css';
+
+interface AuditViewerHeaderProps {
+  title: string;
+  hasEntries: boolean;
+  onExportCSV: () => void;
+  onExportJSON: () => void;
+  onGenerateReport: () => void;
+  onClose: () => void;
+}
+
+export const AuditViewerHeader = ({
+  title,
+  hasEntries,
+  onExportCSV,
+  onExportJSON,
+  onGenerateReport,
+  onClose,
+}: AuditViewerHeaderProps) => {
+  return (
+    <div className={styles.header}>
+      <h2 className={styles.title}>{title}</h2>
+      <div className={styles.headerActions}>
+        {hasEntries && (
+          <div className={styles.exportButtons}>
+            <button
+              onClick={onExportCSV}
+              className={styles.exportButton}
+              title="CSV - Individual entry log with summary data"
+            >
+              📊 CSV
+            </button>
+            <button
+              onClick={onExportJSON}
+              className={styles.exportButton}
+              title="JSON - Complete log data for version capture and auditing"
+            >
+              📄 JSON
+            </button>
+            <button
+              onClick={onGenerateReport}
+              className={styles.exportButton}
+              title="Summary report only"
+            >
+              📋 Report
+            </button>
+          </div>
+        )}
+        <button className={styles.closeButton} onClick={onClose}>
+          ×
+        </button>
+      </div>
+    </div>
+  );
+};

package/app/components/audit/viewer/audit-viewer-utils.ts

@@ -0,0 +1,123 @@
+import { type AuditAction, type AuditResult, type ValidationAuditEntry } from '~/types';
+
+export interface AuditViewerSummaryStats {
+  totalEntries: number;
+  successfulEntries: number;
+  failedEntries: number;
+  loginSessions: number;
+  securityIncidents: number;
+}
+
+export const getAuditActionIcon = (action: AuditAction): string => {
+  switch (action) {
+    case 'user-login':
+      return '🔑';
+    case 'user-logout':
+      return '🚪';
+    case 'user-profile-update':
+      return '👤';
+    case 'user-password-reset':
+      return '🔒';
+    case 'user-registration':
+      return '📝';
+    case 'email-verification':
+      return '📧';
+    case 'mfa-enrollment':
+      return '🔐';
+    case 'mfa-authentication':
+      return '📱';
+    case 'case-create':
+      return '📂';
+    case 'case-rename':
+      return '✏️';
+    case 'case-delete':
+      return '🗑️';
+    case 'case-archive':
+      return '📦';
+    case 'case-export':
+      return '📤';
+    case 'case-import':
+      return '📥';
+    case 'confirmation-create':
+      return '✅';
+    case 'confirmation-export':
+      return '📤';
+    case 'confirmation-import':
+      return '📥';
+    case 'file-upload':
+      return '⬆️';
+    case 'file-delete':
+      return '🗑️';
+    case 'file-access':
+      return '👁️';
+    case 'annotation-create':
+      return '✨';
+    case 'annotation-edit':
+      return '✏️';
+    case 'annotation-delete':
+      return '❌';
+    case 'pdf-generate':
+      return '📄';
+    case 'security-violation':
+      return '🚨';
+    case 'export':
+      return '📤';
+    case 'import':
+      return '📥';
+    case 'confirm':
+      return '✓';
+    default:
+      return '📄';
+  }
+};
+
+export const getAuditStatusIcon = (result: AuditResult): string => {
+  switch (result) {
+    case 'success':
+      return '✅';
+    case 'failure':
+      return '❌';
+    case 'warning':
+      return '⚠️';
+    case 'blocked':
+      return '🛑';
+    case 'pending':
+      return '⏳';
+    default:
+      return '❓';
+  }
+};
+
+export const formatAuditTimestamp = (timestamp: string): string => {
+  return new Date(timestamp).toLocaleString();
+};
+
+export const summarizeAuditEntries = (entries: ValidationAuditEntry[]): AuditViewerSummaryStats => {
+  return entries.reduce<AuditViewerSummaryStats>((summary, entry) => {
+    summary.totalEntries += 1;
+
+    if (entry.result === 'success') {
+      summary.successfulEntries += 1;
+    }
+
+    if (entry.result === 'failure') {
+      summary.failedEntries += 1;
+    }
+
+    if (entry.action === 'user-login') {
+      summary.loginSessions += 1;
+    }
+
+    if (entry.action === 'security-violation') {
+      summary.securityIncidents += 1;
+    }
+
+    return summary;
+  }, {
+    totalEntries: 0,
+    successfulEntries: 0,
+    failedEntries: 0,
+    loginSessions: 0,
+    securityIncidents: 0
+  });
+};

package/app/components/audit/viewer/types.ts

@@ -0,0 +1 @@
+export type DateRangeFilter = '1d' | '7d' | '30d' | '90d' | 'custom';

package/app/components/audit/viewer/use-audit-viewer-data.ts

@@ -0,0 +1,186 @@
+import { useCallback, useEffect, useState } from 'react';
+import type { User } from 'firebase/auth';
+import { auditService } from '~/services/audit';
+import { type AuditTrail, type UserData, type ValidationAuditEntry, type WorkflowPhase } from '~/types';
+import { getCaseData, getUserData } from '~/utils/data';
+import type { DateRangeFilter } from './types';
+
+const isWorkflowPhase = (phase: unknown): phase is WorkflowPhase =>
+  phase === 'casework' ||
+  phase === 'case-export' ||
+  phase === 'case-import' ||
+  phase === 'confirmation' ||
+  phase === 'user-management';
+
+interface UseAuditViewerDataParams {
+  isOpen: boolean;
+  user: User | null;
+  effectiveCaseNumber?: string;
+  dateRange: DateRangeFilter;
+  customStartDate: string;
+  customEndDate: string;
+}
+
+interface AuditDateQuery {
+  startDate?: string;
+  endDate?: string;
+}
+
+const buildAuditDateQuery = (
+  dateRange: DateRangeFilter,
+  customStartDate: string,
+  customEndDate: string
+): AuditDateQuery => {
+  let startDate: string | undefined;
+  let endDate: string | undefined;
+
+  if (dateRange === 'custom') {
+    if (customStartDate) {
+      startDate = new Date(customStartDate + 'T00:00:00').toISOString();
+    }
+
+    if (customEndDate) {
+      endDate = new Date(customEndDate + 'T23:59:59').toISOString();
+    }
+
+    if (customStartDate && !customEndDate) {
+      endDate = new Date().toISOString();
+    } else if (!customStartDate && customEndDate) {
+      const startDateObj = new Date(customEndDate + 'T23:59:59');
+      startDateObj.setDate(startDateObj.getDate() - 30);
+      startDate = startDateObj.toISOString();
+    }
+  } else if (dateRange === '90d') {
+    const startDateObj = new Date();
+    startDateObj.setDate(startDateObj.getDate() - 90);
+    startDate = startDateObj.toISOString();
+    endDate = new Date().toISOString();
+  } else {
+    const days = parseInt(dateRange.replace('d', ''), 10);
+    const startDateObj = new Date();
+    startDateObj.setDate(startDateObj.getDate() - days);
+    startDate = startDateObj.toISOString();
+    endDate = new Date().toISOString();
+  }
+
+  return {
+    startDate,
+    endDate
+  };
+};
+
+export const useAuditViewerData = ({
+  isOpen,
+  user,
+  effectiveCaseNumber,
+  dateRange,
+  customStartDate,
+  customEndDate
+}: UseAuditViewerDataParams) => {
+  const [auditEntries, setAuditEntries] = useState<ValidationAuditEntry[]>([]);
+  const [userData, setUserData] = useState<UserData | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string>('');
+  const [auditTrail, setAuditTrail] = useState<AuditTrail | null>(null);
+  const [isArchivedReadOnlyCase, setIsArchivedReadOnlyCase] = useState(false);
+  const [bundledAuditWarning, setBundledAuditWarning] = useState<string>('');
+
+  const loadUserData = useCallback(async () => {
+    if (!user) {
+      return;
+    }
+
+    try {
+      const data = await getUserData(user);
+      setUserData(data);
+    } catch (loadError) {
+      console.error('Failed to load user data:', loadError);
+    }
+  }, [user]);
+
+  const loadAuditData = useCallback(async () => {
+    if (!user?.uid) {
+      return;
+    }
+
+    setLoading(true);
+    setError('');
+    setBundledAuditWarning('');
+
+    try {
+      const { startDate, endDate } = buildAuditDateQuery(dateRange, customStartDate, customEndDate);
+
+      if (effectiveCaseNumber) {
+        const caseData = await getCaseData(user, effectiveCaseNumber);
+        const archivedReadOnlyCase = Boolean(caseData?.isReadOnly && caseData.archived === true);
+        setIsArchivedReadOnlyCase(archivedReadOnlyCase);
+
+        if (archivedReadOnlyCase && !caseData?.bundledAuditTrail?.entries?.length) {
+          setBundledAuditWarning(
+            'This imported archived case does not include bundled audit trail data. No audit entries are available for this case.'
+          );
+        }
+      } else {
+        setIsArchivedReadOnlyCase(false);
+      }
+
+      const entries = await auditService.getAuditEntriesForUser(user.uid, {
+        requestingUser: user,
+        caseNumber: effectiveCaseNumber,
+        startDate,
+        endDate,
+        limit: effectiveCaseNumber ? 1000 : 500
+      });
+
+      setAuditEntries(entries);
+
+      if (effectiveCaseNumber && entries.length > 0) {
+        const trail: AuditTrail = {
+          caseNumber: effectiveCaseNumber,
+          workflowId: `workflow-${effectiveCaseNumber}-${user.uid}`,
+          entries,
+          summary: {
+            totalEvents: entries.length,
+            successfulEvents: entries.filter(entry => entry.result === 'success').length,
+            failedEvents: entries.filter(entry => entry.result === 'failure').length,
+            warningEvents: entries.filter(entry => entry.result === 'warning').length,
+            workflowPhases: [...new Set(entries
+              .map(entry => entry.details.workflowPhase)
+              .filter(isWorkflowPhase))],
+            participatingUsers: [...new Set(entries.map(entry => entry.userId))],
+            startTimestamp: entries[entries.length - 1]?.timestamp || new Date().toISOString(),
+            endTimestamp: entries[0]?.timestamp || new Date().toISOString(),
+            complianceStatus: entries.some(entry => entry.result === 'failure') ? 'non-compliant' : 'compliant',
+            securityIncidents: entries.filter(entry => entry.action === 'security-violation').length
+          }
+        };
+        setAuditTrail(trail);
+      } else {
+        setAuditTrail(null);
+      }
+    } catch (loadError) {
+      setError(loadError instanceof Error ? loadError.message : 'Failed to load audit data');
+    } finally {
+      setLoading(false);
+    }
+  }, [user, dateRange, customStartDate, customEndDate, effectiveCaseNumber]);
+
+  useEffect(() => {
+    if (isOpen && user) {
+      void loadAuditData();
+      void loadUserData();
+    }
+  }, [isOpen, user, loadAuditData, loadUserData]);
+
+  return {
+    auditEntries,
+    userData,
+    loading,
+    error,
+    setError,
+    auditTrail,
+    isArchivedReadOnlyCase,
+    bundledAuditWarning,
+    loadAuditData
+  };
+};

package/app/components/audit/viewer/use-audit-viewer-export.ts

@@ -0,0 +1,176 @@
+import { useCallback } from 'react';
+import type { Dispatch, SetStateAction } from 'react';
+import type { User } from 'firebase/auth';
+import { auditExportService } from '~/services/audit';
+import type { AuditTrail, ValidationAuditEntry } from '~/types';
+
+interface UseAuditViewerExportParams {
+  user: User | null;
+  effectiveCaseNumber?: string;
+  filteredEntries: ValidationAuditEntry[];
+  auditTrail: AuditTrail | null;
+  setError: Dispatch<SetStateAction<string>>;
+}
+
+export const useAuditViewerExport = ({
+  user,
+  effectiveCaseNumber,
+  filteredEntries,
+  auditTrail,
+  setError
+}: UseAuditViewerExportParams) => {
+  const resolveExportContext = useCallback(() => {
+    if (!user) {
+      return null;
+    }
+
+    const identifier = effectiveCaseNumber || user.uid;
+    const scopeType: 'case' | 'user' = effectiveCaseNumber ? 'case' : 'user';
+
+    return {
+      identifier,
+      scopeType,
+      context: {
+        user,
+        scopeType,
+        scopeIdentifier: identifier,
+        caseNumber: effectiveCaseNumber || undefined
+      } as const
+    };
+  }, [user, effectiveCaseNumber]);
+
+  const handleExportCSV = useCallback(async () => {
+    const exportContextData = resolveExportContext();
+    if (!exportContextData) {
+      return;
+    }
+
+    const filename = auditExportService.generateFilename(
+      exportContextData.scopeType,
+      exportContextData.identifier,
+      'csv'
+    );
+
+    try {
+      if (auditTrail && effectiveCaseNumber) {
+        await auditExportService.exportAuditTrailToCSV(auditTrail, filename, exportContextData.context);
+      } else {
+        await auditExportService.exportToCSV(filteredEntries, filename, exportContextData.context);
+      }
+    } catch (exportError) {
+      console.error('Export failed:', exportError);
+      setError('Failed to export audit trail to CSV');
+    }
+  }, [resolveExportContext, auditTrail, effectiveCaseNumber, filteredEntries, setError]);
+
+  const handleExportJSON = useCallback(async () => {
+    const exportContextData = resolveExportContext();
+    if (!exportContextData) {
+      return;
+    }
+
+    const filename = auditExportService.generateFilename(
+      exportContextData.scopeType,
+      exportContextData.identifier,
+      'csv'
+    );
+
+    try {
+      if (auditTrail && effectiveCaseNumber) {
+        await auditExportService.exportAuditTrailToJSON(auditTrail, filename, exportContextData.context);
+      } else {
+        await auditExportService.exportToJSON(filteredEntries, filename, exportContextData.context);
+      }
+    } catch (exportError) {
+      console.error('Export failed:', exportError);
+      setError('Failed to export audit trail to JSON');
+    }
+  }, [resolveExportContext, auditTrail, effectiveCaseNumber, filteredEntries, setError]);
+
+  const handleGenerateReport = useCallback(async () => {
+    const exportContextData = resolveExportContext();
+    if (!exportContextData) {
+      return;
+    }
+
+    const resolvedUser = exportContextData.context.user;
+
+    const filename = `${exportContextData.scopeType}-audit-report-${exportContextData.identifier}-${new Date().toISOString().split('T')[0]}.txt`;
+
+    try {
+      let reportContent: string;
+
+      if (auditTrail && effectiveCaseNumber) {
+        reportContent = await auditExportService.generateReportSummary(auditTrail, exportContextData.context);
+      } else {
+        const totalEntries = filteredEntries.length;
+        const successfulActions = filteredEntries.filter(entry => entry.result === 'success').length;
+        const failedActions = filteredEntries.filter(entry => entry.result === 'failure').length;
+
+        const actionCounts = filteredEntries.reduce((accumulator, entry) => {
+          accumulator[entry.action] = (accumulator[entry.action] || 0) + 1;
+          return accumulator;
+        }, {} as Record<string, number>);
+
+        const detectedDateRange = filteredEntries.length > 0
+          ? {
+              earliest: new Date(Math.min(...filteredEntries.map(entry => new Date(entry.timestamp).getTime()))),
+              latest: new Date(Math.max(...filteredEntries.map(entry => new Date(entry.timestamp).getTime())))
+            }
+          : null;
+
+        reportContent = `${effectiveCaseNumber ? 'CASE' : 'USER'} AUDIT REPORT
+Generated: ${new Date().toISOString()}
+      ${effectiveCaseNumber ? `Case: ${effectiveCaseNumber}` : `User: ${resolvedUser.email}`}
+      ${effectiveCaseNumber ? '' : `User ID: ${resolvedUser.uid}`}
+
+=== SUMMARY ===
+Total Actions: ${totalEntries}
+Successful: ${successfulActions}
+Failed: ${failedActions}
+Success Rate: ${totalEntries > 0 ? ((successfulActions / totalEntries) * 100).toFixed(1) : 0}%
+
+${detectedDateRange ? `Date Range: ${detectedDateRange.earliest.toLocaleDateString()} - ${detectedDateRange.latest.toLocaleDateString()}` : 'No entries found'}
+
+=== ACTION BREAKDOWN ===
+${Object.entries(actionCounts)
+  .sort(([, actionCountA], [, actionCountB]) => actionCountB - actionCountA)
+  .map(([action, count]) => `${action}: ${count}`)
+  .join('\n')}
+
+=== RECENT ACTIVITIES ===
+${filteredEntries.slice(0, 10).map(entry =>
+  `${new Date(entry.timestamp).toLocaleString()} | ${entry.action} | ${entry.result}${entry.details.caseNumber ? ` | Case: ${entry.details.caseNumber}` : ''}`
+).join('\n')}
+
+Generated by Striae
+`;
+
+        reportContent = await auditExportService.appendSignedReportIntegrity(
+          reportContent,
+          exportContextData.context,
+          totalEntries
+        );
+      }
+
+      const blob = new Blob([reportContent], { type: 'text/plain' });
+      const url = URL.createObjectURL(blob);
+      const anchor = document.createElement('a');
+      anchor.href = url;
+      anchor.download = filename;
+      document.body.appendChild(anchor);
+      anchor.click();
+      document.body.removeChild(anchor);
+      URL.revokeObjectURL(url);
+    } catch (reportError) {
+      console.error('Report generation failed:', reportError);
+      setError('Failed to generate audit report');
+    }
+  }, [resolveExportContext, auditTrail, effectiveCaseNumber, filteredEntries, setError]);
+
+  return {
+    handleExportCSV,
+    handleExportJSON,
+    handleGenerateReport
+  };
+};

package/app/components/audit/viewer/use-audit-viewer-filters.ts

@@ -0,0 +1,141 @@
+import { useCallback, useMemo, useState } from 'react';
+import type { AuditAction, AuditResult, ValidationAuditEntry } from '~/types';
+import type { DateRangeFilter } from './types';
+
+export const useAuditViewerFilters = (caseNumber?: string) => {
+  const [filterAction, setFilterAction] = useState<AuditAction | 'all'>('all');
+  const [filterResult, setFilterResult] = useState<AuditResult | 'all'>('all');
+  const [filterCaseNumber, setFilterCaseNumber] = useState<string>('');
+  const [caseNumberInput, setCaseNumberInput] = useState<string>('');
+  const [filterBadgeId, setFilterBadgeId] = useState<string>('');
+  const [badgeIdInput, setBadgeIdInput] = useState<string>('');
+  const [dateRange, setDateRange] = useState<DateRangeFilter>('1d');
+  const [customStartDate, setCustomStartDate] = useState<string>('');
+  const [customEndDate, setCustomEndDate] = useState<string>('');
+  const [customStartDateInput, setCustomStartDateInput] = useState<string>('');
+  const [customEndDateInput, setCustomEndDateInput] = useState<string>('');
+
+  const handleApplyCaseFilter = useCallback(() => {
+    setFilterCaseNumber(caseNumberInput.trim());
+  }, [caseNumberInput]);
+
+  const handleClearCaseFilter = useCallback(() => {
+    setCaseNumberInput('');
+    setFilterCaseNumber('');
+  }, []);
+
+  const handleApplyBadgeFilter = useCallback(() => {
+    setFilterBadgeId(badgeIdInput.trim());
+  }, [badgeIdInput]);
+
+  const handleClearBadgeFilter = useCallback(() => {
+    setBadgeIdInput('');
+    setFilterBadgeId('');
+  }, []);
+
+  const handleApplyCustomDateRange = useCallback(() => {
+    setCustomStartDate(customStartDateInput);
+    setCustomEndDate(customEndDateInput);
+  }, [customStartDateInput, customEndDateInput]);
+
+  const handleClearCustomDateRange = useCallback(() => {
+    setCustomStartDateInput('');
+    setCustomEndDateInput('');
+    setCustomStartDate('');
+    setCustomEndDate('');
+  }, []);
+
+  const handleDateRangeChange = useCallback((value: DateRangeFilter) => {
+    setDateRange(value);
+    if (value === 'custom') {
+      setCustomStartDateInput(customStartDate);
+      setCustomEndDateInput(customEndDate);
+    }
+  }, [customStartDate, customEndDate]);
+
+  const getFilteredEntries = useCallback((entries: ValidationAuditEntry[]): ValidationAuditEntry[] => {
+    const normalizedBadgeFilter = filterBadgeId.trim().toLowerCase();
+
+    return entries.filter(entry => {
+      let actionMatch: boolean;
+      if (filterAction === 'all') {
+        actionMatch = true;
+      } else if (filterAction === 'confirmation-create') {
+        actionMatch = entry.action === 'confirm' || entry.action === 'confirmation-create';
+      } else if (filterAction === 'case-export') {
+        actionMatch = entry.action === 'export' && entry.details.workflowPhase === 'case-export';
+      } else if (filterAction === 'case-import') {
+        actionMatch = entry.action === 'import' && entry.details.workflowPhase === 'case-import';
+      } else if (filterAction === 'confirmation-export') {
+        actionMatch = entry.action === 'export' && entry.details.workflowPhase === 'confirmation';
+      } else if (filterAction === 'confirmation-import') {
+        actionMatch = entry.action === 'import' && entry.details.workflowPhase === 'confirmation';
+      } else {
+        actionMatch = entry.action === filterAction;
+      }
+
+      const resultMatch = filterResult === 'all' || entry.result === filterResult;
+      const entryBadgeId = entry.details.userProfileDetails?.badgeId?.trim().toLowerCase() || '';
+      const badgeMatch = normalizedBadgeFilter === '' || entryBadgeId.includes(normalizedBadgeFilter);
+
+      return actionMatch && resultMatch && badgeMatch;
+    });
+  }, [filterAction, filterResult, filterBadgeId]);
+
+  const dateRangeDisplay = useMemo(() => {
+    switch (dateRange) {
+      case '90d':
+        return 'Last 90 Days';
+      case 'custom':
+        if (customStartDate && customEndDate) {
+          const startFormatted = new Date(customStartDate).toLocaleDateString();
+          const endFormatted = new Date(customEndDate).toLocaleDateString();
+          return `${startFormatted} - ${endFormatted}`;
+        }
+        if (customStartDate) {
+          return `From ${new Date(customStartDate).toLocaleDateString()}`;
+        }
+        if (customEndDate) {
+          return `Until ${new Date(customEndDate).toLocaleDateString()}`;
+        }
+        return 'Custom Range';
+      default:
+        return `Last ${dateRange}`;
+    }
+  }, [dateRange, customStartDate, customEndDate]);
+
+  const effectiveCaseNumber = useMemo(() => {
+    const trimmedCaseNumber = filterCaseNumber.trim();
+    return caseNumber || trimmedCaseNumber || undefined;
+  }, [caseNumber, filterCaseNumber]);
+
+  return {
+    filterAction,
+    setFilterAction,
+    filterResult,
+    setFilterResult,
+    filterCaseNumber,
+    caseNumberInput,
+    setCaseNumberInput,
+    filterBadgeId,
+    badgeIdInput,
+    setBadgeIdInput,
+    dateRange,
+    customStartDate,
+    customEndDate,
+    customStartDateInput,
+    customEndDateInput,
+    setCustomStartDateInput,
+    setCustomEndDateInput,
+    handleApplyCaseFilter,
+    handleClearCaseFilter,
+    handleApplyBadgeFilter,
+    handleClearBadgeFilter,
+    handleApplyCustomDateRange,
+    handleClearCustomDateRange,
+    handleDateRangeChange,
+    getFilteredEntries,
+    dateRangeDisplay,
+    effectiveCaseNumber
+  };
+};