feat: Update document processing to use reportId instead of filePath and add report status checking

adamrefaey · adamrefaey · commit c9653221d4f0 · 2025-04-17T23:31:20.000+02:00
diff --git a/backend/src/document-processor/controllers/document-processor.controller.ts b/backend/src/document-processor/controllers/document-processor.controller.ts
@@ -39,7 +39,7 @@ export class DocumentProcessorController {
 
   @Post('upload')
   @UseInterceptors(FileInterceptor('file'))
-  async processDocument(
+  async uploadAndProcessReport(
     @UploadedFile() file: Express.Multer.File,
     @Body('userId') userId: string,
     @Body('debug') debug?: string,
@@ -115,12 +115,12 @@ export class DocumentProcessorController {
   }
 
   @Post('process-file')
-  async processFileFromPath(
-    @Body('filePath') filePath: string,
+  async processReport(
+    @Body('reportId') reportId: string,
     @Req() request: RequestWithUser,
-  ): Promise<ProcessedDocumentResult | any> {
-    if (!filePath) {
-      throw new BadRequestException('No filePath provided');
+  ): Promise<any> {
+    if (!reportId) {
+      throw new BadRequestException('No reportId provided');
     }
 
     // Extract userId from the request (attached by auth middleware)
@@ -129,21 +129,70 @@ export class DocumentProcessorController {
       throw new UnauthorizedException('User ID not found in request');
     }
 
-    this.logger.log(`Processing document from file path: ${filePath}`);
+    this.logger.log(`Queueing document for processing, report ID: ${reportId}`);
 
     try {
-      // Fetch the associated report record from DynamoDB
-      const report = await this.reportsService.findByFilePath(filePath, userId);
+      // Fetch the associated report record from DynamoDB using findOne method
+      const report = await this.reportsService.findOne(reportId, userId);
       if (!report) {
-        throw new NotFoundException(`Report with filePath ${filePath} not found`);
+        throw new NotFoundException(`Report with ID ${reportId} not found`);
+      }
+
+      // Make sure we have a filePath to retrieve the file
+      if (!report.filePath) {
+        throw new BadRequestException(`Report with ID ${reportId} has no associated file`);
       }
 
+      // Update report status to IN_PROGRESS before starting async processing
+      report.processingStatus = ProcessingStatus.IN_PROGRESS;
+      report.updatedAt = new Date().toISOString();
+      await this.reportsService.updateReport(report);
+
+      // Start async processing in background
+      this.processReportAsync(reportId, userId, report.filePath).catch(error => {
+        this.logger.error(`Async processing failed for report ${reportId}: ${error.message}`);
+      });
+
+      return {
+        success: true,
+        reportId: report.id,
+        status: ProcessingStatus.IN_PROGRESS,
+        message: 'Document processing started. Check the report status to know when it completes.',
+      };
+    } catch (error: unknown) {
+      this.logger.error(
+        `Error queueing document for report ID ${reportId}: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Processes a report file asynchronously
+   * @param reportId - ID of the report to process
+   * @param userId - ID of the user who owns the report
+   * @param filePath - S3 path to the file
+   */
+  private async processReportAsync(
+    reportId: string,
+    userId: string,
+    filePath: string,
+  ): Promise<void> {
+    try {
+      this.logger.log(`Started async processing for report: ${reportId}`);
+
       // Get the file from S3
       const fileBuffer = await this.getFileFromS3(filePath);
 
       // Process the document
       const result = await this.documentProcessorService.processDocument(fileBuffer, userId);
 
+      // Fetch the report again to ensure we have the latest version
+      const report = await this.reportsService.findOne(reportId, userId);
+      if (!report) {
+        throw new Error(`Report ${reportId} not found during async processing`);
+      }
+
       // Update the report with analysis results
       report.title = result.analysis.title || 'Untitled Report';
       report.category = result.analysis.category || 'general';
@@ -163,13 +212,26 @@ export class DocumentProcessorController {
       // Update the report in DynamoDB
       await this.reportsService.updateReport(report);
 
-      return {
-        success: true,
-        reportId: report.id,
-      };
-    } catch (error: unknown) {
+      this.logger.log(`Completed async processing for report: ${reportId}`);
+    } catch (error) {
+      // If processing fails, update the report status to indicate failure
+      try {
+        const report = await this.reportsService.findOne(reportId, userId);
+        if (report) {
+          report.processingStatus = ProcessingStatus.UNPROCESSED; // Could add a FAILED status in the enum if needed
+          report.updatedAt = new Date().toISOString();
+          await this.reportsService.updateReport(report);
+        }
+      } catch (updateError: unknown) {
+        this.logger.error(
+          `Failed to update report status after processing error: ${
+            updateError instanceof Error ? updateError.message : 'Unknown error'
+          }`,
+        );
+      }
+
       this.logger.error(
-        `Error processing document from path ${filePath}: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        `Error during async processing for report ${reportId}: ${error instanceof Error ? error.message : 'Unknown error'}`,
       );
       throw error;
     }
@@ -607,4 +669,42 @@ export class DocumentProcessorController {
 
     res.type('text/html').send(html);
   }
+
+  @Get('report-status/:reportId')
+  async getReportStatus(
+    @Req() request: RequestWithUser,
+    @Body('reportId') idFromBody: string,
+  ): Promise<any> {
+    // Get reportId from path parameter or body
+    const reportId = request.params.reportId || idFromBody;
+
+    if (!reportId) {
+      throw new BadRequestException('No reportId provided');
+    }
+
+    // Extract userId from the request (attached by auth middleware)
+    const userId = request.user?.sub;
+    if (!userId) {
+      throw new UnauthorizedException('User ID not found in request');
+    }
+
+    try {
+      // Fetch the associated report record from DynamoDB
+      const report = await this.reportsService.findOne(reportId, userId);
+      if (!report) {
+        throw new NotFoundException(`Report with ID ${reportId} not found`);
+      }
+
+      return {
+        reportId: report.id,
+        status: report.processingStatus,
+        isComplete: report.processingStatus === ProcessingStatus.PROCESSED,
+      };
+    } catch (error: unknown) {
+      this.logger.error(
+        `Error fetching report status for ${reportId}: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      );
+      throw error;
+    }
+  }
 }
diff --git a/frontend/src/common/components/Upload/UploadModal.tsx b/frontend/src/common/components/Upload/UploadModal.tsx
@@ -63,10 +63,10 @@ const UploadModal = ({ isOpen, onClose, onUploadComplete }: UploadModalProps): J
         if (onUploadComplete) {
           onUploadComplete(result);
         }
-        // Navigate to the processing tab with filePath in state
+        // Navigate to the processing tab with reportId in state
         if (file) {
           history.push('/tabs/processing', {
-            filePath: result.filePath,
+            reportId: result.id,
           });
         } else {
           history.push('/tabs/processing');
diff --git a/frontend/src/pages/Processing/Processing.tsx b/frontend/src/pages/Processing/Processing.tsx
@@ -2,7 +2,7 @@ import { IonContent, IonPage } from '@ionic/react';
 import { useCurrentUser } from '../../common/hooks/useAuth';
 import Avatar from '../../common/components/Icon/Avatar';
 import { useLocation, useHistory } from 'react-router-dom';
-import { useEffect, useState } from 'react';
+import { useEffect, useState, useRef } from 'react';
 import { useAxios } from '../../common/hooks/useAxios';
 import './Processing.scss';
 import { getAuthConfig } from 'common/api/reportService';
@@ -21,22 +21,62 @@ const Processing: React.FC = () => {
   // States to track processing
   const [isProcessing, setIsProcessing] = useState(true);
   const [processingError, setProcessingError] = useState<string | null>(null);
+  const statusCheckIntervalRef = useRef<number | null>(null);
 
-  // Get the location state which may contain the filePath
-  const location = useLocation<{ filePath: string }>();
-  const filePath = location.state?.filePath;
-  const [reportId, setReportId] = useState(null);
+  // Get the location state which may contain the reportId (previously filePath)
+  const location = useLocation<{ reportId: string }>();
+  const reportId = location.state?.reportId;
   const [isFetching, setIsFetching] = useState(false);
 
+  // Check the status of the report processing
+  const checkReportStatus = async () => {
+    if (!reportId) return;
+
+    try {
+      const response = await axios.get(
+        `${API_URL}/api/document-processor/report-status/${reportId}`,
+        await getAuthConfig(),
+      );
+
+      console.log('Report status:', response.data);
+
+      // If processing is complete, clear the interval and redirect to the report page
+      if (response.data.isComplete) {
+        setIsProcessing(false);
+
+        // Clear the interval
+        if (statusCheckIntervalRef.current) {
+          window.clearInterval(statusCheckIntervalRef.current);
+          statusCheckIntervalRef.current = null;
+        }
+
+        console.log('Processing complete');
+
+        // Redirect to report detail page
+        history.push(`/tabs/reports/${reportId}`);
+      }
+    } catch (error) {
+      console.error('Error checking report status:', error);
+      setProcessingError('Failed to check the status of the report. Please try again.');
+      setIsProcessing(false);
+
+      // Clear the interval on error
+      if (statusCheckIntervalRef.current) {
+        window.clearInterval(statusCheckIntervalRef.current);
+        statusCheckIntervalRef.current = null;
+      }
+    }
+  };
+
   // Send the API request when component mounts
   useEffect(() => {
-    if (!filePath) {
-      setProcessingError('No file path provided');
+    if (!reportId) {
+      setProcessingError('No report ID provided');
       setIsProcessing(false);
       return;
     }
 
-    if (reportId && isFetching) {
+    if (isFetching) {
       return;
     }
 
@@ -47,12 +87,17 @@ const Processing: React.FC = () => {
         // Send POST request to backend API
         const response = await axios.post(
           `${API_URL}/api/document-processor/process-file`,
-          { filePath },
+          { reportId },
           await getAuthConfig(),
         );
-        setReportId(response.data.reportId);
 
-        console.log('File processed successfully:', response.data);
+        console.log('File processing started:', response.data);
+
+        // Start checking the status every 5 seconds
+        statusCheckIntervalRef.current = window.setInterval(checkReportStatus, 5000);
+
+        // Run the first status check immediately
+        checkReportStatus();
       } catch (error) {
         console.error('Error processing file:', error);
         setProcessingError('Failed to process the file. Please try again.');
@@ -61,7 +106,14 @@ const Processing: React.FC = () => {
     };
 
     processFile();
-  }, [filePath, axios, history]);
+
+    // Clean up the interval when the component unmounts
+    return () => {
+      if (statusCheckIntervalRef.current) {
+        window.clearInterval(statusCheckIntervalRef.current);
+      }
+    };
+  }, [reportId, axios, history]);
 
   return (
     <IonPage className="processing-page">
