app.py

# -*- coding: utf-8 -*-
import gradio as gr
import json
# 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

# Shared state for token received via POST
token_received = {"status": False, "token": None, "client_id": None}

# --- Function to get user_token from URL on load ---
def get_url_user_token(request: gr.Request):
    """
    This function is called when the Gradio app loads.
    It attempts to retrieve 'user_token' from the URL query parameters.
    """
    user_token_from_url = "user_token not found in URL" # Default message
    if request:
        # request.query_params is a dictionary-like object.
        # Example URL: https://your-gradio-app/?user_token=ABC123XYZ
        # query_params would be {'user_token': 'ABC123XYZ'}
        retrieved_token = request.query_params.get("session_id")
        if retrieved_token:
            user_token_from_url = retrieved_token
            print(f"Retrieved user_token from URL: {user_token_from_url}")
        else:
            print("user_token key was not found in the URL query parameters.")
    else:
        # This case should ideally not happen if app.load is configured correctly
        # and Gradio supplies the request object.
        print("Request object not available to get_url_user_token function.")
        user_token_from_url = "Could not access request object on load"
    return user_token_from_url

# --- 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
        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["status"] = True
    token_received["token"] = token_dict
    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
    }

def check_status():
    return "✅ Token received (POST)" if token_received["status"] else "❌ Waiting for token (POST)…"

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")
    return ""

def show_client(): # Shows client_id from POST
    return token_received["client_id"] if token_received["status"] and token_received["client_id"] else ""

# --- Guarded fetch functions (using token from POST) ---
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
    html = fetch_and_render_dashboard(
        token_received["client_id"],
        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
        )
    # 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"]
    )
    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)
    html, fig = generate_mentions_dashboard(
        token_received["client_id"],
        token_received["token"]
    )
    return html, fig

# --- Build the Gradio UI ---
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.")

    # 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_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...")
    
    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)

    # --- 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`.
    app.load(
        fn=get_url_user_token,
        inputs=None, # No explicit Gradio inputs needed, only gr.Request
        outputs=[url_user_token_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]
    )

    # 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.tick(fn=check_status, outputs=status_box)
    timer.tick(fn=show_token, outputs=token_display)
    timer.tick(fn=show_client, outputs=client_display)

    # Tabs for functionality
    with gr.Tabs():
        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>")
            fetch_dashboard_btn.click(
                fn=guarded_fetch_dashboard,
                inputs=[],
                outputs=[dashboard_html]
            )

        with gr.TabItem("2️⃣ Analytics"):
            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>")
            
            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

            with gr.Row():
                post_eng_rate_plot = gr.Plot(visible=True) # Made visible

            with gr.Row():
                interaction_data = gr.Plot(visible=True) # Made visible

            with gr.Row():
                eb_data = gr.Plot(visible=True) # Made visible

            with gr.Row():
                mentions_vol_data = gr.Plot(visible=True) # Made visible
                mentions_sentiment_data = gr.Plot(visible=True) # Made visible
            
            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.
            )

        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
            fetch_mentions_btn.click(
                fn=run_mentions_and_load,
                inputs=[],
                outputs=[mentions_html, mentions_plot]
            )

# 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.
    app.launch(server_name="0.0.0.0", server_port=7860, share=True)