Implement dedicated document upload function and update prediction handling in SimplifiedUploader component

Author: Novapool

frontend/src/components/SimplifiedUploader.tsx

@@ -7,6 +7,15 @@ interface Prediction {
   reasoning: string;
 }
 
+interface PredictionResponse {
+  success: boolean;
+  prediction?: {
+    grade: number | string;
+    reasoning: string;
+  };
+  message?: string;
+}
+
 const SimplifiedUploader: React.FC = () => {
   const { currentUser } = useAuth();
   const [file, setFile] = useState<File | null>(null);
@@ -46,24 +55,34 @@ const SimplifiedUploader: React.FC = () => {
         const base64String = fileReader.result as string;
 
         try {
-          // Use predictGrades function for both upload and prediction
-          const predictGrades = httpsCallable(functions, 'predictGrades');
-          const result = await predictGrades({
+          // Use dedicated upload function
+          const uploadDocument = httpsCallable(functions, 'uploadDocument');
+          const result = await uploadDocument({
             documentType: documentType,
             documentBase64: base64String
           });
 
           const data = result.data as any;
 
           if (data.success) {
-            setStatus('Document uploaded successfully. Processing...');
+            setStatus('Document uploaded successfully.');
 
-            if (data.prediction) {
-              setPrediction({
-                grade: data.prediction.grade,
-                reasoning: data.prediction.reasoning
-              });
+            // After successful upload, call predictGrades
+            try {
+              const predictGrades = httpsCallable(functions, 'predictGrades');
+              const predictionResult = await predictGrades({}) as { data: PredictionResponse };
+              
+              if (predictionResult.data.success && predictionResult.data.prediction) {
+                setPrediction({
+                  grade: predictionResult.data.prediction.grade,
+                  reasoning: predictionResult.data.prediction.reasoning || 'No reasoning provided'
+                });
+              }
+            } catch (predictionError: any) {
+              console.error('Prediction error:', predictionError);
+              // Don't show prediction errors to user, just log them
             }
+            
             setStatus('');
             setIsUploading(false);
           } else {

functions-node/index.js

@@ -8,6 +8,85 @@ const OpenAI = require('openai');
 // Initialize Firebase Admin
 admin.initializeApp();
 
+/**
+ * Dedicated function for handling PDF document uploads
+ */
+exports.uploadDocument = functions.https.onCall(async (data, context) => {
+  try {
+    console.log('uploadDocument called with document type:', data.documentType);
+    
+    // Ensure user is authenticated
+    if (!context.auth) {
+      throw new functions.https.HttpsError('unauthenticated', 'User must be authenticated');
+    }
+    
+    const userId = context.auth.uid;
+    
+    // Validate input
+    if (!data.documentBase64 || !data.documentType) {
+      throw new functions.https.HttpsError('invalid-argument', 'Missing document data or type');
+    }
+    
+    // Process base64 data - handle different formats of base64 strings
+    let base64Data = data.documentBase64;
+    if (base64Data.includes('base64,')) {
+      base64Data = base64Data.split('base64,')[1];
+    }
+    
+    // Create buffer from base64
+    const buffer = Buffer.from(base64Data, 'base64');
+    console.log(`Created buffer with ${buffer.length} bytes`);
+    
+    // Create temp file
+    const tempFile = tmp.fileSync({ postfix: '.pdf' });
+    fs.writeFileSync(tempFile.name, buffer);
+    console.log(`Wrote buffer to temp file: ${tempFile.name}`);
+    
+    try {
+      // Get default bucket
+      const bucket = admin.storage().bucket();
+      const filePath = `users/${userId}/${data.documentType}/${Date.now()}.pdf`;
+      
+      console.log(`Uploading to Firebase Storage: ${filePath}`);
+      await bucket.upload(tempFile.name, {
+        destination: filePath,
+        metadata: {
+          contentType: 'application/pdf'
+        }
+      });
+      
+      console.log(`Successfully uploaded to ${filePath}`);
+      
+      // Store reference in Firestore
+      const db = admin.firestore();
+      const docRef = db.collection('users').doc(userId).collection('documents').doc(data.documentType);
+      
+      await docRef.set({
+        filePath: filePath,
+        uploadedAt: admin.firestore.FieldValue.serverTimestamp(),
+        status: 'uploaded'
+      });
+      
+      console.log(`Firestore document updated for ${filePath}`);
+      
+      return {
+        success: true,
+        message: 'Document uploaded successfully',
+        filePath: filePath
+      };
+    } catch (uploadError) {
+      console.error('Error during upload:', uploadError);
+      throw new functions.https.HttpsError('internal', `Storage upload failed: ${uploadError.message}`);
+    } finally {
+      // Clean up temp file
+      tempFile.removeCallback();
+    }
+  } catch (error) {
+    console.error('Error in uploadDocument:', error);
+    throw new functions.https.HttpsError('internal', `Upload failed: ${error.message}`);
+  }
+});
+
 // Get OpenAI API key from Firebase configuration or environment variable
 function getOpenAIApiKey() {
   const apiKey = process.env.OPENAI_API_KEY || 
@@ -191,7 +270,7 @@ exports.predictGrades = functions.https.onCall(async (data, context) => {
       fs.writeFileSync(tempFile.name, buffer);
 
       // Upload to Firebase Storage
-      const bucket = admin.storage().bucket('gradingai.appspot.com');
+      const bucket = admin.storage().bucket();
       const filePath = `users/${userId}/${data.documentType}/${Date.now()}.pdf`;
 
       await bucket.upload(tempFile.name, {
@@ -320,7 +399,7 @@ async function extractTextFromPdf(userId, documentType, filePath) {
   console.log(`Extracting text from ${documentType} PDF: ${filePath} for user ${userId}`);
 
   // Get a reference to the default bucket
-  const bucket = admin.storage().bucket('gradingai.appspot.com');
+  const bucket = admin.storage().bucket();
   console.log(`Using bucket: ${bucket.name}`);
 
   let tempFile = null;