Upload main.py

main.py

@@ -40,6 +40,8 @@ app.add_middleware(
 SCAMMER_DWC_SPREADSHEET_ID = os.getenv('SCAMMER_DWC_SPREADSHEET_ID', '1sgkhBNGw_r6tBIxvdeXaI0bVmWBeACN4jiw_oDEeXLw')
 # Spreadsheet containing Value lists and Dupe list
 VALUES_DUPE_SPREADSHEET_ID = os.getenv('VALUES_DUPE_SPREADSHEET_ID', '1Toe07o3P517q8sm9Qb1e5xyFWCuwgskj71IKJwJNfNU')
+# New spreadsheet for Teams and Servers data
+TEAMS_SERVERS_SPREADSHEET_ID = os.getenv('TEAMS_SERVERS_SPREADSHEET_ID', '1HWnvzPd4AtRdAroXnwQaN4Dcpj6lZbtnCBavqiAxokQ')
 
 SCOPES = ['https://www.googleapis.com/auth/spreadsheets.readonly']
 
@@ -63,6 +65,12 @@ CATEGORIES = [
 ]
 VALUES_RANGE = 'B6:R' # Range within each category sheet including column R for lastUpdated
 
+# New Sheet Names and Ranges within TEAMS_SERVERS_SPREADSHEET_ID
+TEAMS_SHEET = "Our Teams Page"
+TEAMS_RANGE = "B6:K"
+SERVERS_SHEET = "Private Server Links"
+SERVERS_RANGE = "B6:F"
+
 # Cache Update Interval
 CACHE_UPDATE_INTERVAL_SECONDS = 60
 
@@ -84,6 +92,8 @@ cache = {
     "dwc": [],
     "trusted": [],            # New cache key for trusted entries
     "dupes": [],              # List of duped usernames
+    "teams": [],              # New cache key for teams data
+    "servers": [],            # New cache key for servers data
     "last_updated": None,     # Timestamp of the last successful/partial update
     "is_ready": False,        # Is the cache populated at least once?
     "service_available": True # Is the Google Sheets service reachable?
@@ -449,6 +459,57 @@ def process_dupe_list_data(values): # For Dupe List Sheet
                  processed_dupes.append(username)
     return processed_dupes
 
+def process_teams_data(values): # For Teams Sheet
+    if not values: return []
+    processed_data = []
+    for row in values: # Expected range like B6:K
+        if not row or len(row) < 2: continue
+        # Indices based on B6:K (0-indexed from B)
+        discord_username = clean_string_optional(row[0]) if len(row) > 0 else None # Col B
+        discord_user_id = clean_string_optional(row[1]) if len(row) > 1 else None # Col C
+        # Skip if both identifiers are missing
+        if not discord_username and not discord_user_id: continue
+        # Skip if it looks like a header row
+        if str(discord_username).lower() == 'discord username' or str(discord_user_id).lower() == 'discord user id':
+            continue
+        processed_item = {
+            'discord_username': discord_username,
+            'discord_user_id': discord_user_id,
+            'position': clean_string(row[2]) if len(row) > 2 else 'N/A', # Col D
+            'second_position': clean_string_optional(row[3]) if len(row) > 3 else None, # Col E
+            'third_position': clean_string_optional(row[4]) if len(row) > 4 else None, # Col F
+            'roblox_username': clean_string_optional(row[5]) if len(row) > 5 else None, # Col G
+            'discord_server_link': clean_string_optional(row[6]) if len(row) > 6 else None, # Col H
+            'custom_bio': clean_string_optional(row[7]) if len(row) > 7 else None, # Col I
+            'likes': int(row[8]) if len(row) > 8 and row[8] and str(row[8]).isdigit() else 0, # Col J
+            'last_updated': clean_string_optional(row[9]) if len(row) > 9 else None, # Col K
+            'roblox_avatar_url': None # Will be filled later
+        }
+        processed_data.append(processed_item)
+    return processed_data
+
+def process_servers_data(values): # For Servers Sheet
+    if not values: return []
+    processed_data = []
+    for row in values: # Expected range like B6:F
+        if not row or len(row) < 1: continue
+        # Indices based on B6:F (0-indexed from B)
+        server_link = clean_string_optional(row[0]) if len(row) > 0 else None # Col B
+        # Skip if server link is missing
+        if not server_link: continue
+        # Skip if it looks like a header row
+        if str(server_link).lower() == 'server link':
+            continue
+        processed_item = {
+            'server_link': server_link,
+            'server_owner': clean_string(row[1]) if len(row) > 1 else 'N/A', # Col C
+            'expires': clean_string_optional(row[2]) if len(row) > 2 else None, # Col D
+            'rules': clean_string_optional(row[3]) if len(row) > 3 else None, # Col E
+            'extra_notes': clean_string_optional(row[4]) if len(row) > 4 else None # Col F
+        }
+        processed_data.append(processed_item)
+    return processed_data
+
 
 # --- Async Fetching Functions ---
 
@@ -566,6 +627,8 @@ async def update_cache_periodically():
                 "dwc": [],
                 "trusted": [], # Add trusted key
                 "dupes": [],
+                "teams": [],   # Add teams key
+                "servers": [], # Add servers key
             }
             current_errors = {} # Track errors for specific fetches/sheets
 
@@ -590,6 +653,20 @@ async def update_cache_periodically():
                     TRUSTED_SHEET: "trusted", # Add trusted target key
                 }
 
