Update main.py

main.py

@@ -5,6 +5,7 @@ import io
 from flask import Flask, request, jsonify
 from flask_cors import CORS, cross_origin
 import firebase_admin
+import logging
 from firebase_admin import credentials, firestore
 from dotenv import load_dotenv
 from pandasai import SmartDatalake
@@ -93,130 +94,99 @@ def marketing_rec():
 
     return jsonify(str(response['text']))
 
-# Profit/Customer Engagement Prediction endpoint
 @app.route("/predict_metric", methods=["POST"])
 @cross_origin()
 def predict_metric():
     try:
         request_data = request.json
+        logging.info(f"Received request data: {request_data}")
+
         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)
+        # Check if user_id is provided
+        if not user_id:
+            logging.error("User ID is missing in the request")
+            return jsonify({"error": "User ID is missing"}), 400
 
         transactions_ref = db.collection("system_users").document(user_id).collection("transactions")
         data = []
         
+        # Fetch Income and Expense for Profit calculation
         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
+            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()
+                logging.info(f"Processing income transaction: {transaction}")
+                date_str = transaction["date"]
+                amount = transaction["amountDue"]
+                income_data[date_str] = income_data.get(date_str, 0) + amount
+
+            for doc in expense_query:
+                transaction = doc.to_dict()
+                logging.info(f"Processing expense transaction: {transaction}")
+                date_str = transaction["date"]
+                amount = transaction["amountDue"]
+                expense_data[date_str] = expense_data.get(date_str, 0) + amount
+
+            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":
-            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)
+            income_query = transactions_ref.where("transactionType", "==", "Income").stream()
+            engagement_data = {}
 
-            # Ensure 'date' column is datetime
-            df['date'] = pd.to_datetime(df['date'], errors='coerce')
-            df['date'] = df['date'].dt.tz_localize(None)
+            for doc in income_query:
+                transaction = doc.to_dict()
+                logging.info(f"Processing engagement transaction: {transaction}")
+                date_str = transaction["date"]
+                engagement_data[date_str] = engagement_data.get(date_str, 0) + 1
 
-            # Drop rows where 'date' could not be parsed
-            df = df.dropna(subset=['date'])
+            for date, count in engagement_data.items():
+                data.append({"date": date, "amountDue": count})
 
-            # Set 'date' as index
-            df = df.sort_values("date").set_index("date")
+        # Log final aggregated data before processing
+        logging.info(f"Aggregated data: {data}")
 
-            # Resample daily to ensure regular intervals (fill missing dates)
-            df = df.resample("D").sum().reset_index()
-            print("Data after resampling:", df)
+        # Data processing with Prophet
+        df = pd.DataFrame(data)
+        df['date'] = pd.to_datetime(df['date'])
+        df['date'] = df['date'].dt.tz_localize(None)
+        df = df.sort_values("date").set_index("date")
+        df = df.resample("D").sum().reset_index()
+        df.columns = ["ds", "y"]
 
-            df.columns = ["ds", "y"]  # ds: date, y: target
+        # Check if data is sufficient
+        if df.shape[0] < 10:
+            logging.warning("Not enough data to train the Prophet model")
+            return jsonify({"error": "Not enough data for prediction"}), 400
 
-            # 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
+        # Train Prophet model
+        model = Prophet(daily_seasonality=True, yearly_seasonality=True)
+        model.fit(df)
 
-        except Exception as e:
-            print("Error processing DataFrame:", str(e))
-            return jsonify({"error": "Error processing DataFrame"}), 500
+        # Make future predictions
+        future_dates = model.make_future_dataframe(periods=interval)
+        forecast = model.predict(future_dates)
 
-        # Prophet prediction
-        try:
-            # Initialize and fit the Prophet model
-            model = Prophet(daily_seasonality=True, yearly_seasonality=True)
-            model.fit(df)
-
-            # DataFrame for future predictions
-            future_dates = model.make_future_dataframe(periods=interval)
-            forecast = model.predict(future_dates)
-
-            # 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()]
+        # Prepare and log predictions
+        forecast_data = forecast[['ds', 'yhat']].tail(interval)
+        predictions = [{"date": row['ds'].strftime('%Y-%m-%d'), "value": row['yhat']} for _, row in forecast_data.iterrows()]
+        logging.info(f"Predictions: {predictions}")
 
-            # Log the predictions before returning
-            print("Predictions:", predictions)
-
-            # Return predictions in JSON format
-            return jsonify({"predictedData": predictions})
-
-        except Exception as e:
-            print("Error in Prophet prediction:", str(e))
-            return jsonify({"error": "Error in Prophet prediction"}), 500
+        return jsonify({"predictedData": predictions})
 
     except Exception as e:
-        print("General error:", str(e))
-        return jsonify({"error": "Internal server error"}), 500
+        logging.error(f"Error in /predict_metric endpoint: {e}")
+        return jsonify({"error": str(e)}), 500
+