Update app.py

app.py

@@ -1,88 +1,195 @@
 # -*- coding: utf-8 -*-
 import gradio as gr
 import json
+import requests # Added for API calls
+import os # Added for environment variables
+import urllib.parse # Added for URL encoding (though requests handles params well)
+
 # Assuming these custom modules exist in your project directory or Python path
 from Data_Fetching_and_Rendering import fetch_and_render_dashboard
 from analytics_fetch_and_rendering import fetch_and_render_analytics
 from mentions_dashboard import generate_mentions_dashboard
 
-from gradio_utils import get_url_user_token
+# Import the function from your utils file
+from gradio_utils import get_url_user_token # Assuming gradio_utils.py is in the same directory
 
-# Shared state for token received via POST
+# Shared state for token received via POST or Bubble
 token_received = {"status": False, "token": None, "client_id": None}
 
-
 # --- Handlers for token reception (POST) and status ---
 def receive_token(accessToken: str, client_id: str):
     """
     Called by a hidden POST mechanism to supply the OAuth code/token and client ID.
     """
     try:
-        # The .replace("'", '"') is kept from your original code.
-        # Be cautious if accessToken format can vary.
         token_dict = json.loads(accessToken.replace("'", '"'))
     except json.JSONDecodeError as e:
-        print(f"Error decoding accessToken: {e}")
-        token_received["status"] = False # Ensure status reflects failure
+        print(f"Error decoding accessToken (POST): {e}")
+        token_received["status"] = False
         token_received["token"] = None
-        token_received["client_id"] = client_id # Keep client_id if provided
-        return {
-            "status": "❌ Invalid token format (POST)",
-            "token": "",
-            "client_id": client_id
-        }
+        token_received["client_id"] = client_id
+        return "❌ Invalid token format (POST)", "", client_id
     
     token_received["status"] = True
-    token_received["token"] = token_dict
+    token_received["token"] = token_dict # This should be the dict like {"access_token": "value"}
     token_received["client_id"] = client_id
     print(f"Token (from POST) received successfully. Client ID: {client_id}")
-    return {
-        "status": "✅ Token received (POST)",
-        "token": token_dict.get("access_token", "Access token key missing"), # Display part of the token
-        "client_id": client_id
-    }
+    # Update status box, token display, client display directly
+    return check_status(), show_token(), show_client()
+
 
 def check_status():
-    return "✅ Token received (POST)" if token_received["status"] else "❌ Waiting for token (POST)…"
+    return "✅ Token available" if token_received["status"] else "❌ Waiting for token…"
 
-def show_token(): # Shows token from POST
-    if token_received["status"] and token_received["token"]:
-        return token_received["token"].get("access_token", "Access token key missing")
+def show_token(): # Shows access_token if available
+    if token_received["status"] and token_received["token"] and isinstance(token_received["token"], dict):
+        return token_received["token"].get("access_token", "Access token key missing in dict")
+    elif token_received["status"] and token_received["token"]: # If token is a raw string (should not happen with new logic)
+        return str(token_received["token"]) # Fallback, but ideally token_received["token"] is always a dict if status is True
     return ""
 
-def show_client(): # Shows client_id from POST
+def show_client():
     return token_received["client_id"] if token_received["status"] and token_received["client_id"] else ""
 
