Update app.py

app.py

@@ -3,23 +3,27 @@ import csv
 import requests
 import time
 import os
+import re
+import json
+from urllib.parse import urlparse, parse_qs, urlencode, urlunparse
 
 # File path configuration
 CSV_FILE = 'endpoints.csv'
 
+# -------------------------------------------------------------------------
+# DATA LOADING & UTILS
+# -------------------------------------------------------------------------
+
 def load_data():
     """Loads the endpoints from the CSV file."""
     if not os.path.exists(CSV_FILE):
-        print(f"Error: {CSV_FILE} not found.")
         return []
     
     data = []
     try:
         with open(CSV_FILE, 'r', encoding='utf-8') as f:
-            # Assumes headers: TYPE1, TYPE2, URL
             reader = csv.DictReader(f)
             for row in reader:
-                # specific cleanup to remove potential whitespace from CSV keys/values
                 cleaned_row = {k.strip(): v.strip() for k, v in row.items() if k}
                 data.append(cleaned_row)
         return data
@@ -28,61 +32,154 @@ def load_data():
         return []
 
 def get_type1_choices():
-    """Extracts unique TYPE1 categories (e.g., profile, video, comments)."""
+    """Extracts unique TYPE1 categories."""
     data = load_data()
     if not data:
         return []
-    # Set comprehension to get unique values
     return list(set([item.get('TYPE1') for item in data if item.get('TYPE1')]))
 
 def get_type2_choices(selected_type1):
-    """
-    Extracts TYPE2 options based on selected TYPE1.
-    Adds an 'ALL ...' option at the beginning.
-    """
+    """Extracts TYPE2 options based on selected TYPE1."""
     data = load_data()
     if not data or not selected_type1:
         return []
     
-    # Filter data for the selected category
     choices = [item.get('TYPE2') for item in data if item.get('TYPE1') == selected_type1]
     unique_choices = list(set(choices))
     unique_choices.sort()
     
-    # Add the "ALL" option at the top
     all_option = f"ALL {selected_type1.upper()} REPORTS"
     return [all_option] + unique_choices
 
-def execute_reports(type1, type2):
+# -------------------------------------------------------------------------
+# LINK RESOLVER (Scraper)
+# -------------------------------------------------------------------------
+
+def resolve_tiktok_link(url):
+    """
+    Attempts to fetch Object ID, Owner ID, and SecUID from a TikTok URL.
+    Returns a dictionary of values to populate the UI.
+    """
+    headers = {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        "Referer": "https://www.tiktok.com/"
+    }
+    
+    try:
+        # Determine if it's a video or profile
+        is_video = "/video/" in url
+        response = requests.get(url, headers=headers, timeout=10)
+        html = response.text
+
+        data = {
+            "object_id": "",
+            "owner_id": "",
+            "sec_uid": "",
+            "nickname": ""
+        }
+
+        # Regex to find standard TikTok JSON data in HTML
+        # Checking SIGI_STATE or generic JSON structures
+        # Note: TikTok changes this often, this is a best-effort approach.
+        
+        # 1. Try to find User ID (owner_id)
+        user_id_match = re.search(r'"userId":"(\d+)"', html)
+        if user_id_match:
+            data["owner_id"] = user_id_match.group(1)
+
+        # 2. Try to find SecUID
+        sec_uid_match = re.search(r'"secUid":"(MS4wLjAB[^"]+)"', html)
+        if sec_uid_match:
+            data["sec_uid"] = sec_uid_match.group(1)
+
+        # 3. Try to find Nickname
+        nickname_match = re.search(r'"uniqueId":"([^"]+)"', html)
+        if nickname_match:
+            data["nickname"] = nickname_match.group(1)
+
+        # 4. Determine Object ID
+        if is_video:
+            # For video, object_id is the video ID found in URL
+            vid_match = re.search(r'/video/(\d+)', url)
+            if vid_match:
+                data["object_id"] = vid_match.group(1)
+        else:
+            # For profile, object_id is usually the same as owner_id (User ID)
+            data["object_id"] = data["owner_id"]
+
+        return (
+            data["object_id"], 
+            data["owner_id"], 
+            data["sec_uid"], 
+            data["nickname"],
+            f"✅ Success! Found: {data['nickname']} (ID: {data['object_id']})"
+        )
+
+    except Exception as e:
+        return "", "", "", "", f"❌ Error resolving link: {str(e)}"
+
+# -------------------------------------------------------------------------
+# REPORT EXECUTION LOGIC
+# -------------------------------------------------------------------------
+
+def patch_url(original_url, new_params):
     """
-    Main logic to send requests to TikTok endpoints.
-    Generator function to stream logs to the UI.
+    Replaces query parameters in the original URL with new values.
+    """
+    parsed = urlparse(original_url)
+    query_params = parse_qs(parsed.query)
+
+    # Mapping UI fields to URL parameters
+    # Note: 'target' is often used interchangeably with object_id in some endpoints
+    mapping = {
+        'object_id': new_params.get('object_id'),
+        'owner_id': new_params.get('owner_id'),
+        'secUid': new_params.get('sec_uid'),
+        'nickname': new_params.get('nickname'),
+        'target': new_params.get('object_id'), # Often target == object_id
+    }
+
+    # Only update if the user provided a value
+    for param_key, new_value in mapping.items():
+        if new_value and new_value.strip():
+            query_params[param_key] = [new_value.strip()]
+
+    # Rebuild URL
+    new_query = urlencode(query_params, doseq=True)
+    new_url = urlunparse(parsed._replace(query=new_query))
+    return new_url
+
+def execute_reports(type1, type2, obj_id, own_id, sec_uid, nick):
+    """
+    Main execution handler.
+    Streams logs to the UI.
     """
     data = load_data()
     if not data:
         yield "❌ Error: endpoints.csv not found or empty."
         return
 