+                # Define ranges for teams and servers
+                teams_servers_ranges = [
+                    f"{quote_sheet_name(TEAMS_SHEET)}!{TEAMS_RANGE}",
+                    f"{quote_sheet_name(SERVERS_SHEET)}!{SERVERS_RANGE}",
+                ]
+                teams_servers_processor_map = {
+                    TEAMS_SHEET: process_teams_data,
+                    SERVERS_SHEET: process_servers_data,
+                }
+                teams_servers_target_key_map = {
+                    TEAMS_SHEET: "teams",
+                    SERVERS_SHEET: "servers",
+                }
+
                 values_dupes_ranges = [f"{quote_sheet_name(DUPE_LIST_SHEET)}!{DUPE_LIST_RANGE}"]
                 values_dupes_ranges.extend([f"{quote_sheet_name(cat)}!{VALUES_RANGE}" for cat in CATEGORIES])
 
@@ -609,6 +686,23 @@ async def update_cache_periodically():
                 # Add delay between sheet updates
                 await asyncio.sleep(SHEET_UPDATE_DELAY_SECONDS)
                 
+                # Now fetch teams/servers batch
+                fetch_tasks = {
+                    "teams_batch": fetch_batch_ranges_async(
+                        TEAMS_SERVERS_SPREADSHEET_ID,
+                        teams_servers_ranges,
+                        value_render_option='FORMATTED_VALUE'
+                    )
+                }
+                
+                # Execute teams/servers batch
+                teams_results = await asyncio.gather(*fetch_tasks.values(), return_exceptions=True)
+                task_keys.extend(list(fetch_tasks.keys()))
+                results.extend(teams_results)
+                
+                # Add delay between sheet updates
+                await asyncio.sleep(SHEET_UPDATE_DELAY_SECONDS)
+                
                 # Now fetch values/dupes batch
                 fetch_tasks = {
                     "values_dupes_batch": fetch_batch_ranges_async(
@@ -625,6 +719,7 @@ async def update_cache_periodically():
 
                 # --- Process Results ---
                 raw_scammer_dwc_results = None
+                raw_teams_servers_results = None
                 raw_values_dupes_results = None
 
                 for i, result in enumerate(results):
@@ -637,6 +732,8 @@ async def update_cache_periodically():
                     else:
                         if key == "scammer_dwc_batch":
                             raw_scammer_dwc_results = result
+                        elif key == "teams_batch":
+                            raw_teams_servers_results = result
                         elif key == "values_dupes_batch":
                             raw_values_dupes_results = result
 
@@ -667,6 +764,32 @@ async def update_cache_periodically():
                 else:
                     logger.warning("Skipping Scammer/DWC processing due to fetch error.")
 
+                # --- Process Teams/Servers Results ---
+                if raw_teams_servers_results is not None:
+                    logger.info(f"Processing {len(raw_teams_servers_results)} valueRanges from Teams/Servers sheet...")
+                    for vr in raw_teams_servers_results:
+                        range_str = vr.get('range', '')
+                        match = re.match(r"^'?([^'!]+)'?!", range_str)
+                        if not match:
+                            logger.warning(f"Could not extract sheet name from range '{range_str}' in Teams/Servers response.")
+                            continue
+                        sheet_name = match.group(1).replace("''", "'")
+
+                        if sheet_name in teams_servers_processor_map:
+                            processor = teams_servers_processor_map[sheet_name]
+                            target_key = teams_servers_target_key_map[sheet_name]
+                            values = vr.get('values', [])
+                            try:
+                                processed_data = processor(values)
+                                new_cache_data[target_key] = processed_data # Store fetched data temporarily
+                                logger.info(f"Processed {len(processed_data)} items for {sheet_name} -> {target_key}")
+                            except Exception as e:
+                                logger.error(f"Error processing data for {sheet_name} using {processor.__name__}: {e}", exc_info=True)
+                                current_errors[f"process_{target_key}"] = str(e)
+                        else:
+                            logger.warning(f"No processor found for sheet name '{sheet_name}' derived from range '{range_str}' in Teams/Servers sheet.")
+                else:
+                    logger.warning("Skipping Teams/Servers processing due to fetch error.")
 
                 # --- Process Values/Dupes Results ---
                 if raw_values_dupes_results is not None:
@@ -702,10 +825,12 @@ async def update_cache_periodically():
                 if not current_errors.get("scammer_dwc_batch") and \
                    not current_errors.get("process_user_scammers") and \
                    not current_errors.get("process_dwc") and \
-                   not current_errors.get("process_trusted"): # Check trusted processing too
+                   not current_errors.get("process_trusted") and \
+                   not current_errors.get("teams_batch") and \
+                   not current_errors.get("process_teams"): # Check teams processing too
                     logger.info("Fetching Roblox avatars for newly processed data...")
                     avatar_tasks = []
-                    entries_needing_avatars = new_cache_data.get("user_scammers", []) + new_cache_data.get("dwc", []) + new_cache_data.get("trusted", []) # Include trusted list
+                    entries_needing_avatars = new_cache_data.get("user_scammers", []) + new_cache_data.get("dwc", []) + new_cache_data.get("trusted", []) + new_cache_data.get("teams", []) # Include teams list
                     for entry in entries_needing_avatars:
                         if entry.get('roblox_username'):
                             avatar_tasks.append(fetch_avatar_for_entry_update(session, entry))
@@ -713,8 +838,7 @@ async def update_cache_periodically():
                         await asyncio.gather(*avatar_tasks) # Exceptions logged within helper
                     logger.info(f"Finished fetching avatars for {len(avatar_tasks)} potential new entries.")
                 else:
-                    logger.warning("Skipping avatar fetching due to errors in fetching/processing scammer/dwc/trusted data.")
-
+                    logger.warning("Skipping avatar fetching due to errors in fetching/processing scammer/dwc/trusted/teams data.")
 
                 # --- Change Detection & Webhook Preparation (ONLY if cache is ready) ---
                 current_time = datetime.now(timezone.utc)
@@ -908,6 +1032,8 @@ async def update_cache_periodically():
                     cache["dwc"] = new_cache_data["dwc"]
                     cache["trusted"] = new_cache_data["trusted"]
                     cache["dupes"] = new_cache_data["dupes"]
+                    cache["teams"] = new_cache_data["teams"]
+                    cache["servers"] = new_cache_data["servers"]
                     cache["value_changes"] = detected_value_changes_for_api # Store the detected changes
                     cache["last_updated"] = current_time
                     if can_set_ready:
@@ -953,6 +1079,20 @@ async def update_cache_periodically():
                     else:
                          logger.warning("Skipping update for 'user_scammers', 'server_scammers', 'dwc', 'trusted' due to batch fetch error.")
 
+                    # Update teams and servers sections if their batch succeeded AND processing succeeded
+                    if "teams_batch" not in current_errors:
+                        for key in ["teams", "servers"]:
+                            process_error_key = f"process_{key}"
+                            if process_error_key not in current_errors:
+                                if cache.get(key) != new_cache_data[key]:
+                                    cache[key] = new_cache_data[key]
+                                    partial_update_details.append(key)
+                                    update_occurred = True
+                            else:
+                                logger.warning(f"Skipping update for '{key}' due to processing error.")
+                    else:
+                        logger.warning("Skipping update for 'teams' and 'servers' due to batch fetch error.")
+
                     if update_occurred:
                          cache["last_updated"] = current_time # Mark partial update time
                          # Mark cache ready only if it was *already* ready and we managed a partial update
@@ -1053,6 +1193,8 @@ async def get_status():
             "dwc_entries": len(cache.get("dwc", [])),
             "trusted_entries": len(cache.get("trusted", [])), # Add trusted count
             "duped_usernames": len(cache.get("dupes", [])),
+            "teams": len(cache.get("teams", [])),
+            "servers": len(cache.get("servers", [])),
         },
          "value_change_categories_in_last_cycle": len(cache.get("value_changes", {}))
     }
