Update app.py

app.py

@@ -3,7 +3,6 @@ import gspread
 import gradio as gr
 from oauth2client.service_account import ServiceAccountCredentials
 from datetime import datetime
-from math import radians, cos, sin, asin, sqrt
 
 # ------------------ AUTH ------------------
 VALID_USERS = {
@@ -26,111 +25,90 @@ def load_tab(sheet_name):
     except:
         return pd.DataFrame([["⚠️ Could not load sheet."]], columns=["Error"])
 
-def haversine(coord1, coord2):
-    lon1, lat1 = map(radians, map(float, coord1.split(',')[::-1]))
-    lon2, lat2 = map(radians, map(float, coord2.split(',')[::-1]))
-    dlon = lon2 - lon1
-    dlat = lat2 - lat1
-    a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
-    c = 2 * asin(sqrt(a))
-    return 6371 * c
-
-# ------------------ FIELD SALES ------------------
-def load_field_sales():
-    df = load_tab("Field Sales")
-    if df.empty or "Date" not in df.columns:
-        return pd.DataFrame()
+def get_combined_orders(date_str):
+    df_field = load_tab("Field Sales")
+    df_ts = load_tab("TeleSales")
+
+    combined = []
+
+    if not df_field.empty:
+        df_field['Date'] = pd.to_datetime(df_field['Date'], errors='coerce')
+        df_field['DateStr'] = df_field['Date'].dt.date.astype(str)
+        df_field = df_field[df_field['DateStr'] == date_str.strip()]
+        df_field['Order Value'] = pd.to_numeric(df_field['Order Value'], errors='coerce').fillna(0)
+        df_field_orders = df_field.groupby("Rep").agg({
+            "Order Received": lambda x: (x == "Yes").sum(),
+            "Order Value": "sum"
+        }).reset_index().rename(columns={
+            "Order Received": "Orders Received",
+            "Order Value": "Total Order Value"
+        })
+        df_field_orders["Source"] = "Field Sales"
+        combined.append(df_field_orders)
+
+    if not df_ts.empty:
+        df_ts['Date'] = pd.to_datetime(df_ts['Date'], errors='coerce')
+        df_ts['DateStr'] = df_ts['Date'].dt.date.astype(str)
+        df_ts = df_ts[df_ts['DateStr'] == date_str.strip()]
+        df_ts['Order Value'] = pd.to_numeric(df_ts['Order Value'], errors='coerce').fillna(0)
+        df_ts_orders = df_ts.groupby("Rep").agg({
+            "Order Received": lambda x: (x == "Yes").sum(),
+            "Order Value": "sum"
+        }).reset_index().rename(columns={
+            "Order Received": "Orders Received",
+            "Order Value": "Total Order Value"
+        })
+        df_ts_orders["Source"] = "TeleSales"
+        combined.append(df_ts_orders)
+
+    if combined:
+        return pd.concat(combined, ignore_index=True)
+    else:
+        return pd.DataFrame([["No orders on this date"]], columns=["Message"])
 
-    df['Date'] = pd.to_datetime(df['Date'], errors='coerce')
-    df = df.dropna(subset=["Date"])
-    df['DateStr'] = df['Date'].dt.date.astype(str)
+def get_requests():
+    df = load_tab("Customer Requests")
+    return df if not df.empty else pd.DataFrame([["No requests yet."]], columns=["Message"])
 
-    if "Order Value" not in df.columns:
-        df["Order Value"] = 0
-    else:
-        df["Order Value"] = pd.to_numeric(df["Order Value"], errors="coerce").fillna(0)
-
-    # Distance calc
-    distances = [0]
-    for i in range(1, len(df)):
-        try:
-            prev = df.loc[i-1, 'Location']
-            curr = df.loc[i, 'Location']
-            if pd.notna(prev) and pd.notna(curr):
-                distances.append(round(haversine(prev, curr), 2))
-            else:
-                distances.append(0)
-        except:
-            distances.append(0)
-    df["Distance Travelled (km)"] = distances
+def get_listings():
+    df = load_tab("CustomerListings")
+    return df if not df.empty else pd.DataFrame([["No listings found."]], columns=["Message"])
 
-    return df
+def get_users():
+    df = load_tab("Users")
+    return df if not df.empty else pd.DataFrame([["No users configured."]], columns=["Message"])
 
-# ------------------ TELESALES ------------------
-def load_telesales():
+def get_telesales_summary():
     df = load_tab("TeleSales")
-    if df.empty or "Rep Email" not in df.columns:
-        return pd.DataFrame()
-
-    df["Date"] = pd.to_datetime(df.get("Date", datetime.today()), errors='coerce')
-    df["DateStr"] = df["Date"].dt.date.astype(str)
-    return df
+    if df.empty or "Rep" not in df.columns:
+        return pd.DataFrame([["No Telesales data available"]], columns=["Message"])
+    return df.groupby("Rep").size().reset_index(name="Total Calls Made")
 
-# ------------------ OEM ------------------
-def load_oem():
+def get_oem_summary():
     df = load_tab("OEM Visit")
     if df.empty or "Rep" not in df.columns:
+        return pd.DataFrame([["No OEM data available"]], columns=["Message"])
+    return df.groupby("Rep").size().reset_index(name="Total OEM Visits")
+
+def get_escalations():
+    df = load_tab("Field Sales")
+    if df.empty:
+        return pd.DataFrame([["No data in Field Sales"]], columns=["Message"])
+    col = "Customer Type & Status"
+    if col in df.columns:
+        flagged = df[df[col].str.contains("Second", na=False)]
+        return flagged if not flagged.empty else pd.DataFrame([["No second-hand dealerships flagged."]], columns=["Message"])
+    else:
+        return pd.DataFrame([["⚠️ Column 'Customer Type & Status' not found."]], columns=["Message"])
+
+def load_field_sales():
+    df = load_tab("Field Sales")
+    if df.empty:
         return pd.DataFrame()
     df["Date"] = pd.to_datetime(df.get("Date", datetime.today()), errors='coerce')
     df["DateStr"] = df["Date"].dt.date.astype(str)
     return df
 
-# ------------------ SUMMARY ------------------
-def generate_summary(date_str):
-    df = load_field_sales()
-    if df.empty:
-        return pd.DataFrame([["No Field Sales data"]], columns=["Message"])*5
-
-    df_day = df[df['DateStr'] == date_str.strip()]
-    all_reps = sorted(df['Rep'].dropna().unique())
-    col = "Current/Prospect Customer"
-
-    # --- Visits Breakdown
-    total_visits = df_day.groupby("Rep").size().reset_index(name="Total Visits")
-    current = df_day[df_day[col] == "Current"]
-    prospect = df_day[df_day[col] == "Prospect"]
-    breakdown = pd.DataFrame({
-        "Rep": all_reps,
-        "Current": [len(current[current["Rep"] == rep]) for rep in all_reps],
-        "Prospect": [len(prospect[prospect["Rep"] == rep]) for rep in all_reps]
-    })
-    inactive = pd.DataFrame({'Inactive Reps': [rep for rep in all_reps if rep not in total_visits["Rep"].tolist()]})
-
-    # --- Field Summary per Rep
-    rep_summary = df_day.groupby("Rep").agg({
-        "Order Value": "sum",
-        "Order Received": lambda x: (x == "Yes").sum(),
-        "Current/Prospect Customer": lambda x: (x == "Current").sum(),
-        "Distance Travelled (km)": "sum"
-    }).rename(columns={
-        "Order Value": "Total Order Value",
-        "Order Received": "Orders Received",
-        "Current/Prospect Customer": "Current Customers",
-        "Distance Travelled (km)": "Total Distance (km)"
-    }).reset_index()
-
-    # --- TeleSales Summary
-    df_ts = load_telesales()
-    df_ts_day = df_ts[df_ts['DateStr'] == date_str.strip()]
-    ts_summary = df_ts_day.groupby("Rep Email").size().reset_index(name="Total Calls Made") if not df_ts_day.empty else pd.DataFrame([["No Telesales"]], columns=["Info"])
-
-    # --- OEM Summary
-    df_oem = load_oem()
-    df_oem_day = df_oem[df_oem['DateStr'] == date_str.strip()]
-    oem_summary = df_oem_day.groupby("Rep").size().reset_index(name="Total OEM Visits") if not df_oem_day.empty else pd.DataFrame([["No OEM Visits"]], columns=["Info"])
-
-    return total_visits, breakdown, inactive, rep_summary, ts_summary, oem_summary
-
 # ------------------ GRADIO APP ------------------
 with gr.Blocks() as app:
     with gr.Row():
@@ -147,18 +125,49 @@ with gr.Blocks() as app:
             df_initial = load_field_sales()
             unique_dates = sorted(df_initial["DateStr"].unique(), reverse=True) if not df_initial.empty else []
 
-            # --- Summary Tab ---
+            # --- Tabs ---
             with gr.Tab("📊 Summary"):
-                date_summary = gr.Dropdown(label="Select Date", choices=unique_dates)
-                visits = gr.Dataframe(label="✅ Total Visits")
-                breakdown = gr.Dataframe(label="🏷️ Current vs. Prospect")
-                inactive = gr.Dataframe(label="⚠️ Inactive Reps")
-                field_summary = gr.Dataframe(label="🚗 Field Sales Summary")
-                ts_summary = gr.Dataframe(label="📞 Telesales Summary")
-                oem_summary = gr.Dataframe(label="🏭 OEM Visit Summary")
-
-                date_summary.change(fn=generate_summary, inputs=date_summary,
-                                    outputs=[visits, breakdown, inactive, field_summary, ts_summary, oem_summary])
+                gr.Markdown("Summary content coming soon...")
+
+            with gr.Tab("📂 Field Sales"):
+                field_df = gr.Dataframe(value=load_field_sales, label="📂 Field Sales Records", interactive=False)
+                field_btn = gr.Button("🔄 Refresh Field Sales")
+                field_btn.click(fn=load_field_sales, outputs=field_df)
+
+            with gr.Tab("📞 TeleSales"):
+                ts_table = gr.Dataframe(value=get_telesales_summary, label="📞 TeleSales Summary")
+                ts_refresh = gr.Button("🔄 Refresh")
+                ts_refresh.click(fn=get_telesales_summary, outputs=ts_table)
+
+            with gr.Tab("📦 Orders Summary"):
+                order_date = gr.Dropdown(label="Select Date", choices=unique_dates, interactive=True)
+                order_table = gr.Dataframe(label="🧾 Combined Order Summary")
+                order_date.change(fn=get_combined_orders, inputs=order_date, outputs=order_table)
+
+            with gr.Tab("🚨 Escalations"):
+                esc_table = gr.Dataframe(value=get_escalations, label="🚨 Used Dealership Escalations")
+                esc_btn = gr.Button("🔄 Refresh Escalations")
+                esc_btn.click(fn=get_escalations, outputs=esc_table)
+
+            with gr.Tab("🏭 OEM Visits"):
+                oem_table = gr.Dataframe(value=get_oem_summary, label="🏭 OEM Visit Summary")
+                oem_refresh = gr.Button("🔄 Refresh")
+                oem_refresh.click(fn=get_oem_summary, outputs=oem_table)
+
+            with gr.Tab("📬 Customer Requests"):
+                req_table = gr.Dataframe(value=get_requests, label="📬 Customer Requests", interactive=False)
+                req_refresh = gr.Button("🔄 Refresh Requests")
+                req_refresh.click(fn=get_requests, outputs=req_table)
+
+            with gr.Tab("📋 Dealership Directory"):
+                listings_table = gr.Dataframe(value=get_listings, label="📋 Customer Listings")
+                listings_refresh = gr.Button("🔄 Refresh Listings")
+                listings_refresh.click(fn=get_listings, outputs=listings_table)
+
+            with gr.Tab("👤 Users"):
+                users_table = gr.Dataframe(value=get_users, label="👥 Users")
+                users_refresh = gr.Button("🔄 Refresh Users")
+                users_refresh.click(fn=get_users, outputs=users_table)
 
     def do_login(user, pw):
         if VALID_USERS.get(user) == pw: