850 lines
34 KiB
Python
850 lines
34 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 math
|
|
import threading
|
|
import base64
|
|
import mimetypes
|
|
import re
|
|
from array import array
|
|
from collections import OrderedDict
|
|
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",
|
|
}
|
|
|
|
|
|
# Cache only derived read-only data. A DB replacement or WAL commit invalidates
|
|
# its entry; no SQLite connection or file handle remains open between requests.
|
|
_CACHE_LOCK = threading.RLock()
|
|
_CACHES: dict[str, OrderedDict] = {}
|
|
_CACHE_LIMITS = {"index": 4, "names": 64, "files": 64, "counts": 64, "messages": 32}
|
|
_MEDIA_CACHE_LIMIT = 256
|
|
_MEDIA_REF = re.compile(r"(?<![0-9a-f])[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}(?![0-9a-f])|(?<![\w.-])[\w\u4e00-\u9fff()（）【】\[\]-]{2,120}\.(?:png|jpe?g|gif|bmp|webp)(?!\w)", re.I)
|
|
_MEDIA_INDEX_CACHE: OrderedDict = OrderedDict()
|
|
_VOICE_READERS: dict[str, Any] = {}
|
|
|
|
|
|
def clear_browser_cache() -> None:
|
|
with _CACHE_LOCK:
|
|
_CACHES.clear()
|
|
_MEDIA_INDEX_CACHE.clear()
|
|
|
|
|
|
def _media_index(root: Path) -> dict[str, list[Path]]:
|
|
"""Index image cache files; references are matched by exact basename/stem."""
|
|
root = Path(root).resolve()
|
|
key = str(root).casefold()
|
|
try:
|
|
revision = tuple((str(p), p.stat().st_mtime_ns, p.stat().st_size)
|
|
for p in root.glob("**/*") if p.is_file())
|
|
except OSError:
|
|
revision = ()
|
|
with _CACHE_LOCK:
|
|
found = _MEDIA_INDEX_CACHE.get(key)
|
|
if found and found[0] == revision:
|
|
_MEDIA_INDEX_CACHE.move_to_end(key)
|
|
return found[1]
|
|
result: dict[str, list[Path]] = {}
|
|
if root.is_dir():
|
|
try:
|
|
files = [p for p in root.rglob("*") if p.is_file()][:20000]
|
|
except OSError:
|
|
files = []
|
|
for path in files:
|
|
if path.suffix.casefold() not in {".png", ".jpg", ".jpeg", ".gif", ".bmp", ".webp"}:
|
|
continue
|
|
tokens = {path.name.casefold(), path.stem.casefold()}
|
|
match = re.match(r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}", path.name, re.I)
|
|
if match:
|
|
tokens.add(match.group(0).casefold())
|
|
for token in tokens:
|
|
result.setdefault(token, []).append(path)
|
|
with _CACHE_LOCK:
|
|
_MEDIA_INDEX_CACHE[key] = (revision, result)
|
|
_MEDIA_INDEX_CACHE.move_to_end(key)
|
|
while len(_MEDIA_INDEX_CACHE) > _MEDIA_CACHE_LIMIT:
|
|
_MEDIA_INDEX_CACHE.popitem(last=False)
|
|
return result
|
|
|
|
|
|
def _media_data(raw: Any, media_root: Path | None, content_type: Any) -> dict[str, Any]:
|
|
"""Return a bounded data URI after an exact decoded image-cache match."""
|
|
try:
|
|
kind = int(content_type)
|
|
except (TypeError, ValueError):
|
|
kind = -1
|
|
if kind not in {3, 14, 123} or media_root is None:
|
|
return {}
|
|
if isinstance(raw, str):
|
|
raw = raw.encode("utf-8", errors="ignore")
|
|
if not isinstance(raw, (bytes, bytearray, memoryview)):
|
|
return {}
|
|
text = bytes(raw).decode("utf-8", errors="ignore")
|
|
refs = [match.group(0).casefold() for match in _MEDIA_REF.finditer(text)][:32]
|
|
if not refs:
|
|
return {}
|
|
index = _media_index(media_root)
|
|
matches = []
|
|
for ref in refs:
|
|
matches.extend(index.get(ref, ()))
|
|
unique = {str(path.resolve()): path for path in matches}
|
|
if len(unique) != 1:
|
|
return {}
|
|
path = next(iter(unique.values()))
|
|
try:
|
|
info = path.stat()
|
|
if info.st_size <= 0 or info.st_size > 2 * 1024 * 1024:
|
|
return {}
|
|
data = path.read_bytes()
|
|
except OSError:
|
|
return {}
|
|
if not data.startswith((b"\x89PNG\r\n\x1a\n", b"\xff\xd8\xff", b"GIF8", b"BM", b"RIFF")):
|
|
return {}
|
|
mime = mimetypes.guess_type(path.name)[0] or "image/png"
|
|
return {"src": "data:" + mime + ";base64," + base64.b64encode(data).decode("ascii"),
|
|
"name": path.name, "mime": mime}
|
|
|
|
|
|
def _database_revision(path: Path) -> tuple:
|
|
values = [str(path.resolve()).casefold()]
|
|
for candidate in (path, Path(str(path) + "-wal")):
|
|
try:
|
|
info = candidate.stat()
|
|
values.append((info.st_size, info.st_mtime_ns, info.st_ctime_ns, info.st_ino))
|
|
except OSError:
|
|
values.append(None)
|
|
return tuple(values)
|
|
|
|
|
|
def _cached(kind: str, key: Any, revision: tuple, build):
|
|
# Building under the lock coalesces simultaneous navigation requests. The
|
|
# GUI already loads in a worker; repeated searches cannot multiply scans.
|
|
with _CACHE_LOCK:
|
|
cache = _CACHES.setdefault(kind, OrderedDict())
|
|
found = cache.get(key)
|
|
if found is not None and found[0] == revision:
|
|
cache.move_to_end(key)
|
|
return found[1]
|
|
value = build()
|
|
cache[key] = (revision, value)
|
|
cache.move_to_end(key)
|
|
while len(cache) > _CACHE_LIMITS.get(kind, 16):
|
|
cache.popitem(last=False)
|
|
return value
|
|
|
|
|
|
def _message_index(message_path: Path) -> dict:
|
|
revision = _database_revision(message_path)
|
|
def build():
|
|
connection = connect_sqlite(str(message_path))
|
|
try:
|
|
columns = _columns(connection, "message_table")
|
|
result = {"columns": columns, "total_messages": 0, "conversations": {},
|
|
"ordered": [], "previews": {}, "revision": revision}
|
|
if not {"conversation_id", "send_time"}.issubset(columns):
|
|
return result
|
|
result["total_messages"] = _message_counts(message_path)[0]
|
|
# Sort/group inside SQLite instead of allocating one Python tuple
|
|
# per message. Only compact row IDs and one timestamp per chat are
|
|
# retained; message bodies are fetched for the visible page only.
|
|
cursor = connection.execute(
|
|
"SELECT conversation_id,GROUP_CONCAT(message_rowid),MAX(message_time) "
|
|
"FROM (SELECT rowid AS message_rowid,conversation_id,CAST(send_time AS REAL) AS message_time "
|
|
"FROM message_table WHERE conversation_id IS NOT NULL AND conversation_id<>'' "
|
|
"AND conversation_id NOT LIKE 'Y:%' "
|
|
"ORDER BY conversation_id,CAST(send_time AS REAL),rowid) GROUP BY conversation_id"
|
|
)
|
|
for conversation_id, encoded_rows, timestamp in cursor:
|
|
row_ids = array("q", map(int, str(encoded_rows).split(",")))
|
|
timestamp = float(timestamp or 0)
|
|
if not math.isfinite(timestamp):
|
|
timestamp = 0.0
|
|
result["conversations"][str(conversation_id)] = {
|
|
"rows": row_ids, "lastTimestamp": timestamp, "lastRowId": row_ids[-1],
|
|
}
|
|
result["ordered"] = sorted(result["conversations"], key=lambda key: (
|
|
result["conversations"][key]["lastTimestamp"],
|
|
result["conversations"][key]["lastRowId"], key), reverse=True)
|
|
return result
|
|
finally:
|
|
connection.close()
|
|
return _cached("index", revision[0], revision, build)
|
|
|
|
|
|
def _read_message_rows(message_path: Path, index: dict, row_ids: list[int]) -> dict[int, dict]:
|
|
if not row_ids:
|
|
return {}
|
|
columns = index["columns"]
|
|
wanted = [name for name in ("conversation_id", "sender_id", "send_time", "content_type", "content", "server_id", "client_id") if name in columns]
|
|
if not wanted:
|
|
return {}
|
|
connection = connect_sqlite(str(message_path))
|
|
try:
|
|
result = {}
|
|
for offset in range(0, len(row_ids), 500):
|
|
batch = row_ids[offset:offset + 500]
|
|
marks = ",".join("?" for _ in batch)
|
|
for row in connection.execute(f"SELECT rowid,{','.join(wanted)} FROM message_table WHERE rowid IN ({marks})", batch):
|
|
result[int(row[0])] = dict(zip(wanted, row[1:]))
|
|
return result
|
|
finally:
|
|
connection.close()
|
|
|
|
|
|
def _ensure_previews(message_path: Path, index: dict, conversation_ids: list[str]) -> None:
|
|
with _CACHE_LOCK:
|
|
missing = [key for key in conversation_ids if key not in index["previews"]]
|
|
for offset in range(0, len(missing), 500):
|
|
batch = missing[offset:offset + 500]
|
|
rows = _read_message_rows(message_path, index, [index["conversations"][key]["lastRowId"] for key in batch])
|
|
for key in batch:
|
|
item = rows.get(index["conversations"][key]["lastRowId"], {})
|
|
# A cache file can be atomically replaced between indexing and
|
|
# reading. Reused row IDs must never expose another chat.
|
|
if str(item.get("conversation_id") or "") != key:
|
|
index["previews"][key] = {"text": "", "sender": ""}
|
|
continue
|
|
index["previews"][key] = {
|
|
"text": _content_label(item.get("content"), item.get("content_type")).replace("\n", " ")[:2000],
|
|
"sender": str(item.get("sender_id") or ""),
|
|
}
|
|
|
|
|
|
def _load_names(databases: dict[str, Path], account: str):
|
|
revision = tuple((name, _database_revision(databases[name])) for name in ("user.db", "session.db") if name in databases)
|
|
key = (account, tuple((name, str(path.resolve()).casefold()) for name, path in databases.items() if name in {"user.db", "session.db"}))
|
|
return _cached("names", key, revision, lambda: _load_names_uncached(databases, account))
|
|
|
|
|
|
def _database_files(databases: dict[str, Path]):
|
|
revision = tuple((name, _database_revision(path)) for name, path in sorted(databases.items()))
|
|
key = tuple((name, str(path.resolve()).casefold()) for name, path in sorted(databases.items()))
|
|
files, size = _cached("files", key, revision, lambda: _database_files_uncached(databases))
|
|
return [dict(item) for item in files], size
|
|
|
|
|
|
def _message_counts(message_path: Path) -> tuple[int, int]:
|
|
revision = _database_revision(message_path)
|
|
def build():
|
|
connection = connect_sqlite(str(message_path))
|
|
try:
|
|
columns = _columns(connection, "message_table")
|
|
if "conversation_id" not in columns:
|
|
return _count(connection, "message_table"), 0
|
|
values = connection.execute(
|
|
"SELECT COUNT(*),COUNT(DISTINCT CASE WHEN conversation_id IS NOT NULL "
|
|
"AND conversation_id<>'' AND conversation_id NOT LIKE 'Y:%' "
|
|
"THEN conversation_id END) FROM message_table"
|
|
).fetchone()
|
|
return int(values[0]), int(values[1])
|
|
finally:
|
|
connection.close()
|
|
return _cached("counts", revision[0], revision, build)
|
|
|
|
|
|
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_uncached(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:
|
|
from archive_content_parser import parse_message_content
|
|
parsed = parse_message_content(content, content_type)["text"].strip()
|
|
if parsed:
|
|
return parsed
|
|
return f"[{get_msg_type_name(content_type)}]"
|
|
|
|
|
|
def _database_files_uncached(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 = _message_counts(path)[0] if table == "message_table" else _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,
|
|
offset: int = 0,
|
|
) -> tuple[list[dict[str, Any]], int, int]:
|
|
index = _message_index(message_path)
|
|
ordered = index["ordered"]
|
|
needle = str(query or "").strip().casefold()
|
|
offset = max(0, int(offset))
|
|
candidates = ordered if needle else ordered[offset:offset + limit]
|
|
_ensure_previews(message_path, index, candidates)
|
|
result = []
|
|
matching = 0
|
|
for conversation_id in candidates:
|
|
name = _conversation_name(account, conversation_id, users, conversations)
|
|
preview = index["previews"][conversation_id]
|
|
if needle and needle not in f"{name} {conversation_id} {preview['text']}".casefold():
|
|
continue
|
|
if needle:
|
|
matching += 1
|
|
if matching <= offset:
|
|
continue
|
|
group = index["conversations"][conversation_id]
|
|
result.append({
|
|
"id": conversation_id, "name": name, "kind": _conversation_kind(conversation_id),
|
|
"messageCount": len(group["rows"]), "lastTime": _format_time(group["lastTimestamp"]),
|
|
"lastTimestamp": group["lastTimestamp"], "preview": preview["text"][:160],
|
|
"lastDirection": "发出" if preview["sender"] == account else "收到",
|
|
})
|
|
if len(result) >= limit:
|
|
break
|
|
return result, len(ordered), index["total_messages"]
|
|
|
|
|
|
def _messages(
|
|
message_path: Path,
|
|
account: str,
|
|
conversation_id: str,
|
|
users: dict[str, str],
|
|
limit: int,
|
|
offset: int = 0,
|
|
media_root: Path | None = None,
|
|
) -> list[dict[str, Any]]:
|
|
if not conversation_id:
|
|
return []
|
|
index = _message_index(message_path)
|
|
rows = (index["conversations"].get(conversation_id) or {}).get("rows", [])
|
|
offset = max(0, int(offset))
|
|
limit = max(1, min(int(limit), 1000))
|
|
end = max(0, len(rows) - offset)
|
|
row_ids = list(rows[max(0, end - limit):end])
|
|
revision = index["revision"]
|
|
key = (revision[0], conversation_id, limit, offset)
|
|
records = _cached("messages", key, revision, lambda: _read_message_rows(message_path, index, row_ids))
|
|
result = []
|
|
connection = None
|
|
try:
|
|
from archive_content_parser import parse_message_content
|
|
from voice_messages import is_voice, cached_voice_fields
|
|
if any(is_voice(row) for row in records.values()):
|
|
connection = connect_sqlite(str(message_path))
|
|
for row_id in row_ids:
|
|
item = records.get(row_id)
|
|
if item is None or str(item.get("conversation_id") or "") != conversation_id:
|
|
continue
|
|
sender_id = str(item.get("sender_id") or "")
|
|
try:
|
|
timestamp = float(item.get("send_time") or 0)
|
|
if not math.isfinite(timestamp):
|
|
timestamp = 0.0
|
|
except (ValueError, TypeError, OverflowError):
|
|
timestamp = 0.0
|
|
content_type = item.get("content_type")
|
|
decoded = parse_message_content(item.get("content"), content_type)
|
|
fields = {}
|
|
server_id = str(item.get("server_id") or "")
|
|
if is_voice(item) and connection is not None:
|
|
fields = cached_voice_fields(connection, account, conversation_id, server_id, item.get("content"))
|
|
content = fields.get("content") or decoded.get("text") or _content_label(item.get("content"), content_type)
|
|
message = {
|
|
"id": server_id or str(item.get("client_id") or row_id),
|
|
"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(timestamp), "timestamp": timestamp,
|
|
"type": get_msg_type_name(content_type), "content": content,
|
|
"account": account, "conv_id": conversation_id, "server_id": server_id,
|
|
"content_type": content_type, "voice_refs": fields.get("voice_refs", []),
|
|
**fields,
|
|
}
|
|
result.append(message)
|
|
finally:
|
|
if connection is not None:
|
|
connection.close()
|
|
# Queue every visible voice in the history, including messages sent by us;
|
|
# the reply engine's default unanswered-only behavior remains unchanged.
|
|
if any(int(item.get("content_type") or 0) in {4, 16} for item in result):
|
|
source_key = str(media_root.parent.parent if media_root else "").casefold()
|
|
if source_key:
|
|
reader = _VOICE_READERS.get(source_key)
|
|
if reader is None:
|
|
from voice_messages import VoiceMessageReader
|
|
reader = _VOICE_READERS[source_key] = VoiceMessageReader(Path(source_key), background_index=True)
|
|
reader.prepare(result, include_history=True)
|
|
for message in result:
|
|
if message.get("voice_transcribed") and message.get("content"):
|
|
continue
|
|
image = _media_data(records.get(next((rid for rid, row in records.items() if str(row.get("server_id") or row.get("client_id") or rid) == message["id"]), 0), {}).get("content"), media_root, message.get("content_type"))
|
|
if image:
|
|
message["media"] = {"kind": "image", **image}
|
|
for message in result:
|
|
for key_name in ("account", "conv_id", "server_id", "content_type", "voice_refs"):
|
|
message.pop(key_name, None)
|
|
return result
|
|
|
|
|
|
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,
|
|
conversation_offset: int = 0,
|
|
message_offset: int = 0,
|
|
) -> 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()
|
|
clear_browser_cache()
|
|
discovered = _discover_databases(roots)
|
|
if not source_root and cache_roots is None:
|
|
try:
|
|
source_root = str(detect_wxwork_dir() or "")
|
|
except Exception:
|
|
source_root = ""
|
|
|
|
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": [],
|
|
"conversationLimit": max(1, min(int(conversation_limit), 1000)),
|
|
"messageLimit": max(1, min(int(message_limit), 1000)),
|
|
"messageTotal": 0,
|
|
"conversationTotal": 0,
|
|
"conversationHasMore": False,
|
|
"messageHasMore": False,
|
|
"messageLoadDirection": "newest",
|
|
}
|
|
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:
|
|
message_count, conversation_count = _message_counts(message_path)
|
|
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, total_conversations, total_messages = _conversation_rows(
|
|
message_path,
|
|
account,
|
|
users,
|
|
conversation_names,
|
|
str(query or ""),
|
|
max(1, min(int(conversation_limit), 1000)),
|
|
offset=max(0, int(conversation_offset)),
|
|
)
|
|
state["conversations"] = conversations
|
|
state["conversationTotal"] = total_conversations
|
|
state["messageTotal"] = len((_message_index(message_path).get("conversations", {}).get(str(selected_conversation or ""), {}).get("rows", []))) if selected_conversation else 0
|
|
state["conversationHasMore"] = len(conversations) < total_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,
|
|
offset=max(0, int(message_offset)),
|
|
media_root=(Path(source_root) / account / "Cache") if source_root else None,
|
|
)
|
|
state["messageTotal"] = len((_message_index(message_path).get("conversations", {}).get(conversation, {}).get("rows", [])))
|
|
state["messageHasMore"] = len(state["messages"]) < state["messageTotal"]
|
|
except sqlite3.Error as exc:
|
|
state["error"] = f"读取消息数据库失败：{exc}"
|
|
state["manualSetupRequired"] = True
|
|
return state
|