Add utility functions for grade conversion and document type normalization; implement OpenAI API key retrieval

Author: Novapool

frontend/src/components/DocumentManager.tsx

@@ -1,4 +1,4 @@
-import React, { useState, useEffect, useCallback } from 'react';
+import React, { useState, useEffect } from 'react';
 import { useAuth } from '../contexts/AuthContext';
 import { getFunctions, httpsCallable } from 'firebase/functions';
 import DocumentProcessingStatus from './DocumentProcessingStatus';
@@ -23,8 +23,8 @@ const DocumentManager: React.FC = () => {
 
   const functions = getFunctions();
 
-  // Memoize fetchUserDocuments with useCallback
-  const fetchUserDocuments = useCallback(async () => {
+  // Fetch user documents
+  const fetchUserDocuments = async () => {
     try {
       const getUserDocuments = httpsCallable(functions, 'getUserDocuments');
       const result = await getUserDocuments();
@@ -36,14 +36,14 @@ const DocumentManager: React.FC = () => {
       console.error('Error fetching documents:', err);
       setError('Failed to load existing documents');
     }
-  }, [functions, setError]);
+  };
 
   // Fetch existing documents on component mount
   useEffect(() => {
     if (!currentUser) return;
 
     fetchUserDocuments();
-  }, [currentUser, fetchUserDocuments]);
+  }, [currentUser]);
 
   const handleFileChange = (e: React.ChangeEvent<HTMLInputElement>) => {
     if (e.target.files) {

frontend/src/components/DocumentProcessingStatus.tsx

@@ -224,68 +224,6 @@ const DocumentProcessingStatus: React.FC<DocumentProcessingStatusProps> = ({ onP
     return progress;
   };
 
-  // Function to inspect document data
-  const inspectDocumentData = async (documentId: string) => {
-    if (!currentUser) return;
-    
-    setStatus(`Inspecting document ${documentId}...`);
-    
-    try {
-      // Get document from Firestore
-      const db = getFirestore();
-      const docRef = doc(db, 'users', currentUser.uid, 'documents', documentId);
-      const docSnap = await getDoc(docRef);
-      
-      if (docSnap.exists()) {
-        const data = docSnap.data();
-        console.log("===== DOCUMENT DATA =====");
-        console.log(`Document ID: ${documentId}`);
-        console.log(`Type: ${data.documentType}`);
-        console.log(`Status: ${data.status}`);
-        console.log(`Name: ${data.name}`);
-        
-        // Log text data if available (limited to first 500 chars for readability)
-        if (data.text) {
-          console.log(`Text length: ${data.text.length} characters`);
-          console.log("First 500 characters:");
-          console.log(data.text.substring(0, 500) + "...");
-        }
-        
-        setStatus(`Document data logged to console for ${documentId}`);
-      } else {
-        setError(`Document not found: ${documentId}`);
-      }
-    } catch (err: any) {
-      console.error('Error inspecting document:', err);
-      setError(`Inspection failed: ${err.message || 'Unknown error'}`);
-    }
-  };
-
-  // Function to inspect formatted data
-  const inspectFormattedData = async () => {
-    if (!currentUser) return;
-    
-    setStatus('Fetching formatted data...');
-    
-    try {
-      const db = getFirestore();
-      const formattedDataRef = doc(db, 'users', currentUser.uid, 'data', 'formatted_data');
-      const docSnap = await getDoc(formattedDataRef);
-      
-      if (docSnap.exists()) {
-        const data = docSnap.data();
-        console.log("===== FORMATTED DATA =====");
-        console.log(JSON.stringify(data.formatted_data, null, 2));
-        setStatus('Formatted data logged to console');
-      } else {
-        console.log("No formatted data document found");
-        setError('No formatted data available');
-      }
-    } catch (err: any) {
-      console.error('Error fetching formatted data:', err);
-      setError(`Failed to fetch formatted data: ${err.message || 'Unknown error'}`);
-    }
-  };
 
   const progress = calculateProgress();
   const canFormat = documentCounts.extracted > 0 && !isFormatting;
@@ -376,12 +314,6 @@ const DocumentProcessingStatus: React.FC<DocumentProcessingStatusProps> = ({ onP
           >
             {isFormatting ? 'Formatting...' : 'Format Documents'}
           </button>
-          <button 
-            onClick={inspectFormattedData}
-            style={{...styles.formatButton, backgroundColor: '#666', marginLeft: '10px'}}
-          >
-            Inspect Formatted Data
-          </button>
         </div>
       )}
 
@@ -430,12 +362,6 @@ const DocumentProcessingStatus: React.FC<DocumentProcessingStatusProps> = ({ onP
                           Retry Processing
                         </button>
                       )}
-                      <button
-                        onClick={() => inspectDocumentData(doc.id)}
-                        style={{...styles.actionButton, backgroundColor: '#666'}}
-                      >
-                        Inspect
-                      </button>
                     </div>
                     {doc.error && (
                       <div style={styles.errorMessage}>

frontend/src/components/PredictionPanel.tsx

@@ -128,12 +128,6 @@ const PredictionPanel: React.FC = () => {
   // Determine if we can make a prediction based on document status or processing completion
   const canPredict = documents.some(doc => doc.status === 'processed') || processingComplete;
 
-  // We'll keep this comment to document what we're calculating, but remove the unused variable
-  // Get count of documents by type
-  // const docCounts = documents.reduce((acc: Record<string, number>, doc) => {
-  //   acc[doc.documentType] = (acc[doc.documentType] || 0) + 1;
-  //   return acc;
-  // }, {});
 
   return (
     <div style={styles.container}>

functions-node/calculateGrade.js

@@ -1,5 +1,7 @@
 const functions = require('firebase-functions');
 const admin = require('firebase-admin');
+const { getLetterGrade } = require('./utils/gradeUtils');
+const { calculateExactGradeStatistics, generateGradeAnalysis } = require('./utils/calculationUtils');
 
 /**
  * Cloud Function to calculate current grade based on submitted assignments
@@ -60,164 +62,6 @@ exports.calculateCurrentGrade = functions.https.onCall(async (data, context) =>
   }
 });
 
-/**
- * Calculate grade statistics with precision
- * @param {Object} data - Formatted data from formatDataForCalculation
- * @returns {Object} Calculated statistics
- */
-function calculateExactGradeStatistics(data) {
-  const { gradeWeights, completedAssignments, remainingAssignments } = data;
-  
-  // Initialize tracking variables
-  const categoryStats = {};
-  let totalWeightCovered = 0;
-  
-  // Calculate stats for each category
-  gradeWeights.forEach(category => {
-    const categoryAssignments = completedAssignments.filter(
-      a => a.category === category.name
-    );
-    
-    const categoryRemaining = remainingAssignments.filter(
-      a => a.category === category.name
-    );
-    
-    // Calculate total points and max possible in this category
-    let totalPoints = 0;
-    let maxPoints = 0;
-    
-    categoryAssignments.forEach(assignment => {
-      // Handle numeric grades and special cases like "Dropped"
-      if (typeof assignment.grade === 'number') {
-        totalPoints += assignment.grade;
-        maxPoints += assignment.maxPoints || 100;
-      } else if (assignment.grade !== 'Dropped') {
-        const numericGrade = parseFloat(assignment.grade);
-        if (!isNaN(numericGrade)) {
-          totalPoints += numericGrade;
-          maxPoints += assignment.maxPoints || 100;
-        }
-      }
-    });
-    
-    // Calculate category average
-    const categoryAverage = maxPoints > 0 ? (totalPoints / maxPoints) * 100 : null;
-    
-    // Store stats
-    categoryStats[category.name] = {
-      completed: categoryAssignments,
-      remaining: categoryRemaining,
-      totalPoints,
-      maxPoints,
-      average: categoryAverage,
-      weight: category.weight
-    };
-    
-    // Add to total weight if we have assignments in this category
-    if (maxPoints > 0) {
-      totalWeightCovered += category.weight;
-    }
-  });
-  
-  // Calculate overall current grade
-  let currentGradeWeighted = 0;
-  
-  Object.values(categoryStats).forEach(stats => {
-    if (stats.average !== null) {
-      // Scale by weight
-      currentGradeWeighted += (stats.average / 100) * stats.weight;
-    }
-  });
-  
-  // Normalize by covered weight if needed
-  const currentGrade = totalWeightCovered > 0 
-    ? (currentGradeWeighted / totalWeightCovered) * 100
-    : 0;
-  
-  // Calculate max possible grade (if all remaining is 100%)
-  let maxPossibleGrade = currentGradeWeighted;
-  let remainingWeight = 0;
-  
-  Object.values(categoryStats).forEach(stats => {
-    // Count weight for categories with remaining assignments
-    if (stats.remaining.length > 0) {
-      const categoryRemainingWeight = stats.weight * (stats.remaining.length / 
-        (stats.completed.length + stats.remaining.length || 1));
-      
-      remainingWeight += categoryRemainingWeight;
-      maxPossibleGrade += categoryRemainingWeight;
-    }
-  });
-  
-  // Normalize max grade
-  maxPossibleGrade = totalWeightCovered > 0 
-    ? (maxPossibleGrade / (totalWeightCovered + remainingWeight)) * 100
-    : 100;
-  
-  // Min grade (if all remaining is 0%)
-  const minPossibleGrade = totalWeightCovered > 0 
-    ? (currentGradeWeighted / (totalWeightCovered + remainingWeight)) * 100
-    : 0;
-  
-  // Format for return
-  return {
-    current_grade: currentGrade,
-    current_percentage: currentGrade,
-    letter_grade: getLetterGrade(currentGrade),
-    max_possible_grade: maxPossibleGrade,
-    min_possible_grade: minPossibleGrade,
-    categorized_grades: categoryStats,
-    analysis: generateGradeAnalysis({
-      currentGrade,
-      maxPossibleGrade,
-      minPossibleGrade,
-      letterGrade: getLetterGrade(currentGrade),
-      categorizedGrades: categoryStats
-    })
-  };
-}
-
-/**
- * Get letter grade from numeric value
- * @param {number} grade - Numeric grade
- * @returns {string} Letter grade
- */
-function getLetterGrade(grade) {
-  if (grade >= 93) return 'A';
-  if (grade >= 90) return 'A-';
-  if (grade >= 87) return 'B+';
-  if (grade >= 83) return 'B';
-  if (grade >= 80) return 'B-';
-  if (grade >= 77) return 'C+';
-  if (grade >= 73) return 'C';
-  if (grade >= 70) return 'C-';
-  if (grade >= 67) return 'D+';
-  if (grade >= 63) return 'D';
-  if (grade >= 60) return 'D-';
-  return 'F';
-}
-
-/**
- * Generate natural language analysis of grade stats
- * @param {Object} stats - Grade statistics
- * @returns {string} Analysis text
- */
-function generateGradeAnalysis(stats) {
-  const { currentGrade, maxPossibleGrade, minPossibleGrade, letterGrade } = stats;
-  const analysis = [];
-  
-  analysis.push(`Current grade is ${currentGrade.toFixed(1)}% (${letterGrade})`);
-  
-  if (maxPossibleGrade > currentGrade) {
-    analysis.push(`Maximum possible grade is ${maxPossibleGrade.toFixed(1)}%`);
-  }
-  
-  if (minPossibleGrade < currentGrade) {
-    analysis.push(`Minimum possible grade is ${minPossibleGrade.toFixed(1)}%`);
-  }
-  
-  return analysis.join('. ');
-}
 
 /**
  * Fetch structured data from Firestore

functions-node/formatDocumentsData.js

@@ -1,7 +1,8 @@
 const OpenAI = require('openai');
 const functions = require('firebase-functions');
 const admin = require('firebase-admin');
-const { DOCUMENT_TYPES, normalizeDocumentType } = require('./constants/documentTypes');
+const { DOCUMENT_TYPES, normalizeDocumentType } = require('./utils/documentUtils');
+const { getOpenAIApiKey } = require('./utils/apiUtils');
 
 /**
  * Store debugging data in Firestore
@@ -412,17 +413,3 @@ function extractGradeWeights(text) {
     return [];
   }
 }
-
-/**
- * Helper function to get OpenAI API key
- */
-function getOpenAIApiKey() {
-  const apiKey = process.env.OPENAI_API_KEY || 
-                (functions.config && functions.config().openai && functions.config().openai.apikey);
-  
-  if (!apiKey) {
-    throw new Error('OpenAI API key not configured. Please set OPENAI_API_KEY or firebase config openai.apikey');
-  }
-  
-  return apiKey;
-}