-# --- Guarded fetch functions (using token from POST) ---
+# --- Function to fetch LinkedIn Token from Bubble.io ---
+def fetch_linkedin_token_from_bubble(url_user_token_str):
+    """
+    Fetches LinkedIn access token from Bubble.io API using the state value (url_user_token_str).
+    The token is expected in a 'Raw_text' field as a JSON string, which is then parsed.
+    Updates the global token_received state if successful.
+    Returns status messages for UI update.
+    """
+    # Initial UI states (in case of early exit or error)
+    current_status = check_status()
+    current_token_display = show_token()
+    current_client_display = show_client()
+
+    bubble_api_key = os.environ.get("Bubble_API")
+    if not bubble_api_key:
+        error_msg = "❌ Bubble API Error: The 'Bubble_API' environment variable is not set."
+        print(error_msg)
+        return error_msg, current_status, current_token_display, current_client_display
+
+    if not url_user_token_str or "not found" in url_user_token_str or "Could not access" in url_user_token_str:
+        return f"ℹ️ No valid user token from URL to query Bubble. ({url_user_token_str})", current_status, current_token_display, current_client_display
+
+    base_url = "https://app.ingaze.ai/version-test/api/1.1/obj/Linkedin_access"
+    constraints = [{"key": "state", "constraint_type": "equals", "value": url_user_token_str}]
+    params = {'constraints': json.dumps(constraints)}
+    headers = {"Authorization": f"Bearer {bubble_api_key}"} 
+    
+    bubble_api_status_msg = f"Attempting to fetch token from Bubble for state: {url_user_token_str}..."
+    print(bubble_api_status_msg)
+
+    response = None 
+    try:
+        response = requests.get(base_url, params=params, headers=headers, timeout=15) # Increased timeout slightly
+        response.raise_for_status() 
+        
+        data = response.json()
+        results = data.get("response", {}).get("results", [])
+        
+        if results:
+            raw_text_from_bubble = results[0].get("Raw_text", None)
+            parsed_token_dict = None 
+
+            if raw_text_from_bubble and isinstance(raw_text_from_bubble, str):
+                try:
+                    parsed_token_dict = json.loads(raw_text_from_bubble)
+                    if not isinstance(parsed_token_dict, dict):
+                        bubble_api_status_msg = (f"⚠️ Bubble API: 'Raw_text' field did not contain a valid JSON dictionary string. "
+                                                 f"Content type: {type(raw_text_from_bubble)}, Value: {raw_text_from_bubble}")
+                        print(bubble_api_status_msg)
+                        parsed_token_dict = None 
+                    # If it is a dict, parsed_token_dict is now the token dictionary itself
+                except json.JSONDecodeError as e:
+                    bubble_api_status_msg = (f"⚠️ Bubble API: Error decoding 'Raw_text' JSON string: {e}. "
+                                             f"Content: {raw_text_from_bubble}")
+                    print(bubble_api_status_msg)
+                    parsed_token_dict = None 
+            elif raw_text_from_bubble: # It exists but is not a string
+                 bubble_api_status_msg = (f"⚠️ Bubble API: 'Raw_text' field was not a string. "
+                                         f"Type: {type(raw_text_from_bubble)}, Value: {raw_text_from_bubble}")
+                 print(bubble_api_status_msg)
+
+
+            if parsed_token_dict and "access_token" in parsed_token_dict:
+                token_received["status"] = True
+                token_received["token"] = parsed_token_dict # Store the entire parsed dictionary
+                token_received["client_id"] = f"Bubble (state: {url_user_token_str})"
+                bubble_api_status_msg = f"✅ LinkedIn Token successfully fetched and parsed from Bubble 'Raw_text' for state: {url_user_token_str}"
+                print(bubble_api_status_msg)
+            elif raw_text_from_bubble and not parsed_token_dict:
+                # Error message already set by parsing logic if raw_text_from_bubble existed but parsing failed.
+                # If bubble_api_status_msg wasn't set by specific parsing errors, use a general one.
+                if not bubble_api_status_msg.startswith("⚠️"): # Avoid overwriting specific parsing error
+                    bubble_api_status_msg = f"⚠️ Bubble API: 'Raw_text' found but could not be parsed into a valid token dictionary for state: {url_user_token_str}."
+                print(bubble_api_status_msg)
+            elif not raw_text_from_bubble:
+                 bubble_api_status_msg = (f"⚠️ Bubble API: Token field ('Raw_text') "
+                                         f"not found or is null in response for state: {url_user_token_str}. Result: {results[0]}")
+                 print(bubble_api_status_msg)
+            elif parsed_token_dict and "access_token" not in parsed_token_dict: # Parsed OK, but missing the crucial key
+                 bubble_api_status_msg = (f"⚠️ Bubble API: 'access_token' key missing in parsed 'Raw_text' dictionary for state: {url_user_token_str}. Parsed: {parsed_token_dict}")
+                 print(bubble_api_status_msg)
+            # If none of the above, the initial bubble_api_status_msg will be used or an error below will catch it.
+
+        else: # No results from Bubble for the given state
+            bubble_api_status_msg = f"❌ Bubble API: No results found for state: {url_user_token_str}"
+            print(bubble_api_status_msg)
+            
+    except requests.exceptions.HTTPError as http_err:
+        error_details = response.text if response else "No response content"
+        bubble_api_status_msg = f"❌ Bubble API HTTP error: {http_err} - Response: {error_details}"
+        print(bubble_api_status_msg)
+    except requests.exceptions.Timeout:
+        bubble_api_status_msg = "❌ Bubble API Request timed out."
+        print(bubble_api_status_msg)
+    except requests.exceptions.RequestException as req_err:
+        bubble_api_status_msg = f"❌ Bubble API Request error: {req_err}"
+        print(bubble_api_status_msg)
+    except json.JSONDecodeError as json_err: # Error decoding the main Bubble response, not Raw_text
+        error_details = response.text if response else "No response content"
+        bubble_api_status_msg = f"❌ Bubble API main response JSON decode error: {json_err}. Response: {error_details}"
+        print(bubble_api_status_msg)
+    except Exception as e:
+        bubble_api_status_msg = f"❌ An unexpected error occurred while fetching from Bubble: {str(e)}"
+        print(bubble_api_status_msg)
+
+    # Return values to update all relevant UI components
+    return bubble_api_status_msg, check_status(), show_token(), show_client()
+
+
+# --- Guarded fetch functions (using token from POST or Bubble) ---
+# These functions expect token_received["token"] to be a dictionary 
+# like {"access_token": "actual_token_value", ...}
 def guarded_fetch_dashboard():
     if not token_received["status"]:
