Update main.py

main.py

@@ -97,105 +97,127 @@ def marketing_rec():
 @app.route("/predict_metric", methods=["POST"])
 @cross_origin()
 def predict_metric():
-    request_data = request.json
-    user_id = request_data.get("user_id")
-    interval = request_data.get("interval", 30)
-    metric_type = request_data.get("metric_type", "Profit")  # "Profit" or "Customer Engagement"
-
-    transactions_ref = db.collection("system_users").document(user_id).collection("transactions")
-
-    data = []
-    
-    if metric_type == "Profit":
-        # Fetch both Income and Expense transactions for Profit calculation
-        income_query = transactions_ref.where("transactionType", "==", "Income").stream()
-        expense_query = transactions_ref.where("transactionType", "==", "Expense").stream()
-
-        income_data = {}
-        expense_data = {}
-
-        for doc in income_query:
-            transaction = doc.to_dict()
-            date_str = transaction["date"].toDate()  # Convert Firestore Timestamp to DateTime
-            amount = transaction["amountDue"]
-            income_data[date_str] = income_data.get(date_str, 0) + amount
-            print(f"Income transaction - Date: {date_str}, Amount: {amount}")
-
-        for doc in expense_query:
-            transaction = doc.to_dict()
-            date_str = transaction["date"].toDate()  # Convert Firestore Timestamp to DateTime
-            amount = transaction["amountDue"]
-            expense_data[date_str] = expense_data.get(date_str, 0) + amount
-            print(f"Expense transaction - Date: {date_str}, Amount: {amount}")
-
-        # Calculate net profit for each date
-        for date, income in income_data.items():
-            expense = expense_data.get(date, 0)
-            data.append({"date": date, "amountDue": income - expense})
-
-    elif metric_type == "Customer Engagement":
-        # Use count of Income transactions per day as Customer Engagement
-        income_query = transactions_ref.where("transactionType", "==", "Income").stream()
-
-        engagement_data = {}
-        for doc in income_query:
-            transaction = doc.to_dict()
-            date_str = transaction["date"].toDate()  # Convert Firestore Timestamp to DateTime
-            engagement_data[date_str] = engagement_data.get(date_str, 0) + 1
-            print(f"Engagement transaction - Date: {date_str}")
-
-        for date, count in engagement_data.items():
-            data.append({"date": date, "amountDue": count})
+    try:
+        request_data = request.json
+        user_id = request_data.get("user_id")
+        interval = request_data.get("interval", 30)
+        metric_type = request_data.get("metric_type", "Profit")  # "Profit" or "Customer Engagement"
+
+        # Log received request data
+        print("Received request:", request_data)
+
+        transactions_ref = db.collection("system_users").document(user_id).collection("transactions")
+        data = []
+        
+        if metric_type == "Profit":
+            try:
+                # Fetch both Income and Expense transactions for Profit calculation
+                income_query = transactions_ref.where("transactionType", "==", "Income").stream()
+                expense_query = transactions_ref.where("transactionType", "==", "Expense").stream()
+
+                income_data = {}
+                expense_data = {}
+
+                for doc in income_query:
+                    transaction = doc.to_dict()
+                    date_str = transaction["date"].toDate()  # Convert Firestore Timestamp to DateTime
+                    amount = transaction["amountDue"]
+                    income_data[date_str] = income_data.get(date_str, 0) + amount
+                    print(f"Income transaction - Date: {date_str}, Amount: {amount}")
+
+                for doc in expense_query:
+                    transaction = doc.to_dict()
+                    date_str = transaction["date"].toDate()  # Convert Firestore Timestamp to DateTime
+                    amount = transaction["amountDue"]
+                    expense_data[date_str] = expense_data.get(date_str, 0) + amount
+                    print(f"Expense transaction - Date: {date_str}, Amount: {amount}")
+
+                # Calculate net profit for each date
+                for date, income in income_data.items():
+                    expense = expense_data.get(date, 0)
+                    data.append({"date": date, "amountDue": income - expense})
+
+            except Exception as e:
+                print("Error processing Profit data:", str(e))
+                return jsonify({"error": "Error processing Profit data"}), 500
+
+        elif metric_type == "Customer Engagement":
+            try:
+                # Use count of Income transactions per day as Customer Engagement
+                income_query = transactions_ref.where("transactionType", "==", "Income").stream()
+
+                engagement_data = {}
+                for doc in income_query:
+                    transaction = doc.to_dict()
+                    date_str = transaction["date"].toDate()  # Convert Firestore Timestamp to DateTime
+                    engagement_data[date_str] = engagement_data.get(date_str, 0) + 1
+                    print(f"Engagement transaction - Date: {date_str}")
+
+                for date, count in engagement_data.items():
+                    data.append({"date": date, "amountDue": count})
+
+            except Exception as e:
+                print("Error processing Customer Engagement data:", str(e))
+                return jsonify({"error": "Error processing Customer Engagement data"}), 500
+
+        # Create DataFrame from the aggregated data
+        try:
+            df = pd.DataFrame(data)
+            print("Data before processing:", df)
 
