604 lines
23 KiB
Python
604 lines
23 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""Read-only browser model for locally decrypted WeCom message databases.
|
|
|
|
The auto-reply engine and archive uploader already maintain decrypted SQLite
|
|
copies. This module only reads those copies and therefore never writes to the
|
|
live WeCom databases. A manual refresh may update the existing decrypted
|
|
cache through ``wxwork_db.decrypt_with_keys`` before the snapshot is built.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import sqlite3
|
|
import time
|
|
from datetime import datetime
|
|
from pathlib import Path
|
|
from typing import Any, Iterable
|
|
|
|
from runtime_paths import application_data_dir
|
|
from wxwork_db import (
|
|
connect_sqlite,
|
|
decrypt_with_keys,
|
|
detect_wxwork_dir,
|
|
get_msg_type_name,
|
|
load_keys,
|
|
parse_content,
|
|
)
|
|
|
|
|
|
DATABASE_TABLES = {
|
|
"message.db": "message_table",
|
|
"session.db": "conversation_table",
|
|
"user.db": "user_table",
|
|
"company.db": "company_table",
|
|
}
|
|
|
|
|
|
def _format_time(value: Any) -> str:
|
|
try:
|
|
timestamp = float(value or 0)
|
|
except (TypeError, ValueError):
|
|
return ""
|
|
if timestamp > 10**12:
|
|
timestamp /= 1000
|
|
if timestamp <= 0:
|
|
return ""
|
|
try:
|
|
return datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d %H:%M:%S")
|
|
except (OSError, OverflowError, ValueError):
|
|
return ""
|
|
|
|
|
|
def _size_label(size: int) -> str:
|
|
if size < 1024:
|
|
return f"{size} B"
|
|
if size < 1024 * 1024:
|
|
return f"{size / 1024:.1f} KB"
|
|
if size < 1024 * 1024 * 1024:
|
|
return f"{size / (1024 * 1024):.1f} MB"
|
|
return f"{size / (1024 * 1024 * 1024):.2f} GB"
|
|
|
|
|
|
def _columns(connection: sqlite3.Connection, table: str) -> set[str]:
|
|
try:
|
|
return {
|
|
str(row[1])
|
|
for row in connection.execute(f'PRAGMA table_info("{table}")').fetchall()
|
|
}
|
|
except sqlite3.Error:
|
|
return set()
|
|
|
|
|
|
def _count(connection: sqlite3.Connection, table: str) -> int:
|
|
try:
|
|
return int(connection.execute(f'SELECT COUNT(*) FROM "{table}"').fetchone()[0])
|
|
except (sqlite3.Error, TypeError, ValueError):
|
|
return 0
|
|
|
|
|
|
def default_cache_roots() -> list[Path]:
|
|
data_root = application_data_dir()
|
|
source_root = Path(__file__).resolve().parent
|
|
candidates = [
|
|
data_root / "archive_auto_backup" / "decrypted",
|
|
data_root / "wxwork_decrypted",
|
|
source_root / "archive_auto_backup" / "decrypted",
|
|
source_root / "wxwork_decrypted",
|
|
]
|
|
result: list[Path] = []
|
|
seen: set[str] = set()
|
|
for candidate in candidates:
|
|
identity = str(candidate.resolve()).casefold()
|
|
if identity in seen:
|
|
continue
|
|
seen.add(identity)
|
|
result.append(candidate)
|
|
return result
|
|
|
|
|
|
def _discover_databases(cache_roots: Iterable[Path]) -> dict[str, dict[str, Path]]:
|
|
"""Choose the newest readable copy of every database for each account."""
|
|
|
|
discovered: dict[str, dict[str, Path]] = {}
|
|
for root in cache_roots:
|
|
if not root.is_dir():
|
|
continue
|
|
try:
|
|
account_dirs = list(root.iterdir())
|
|
except OSError:
|
|
continue
|
|
for account_dir in account_dirs:
|
|
if not account_dir.is_dir():
|
|
continue
|
|
account = account_dir.name
|
|
for database_path in account_dir.glob("*.db"):
|
|
current = discovered.setdefault(account, {}).get(database_path.name)
|
|
try:
|
|
newer = current is None or database_path.stat().st_mtime > current.stat().st_mtime
|
|
except OSError:
|
|
continue
|
|
if newer:
|
|
discovered[account][database_path.name] = database_path
|
|
return discovered
|
|
|
|
|
|
def _refresh_cache(*, auto_acquire: bool = False) -> tuple[str, str]:
|
|
"""先复用密钥解密；自动初始化时，仅在无法读取后获取一次本机密钥。"""
|
|
source_root = detect_wxwork_dir()
|
|
if not source_root:
|
|
return "", "自动检测未找到企业微信数据库。请先在本机登录企业微信后刷新，或手动选择数据目录"
|
|
from wxwork_local_setup import acquire_local_keys, select_source_directory
|
|
|
|
try:
|
|
# 让独立 EXE 密钥工作进程使用同一个已识别的目录。
|
|
if auto_acquire:
|
|
select_source_directory(source_root)
|
|
expected = {p.parent.parent.name for p in Path(source_root).glob("*/Data/message.db")}
|
|
|
|
def decrypt() -> tuple[set[str], dict]:
|
|
try:
|
|
keys = load_keys()
|
|
except ValueError:
|
|
keys = {}
|
|
output = str(application_data_dir() / "wxwork_decrypted")
|
|
decrypted = decrypt_with_keys(source_root, output, keys, use_cache=True)
|
|
readable = set()
|
|
invalid = False
|
|
for path, name, account in decrypted:
|
|
if name != "message.db":
|
|
continue
|
|
try:
|
|
connection = connect_sqlite(path)
|
|
try:
|
|
connection.execute("SELECT conversation_id FROM message_table LIMIT 1").fetchone()
|
|
readable.add(account)
|
|
finally:
|
|
connection.close()
|
|
except sqlite3.Error:
|
|
invalid = True
|
|
# 缓存大小/时间正常也可能已经损坏；重建后再次检查。
|
|
if invalid:
|
|
decrypted = decrypt_with_keys(source_root, output, keys, use_cache=False)
|
|
readable.clear()
|
|
for path, name, account in decrypted:
|
|
if name != "message.db":
|
|
continue
|
|
try:
|
|
connection = connect_sqlite(path)
|
|
try:
|
|
connection.execute("SELECT conversation_id FROM message_table LIMIT 1").fetchone()
|
|
readable.add(account)
|
|
finally:
|
|
connection.close()
|
|
except sqlite3.Error:
|
|
continue
|
|
return readable, keys
|
|
|
|
readable, keys = decrypt()
|
|
if expected and expected <= readable:
|
|
return source_root, ""
|
|
if auto_acquire:
|
|
try:
|
|
acquire_local_keys()
|
|
except (OSError, ValueError) as exc:
|
|
return source_root, f"自动解密未完成：{exc}。可重新刷新自动检测，或使用下方手动设置"
|
|
readable, keys = decrypt()
|
|
if expected and expected <= readable:
|
|
return source_root, ""
|
|
return source_root, "自动获取密钥后仍有数据库无法解密，请确认企业微信已登录，或使用下方手动设置"
|
|
if not keys:
|
|
return source_root, "已找到企业微信数据库，但本机尚未配置密钥。请点击刷新自动获取，或导入当前电脑的密钥文件"
|
|
return source_root, "已找到企业微信数据库，但现有密钥无法解密全部数据库。请刷新重新获取本机密钥或导入匹配的密钥文件"
|
|
except Exception as exc:
|
|
return source_root, f"更新解密缓存失败：{exc}"
|
|
|
|
|
|
def _load_names(databases: dict[str, Path], account: str) -> tuple[dict[str, str], dict[str, str], str]:
|
|
users: dict[str, str] = {}
|
|
conversations: dict[str, str] = {}
|
|
account_name = account
|
|
|
|
user_path = databases.get("user.db")
|
|
if user_path:
|
|
try:
|
|
connection = connect_sqlite(str(user_path))
|
|
try:
|
|
columns = _columns(connection, "user_table")
|
|
wanted = [name for name in ("id", "name", "real_name", "account") if name in columns]
|
|
if "id" in wanted:
|
|
cursor = connection.execute(f"SELECT {','.join(wanted)} FROM user_table")
|
|
for values in cursor.fetchall():
|
|
item = dict(zip(wanted, values))
|
|
user_id = str(item.get("id") or "")
|
|
label = str(
|
|
item.get("name")
|
|
or item.get("real_name")
|
|
or item.get("account")
|
|
or user_id
|
|
)
|
|
if user_id:
|
|
users[user_id] = label
|
|
account_name = users.get(account) or account_name
|
|
finally:
|
|
connection.close()
|
|
except sqlite3.Error:
|
|
pass
|
|
|
|
session_path = databases.get("session.db")
|
|
if session_path:
|
|
try:
|
|
connection = connect_sqlite(str(session_path))
|
|
try:
|
|
columns = _columns(connection, "conversation_table")
|
|
wanted = [
|
|
name
|
|
for name in ("id", "name", "roomname_remark", "session_id")
|
|
if name in columns
|
|
]
|
|
if "id" in wanted:
|
|
cursor = connection.execute(
|
|
f"SELECT {','.join(wanted)} FROM conversation_table"
|
|
)
|
|
for values in cursor.fetchall():
|
|
item = dict(zip(wanted, values))
|
|
conversation_id = str(item.get("id") or "")
|
|
label = str(
|
|
item.get("roomname_remark")
|
|
or item.get("name")
|
|
or item.get("session_id")
|
|
or ""
|
|
)
|
|
if conversation_id and label:
|
|
conversations[conversation_id] = label
|
|
finally:
|
|
connection.close()
|
|
except sqlite3.Error:
|
|
pass
|
|
return users, conversations, account_name
|
|
|
|
|
|
def _conversation_name(
|
|
account: str,
|
|
conversation_id: str,
|
|
users: dict[str, str],
|
|
conversations: dict[str, str],
|
|
) -> str:
|
|
label = str(conversations.get(conversation_id) or "").strip()
|
|
if label and label != conversation_id:
|
|
return label
|
|
if conversation_id.startswith("M:"):
|
|
peer_id = conversation_id[2:]
|
|
return users.get(peer_id) or f"微信用户 {peer_id}"
|
|
if conversation_id.startswith("S:"):
|
|
peers = [item for item in conversation_id[2:].split("_") if item]
|
|
peer_id = next((item for item in peers if item != account), peers[0] if peers else "")
|
|
return users.get(peer_id) or f"企微用户 {peer_id}"
|
|
if conversation_id.startswith("R:"):
|
|
return label or f"群聊 {conversation_id[2:]}"
|
|
if conversation_id.startswith("Y:"):
|
|
return label or f"应用 {conversation_id[2:]}"
|
|
return label or conversation_id or "未知会话"
|
|
|
|
|
|
def _conversation_kind(conversation_id: str) -> str:
|
|
if conversation_id.startswith("M:"):
|
|
return "微信客户"
|
|
if conversation_id.startswith("S:"):
|
|
return "企业微信"
|
|
if conversation_id.startswith("R:"):
|
|
return "群聊"
|
|
if conversation_id.startswith("Y:"):
|
|
return "应用"
|
|
return "其他"
|
|
|
|
|
|
def _content_label(content: Any, content_type: Any) -> str:
|
|
parsed = str(parse_content(content) or "").strip()
|
|
if parsed:
|
|
return parsed[:2000]
|
|
return f"[{get_msg_type_name(content_type)}]"
|
|
|
|
|
|
def _database_files(databases: dict[str, Path]) -> tuple[list[dict[str, Any]], int]:
|
|
files: list[dict[str, Any]] = []
|
|
total_size = 0
|
|
preferred_order = {
|
|
name: index
|
|
for index, name in enumerate(
|
|
("message.db", "session.db", "user.db", "company.db", "message_lookup.db", "user_extend.db")
|
|
)
|
|
}
|
|
for name, path in sorted(
|
|
databases.items(), key=lambda item: (preferred_order.get(item[0], 99), item[0])
|
|
):
|
|
try:
|
|
stat = path.stat()
|
|
size = int(stat.st_size)
|
|
modified = _format_time(stat.st_mtime)
|
|
except OSError:
|
|
size, modified = 0, ""
|
|
total_size += size
|
|
row_count = 0
|
|
status = "可读取"
|
|
table = DATABASE_TABLES.get(name)
|
|
try:
|
|
connection = connect_sqlite(str(path))
|
|
try:
|
|
if table:
|
|
row_count = _count(connection, table)
|
|
connection.execute("SELECT COUNT(*) FROM sqlite_master").fetchone()
|
|
finally:
|
|
connection.close()
|
|
except sqlite3.Error:
|
|
status = "读取失败"
|
|
files.append(
|
|
{
|
|
"name": name,
|
|
"path": str(path),
|
|
"size": size,
|
|
"sizeLabel": _size_label(size),
|
|
"modified": modified,
|
|
"rows": row_count,
|
|
"status": status,
|
|
}
|
|
)
|
|
return files, total_size
|
|
|
|
|
|
def _conversation_rows(
|
|
message_path: Path,
|
|
account: str,
|
|
users: dict[str, str],
|
|
conversations: dict[str, str],
|
|
query: str,
|
|
limit: int,
|
|
) -> tuple[list[dict[str, Any]], int, int]:
|
|
connection = connect_sqlite(str(message_path))
|
|
try:
|
|
columns = _columns(connection, "message_table")
|
|
required = {"conversation_id", "send_time"}
|
|
if not required.issubset(columns):
|
|
return [], 0, 0
|
|
total_messages = _count(connection, "message_table")
|
|
try:
|
|
total_conversations = int(
|
|
connection.execute(
|
|
"SELECT COUNT(DISTINCT conversation_id) FROM message_table "
|
|
"WHERE conversation_id IS NOT NULL AND conversation_id<>'' "
|
|
"AND conversation_id NOT LIKE 'Y:%'"
|
|
).fetchone()[0]
|
|
)
|
|
except (sqlite3.Error, TypeError, ValueError):
|
|
total_conversations = 0
|
|
sender_expr = "sender_id" if "sender_id" in columns else "''"
|
|
type_expr = "content_type" if "content_type" in columns else "NULL"
|
|
content_expr = "content" if "content" in columns else "''"
|
|
fetch_limit = 1000 if str(query or "").strip() else max(limit * 4, limit)
|
|
cursor = connection.execute(
|
|
f"""SELECT conversation_id,COUNT(*) AS message_count,
|
|
MAX(send_time) AS last_time,{sender_expr} AS sender_id,
|
|
{type_expr} AS content_type,{content_expr} AS content
|
|
FROM message_table
|
|
WHERE conversation_id IS NOT NULL AND conversation_id<>''
|
|
AND conversation_id NOT LIKE 'Y:%'
|
|
GROUP BY conversation_id
|
|
ORDER BY last_time DESC
|
|
LIMIT ?""",
|
|
(fetch_limit,),
|
|
)
|
|
needle = str(query or "").strip().casefold()
|
|
result: list[dict[str, Any]] = []
|
|
for conversation_id, count, last_time, sender_id, content_type, content in cursor.fetchall():
|
|
conversation_id = str(conversation_id or "")
|
|
name = _conversation_name(account, conversation_id, users, conversations)
|
|
preview = _content_label(content, content_type).replace("\n", " ")
|
|
if needle and needle not in f"{name} {conversation_id} {preview}".casefold():
|
|
continue
|
|
result.append(
|
|
{
|
|
"id": conversation_id,
|
|
"name": name,
|
|
"kind": _conversation_kind(conversation_id),
|
|
"messageCount": int(count or 0),
|
|
"lastTime": _format_time(last_time),
|
|
"lastTimestamp": float(last_time or 0),
|
|
"preview": preview[:160],
|
|
"lastDirection": "发出" if str(sender_id or "") == account else "收到",
|
|
}
|
|
)
|
|
if len(result) >= limit:
|
|
break
|
|
return result, total_conversations, total_messages
|
|
finally:
|
|
connection.close()
|
|
|
|
|
|
def _messages(
|
|
message_path: Path,
|
|
account: str,
|
|
conversation_id: str,
|
|
users: dict[str, str],
|
|
limit: int,
|
|
) -> list[dict[str, Any]]:
|
|
if not conversation_id:
|
|
return []
|
|
connection = connect_sqlite(str(message_path))
|
|
try:
|
|
columns = _columns(connection, "message_table")
|
|
if "conversation_id" not in columns:
|
|
return []
|
|
wanted = [
|
|
name
|
|
for name in (
|
|
"sender_id",
|
|
"send_time",
|
|
"content_type",
|
|
"content",
|
|
"server_id",
|
|
"client_id",
|
|
)
|
|
if name in columns
|
|
]
|
|
if not wanted:
|
|
return []
|
|
cursor = connection.execute(
|
|
f"SELECT {','.join(wanted)} FROM message_table "
|
|
"WHERE conversation_id=? ORDER BY send_time DESC,rowid DESC LIMIT ?",
|
|
(conversation_id, max(1, min(int(limit), 1000))),
|
|
)
|
|
result: list[dict[str, Any]] = []
|
|
for values in reversed(cursor.fetchall()):
|
|
item = dict(zip(wanted, values))
|
|
sender_id = str(item.get("sender_id") or "")
|
|
content_type = item.get("content_type")
|
|
result.append(
|
|
{
|
|
"id": str(item.get("server_id") or item.get("client_id") or ""),
|
|
"senderId": sender_id,
|
|
"sender": users.get(sender_id) or ("当前账号" if sender_id == account else sender_id),
|
|
"direction": "outbound" if sender_id == account else "inbound",
|
|
"time": _format_time(item.get("send_time")),
|
|
"timestamp": float(item.get("send_time") or 0),
|
|
"type": get_msg_type_name(content_type),
|
|
"content": _content_label(item.get("content"), content_type),
|
|
}
|
|
)
|
|
return result
|
|
finally:
|
|
connection.close()
|
|
|
|
|
|
def load_browser_snapshot(
|
|
*,
|
|
selected_account: str = "",
|
|
selected_conversation: str = "",
|
|
query: str = "",
|
|
refresh_cache: bool = False,
|
|
auto_initialize: bool = False,
|
|
cache_roots: Iterable[Path] | None = None,
|
|
conversation_limit: int = 200,
|
|
message_limit: int = 500,
|
|
) -> dict[str, Any]:
|
|
"""Build the JSON-ready state used by the desktop message-library page."""
|
|
|
|
source_root = ""
|
|
warning = ""
|
|
roots = [Path(item) for item in (cache_roots or default_cache_roots())]
|
|
discovered = _discover_databases(roots)
|
|
if refresh_cache or auto_initialize or not discovered:
|
|
source_root, warning = _refresh_cache(auto_acquire=True) if auto_initialize else _refresh_cache()
|
|
discovered = _discover_databases(roots)
|
|
|
|
state: dict[str, Any] = {
|
|
"loading": False,
|
|
"error": "",
|
|
"warning": warning,
|
|
"manualSetupRequired": bool(warning),
|
|
"initializationAttempted": bool(auto_initialize),
|
|
"sourceRoot": source_root,
|
|
"refreshedAt": _format_time(time.time()),
|
|
"query": str(query or ""),
|
|
"selectedAccount": "",
|
|
"selectedConversation": "",
|
|
"accountCount": len(discovered),
|
|
"databaseCount": 0,
|
|
"conversationCount": 0,
|
|
"messageCount": 0,
|
|
"accounts": [],
|
|
"conversations": [],
|
|
"messages": [],
|
|
"files": [],
|
|
}
|
|
if not discovered:
|
|
state["error"] = warning or "尚未找到可读取的企业微信数据库，请刷新自动检测，或使用手动设置"
|
|
state["manualSetupRequired"] = True
|
|
return state
|
|
|
|
account_models: list[dict[str, Any]] = []
|
|
account_metadata: dict[str, tuple[dict[str, str], dict[str, str], str]] = {}
|
|
for account, databases in discovered.items():
|
|
files, total_size = _database_files(databases)
|
|
users, conversations, account_name = _load_names(databases, account)
|
|
account_metadata[account] = (users, conversations, account_name)
|
|
message_count = 0
|
|
conversation_count = 0
|
|
message_path = databases.get("message.db")
|
|
if message_path:
|
|
try:
|
|
connection = connect_sqlite(str(message_path))
|
|
try:
|
|
message_count = _count(connection, "message_table")
|
|
conversation_count = int(
|
|
connection.execute(
|
|
"SELECT COUNT(DISTINCT conversation_id) FROM message_table "
|
|
"WHERE conversation_id IS NOT NULL AND conversation_id<>'' "
|
|
"AND conversation_id NOT LIKE 'Y:%'"
|
|
).fetchone()[0]
|
|
)
|
|
finally:
|
|
connection.close()
|
|
except (sqlite3.Error, TypeError, ValueError):
|
|
pass
|
|
updated = max(
|
|
(item.get("modified") or "" for item in files),
|
|
default="",
|
|
)
|
|
account_models.append(
|
|
{
|
|
"id": account,
|
|
"name": account_name,
|
|
"databaseCount": len(files),
|
|
"messageCount": message_count,
|
|
"conversationCount": conversation_count,
|
|
"size": total_size,
|
|
"sizeLabel": _size_label(total_size),
|
|
"updated": updated,
|
|
"files": files,
|
|
}
|
|
)
|
|
account_models.sort(key=lambda item: (item["updated"], item["messageCount"]), reverse=True)
|
|
account_ids = {str(item["id"]) for item in account_models}
|
|
account = str(selected_account or "")
|
|
if account not in account_ids:
|
|
account = str(account_models[0]["id"])
|
|
state["selectedAccount"] = account
|
|
state["accounts"] = account_models
|
|
state["databaseCount"] = sum(int(item["databaseCount"]) for item in account_models)
|
|
state["messageCount"] = sum(int(item["messageCount"]) for item in account_models)
|
|
state["conversationCount"] = sum(int(item["conversationCount"]) for item in account_models)
|
|
|
|
current = next(item for item in account_models if str(item["id"]) == account)
|
|
state["files"] = current["files"]
|
|
users, conversation_names, _account_name = account_metadata[account]
|
|
message_path = discovered[account].get("message.db")
|
|
if not message_path:
|
|
state["error"] = "当前账号没有可读取的 message.db"
|
|
state["manualSetupRequired"] = True
|
|
return state
|
|
try:
|
|
conversations, _account_conversations, _account_messages = _conversation_rows(
|
|
message_path,
|
|
account,
|
|
users,
|
|
conversation_names,
|
|
str(query or ""),
|
|
max(1, min(int(conversation_limit), 1000)),
|
|
)
|
|
state["conversations"] = conversations
|
|
available = {str(item["id"]) for item in conversations}
|
|
conversation = str(selected_conversation or "")
|
|
if conversation not in available:
|
|
conversation = str(conversations[0]["id"]) if conversations else ""
|
|
state["selectedConversation"] = conversation
|
|
state["messages"] = _messages(
|
|
message_path,
|
|
account,
|
|
conversation,
|
|
users,
|
|
message_limit,
|
|
)
|
|
except sqlite3.Error as exc:
|
|
state["error"] = f"读取消息数据库失败：{exc}"
|
|
state["manualSetupRequired"] = True
|
|
return state
|