@@ -1118,6 +1260,44 @@ async def get_dupes():
     return {"usernames": cache.get("dupes", [])} # Return empty list if not ready or empty
 
 
+@app.get("/api/teams")
+async def get_teams():
+    """Get all teams data from cache"""
+    check_cache_readiness()
+    return {"members": cache.get("teams", [])}
+
+
+@app.get("/api/servers")
+async def get_servers():
+    """Get all private servers data from cache"""
+    check_cache_readiness()
+    return {"servers": cache.get("servers", [])}
+
+
+class TeamMemberLike(BaseModel):
+    discord_user_id: str
+
+
+@app.post("/api/teams/like")
+async def like_team_member(data: TeamMemberLike):
+    """Increment like count for a team member (to be implemented with spreadsheet update)"""
+    check_cache_readiness()
+    
+    # Find the team member by discord_user_id
+    discord_user_id = data.discord_user_id.strip()
+    teams = cache.get("teams", [])
+    
+    for member in teams:
+        if member.get("discord_user_id") == discord_user_id:
+            # In a real implementation, this would update the spreadsheet
+            # For now, just update the cache
+            member["likes"] = member.get("likes", 0) + 1
+            member["last_updated"] = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
+            return {"success": True, "likes": member["likes"]}
+    
+    raise HTTPException(status_code=404, detail=f"Team member with discord_user_id {discord_user_id} not found")
+
+
 class UsernameCheck(BaseModel):
     username: str