Update Tool-22-Discord-Invite-Fetcher.py

Author: ThatSINEWAVE

Tool-22-URL-Discord-Invite-Fetcher-1.py Tool-22-Discord-Invite-Fetcher.pyTool-22-URL-Discord-Invite-Fetcher-1.py renamed to Tool-22-Discord-Invite-Fetcher.py

@@ -6,7 +6,6 @@
 from urllib.parse import urlparse
 
 
-# Function to convert Discord snowflake ID to timestamp
 def snowflake_to_timestamp(snowflake):
     try:
         discord_epoch = 1420070400000
@@ -16,21 +15,16 @@ def snowflake_to_timestamp(snowflake):
         return int(datetime.datetime.now().timestamp())
 
 
-# Function to load existing database
 def load_database(file_path):
     try:
         print(f"Loading database from {file_path}...")
         with open(file_path, 'r') as file:
             return json.load(file)
-    except FileNotFoundError:
-        print(f"Database file not found. Creating new database.")
-        return {}
-    except json.JSONDecodeError:
-        print(f"Error parsing database file. Creating new database.")
+    except (FileNotFoundError, json.JSONDecodeError):
+        print(f"Database file not found or invalid. Creating new database.")
         return {}
 
 
-# Function to save updated database
 def save_database(file_path, data):
     directory = os.path.dirname(file_path)
     if not os.path.exists(directory):
@@ -43,25 +37,46 @@ def save_database(file_path, data):
     print(f"Database saved successfully.")
 
 
-# Function to ensure all entries have all required fields
 def normalize_entry(entry):
     required_fields = ["INVITE_URL", "FOUND_ON", "SERVER_ID", "REASON"]
     for field in required_fields:
         if field not in entry:
             entry[field] = "UNKNOWN"
+    for field in ["SERVER_STATUS", "SERVER_STATUS_CHANGE", "INVITE_STATUS", "INVITE_STATUS_CHANGE"]:
+        entry.setdefault(field, "UNKNOWN")
     return entry
 
 
-# Function to convert old format to new format
+def normalize_invite_url(url):
+    try:
+        parts = url.split("/")
+        for i, part in enumerate(parts):
+            if part == "invite" and i + 1 < len(parts):
+                return f"https://discord.com/invite/{parts[i + 1]}"
+        return url
+    except:
+        return url
+
+
+def extract_invite_code(url):
+    try:
+        url = normalize_invite_url(url)
+        parts = url.lower().split("/")
+        return parts[-1] if parts[-1] else ""
+    except:
+        return ""
+
+
 def convert_database_format(old_database):
     print("Converting database to new format...")
     new_database = {}
     count = 1
-    processed_urls = set()
+    processed_codes = set()
 
-    for url, data in old_database.items():
-        normalized_url = url.lower()
-        if normalized_url in processed_urls:
+    for _, data in old_database.items():
+        url = normalize_invite_url(data.get("INVITE_URL", ""))
+        code = extract_invite_code(url)
+        if code in processed_codes:
             continue
 
         new_entry = {
@@ -76,36 +91,13 @@ def convert_database_format(old_database):
         }
 
         new_database[f"DISCORD_SERVER_{count}"] = normalize_entry(new_entry)
-        processed_urls.add(normalized_url)
+        processed_codes.add(code)
         count += 1
 
     print(f"Converted {count - 1} entries to new format.")
     return new_database
 
 
-# Function to extract invite code from URL
-def extract_invite_code(url):
-    try:
-        parts = url.lower().split("/")
-        return parts[-1] if parts[-1] else ""
-    except:
-        return ""
-
-
-# Function to check if invite code already exists in database
-def invite_code_exists_in_database(invite_code, database):
-    if not invite_code:
-        return False
-    invite_code = invite_code.lower()
-    for entry_data in database.values():
-        url = entry_data.get("INVITE_URL", "").lower()
-        existing_code = extract_invite_code(url)
-        if existing_code == invite_code:
-            return True
-    return False
-
-
-# Function to renumber all database entries sequentially
 def renumber_database(database):
     print("Renumbering database entries sequentially...")
     new_database = {}
@@ -117,27 +109,31 @@ def renumber_database(database):
     return new_database
 
 
-# Main function to fetch and process data
 def update_discord_servers_database():
     start_time = time.time()
     print("Starting Discord server database update...")
 
     api_url = "https://api.phish.gg/servers/all"
     db_file_path = "../Database-Files/Filter-Database/Discord-Servers.json"
