redplanet
/
whatsapp-archiver
1
0
Fork 0
Code Issues 0 Pull-Requests 0 Releases 0 Wiki Aktivität
Du kannst nicht mehr als 25 Themen auswählen Themen müssen entweder mit einem Buchstaben oder einer Ziffer beginnen. Sie können Bindestriche („-“) enthalten und bis zu 35 Zeichen lang sein.
3 Commits
1 Branch
229 KiB
 
Struktur: 367fcb754b
Branches Tags
${ item.name }
Erstelle Branch ${ searchTerm }
von „367fcb754b“
${ noResults }
whatsapp-archiver/whatsapp_archiver.py

773 Zeilen
30 KiB
Originalformat Blame Verlauf 

  1. #! /usr/bin/env python3

  2. # WhatsApp Chat Archiver

  3. 

  4. import sqlite3

  5. import os

  6. import argparse

  7. import html

  8. from datetime import datetime, timedelta

  9. import shutil

  10. 

  11. # WhatsApp's epoch starts on 2001-01-01 00:00:00 (Core Data timestamp)

  12. WHATSAPP_EPOCH = datetime(2001, 1, 1)

  13. 

  14. def convert_whatsapp_timestamp(ts):

  15.     """Converts WhatsApp's Core Data timestamp to a human-readable string."""

  16.     if not ts:

  17.         return ""

  18.     try:

  19.         # Timestamps are seconds since the WhatsApp epoch

  20.         dt = WHATSAPP_EPOCH + timedelta(seconds=ts)

  21.         return dt.strftime('%Y-%m-%d %H:%M:%S')

  22.     except (ValueError, TypeError):

  23.         return "Invalid date"

  24. 

  25. def get_media_tag(media_path, output_dir):

  26.     """Generates the appropriate HTML tag for a given media file and copies it."""

  27.     if not media_path:

  28.         return ""

  29. 

  30.     # Path in the DB is often relative like 'Media/WhatsApp Images/IMG-...'

  31.     test_path = os.path.join(output_dir, 'Message', media_path)

  32.     full_media_path = ''

  33.     if not os.path.exists(test_path):

  34.         return f'<div class="media-missing">Media not found: {html.escape(test_path)}</div>'

  35.     

  36.     full_media_path = os.path.join('Message', media_path)

  37.     # remove ./ in the beginning if present

  38.     full_media_path = full_media_path.lstrip('./')

  39. 

  40.     ext = os.path.splitext(media_path)[1].lower()

  41.     

  42.     if ext in ['.jpg', '.jpeg', '.png', '.gif', '.webp']:

  43.         return f'<img src="../{full_media_path}"  loading="lazy" alt="Image" class="media-item">'

  44.     elif ext in ['.mp4', '.mov', '.webm']:

  45.         return f'<video controls src="../{full_media_path}" class="media-item" loading="lazy"></video>'

  46.     elif ext in ['.mp3', '.ogg', '.opus', '.m4a']:

  47.         return f'<audio controls src="../{full_media_path}" loading="lazy"></audio>'

  48.     else:

  49.         return f'<a href="../{full_media_path}" target="_blank">View Media: {os.path.basename(media_path)}</a>'

  50. 

  51. def generate_html_chat(db_path, media_path, output_dir, chat_id, chat_name, is_group, contact_jid):

  52.     """Generates an HTML file for a single chat session."""

  53.     conn = sqlite3.connect(db_path)

  54.     cursor = conn.cursor()

  55. 

  56.     # Updated query to fetch more potential name fields (like ZFIRSTNAME) to find the best one.

  57.     query = """

  58.     SELECT

  59.         m.ZISFROMME,

  60.         m.ZTEXT,

  61.         m.ZMESSAGEDATE,

  62.         m.ZFROMJID,

  63.         g.ZCONTACTNAME AS GroupMemberContactName,

  64.         cs.ZPARTNERNAME AS ChatPartnerName,

  65.         p.ZPUSHNAME AS ProfilePushName,

  66.         mi.ZMEDIALOCALPATH,

  67.         cs.ZCONTACTJID AS ChatJID

  68.     FROM

  69.         ZWAMESSAGE m

  70.     LEFT JOIN

  71.         ZWAGROUPMEMBER g ON m.ZGROUPMEMBER = g.Z_PK

  72.     LEFT JOIN

  73.         ZWACHATSESSION cs ON m.ZCHATSESSION = cs.Z_PK

  74.     LEFT JOIN

  75.         ZWAPROFILEPUSHNAME p ON m.ZFROMJID = p.ZJID

  76.     LEFT JOIN

  77.         ZWAMEDIAITEM mi ON m.ZMEDIAITEM = mi.Z_PK

  78.     WHERE

  79.         m.ZCHATSESSION = ?

  80.     ORDER BY

  81.         m.ZMESSAGEDATE ASC;

  82.     """

  83. 

  84.     cursor.execute(query, (chat_id,))

  85.     messages = cursor.fetchall()

  86.     conn.close()

  87. 

  88.     if not messages:

  89.         print(f"No messages found for chat: {chat_name}")

  90.         return

  91. 

  92.     # Sanitize contact_jid for a unique and safe filename

  93.     if contact_jid:

  94.         safe_filename = "".join(c if c.isalnum() else "_" for c in contact_jid)

  95.     else:

  96.         # Fallback to chat_id if contact_jid is not available

  97.         safe_filename = str(chat_id)

  98. 

  99.     chats_dir = os.path.join(output_dir, "chats")

  100.     os.makedirs(chats_dir, exist_ok=True)

  101.     html_filename = os.path.join(chats_dir, f"{safe_filename}.html")

  102. 

  103.     with open(html_filename, 'w', encoding='utf-8') as f:

  104.         f.write(f"""

  105.     <!DOCTYPE html>

  106.     <html lang="en">

  107.     <head>

  108.         <meta charset="UTF-8">

  109.         <meta name="viewport" content="width=device-width, initial-scale=1.0">

  110.         <title>Chat with {html.escape(chat_name)}</title>

  111.         <style>

  112.         body {{

  113.             font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif;

  114.             background-color: #e5ddd5;

  115.             margin: 0;

  116.             padding: 20px;

  117.             color: #111b21;

  118.             min-height: 100vh;

  119.             box-sizing: border-box;

  120.         }}

  121.         .chat-container {{

  122.             max-width: 800px;

  123.             margin: auto;

  124.             background-image: url('../current_wallpaper.jpg');

  125.             background-size: auto 100%;

  126.             background-attachment: fixed;

  127.             background-position: center;

  128.             border-radius: 8px;

  129.             box-shadow: 0 1px 1px 0 rgba(0,0,0,0.06), 0 2px 5px 0 rgba(0,0,0,0.06);

  130.             overflow: hidden;

  131.         }}

  132.         .chat-header {{

  133.             background-color: #008069;

  134.             color: white;

  135.             padding: 15px 20px;

  136.             font-size: 1.2em;

  137.             text-align: center;

  138.         }}

  139. 

  140. 

  141.         .chat-header-id {{

  142.             font-size: 0.7em;

  143.             opacity: 0.8;

  144.             margin-top: 5px;

  145.         }}

  146.         

  147.         .chat-box {{

  148.             padding: 20px;

  149.             display: flex;

  150.             flex-direction: column;

  151.             gap: 12px;

  152.         }}

  153.         .message {{

  154.             padding: 8px 12px;

  155.             border-radius: 18px;

  156.             max-width: 70%;

  157.             word-wrap: break-word;

  158.             position: relative;

  159.         }}

  160.         .message.sent {{

  161.             background-color: #dcf8c6;

  162.             align-self: flex-end;

  163.             border-bottom-right-radius: 4px;

  164.         }}

  165.         .message.received {{

  166.             background-color: #ffffff;

  167.             align-self: flex-start;

  168.             border-bottom-left-radius: 4px;

  169.         }}

  170.         .sender-name {{

  171.             font-weight: bold;

  172.             font-size: 0.9em;

  173.             color: #005c4b;

  174.             margin-bottom: 4px;

  175.         }}

  176.         .timestamp {{

  177.             font-size: 0.75em;

  178.             color: #667781;

  179.             margin-top: 5px;

  180.             text-align: right;

  181.         }}

  182.         .media-item {{

  183.             max-width: 100%;

  184.             border-radius: 8px;

  185.             margin-top: 5px;

  186.             display: block;

  187.         }}

  188.         .media-missing {{

  189.             font-style: italic;

  190.             color: #888;

  191.             background-color: #fcebeb;

  192.             border: 1px solid #f5c6cb;

  193.             padding: 10px;

  194.             border-radius: 8px;

  195.         }}

  196.         </style>

  197.     </head>

  198.     <body>

  199.         <div class="chat-container">

  200.         <div class="chat-header">

  201.             {html.escape(chat_name)}

  202.             <div class="chat-header-id">{contact_jid}</div>

  203.         </div>

  204.         <div class="chat-box">

  205.         """)

  206. 

  207.         # Write messages

  208.         for is_from_me, text, timestamp, from_jid, group_member_contact_name, chat_partner_name, profile_push_name, media_local_path, contact_jid in messages:

  209.             msg_class = "sent" if is_from_me else "received"

  210.             

  211.             f.write(f'<div class="message {msg_class}">')

  212. 

  213.             # Determine and display the sender's name for incoming messages

  214.             if not is_from_me:

  215.                 # Prioritize group member contact name for group chats

  216.                 if is_group:

  217.                     # Try names in order of preference, avoiding encoded-looking strings

  218.                     potential_names = [

  219.                         group_member_contact_name,

  220.                         profile_push_name,

  221.                         from_jid,

  222.                         chat_partner_name,

  223.                     ]

  224.                     

  225.                     # Filter out None values and strings that look like they're encoded

  226.                     valid_names = [name for name in potential_names if name and not (

  227.                         name.startswith('CK') and any(c.isupper() for c in name[2:]) and '=' in name

  228.                     )]

  229.                     

  230.                     sender_name = next((name for name in valid_names), "Unknown")

  231.                 else:

  232.                     # For individual chats, prefer partner name or push name

  233.                     sender_name = chat_partner_name or profile_push_name or from_jid or "Unknown"

  234.                 

  235.                 f.write(f'<div class="sender-name">{html.escape(str(sender_name))}</div>')

  236. 

  237.             if text:

  238.                 # Replace newline characters with <br> tags for proper display

  239.                 escaped_text = html.escape(text)

  240.                 f.write(f'<div>{escaped_text.replace(chr(10), "<br>")}</div>')

  241.             

  242.             if media_local_path:

  243.                 # print("Media path:", media_local_path)

  244.                 f.write(get_media_tag(media_local_path, output_dir))

  245. 

  246.             f.write(f'<div class="timestamp">{convert_whatsapp_timestamp(timestamp)}</div>')

  247.             f.write('</div>')

  248. 

  249.         f.write("""

  250.         </div>

  251.     </div>

  252. </body>

  253. </html>

  254.         """)

  255. 

  256.     print(f"Successfully generated HTML for: {chat_name}")

  257. 

  258. 

  259. # Step: iPhone backup manifest.db processing

  260. def process_iphone_backup(backup_path, output_dir):

  261.     """

  262.     Processes the iPhone backup manifest.db, extracts WhatsApp shared files, and recreates the file structure in output_dir.

  263.     Acts as an archiver to accumulate data across multiple imports without overwriting existing data.

  264.     """

  265.     manifest_db_path = os.path.join(backup_path, 'Manifest.db')

  266.     if not os.path.exists(manifest_db_path):

  267.         print(f"Manifest.db not found in backup path: {manifest_db_path}")

  268.         return

  269. 

  270.     # Connect to manifest.db and extract WhatsApp shared files

  271.     backup_conn = sqlite3.connect(manifest_db_path)

  272.     backup_cursor = backup_conn.cursor()

  273.     backup_cursor.execute("SELECT fileID, domain, relativePath FROM Files WHERE domain = ?", ('AppDomainGroup-group.net.whatsapp.WhatsApp.shared',))

  274.     files = backup_cursor.fetchall()

  275.     print(f"Found {len(files)} WhatsApp shared files in manifest.db.")

  276.     backup_conn.close()

  277.     

  278.     # Count for statistics

  279.     new_files = 0

  280.     updated_files = 0

  281.     skipped_files = 0

  282.     special_db_files = 0

  283.     

  284.     # Check for SQLite database files that need special handling

  285.     db_files_to_merge = [

  286.         'ChatStorage.sqlite',

  287.         'CallHistory.sqlite',

  288.         'DeviceAgents.sqlite',

  289.         'Labels.sqlite',

  290.         'Ranking.sqlite',

  291.         'Sticker.sqlite'

  292.     ]

  293.     

  294.     # Prepare to recreate file structure

  295.     for fileID, domain, relativePath in files:

  296.         src_file = os.path.join(backup_path, fileID[:2], fileID)

  297.         dest_file = os.path.join(output_dir, relativePath)

  298.         os.makedirs(os.path.dirname(dest_file), exist_ok=True)

  299.         

  300.         if not os.path.exists(src_file):

  301.             print(f"Source file missing: {src_file}")

  302.             skipped_files += 1

  303.             continue

  304.         

  305.         # Handle SQLite database files specially - merge data instead of overwriting

  306.         file_basename = os.path.basename(dest_file)

  307.         if file_basename in db_files_to_merge and os.path.exists(dest_file):

  308.             special_db_files += 1

  309.             try:

  310.                 # For SQLite databases, we need to merge the data

  311.                 if file_basename == 'ChatStorage.sqlite':

  312.                     merge_chat_database(src_file, dest_file)

  313.                 else:

  314.                     # For other SQLite databases, make a backup and then replace

  315.                     # Future enhancement: implement proper merging for all database types

  316.                     backup_file = f"{dest_file}.backup_{datetime.now().strftime('%Y%m%d%H%M%S')}"

  317.                     shutil.copy2(dest_file, backup_file)

  318.                     print(f"Created backup of {file_basename} as {os.path.basename(backup_file)}")

  319.                     shutil.copy2(src_file, dest_file)

  320.             except Exception as e:

  321.                 print(f"Error processing database {dest_file}: {e}")

  322.             continue

  323.             

  324.         # For non-database files

  325.         if os.path.exists(dest_file):

  326.             # If file exists, we want to keep the newer one

  327.             # For media files, we always keep them (accumulate data)

  328.             is_media_file = any(relativePath.startswith(prefix) for prefix in ['Media/', 'Message/', 'ProfilePictures/', 'Avatar/'])

  329.             

  330.             if is_media_file:

  331.                 # For media files, don't overwrite but create a version with timestamp if different

  332.                 if not files_are_identical(src_file, dest_file):

  333.                     filename, ext = os.path.splitext(dest_file)

  334.                     timestamp = datetime.now().strftime('%Y%m%d%H%M%S')

  335.                     new_dest_file = f"{filename}_{timestamp}{ext}"

  336.                     try:

  337.                         shutil.copy2(src_file, new_dest_file)

  338.                         print(f"Saved additional version of media file: {os.path.relpath(new_dest_file, output_dir)}")

  339.                         new_files += 1

  340.                     except Exception as e:

  341.                         print(f"Error copying alternate version {src_file}: {e}")

  342.                         skipped_files += 1

  343.                 else:

  344.                     skipped_files += 1

  345.             else:

  346.                 # For non-media files, we'll take the newer one

  347.                 try:

  348.                     shutil.copy2(src_file, dest_file)

  349.                     updated_files += 1

  350.                 except Exception as e:

  351.                     print(f"Error updating {dest_file}: {e}")

  352.                     skipped_files += 1

  353.         else:

  354.             # If file doesn't exist, copy it

  355.             try:

  356.                 shutil.copy2(src_file, dest_file)

  357.                 new_files += 1

  358.             except Exception as e:

  359.                 print(f"Error copying {src_file} to {dest_file}: {e}")

  360.                 skipped_files += 1

  361.     

  362.     print(f"\nBackup import summary:")

  363.     print(f"- Added {new_files} new files")

  364.     print(f"- Updated {updated_files} existing files")

  365.     print(f"- Special handling for {special_db_files} database files")

  366.     print(f"- Skipped {skipped_files} files")

  367. 

  368. 

  369. def files_are_identical(file1, file2):

  370.     """Compare two files to see if they are identical in content."""

  371.     if os.path.getsize(file1) != os.path.getsize(file2):

  372.         return False

  373.         

  374.     # For larger files, just compare a sample to avoid reading entire files into memory

  375.     if os.path.getsize(file1) > 1024*1024:  # 1MB threshold

  376.         with open(file1, 'rb') as f1, open(file2, 'rb') as f2:

  377.             # Compare the first and last 4KB of the file

  378.             start1 = f1.read(4096)

  379.             start2 = f2.read(4096)

  380.             if start1 != start2:

  381.                 return False

  382.                 

  383.             f1.seek(-4096, 2)  # 2 is os.SEEK_END

  384.             f2.seek(-4096, 2)

  385.             end1 = f1.read(4096)

  386.             end2 = f2.read(4096)

  387.             return end1 == end2

  388.     else:

  389.         # For smaller files, read entire contents for comparison

  390.         with open(file1, 'rb') as f1, open(file2, 'rb') as f2:

  391.             return f1.read() == f2.read()

  392. 

  393. 

  394. def merge_chat_database(src_file, dest_file):

  395.     """

  396.     Merge WhatsApp chat databases to combine messages from multiple backups.

  397.     This preserves all existing messages and adds only new ones.

  398.     """

  399.     print(f"Merging chat databases to preserve existing messages...")

  400.     

  401.     # Create a temporary copy for processing

  402.     temp_file = f"{dest_file}.temp"

  403.     shutil.copy2(dest_file, temp_file)

  404.     

  405.     try:

  406.         # Connect to both databases

  407.         src_conn = sqlite3.connect(src_file)

  408.         dest_conn = sqlite3.connect(temp_file)

  409.         

  410.         # Make it safer by enabling foreign keys

  411.         src_conn.execute("PRAGMA foreign_keys = OFF")

  412.         dest_conn.execute("PRAGMA foreign_keys = OFF")

  413.         

  414.         # Get all messages from source

  415.         src_cursor = src_conn.cursor()

  416.         src_cursor.execute("SELECT Z_PK FROM ZWAMESSAGE")

  417.         src_message_ids = {row[0] for row in src_cursor.fetchall()}

  418.         

  419.         # Get all messages from destination to avoid duplicates

  420.         dest_cursor = dest_conn.cursor()

  421.         dest_cursor.execute("SELECT Z_PK FROM ZWAMESSAGE")

  422.         dest_message_ids = {row[0] for row in dest_cursor.fetchall()}

  423.         

  424.         # Find new message IDs that don't exist in the destination

  425.         new_message_ids = src_message_ids - dest_message_ids

  426.         

  427.         if not new_message_ids:

  428.             print("No new messages to import")

  429.             src_conn.close()

  430.             dest_conn.close()

  431.             os.remove(temp_file)

  432.             return

  433.         

  434.         print(f"Found {len(new_message_ids)} new messages to import")

  435.         

  436.         # Tables that need to be merged (simplified for this example)

  437.         tables_to_check = [

  438.             "ZWAMESSAGE", "ZWAMEDIAITEM", "ZWAGROUPMEMBER", 

  439.             "ZWACHATSESSION", "ZWAPROFILEPUSHNAME"

  440.         ]

  441.         

  442.         # For each table, copy new records

  443.         for table in tables_to_check:

  444.             # Check if table exists

  445.             src_cursor.execute(f"SELECT name FROM sqlite_master WHERE type='table' AND name='{table}'")

  446.             if not src_cursor.fetchone():

  447.                 print(f"Table {table} doesn't exist in source database, skipping...")

  448.                 continue

  449.                 

  450.             # Get column names

  451.             src_cursor.execute(f"PRAGMA table_info({table})")

  452.             columns = [row[1] for row in src_cursor.fetchall()]

  453.             column_str = ", ".join(columns)

  454.             

  455.             # For each message ID, copy related records

  456.             for msg_id in new_message_ids:

  457.                 # This is simplified - in reality you'd need more complex logic to follow foreign key relationships

  458.                 src_cursor.execute(f"SELECT {column_str} FROM {table} WHERE Z_PK = ?", (msg_id,))

  459.                 rows = src_cursor.fetchall()

  460.                 

  461.                 for row in rows:

  462.                     # Skip existing records with same primary key

  463.                     dest_cursor.execute(f"SELECT 1 FROM {table} WHERE Z_PK = ?", (row[0],))

  464.                     if dest_cursor.fetchone():

  465.                         continue

  466.                         

  467.                     # Insert new record

  468.                     placeholders = ", ".join(["?" for _ in row])

  469.                     dest_cursor.execute(f"INSERT OR IGNORE INTO {table} ({column_str}) VALUES ({placeholders})", row)

  470.         

  471.         # Commit changes

  472.         dest_conn.commit()

  473.         

  474.         # Close connections

  475.         src_conn.close()

  476.         dest_conn.close()

  477.         

  478.         # Replace destination file with merged file

  479.         os.rename(temp_file, dest_file)

  480.         print(f"Successfully merged chat databases")

  481.         

  482.     except Exception as e:

  483.         print(f"Error merging databases: {e}")

  484.         if os.path.exists(temp_file):

  485.             os.remove(temp_file)

  486. 

  487. 

  488. def main():

  489.     parser = argparse.ArgumentParser(description="WhatsApp Chat Exporter")

  490.     parser.add_argument("--output", default="_html_export", help="Directory to save the HTML files.")

  491.     parser.add_argument("--backup-path", default=None, help="Path to iPhone backup directory (for manifest.db processing)")

  492.     args = parser.parse_args()

  493. 

  494.     if args.backup_path:

  495.         process_iphone_backup(args.backup_path, args.output)

  496.         # Use backup paths for archive creation

  497.         db_path = os.path.join(args.output, "ChatStorage.sqlite")

  498.         media_path = os.path.join(args.output, "Message/")

  499.     else:

  500.         parser.add_argument("db_path", help="Path to the ChatStorage.sqlite file.")

  501.         parser.add_argument("media_path", help="Path to the root 'Media' directory.")

  502.         args = parser.parse_args()

  503.         db_path = args.db_path

  504.         media_path = args.media_path

  505. 

  506.     if not os.path.exists(db_path):

  507.         print(f"Error: Database file not found at '{db_path}'")

  508.         return

  509. 

  510.     if not os.path.exists(media_path):

  511.         print(f"Error: Media directory not found at '{media_path}'")

  512.         return

  513. 

  514.     os.makedirs(args.output, exist_ok=True)

  515. 

  516.     conn = sqlite3.connect(db_path)

  517.     cursor = conn.cursor()

  518.     

  519.     # Get all chats, joining with ZWAPROFILEPUSHNAME and using COALESCE to get the best possible name.

  520.     cursor.execute("""

  521.         SELECT 

  522.             cs.Z_PK, 

  523.             COALESCE(p.ZPUSHNAME, cs.ZPARTNERNAME) AS ChatName, 

  524.             cs.ZCONTACTJID,

  525.             cs.ZMESSAGECOUNTER,

  526.             MIN(m.ZMESSAGEDATE) as FirstMessageDate,

  527.             MAX(m.ZMESSAGEDATE) as LastMessageDate,

  528.             COALESCE(gi.ZPICTUREPATH, pic.ZPATH) AS AvatarPath

  529.         FROM 

  530.             ZWACHATSESSION cs

  531.         LEFT JOIN 

  532.             ZWAPROFILEPUSHNAME p ON cs.ZCONTACTJID = p.ZJID

  533.         LEFT JOIN

  534.             ZWAMESSAGE m ON cs.Z_PK = m.ZCHATSESSION

  535.         LEFT JOIN

  536.             ZWAGROUPINFO gi ON cs.ZGROUPINFO = gi.Z_PK

  537.         LEFT JOIN

  538.             ZWAPROFILEPICTUREITEM pic ON cs.ZCONTACTJID = pic.ZJID

  539.         WHERE

  540.             cs.ZCONTACTJID NOT LIKE '%@status'

  541.         GROUP BY

  542.             cs.Z_PK, ChatName, cs.ZCONTACTJID, cs.ZMESSAGECOUNTER, AvatarPath

  543.         ORDER BY 

  544.             LastMessageDate DESC NULLS LAST, ChatName

  545.     """)

  546.     chats = cursor.fetchall()

  547.     conn.close()

  548. 

  549.     print(f"Found {len(chats)} chats to export.")

  550. 

  551.     index_path = os.path.join(args.output, "whatsapp-chats.html")

  552.     with open(index_path, 'w', encoding='utf-8') as index_f:

  553.         index_f.write(f"""

  554.         <!DOCTYPE html>

  555.         <html lang="en">

  556.         <head>

  557.             <meta charset="UTF-8">

  558.             <meta name="viewport" content="width=device-width, initial-scale=1.0">

  559.             <title>WhatsApp Chat Export</title>

  560.             <link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><path fill='%23128C7E' d='M12 2C6.5 2 2 6.5 2 12c0 2 .6 3.9 1.6 5.4L2 22l4.6-1.6c1.5 1 3.4 1.6 5.4 1.6 5.5 0 10-4.5 10-10S17.5 2 12 2z'/></svg>">

  561.             <style>

  562.             body {{ 

  563.                 font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif; 

  564.                 background-color: #f4f4f9; 

  565.                 margin: 0;

  566.                 padding: 20px;

  567.                 min-height: 100vh;

  568.             }}

  569.             .header {{

  570.                 background-color: #128C7E;

  571.                 color: white;

  572.                 padding: 20px;

  573.                 margin: -20px -20px 20px -20px;

  574.                 text-align: center;

  575.                 box-shadow: 0 2px 4px rgba(0,0,0,0.1);

  576.             }}

  577.             .header h1 {{

  578.                 margin: 0;

  579.                 font-size: 1.8em;

  580.             }}

  581.             .export-info {{

  582.                 color: rgba(255,255,255,0.9);

  583.                 margin-top: 8px;

  584.                 font-size: 0.9em;

  585.             }}

  586.             .container {{ 

  587.                 max-width: 700px; 

  588.                 margin: auto;

  589.                 background: white;

  590.                 padding: 20px;

  591.                 border-radius: 12px;

  592.                 box-shadow: 0 2px 8px rgba(0,0,0,0.1);

  593.             }}

  594.             ul {{ list-style-type: none; padding: 0; }}

  595.             li {{ margin: 8px 0; }}

  596.             .chat-entry {{ 

  597.                 text-decoration: none; 

  598.                 color: #0056b3; 

  599.                 background-color: #fff;

  600.                 padding: 12px;

  601.                 border-radius: 8px;

  602.                 display: flex;

  603.                 align-items: center;

  604.                 box-shadow: 0 2px 4px rgba(0,0,0,0.1);

  605.                 transition: all 0.2s ease-in-out;

  606.                 gap: 12px;

  607.             }}

  608.             a.chat-entry:hover {{ 

  609.                 background-color: #e9ecef; 

  610.                 transform: translateY(-2px); 

  611.                 box-shadow: 0 4px 8px rgba(0,0,0,0.15); 

  612.             }}

  613.             .chat-entry.inactive {{

  614.                 color: #999;

  615.                 background-color: #f8f9fa;

  616.                 cursor: default;

  617.             }}

  618.             .chat-avatar {{

  619.                 width: 48px;

  620.                 height: 48px;

  621.                 border-radius: 50%;

  622.                 background-size: cover;

  623.                 background-position: center;

  624.                 flex-shrink: 0;

  625.             }}

  626.             .chat-avatar.default-individual {{

  627.                 background-color: #DFE5E7;

  628.                 background-image: url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="%23999"><path d="M12 12c2.21 0 4-1.79 4-4s-1.79-4-4-4-4 1.79-4 4 1.79 4 4 4zm0 2c-2.67 0-8 1.34-8 4v2h16v-2c0-2.66-5.33-4-8-4z"/></svg>');

  629.             }}

  630.             .chat-avatar.default-group {{

  631.                 background-color: #DFE5E7;

  632.                 background-image: url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="%23999"><path d="M16 11c1.66 0 2.99-1.34 2.99-3S17.66 5 16 5c-1.66 0-3 1.34-3 3s1.34 3 3 3zm-8 0c1.66 0 2.99-1.34 2.99-3S9.66 5 8 5C6.34 5 5 6.34 5 8s1.34 3 3 3zm0 2c-2.33 0-7 1.17-7 3.5V19h14v-2.5c0-2.33-4.67-3.5-7-3.5zm8 0c-.29 0-.62.02-.97.05 1.16.84 1.97 1.97 1.97 3.45V19h6v-2.5c0-2.33-4.67-3.5-7-3.5z"/></svg>');

  633.             }}

  634.             .chat-info {{

  635.                 flex-grow: 1;

  636.                 min-width: 0;

  637.             }}

  638.             .message-count {{

  639.                 background-color: #128C7E;

  640.                 color: white;

  641.                 padding: 4px 8px;

  642.                 border-radius: 12px;

  643.                 font-size: 0.85em;

  644.                 min-width: 24px;

  645.                 text-align: center;

  646.             }}

  647.             .message-count.zero {{

  648.                 background-color: #ddd;

  649.             }}

  650.             .chat-info {{

  651.                 display: flex;

  652.                 flex-direction: column;

  653.                 gap: 4px;

  654.             }}

  655.             .chat-name {{

  656.                 font-weight: 500;

  657.             }}

  658.             .date-range {{

  659.                 font-size: 0.8em;

  660.                 color: #667781;

  661.             }}

  662.             .chat-entry.inactive .date-range {{

  663.                 color: #999;

  664.             }}

  665.             </style>

  666.         </head>

  667.         <body>

  668.             <div class="header">

  669.             <h1>WhatsApp Chat Export</h1>

  670.             <div class="export-info">Exported on {datetime.now().strftime('%Y-%m-%d %H:%M')}</div>

  671.             </div>

  672.             <div class="container">

  673.             <ul>

  674.         """)

  675.         for chat_id, chat_name, contact_jid, message_count, first_message_date, last_message_date, avatar_path in chats:

  676.             if not chat_name:

  677.                 chat_name = f"Unknown Chat ({contact_jid or chat_id})"

  678.             full_avatar_path = avatar_path if avatar_path and os.path.isabs(avatar_path) else os.path.join(args.output, avatar_path) if avatar_path else None

  679. 

  680.             # Find all file paths in args.output that start with full_avatar_path

  681.             matching_files = []

  682.             if full_avatar_path:

  683.                 for root, dirs, files in os.walk(args.output):

  684.                     for file in files:

  685.                         file_path = os.path.join(root, file)

  686.                         if file_path.startswith(full_avatar_path):

  687.                             matching_files.append(file_path)

  688. 

  689.             # Use the first matching file if available

  690.             if matching_files:

  691.                 avatar_path = os.path.relpath(matching_files[0], args.output)

  692.                 full_avatar_path = matching_files[0]

  693.             

  694.             # A group chat JID typically ends with '@g.us'

  695.             is_group = contact_jid and '@g.us' in contact_jid

  696.             

  697.             # Sanitize contact_jid for a unique and safe filename

  698.             if contact_jid:

  699.                 safe_filename = "".join(c if c.isalnum() else "_" for c in contact_jid)

  700.             else:

  701.                 # Fallback to chat_id if contact_jid is not available

  702.                 safe_filename = str(chat_id)

  703. 

  704.             # Add default avatar based on chat type

  705.             if avatar_path and os.path.exists(full_avatar_path):

  706.                 avatar_html = f'<div class="chat-avatar" style="background-image: url(\'{avatar_path}\');"></div>'

  707.             else:

  708.                 avatar_html = f'<div class="chat-avatar default-{"group" if is_group else "individual"}"></div>'

  709.             

  710.             # Format date range

  711.             date_range = ""

  712.             if message_count > 0 and first_message_date and last_message_date:

  713.                 first_date = convert_whatsapp_timestamp(first_message_date).split()[0]  # Get just the date part

  714.                 last_date = convert_whatsapp_timestamp(last_message_date).split()[0]

  715.                 if first_date == last_date:

  716.                     date_range = first_date

  717.                 else:

  718.                     date_range = f"{first_date} – {last_date}"

  719.             

  720.             if message_count > 0:

  721.                 # Generate chat HTML only for chats with messages

  722.                 generate_html_chat(db_path, media_path, args.output, chat_id, chat_name, is_group, contact_jid)

  723. 

  724.                 # Clickable entry with link

  725.                 index_f.write(

  726.                     f'<li><a class="chat-entry" href="chats/{html.escape(safe_filename)}.html">'

  727.                     f'{avatar_html}'

  728.                     f'<div class="chat-info">'

  729.                     f'<span class="chat-name">{html.escape(str(chat_name))}</span>'

  730.                     f'<span class="date-range">{date_range}</span>'

  731.                     f'</div>'

  732.                     f'<span class="message-count">{message_count:,}</span>'

  733.                     f'</a></li>'

  734.                 )

  735.             else:

  736.                 # Non-clickable entry for empty chats

  737.                 index_f.write(

  738.                     f'<li><div class="chat-entry inactive">'

  739.                     f'{avatar_html}'

  740.                     f'<div class="chat-info">'

  741.                     f'<span class="chat-name">{html.escape(str(chat_name))}</span>'

  742.                     f'<span class="date-range">No messages</span>'

  743.                     f'</div>'

  744.                     f'<span class="message-count zero">0</span>'

  745.                     f'</div></li>'

  746.                 )

  747. 

  748.         index_f.write("</ul></div></body></html>")

  749. 

  750.     # Create a simple redirect index.html

  751.     redirect_index = os.path.join(args.output, "index.html")

  752.     with open(redirect_index, 'w', encoding='utf-8') as f:

  753.         f.write(f"""<!DOCTYPE html>

  754. <html>

  755. <head>

  756.     <meta http-equiv="refresh" content="0; url=whatsapp-chats.html">

  757.     <title>Redirecting to WhatsApp Chats...</title>

  758. </head>

  759. <body>

  760.     <p>Redirecting to <a href="whatsapp-chats.html">WhatsApp Chats</a>...</p>

  761. </body>

  762. </html>""")

  763. 

  764.     print(f"\nExport complete!")

  765.     print(f"View your chats by opening either of these files in your browser:")

  766.     print(f"  • {os.path.abspath(index_path)}")

  767.     print(f"  • {os.path.abspath(redirect_index)}")

  768. 

  769. 

  770. if __name__ == "__main__":

  771.     main()