@striae-org/striae 4.2.0 → 4.3.0

package/app/utils/data/file-filters.ts

@@ -0,0 +1,201 @@
+import type { FileData } from '~/types';
+import type { FileConfirmationSummary } from '~/utils/data';
+
+export type FilesModalSortBy = 'recent' | 'filename' | 'confirmation' | 'classType';
+
+export type FilesModalConfirmationFilter =
+  | 'all'
+  | 'pending'
+  | 'confirmed'
+  | 'none-requested';
+
+export type FilesModalClassTypeFilter =
+  | 'all'
+  | 'Bullet'
+  | 'Cartridge Case'
+  | 'Shotshell'
+  | 'Other';
+
+export interface FilesModalPreferences {
+  sortBy: FilesModalSortBy;
+  confirmationFilter: FilesModalConfirmationFilter;
+  classTypeFilter: FilesModalClassTypeFilter;
+}
+
+export type FileConfirmationById = Record<string, FileConfirmationSummary>;
+
+const DEFAULT_CONFIRMATION_SUMMARY: FileConfirmationSummary = {
+  includeConfirmation: false,
+  isConfirmed: false,
+  updatedAt: '',
+};
+
+function getFileConfirmationState(fileId: string, statusById: FileConfirmationById): FileConfirmationSummary {
+  return statusById[fileId] || DEFAULT_CONFIRMATION_SUMMARY;
+}
+
+function getConfirmationRank(summary: FileConfirmationSummary): number {
+  if (summary.includeConfirmation && !summary.isConfirmed) {
+    return 0;
+  }
+
+  if (summary.includeConfirmation && summary.isConfirmed) {
+    return 1;
+  }
+
+  return 2;
+}
+
+function getClassTypeRank(classType: FileConfirmationSummary['classType']): number {
+  if (classType === 'Bullet') {
+    return 0;
+  }
+
+  if (classType === 'Cartridge Case') {
+    return 1;
+  }
+
+  if (classType === 'Shotshell') {
+    return 2;
+  }
+
+  if (classType === 'Other') {
+    return 3;
+  }
+
+  return 4;
+}
+
+function parseTimestamp(value: string): number {
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? 0 : parsed;
+}
+
+function matchesConfirmationFilter(
+  summary: FileConfirmationSummary,
+  confirmationFilter: FilesModalConfirmationFilter
+): boolean {
+  if (confirmationFilter === 'all') {
+    return true;
+  }
+
+  if (confirmationFilter === 'pending') {
+    return summary.includeConfirmation && !summary.isConfirmed;
+  }
+
+  if (confirmationFilter === 'confirmed') {
+    return summary.includeConfirmation && summary.isConfirmed;
+  }
+
+  return !summary.includeConfirmation;
+}
+
+function matchesClassTypeFilter(
+  summary: FileConfirmationSummary,
+  classTypeFilter: FilesModalClassTypeFilter
+): boolean {
+  if (classTypeFilter === 'all') {
+    return true;
+  }
+
+  if (classTypeFilter === 'Other') {
+    // Treat legacy/unset class types as Other for filtering.
+    return summary.classType === 'Other' || !summary.classType;
+  }
+
+  return summary.classType === classTypeFilter;
+}
+
+function matchesSearch(file: FileData, query: string): boolean {
+  const normalized = query.trim().toLowerCase();
+  if (!normalized) {
+    return true;
+  }
+
+  return file.originalFilename.toLowerCase().includes(normalized);
+}
+
+export function filterFilesForModal(
+  files: FileData[],
+  preferences: FilesModalPreferences,
+  statusById: FileConfirmationById,
+  searchQuery: string
+): FileData[] {
+  return files.filter((file) => {
+    const summary = getFileConfirmationState(file.id, statusById);
+
+    return (
+      matchesSearch(file, searchQuery) &&
+      matchesConfirmationFilter(summary, preferences.confirmationFilter) &&
+      matchesClassTypeFilter(summary, preferences.classTypeFilter)
+    );
+  });
+}
+
+function compareFileNames(a: string, b: string): number {
+  return a.localeCompare(b, undefined, { numeric: true, sensitivity: 'base' });
+}
+
+export function sortFilesForModal(
+  files: FileData[],
+  sortBy: FilesModalSortBy,
+  statusById: FileConfirmationById
+): FileData[] {
+  const next = [...files];
+
+  if (sortBy === 'recent') {
+    return next.sort((left, right) => {
+      const difference = parseTimestamp(right.uploadedAt) - parseTimestamp(left.uploadedAt);
+      if (difference !== 0) {
+        return difference;
+      }
+
+      return compareFileNames(left.originalFilename, right.originalFilename);
+    });
+  }
+
+  if (sortBy === 'filename') {
+    return next.sort((left, right) =>
+      compareFileNames(left.originalFilename, right.originalFilename)
+    );
+  }
+
+  if (sortBy === 'confirmation') {
+    return next.sort((left, right) => {
+      const leftSummary = getFileConfirmationState(left.id, statusById);
+      const rightSummary = getFileConfirmationState(right.id, statusById);
+      const difference = getConfirmationRank(leftSummary) - getConfirmationRank(rightSummary);
+
+      if (difference !== 0) {
+        return difference;
+      }
+
+      return compareFileNames(left.originalFilename, right.originalFilename);
+    });
+  }
+
+  return next.sort((left, right) => {
+    const leftSummary = getFileConfirmationState(left.id, statusById);
+    const rightSummary = getFileConfirmationState(right.id, statusById);
+    const difference = getClassTypeRank(leftSummary.classType) - getClassTypeRank(rightSummary.classType);
+
+    if (difference !== 0) {
+      return difference;
+    }
+
+    return compareFileNames(left.originalFilename, right.originalFilename);
+  });
+}
+
+export function getFilesForModal(
+  files: FileData[],
+  preferences: FilesModalPreferences,
+  statusById: FileConfirmationById,
+  searchQuery: string
+): FileData[] {
+  return sortFilesForModal(
+    filterFilesForModal(files, preferences, statusById, searchQuery),
+    preferences.sortBy,
+    statusById
+  );
+}