-        return "<p style='color:red; text-align:center;'>❌ Access denied. No token (POST) available. Please send token first.</p>"
-    # token_received["client_id"] and token_received["token"] required by fetch function
+        return "<p style='color:red; text-align:center;'>❌ Access denied. No token available. Please send token first or ensure URL token is valid.</p>"
     html = fetch_and_render_dashboard(
         token_received["client_id"],
-        token_received["token"]
+        token_received["token"] 
     )
     return html
 
 def guarded_fetch_analytics():
     if not token_received["status"]:
         return (
-            "<p style='color:red; text-align:center;'>❌ Access denied. No token (POST) available.</p>",
-            None, None, None, None, None, None, None # Match number of outputs
+            "<p style='color:red; text-align:center;'>❌ Access denied. No token available.</p>",
+            None, None, None, None, None, None, None 
         )
-    # Assuming fetch_and_render_analytics returns 8 values
     count_md, plot, growth_plot, avg_post_eng_rate, interaction_metrics, eb_metrics, mentions_vol_metrics, mentions_sentiment_metrics = fetch_and_render_analytics(
         token_received["client_id"],
-        token_received["token"]
+        token_received["token"] 
     )
     return count_md, plot, growth_plot, avg_post_eng_rate, interaction_metrics, eb_metrics, mentions_vol_metrics, mentions_sentiment_metrics
 
 def run_mentions_and_load():
-    if not token_received["status"]: # Added guard similar to other functions
-        return ("<p style='color:red; text-align:center;'>❌ Access denied. No token (POST) available.</p>", None)
+    if not token_received["status"]:
+        return ("<p style='color:red; text-align:center;'>❌ Access denied. No token available.</p>", None)
     html, fig = generate_mentions_dashboard(
         token_received["client_id"],
-        token_received["token"]
+        token_received["token"] 
     )
     return html, fig
 