-    # Create DataFrame from the aggregated data
-    df = pd.DataFrame(data)
+            # Ensure 'date' column is datetime
+            df['date'] = pd.to_datetime(df['date'], errors='coerce')
+            df['date'] = df['date'].dt.tz_localize(None)
 
-    # Log the DataFrame before further processing
-    print("Data before processing:", df)
+            # Drop rows where 'date' could not be parsed
+            df = df.dropna(subset=['date'])
 
-    # Ensure 'date' column is datetime
-    df['date'] = pd.to_datetime(df['date'], errors='coerce')
-    df['date'] = df['date'].dt.tz_localize(None)
+            # Set 'date' as index
+            df = df.sort_values("date").set_index("date")
 
-    # Log DataFrame after date conversion
-    print("Data after date conversion:", df)
+            # Resample daily to ensure regular intervals (fill missing dates)
+            df = df.resample("D").sum().reset_index()
+            print("Data after resampling:", df)
 
-    # Drop rows where 'date' could not be parsed
-    df = df.dropna(subset=['date'])
+            df.columns = ["ds", "y"]  # ds: date, y: target
 
-    # Set 'date' as index
-    df = df.sort_values("date").set_index("date")
+            # Check if there's enough data to train the model
+            if df.shape[0] < 10:
+                print("Not enough data for prediction")
+                return jsonify({"error": "Not enough data for prediction"}), 400
 
-    # Resample daily to ensure regular intervals (fill missing dates)
-    df = df.resample("D").sum().reset_index()
+        except Exception as e:
+            print("Error processing DataFrame:", str(e))
+            return jsonify({"error": "Error processing DataFrame"}), 500
 
-    # Log DataFrame after resampling
-    print("Data after resampling:", df)
+        # Prophet prediction
+        try:
+            # Initialize and fit the Prophet model
+            model = Prophet(daily_seasonality=True, yearly_seasonality=True)
+            model.fit(df)
 
-    df.columns = ["ds", "y"]  # ds: date, y: target
+            # DataFrame for future predictions
+            future_dates = model.make_future_dataframe(periods=interval)
+            forecast = model.predict(future_dates)
 
-    # Check if there's enough data to train the model
-    if df.shape[0] < 10:
-        print("Not enough data for prediction")
-        return jsonify({"error": "Not enough data for prediction"})
+            # Extract the forecast for the requested interval
+            forecast_data = forecast[['ds', 'yhat']].tail(interval)
+            predictions = [{"date": row['ds'].strftime('%Y-%m-%d'), "value": row['yhat']} for _, row in forecast_data.iterrows()]
 
-    # Initialize and fit the Prophet model
-    model = Prophet(daily_seasonality=True, yearly_seasonality=True)
-    model.fit(df)
+            # Log the predictions before returning
+            print("Predictions:", predictions)
 
-    # DataFrame for future predictions
-    future_dates = model.make_future_dataframe(periods=interval)
-    forecast = model.predict(future_dates)
+            # Return predictions in JSON format
+            return jsonify({"predictedData": predictions})
 
-    # Extract the forecast for the requested interval
-    forecast_data = forecast[['ds', 'yhat']].tail(interval)
-    predictions = [{"date": row['ds'].strftime('%Y-%m-%d'), "value": row['yhat']} for _, row in forecast_data.iterrows()]
+        except Exception as e:
+            print("Error in Prophet prediction:", str(e))
+            return jsonify({"error": "Error in Prophet prediction"}), 500
 
-    # Log the predictions before returning
-    print("Predictions:", predictions)
+    except Exception as e:
+        print("General error:", str(e))
+        return jsonify({"error": "Internal server error"}), 500
 
-    # Return predictions in JSON format
-    return jsonify({"predictedData": predictions})