package/app/utils/data/index.ts

@@ -1,2 +1,12 @@
-export * from './data-operations';
+export * from './operations';
 export * from './permissions';
+
+export {
+  getConfirmationSummaryTelemetry,
+  resetConfirmationSummaryTelemetry,
+  type CaseConfirmationSummary,
+  type ConfirmationSummaryEnsureOptions,
+  type ConfirmationSummaryTelemetry,
+  type FileConfirmationSummary,
+  type UserConfirmationSummaryDocument
+} from './confirmation-summary/summary-core';

package/app/utils/data/operations/batch-operations.ts

@@ -0,0 +1,113 @@
+import type { User } from 'firebase/auth';
+
+import { canModifyCase, validateUserSession } from '../permissions';
+import { getCaseData, updateCaseData } from './case-operations';
+import { getFileAnnotations, saveFileAnnotations } from './file-annotation-operations';
+import type { BatchUpdateResult, DataOperationOptions, FileUpdate } from './types';
+
+/**
+ * Update multiple files with annotation data in a single operation.
+ */
+export const batchUpdateFiles = async (
+  user: User,
+  caseNumber: string,
+  updates: FileUpdate[],
+  options: DataOperationOptions = {}
+): Promise<BatchUpdateResult> => {
+  const result: BatchUpdateResult = {
+    successful: [],
+    failed: []
+  };
+
+  try {
+    const sessionValidation = await validateUserSession(user);
+    if (!sessionValidation.valid) {
+      throw new Error(`Session validation failed: ${sessionValidation.reason}`);
+    }
+
+    const modifyCheck = await canModifyCase(user, caseNumber);
+    if (!modifyCheck.allowed) {
+      throw new Error(`Batch update denied: ${modifyCheck.reason}`);
+    }
+
+    const perFileOptions: DataOperationOptions = {
+      ...options,
+      skipValidation: true
+    };
+
+    for (const update of updates) {
+      try {
+        await saveFileAnnotations(user, caseNumber, update.fileId, update.annotations, perFileOptions);
+        result.successful.push(update.fileId);
+      } catch (error) {
+        result.failed.push({
+          fileId: update.fileId,
+          error: error instanceof Error ? error.message : 'Unknown error'
+        });
+      }
+    }
+
+    return result;
+  } catch (error) {
+    for (const update of updates) {
+      result.failed.push({
+        fileId: update.fileId,
+        error: error instanceof Error ? error.message : 'Batch operation failed'
+      });
+    }
+    return result;
+  }
+};
+
+/**
+ * Duplicate case data from one case to another (for case renaming operations).
+ */
+export const duplicateCaseData = async (
+  user: User,
+  fromCaseNumber: string,
+  toCaseNumber: string,
+  options: { skipDestinationCheck?: boolean } = {}
+): Promise<void> => {
+  try {
+    if (!options.skipDestinationCheck) {
+      const accessResult = await canModifyCase(user, toCaseNumber);
+      if (!accessResult.allowed) {
+        throw new Error(`User does not have permission to create or modify case ${toCaseNumber}: ${accessResult.reason || 'Access denied'}`);
+      }
+    }
+
+    const sourceCaseData = await getCaseData(user, fromCaseNumber);
+    if (!sourceCaseData) {
+      throw new Error(`Source case ${fromCaseNumber} not found`);
+    }
+
+    const newCaseData = {
+      ...sourceCaseData,
+      caseNumber: toCaseNumber,
+      updatedAt: new Date().toISOString()
+    };
+
+    await updateCaseData(user, toCaseNumber, newCaseData);
+
+    if (sourceCaseData.files && sourceCaseData.files.length > 0) {
+      const updates: FileUpdate[] = [];
+
+      for (const file of sourceCaseData.files) {
+        const annotations = await getFileAnnotations(user, fromCaseNumber, file.id);
+        if (annotations) {
+          updates.push({
+            fileId: file.id,
+            annotations
+          });
+        }
+      }
+
+      if (updates.length > 0) {
+        await batchUpdateFiles(user, toCaseNumber, updates);
+      }
+    }
+  } catch (error) {
+    console.error(`Error duplicating case data from ${fromCaseNumber} to ${toCaseNumber}:`, error);
+    throw error;
+  }
+};