@@ -90,46 +197,51 @@ def run_mentions_and_load():
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                title="LinkedIn Post Viewer & Analytics") as app:
     gr.Markdown("# 🚀 LinkedIn Organization Post Viewer & Analytics")
-    gr.Markdown("Send your OAuth token via API call (POST), then explore dashboard and analytics. URL parameters can also be displayed.")
+    gr.Markdown("Token can be supplied via URL parameter (for Bubble.io lookup) or hidden POST. Then explore dashboard and analytics.")
 
     # Hidden elements: simulate POST endpoint for OAuth token
-    hidden_token = gr.Textbox(visible=False, elem_id="hidden_token")
-    hidden_client = gr.Textbox(visible=False, elem_id="hidden_client_id")
+    hidden_token_input = gr.Textbox(visible=False, elem_id="hidden_token") 
+    hidden_client_input = gr.Textbox(visible=False, elem_id="hidden_client_id") 
     hidden_btn = gr.Button(visible=False, elem_id="hidden_btn")
 
     # --- Display elements ---
-    # Textbox for the user_token from URL
-    url_user_token_display = gr.Textbox(label="User Token (from URL)", interactive=False, placeholder="Attempting to load from URL...")
+    url_user_token_display = gr.Textbox(
+        label="User Token (from URL - Hidden)", 
+        interactive=False, 
+        placeholder="Attempting to load from URL...",
+        visible=False 
+    )
     
-    status_box = gr.Textbox(label="POST Token Status", interactive=False) # Clarified label
-    token_display = gr.Textbox(label="Access Token (from POST)", interactive=False)
-    client_display = gr.Textbox(label="Client ID (from POST)", interactive=False)
+    bubble_status_display = gr.Textbox(label="Bubble API Call Status", interactive=False, placeholder="Waiting for URL token...")
 
-    # --- Load URL parameter on app start ---
-    # The `get_url_user_token` function will be called when the app loads.
-    # `gr.Request` is automatically passed to `get_url_user_token`.
+    status_box = gr.Textbox(label="Overall Token Status", interactive=False) 
+    token_display = gr.Textbox(label="Access Token (Active)", interactive=False)
+    client_display = gr.Textbox(label="Client ID (Active)", interactive=False)
+
+    # --- Load URL parameter on app start & Link to Bubble Fetch ---
     app.load(
-        fn=get_url_user_token,
-        inputs=None, # No explicit Gradio inputs needed, only gr.Request
-        outputs=[url_user_token_display]
+        fn=get_url_user_token, 
+        inputs=None, 
+        outputs=[url_user_token_display] 
+    )
+
+    url_user_token_display.change(
+        fn=fetch_linkedin_token_from_bubble,
+        inputs=[url_user_token_display],
+        outputs=[bubble_status_display, status_box, token_display, client_display]
     )
 
-    # Wire hidden POST handler for OAuth token
     hidden_btn.click(
         fn=receive_token,
-        inputs=[hidden_token, hidden_client],
-        outputs=[status_box, token_display, client_display]
+        inputs=[hidden_token_input, hidden_client_input],
+        outputs=[status_box, token_display, client_display] 
     )
-
-    # Polling timer to update status and displays for the POSTed token
-    # Initial values are set by app.load for status_box, token_display, client_display
-    # then updated by timer ticks or hidden_btn click.
-    # We call check_status, show_token, show_client once at load time and then via timer.
+    
     app.load(fn=check_status, outputs=status_box)
     app.load(fn=show_token, outputs=token_display)
     app.load(fn=show_client, outputs=client_display)
     
-    timer = gr.Timer(1.0) # Poll every 1 second
+    timer = gr.Timer(2.0) 
     timer.tick(fn=check_status, outputs=status_box)
     timer.tick(fn=show_token, outputs=token_display)
     timer.tick(fn=show_client, outputs=client_display)