+    compromised_db_path = "../Database-Files/Main-Database/Compromised-Discord-Accounts.json"
 
     database = load_database(db_file_path)
 
-    # Check if old format
     is_old_format = any(key.startswith("http") for key in database.keys())
     if is_old_format:
         database = convert_database_format(database)
 
-    # Normalize entries
     print("Normalizing existing entries...")
     for key, entry in database.items():
+        entry["INVITE_URL"] = normalize_invite_url(entry.get("INVITE_URL", ""))
         database[key] = normalize_entry(entry)
 
-    # Fetch from API
+    existing_invite_codes = {
+        extract_invite_code(entry.get("INVITE_URL", ""))
+        for entry in database.values()
+    }
+
+    # Fetch data from API
     print(f"Fetching data from {api_url}...")
     try:
         response = requests.get(api_url)
@@ -146,62 +142,56 @@ def update_discord_servers_database():
         print(f"Successfully fetched data: {len(servers)} servers found.")
     except requests.RequestException as e:
         print(f"Error fetching data from API: {e}")
-        return
+        servers = []
 
-    new_entries_data = []
-    print("Processing server data...")
+    # Load compromised accounts (even if unused now)
+    try:
+        with open(compromised_db_path, 'r') as file:
+            compromised_accounts = json.load(file)
+    except Exception as e:
+        print(f"Error loading compromised accounts: {e}")
+        compromised_accounts = {}
+
+    # Process new servers
+    new_entries_added = 0
     for server in servers:
         server_id = server.get("serverID", "UNKNOWN")
-        invite_code = server.get("invite", "")
+        raw_invite = server.get("invite", "")
         reason = server.get("reason", "UNKNOWN")
 
-        if not invite_code:
+        if not raw_invite:
             continue
 
-        if invite_code_exists_in_database(invite_code, database):
+        normalized_url = normalize_invite_url(f"https://discord.com/invite/{raw_invite}")
+        invite_code = extract_invite_code(normalized_url)
+
+        if invite_code.lower() in existing_invite_codes:
             continue
 
-        found_on = snowflake_to_timestamp(server_id) if server_id != "UNKNOWN" else int(datetime.datetime.now().timestamp())
-        url = f"https://discord.com/invite/{invite_code}"
+        found_on = snowflake_to_timestamp(server_id)
 
-        new_entries_data.append({
-            "INVITE_URL": url,
+        new_entry = {
+            "INVITE_URL": normalized_url,
             "FOUND_ON": found_on,
             "SERVER_ID": server_id,
             "REASON": reason,
             "SERVER_STATUS": "UNKNOWN",
             "SERVER_STATUS_CHANGE": "UNKNOWN",
             "INVITE_STATUS": "UNKNOWN",
             "INVITE_STATUS_CHANGE": "UNKNOWN"
-        })
-
-    # Track existing invite codes
-    existing_invite_codes = {
-        extract_invite_code(entry.get("INVITE_URL", ""))
-        for entry in database.values()
-    }
-
-    for entry_data in new_entries_data:
-        invite_code = extract_invite_code(entry_data["INVITE_URL"])
-        if invite_code in existing_invite_codes:
-            continue
+        }
 
-        highest_num = max(
-            [int(k.split("_")[-1]) for k in database if k.startswith("DISCORD_SERVER_")],
-            default=0
-        )
-        new_key = f"DISCORD_SERVER_{highest_num + 1}"
-        database[new_key] = entry_data
-        existing_invite_codes.add(invite_code)
+        database[f"DISCORD_SERVER_{len(database) + 1}"] = normalize_entry(new_entry)
+        existing_invite_codes.add(invite_code.lower())
+        new_entries_added += 1
 
+    print(f"New entries added: {new_entries_added}")
     database = renumber_database(database)
     save_database(db_file_path, database)
 
-    end_time = time.time()
-    print(f"Database update completed in {end_time - start_time:.2f} seconds.")
-    print(f"Added {len(new_entries_data)} new entries.")
-    print(f"Total entries in database: {len(database)}")
+    elapsed_time = time.time() - start_time
+    print(f"Update completed in {elapsed_time:.2f} seconds.")
 
 
 if __name__ == "__main__":
-    update_discord_servers_database()
+    update_discord_servers_database()