-    targets = []
-    
-    # Construct the "ALL" string to check against
+    # Check for "ALL" selection
     all_check_str = f"ALL {type1.upper()} REPORTS"
-
-    # Check if the user selected the "ALL" option
     if type2 == all_check_str:
-        # Filter all items matching TYPE1
         targets = [item for item in data if item.get('TYPE1') == type1]
-        yield f"🚀 Preparing to send ALL {len(targets)} reports for category: {type1}...\n"
+        yield f"🚀 Preparing ALL reports for: {type1}...\n"
     else:
-        # Filter specific item matching TYPE1 and TYPE2
         targets = [item for item in data if item.get('TYPE1') == type1 and item.get('TYPE2') == type2]
-        yield f"🚀 Preparing to send specific report: {type2}...\n"
+        yield f"🚀 Preparing specific report: {type2}...\n"
 
     if not targets:
-        yield "❌ No matching endpoints found."
+        yield "❌ No matching endpoints found in CSV."
         return
 
-    # Headers to mimic a real browser (helper to avoid immediate rejection)
+    # Pack the custom target data
+    custom_target_data = {
+        'object_id': obj_id,
+        'owner_id': own_id,
+        'sec_uid': sec_uid,
+        'nickname': nick
+    }
+
     headers = {
         "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
         "Referer": "https://www.tiktok.com/"
@@ -91,35 +188,31 @@ def execute_reports(type1, type2):
     log_history = ""
     
     for i, target in enumerate(targets):
-        url = target.get('URL')
+        original_url = target.get('URL')
         report_name = target.get('TYPE2')
         
-        if not url:
+        if not original_url:
             continue
 
+        # Patch the URL with new target info
+        final_url = patch_url(original_url, custom_target_data)
+
         try:
-            # Send the request
-            # Note: TikTok endpoints usually ignore GET for actions and require POST, 
-            # but based on your URL structure (params in URL), a GET might trigger the hit 
-            # or the URL is intended to be loaded. 
-            # If these are API endpoints, requests.get is standard.
-            response = requests.get(url, headers=headers)
-            
+            # Send Request
+            response = requests.get(final_url, headers=headers)
             timestamp = time.strftime("%H:%M:%S")
             
             if response.status_code == 200:
                 log_entry = f"[{timestamp}] ✅ SENT ({i+1}/{len(targets)}): {report_name}\n"
             else:
-                log_entry = f"[{timestamp}] ⚠️ STATUS {response.status_code} ({i+1}/{len(targets)}): {report_name}\n"
+                log_entry = f"[{timestamp}] ⚠️ STATUS {response.status_code}: {report_name}\n"
             
             log_history += log_entry
             yield log_history
-            
-            # Small delay to be polite to the server
             time.sleep(0.5) 
             
         except Exception as e:
-            log_history += f"[{time.strftime('%H:%M:%S')}] ❌ ERROR: {report_name} - {str(e)}\n"
+            log_history += f"[{time.strftime('%H:%M:%S')}] ❌ ERROR: {str(e)}\n"
             yield log_history
 
     yield log_history + "\n✅ DONE. All tasks completed."
@@ -130,62 +223,86 @@ def execute_reports(type1, type2):
 
 with gr.Blocks(theme=gr.themes.Soft()) as app:
     gr.Markdown("# 🤖 TikTok Report Bot Controller")
-    gr.Markdown("Select a category and report type. Data is loaded from `endpoints.csv`.")
     
     with gr.Row():
+        # --- LEFT COLUMN: Configuration ---
         with gr.Column(scale=1):
-            # Dropdown 1: Category (profile, video, comments)
+            gr.Markdown("### 1. Target Configuration")
+            gr.Markdown("Enter the details of the User/Video you want to report. Use the resolver to auto-fill.")
+            
+            with gr.Group():
+                link_input = gr.Textbox(label="TikTok Link (Profile or Video)", placeholder="https://www.tiktok.com/@username...")
+                resolve_btn = gr.Button("🔍 Resolve IDs from Link", size="sm")
+                resolve_status = gr.Markdown("")
+            
+            with gr.Row():
+                # Inputs that will be passed to logic
+                obj_id_input = gr.Textbox(label="Target Object ID", info="User ID (for profiles) or Video ID")
+                own_id_input = gr.Textbox(label="Target Owner ID", info="The User ID of the account owner")
+            
+            with gr.Row():
+                sec_uid_input = gr.Textbox(label="SecUID", info="Starts with MS4w...")
+                nick_input = gr.Textbox(label="Nickname", info="Username (no @)")
+
+            gr.Markdown("---")
+            gr.Markdown("### 2. Report Settings")
+            
+            # Dropdown 1: Category
             t1_input = gr.Dropdown(
                 choices=get_type1_choices(), 
-                label="Category (Type 1)",
-                info="Select the target category",
+                label="Category",
                 value=None, 
                 interactive=True
             )
             
-            # Dropdown 2: Specific Report or "ALL"
-            # We initialize it empty; it gets populated when t1_input changes
+            # Dropdown 2: Specific Report
             t2_input = gr.Dropdown(
                 choices=[], 
-                label="Report Type (Type 2)",
-                info="Select a specific violation or 'ALL'",
+                label="Report Type",
                 interactive=True
             )
             
-            send_btn = gr.Button("🚀 Send Report(s)", variant="primary")
-            
-            refresh_btn = gr.Button("🔄 Reload CSV Data", variant="secondary")
+            send_btn = gr.Button("🚀 Send Report(s)", variant="primary", size="lg")
+            refresh_btn = gr.Button("🔄 Reload CSV", variant="secondary")
 
-        with gr.Column(scale=2):
-            # Output Logs
+        # --- RIGHT COLUMN: Logs ---
+        with gr.Column(scale=1):
+            gr.Markdown("### 3. Execution Logs")
             logs_output = gr.Textbox(
-                label="Execution Logs", 
-                placeholder="Waiting for command...", 
-                lines=20,
-                max_lines=20,
-                autoscroll=True
+                show_label=False,
+                placeholder="Logs will appear here...", 
+                lines=25,
+                max_lines=25,
+                autoscroll=True,
+                elem_id="log-box"
             )
 
     # ---------------------------------------------------------------------
     # EVENT HANDLERS
     # ---------------------------------------------------------------------
 
-    # 1. When Category changes, update Report Type choices
-    # This fixes the AttributeError by returning a new gr.Dropdown object
+    # 1. Resolve Link Button
+    resolve_btn.click(
+        fn=resolve_tiktok_link,
+        inputs=link_input,
+        outputs=[obj_id_input, own_id_input, sec_uid_input, nick_input, resolve_status]
+    )
+
+    # 2. Update Report Type Choices on Category Change
     def update_second_dropdown(choice):
         new_choices = get_type2_choices(choice)
         return gr.Dropdown(choices=new_choices, value=new_choices[0] if new_choices else None)
 
     t1_input.change(fn=update_second_dropdown, inputs=t1_input, outputs=t2_input)
 
-    # 2. Send Button Logic
+    # 3. Send Button
     send_btn.click(
         fn=execute_reports, 
-        inputs=[t1_input, t2_input], 
+        inputs=[t1_input, t2_input, obj_id_input, own_id_input, sec_uid_input, nick_input], 
         outputs=logs_output
     )
     
-    # 3. Refresh Button Logic
+    # 4. Refresh Button
     def refresh_ui():
         new_t1 = get_type1_choices()
         return gr.Dropdown(choices=new_t1), gr.Dropdown(choices=[], value=None)