@@ -139,7 +251,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
         with gr.TabItem("1️⃣ Dashboard"):
             gr.Markdown("View your organization's recent posts and their engagement statistics.")
             fetch_dashboard_btn = gr.Button("📊 Fetch Posts & Stats", variant="primary")
-            dashboard_html = gr.HTML(value="<p style='text-align: center; color: #555;'>Waiting for POST token...</p>")
+            dashboard_html = gr.HTML(value="<p style='text-align: center; color: #555;'>Waiting for token...</p>")
             fetch_dashboard_btn.click(
                 fn=guarded_fetch_dashboard,
                 inputs=[],
@@ -150,38 +262,36 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             gr.Markdown("View follower count and monthly gains for your organization.")
             fetch_analytics_btn = gr.Button("📈 Fetch Follower Analytics", variant="primary")
             
-            follower_count = gr.Markdown("<p style='text-align: center; color: #555;'>Waiting for POST token...</p>")
+            follower_count = gr.Markdown("<p style='text-align: center; color: #555;'>Waiting for token...</p>")
             
             with gr.Row():
-                follower_plot = gr.Plot(visible=True) # Made visible, will be empty until data
-                growth_rate_plot = gr.Plot(visible=True) # Made visible
+                follower_plot = gr.Plot(visible=True) 
+                growth_rate_plot = gr.Plot(visible=True)
 
             with gr.Row():
-                post_eng_rate_plot = gr.Plot(visible=True) # Made visible
+                post_eng_rate_plot = gr.Plot(visible=True)
 
             with gr.Row():
-                interaction_data = gr.Plot(visible=True) # Made visible
+                interaction_data = gr.Plot(visible=True)
 
             with gr.Row():
-                eb_data = gr.Plot(visible=True) # Made visible
+                eb_data = gr.Plot(visible=True)
 
             with gr.Row():
-                mentions_vol_data = gr.Plot(visible=True) # Made visible
-                mentions_sentiment_data = gr.Plot(visible=True) # Made visible
+                mentions_vol_data = gr.Plot(visible=True)
+                mentions_sentiment_data = gr.Plot(visible=True)
             
             fetch_analytics_btn.click(
                 fn=guarded_fetch_analytics,
                 inputs=[],
-                outputs=[follower_count, follower_plot, growth_rate_plot, post_eng_rate_plot, interaction_data, eb_data, mentions_vol_data, mentions_sentiment_data],
-                # Show plots after click; they might need to be initially invisible if fetch_and_render_analytics can return None for plots on error
-                # For simplicity, keeping them visible. Handle None returns in your fetch function if necessary.
+                outputs=[follower_count, follower_plot, growth_rate_plot, post_eng_rate_plot, interaction_data, eb_data, mentions_vol_data, mentions_sentiment_data]
             )
 
         with gr.TabItem("3️⃣ Mentions"):
             gr.Markdown("Analyze sentiment of recent posts that mention your organization.")
             fetch_mentions_btn = gr.Button("🧠 Fetch Mentions & Sentiment", variant="primary")
-            mentions_html = gr.HTML(value="<p style='text-align: center; color: #555;'>Waiting for POST token...</p>") # Added placeholder
-            mentions_plot = gr.Plot(visible=True) # Made visible
+            mentions_html = gr.HTML(value="<p style='text-align: center; color: #555;'>Waiting for token...</p>")
+            mentions_plot = gr.Plot(visible=True)
             fetch_mentions_btn.click(
                 fn=run_mentions_and_load,
                 inputs=[],
@@ -190,7 +300,8 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
 
 # Launch the app
 if __name__ == "__main__":
-    # The share=True option creates a public link. Be mindful of security.
-    # For embedding, you'll use the server_name and server_port you configure for your hosting.
+    # Ensure the 'Bubble_API' environment variable is set where this app is run.
+    # For local testing, you can set it in your terminal before running:
+    # export Bubble_API="YOUR_ACTUAL_BUBBLE_API_KEY"
+    # python app.py
     app.launch(server_name="0.0.0.0", server_port=7860, share=True)
-