package/app/utils/data/operations/case-operations.ts

@@ -0,0 +1,168 @@
+import type { User } from 'firebase/auth';
+import type { CaseData } from '~/types';
+
+import { fetchDataApi } from '../../api';
+import { canAccessCase, canModifyCase, validateUserSession } from '../permissions';
+import type { DataOperationOptions } from './types';
+
+/**
+ * Get case data from R2 storage with validation and error handling.
+ */
+export const getCaseData = async (
+  user: User,
+  caseNumber: string,
+  options: DataOperationOptions = {}
+): Promise<CaseData | null> => {
+  try {
+    const sessionValidation = await validateUserSession(user);
+    if (!sessionValidation.valid) {
+      throw new Error(`Session validation failed: ${sessionValidation.reason}`);
+    }
+
+    if (options.skipValidation !== true) {
+      const accessCheck = await canAccessCase(user, caseNumber);
+      if (!accessCheck.allowed) {
+        return null;
+      }
+    }
+
+    if (!caseNumber || typeof caseNumber !== 'string' || caseNumber.trim() === '') {
+      throw new Error('Invalid case number provided');
+    }
+
+    const response = await fetchDataApi(
+      user,
+      `/${encodeURIComponent(user.uid)}/${encodeURIComponent(caseNumber)}/data.json`,
+      {
+        method: 'GET'
+      }
+    );
+
+    if (response.status === 404) {
+      return null;
+    }
+
+    if (!response.ok) {
+      throw new Error(`Failed to fetch case data: ${response.status} ${response.statusText}`);
+    }
+
+    const caseData = await response.json() as CaseData;
+    return caseData;
+  } catch (error) {
+    console.error(`Error fetching case data for ${caseNumber}:`, error);
+    throw error;
+  }
+};
+
+/**
+ * Update case data in R2 storage with validation and timestamps.
+ */
+export const updateCaseData = async (
+  user: User,
+  caseNumber: string,
+  caseData: CaseData,
+  options: DataOperationOptions = {}
+): Promise<void> => {
+  try {
+    const sessionValidation = await validateUserSession(user);
+    if (!sessionValidation.valid) {
+      throw new Error(`Session validation failed: ${sessionValidation.reason}`);
+    }
+
+    const modifyCheck = await canModifyCase(user, caseNumber);
+    if (!modifyCheck.allowed) {
+      throw new Error(`Modification denied: ${modifyCheck.reason}`);
+    }
+
+    if (!caseNumber || typeof caseNumber !== 'string') {
+      throw new Error('Invalid case number provided');
+    }
+
+    if (!caseData || typeof caseData !== 'object') {
+      throw new Error('Invalid case data provided');
+    }
+
+    const dataToSave = options.includeTimestamp !== false
+      ? {
+          ...caseData,
+          updatedAt: new Date().toISOString()
+        }
+      : caseData;
+
+    const response = await fetchDataApi(
+      user,
+      `/${encodeURIComponent(user.uid)}/${encodeURIComponent(caseNumber)}/data.json`,
+      {
+        method: 'PUT',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(dataToSave)
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error(`Failed to update case data: ${response.status} ${response.statusText}`);
+    }
+  } catch (error) {
+    console.error(`Error updating case data for ${caseNumber}:`, error);
+    throw error;
+  }
+};
+
+/**
+ * Delete case data from R2 storage with validation.
+ */
+export const deleteCaseData = async (
+  user: User,
+  caseNumber: string,
+  options: DataOperationOptions = {}
+): Promise<void> => {
+  try {
+    const sessionValidation = await validateUserSession(user);
+    if (!sessionValidation.valid) {
+      throw new Error(`Session validation failed: ${sessionValidation.reason}`);
+    }
+
+    if (options.skipValidation !== true) {
+      const modifyCheck = await canModifyCase(user, caseNumber);
+      if (!modifyCheck.allowed) {
+        throw new Error(`Delete denied: ${modifyCheck.reason}`);
+      }
+    }
+
+    const response = await fetchDataApi(
+      user,
+      `/${encodeURIComponent(user.uid)}/${encodeURIComponent(caseNumber)}/data.json`,
+      {
+        method: 'DELETE'
+      }
+    );
+
+    if (!response.ok && response.status !== 404) {
+      throw new Error(`Failed to delete case data: ${response.status} ${response.statusText}`);
+    }
+  } catch (error) {
+    console.error(`Error deleting case data for ${caseNumber}:`, error);
+    throw error;
+  }
+};
+
+/**
+ * Check if a case exists in storage.
+ */
+export const caseExists = async (
+  user: User,
+  caseNumber: string
+): Promise<boolean> => {
+  try {
+    const caseData = await getCaseData(user, caseNumber);
+    return caseData !== null;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes('Access denied')) {
+      return false;
+    }
+    console.error(`Error checking case existence for ${caseNumber}:`, error);
+    return false;
+  }
+};