inventory_analytics/inventory_sync/service.py

from __future__ import annotations

import logging
from typing import Any

from inventory_analytics.logging_utils import log_event as emit_log_event

from .feishu import FeishuApiError, FeishuClient
from .postgres import query_postgres
from .settings import AppConfig
from .specs import BRAND_SYNC_TARGETS, FIELD_SPECS, PRIMARY_FIELD_NAME, PRIMARY_FIELD_SOURCE, BrandSyncTarget


logger = logging.getLogger("inventory_sync.service")

LOG_FIELD_LABELS = {
    "advanced_permission_enabled": "高级权限已开启",
    "brand_name": "品牌",
    "created_records": "新增记录数",
    "deleted_records": "删除记录数",
    "existing_records": "已有记录数",
    "rows": "行数",
    "source_rows": "源数据行数",
    "stage": "阶段",
    "table_count": "表数量",
    "table_name": "表名",
    "target_count": "目标数量",
}


def log_event(level: int, event: str, **fields: Any) -> None:
    emit_log_event(logger, LOG_FIELD_LABELS, level, event, **fields)


def build_feishu_record(row: dict[str, Any]) -> dict[str, Any]:
    if PRIMARY_FIELD_SOURCE not in row:
        raise KeyError(f"映射缺少主字段来源列: {PRIMARY_FIELD_SOURCE}")

    fields: dict[str, Any] = {
        PRIMARY_FIELD_NAME: "" if row.get(PRIMARY_FIELD_SOURCE) is None else str(row.get(PRIMARY_FIELD_SOURCE)),
    }
    for spec in FIELD_SPECS:
        if spec.source_name not in row:
            raise KeyError(f"映射缺少 SQL 列: {spec.source_name} -> {spec.feishu_name}")
        value = row.get(spec.source_name)
        if value is None or value == "":
            fields[spec.feishu_name] = None
        elif spec.field_type == 2:
            number = float(value)
            fields[spec.feishu_name] = int(round(number)) if spec.scale == 0 else round(number, spec.scale or 0)
        else:
            fields[spec.feishu_name] = str(value)
    return {"fields": fields}


def run_feishu_summary(client: FeishuClient) -> dict[str, Any]:
    log_event(logging.INFO, "开始获取飞书访问令牌", stage="feishu_auth")
    access_token = client.get_tenant_access_token()
    log_event(logging.INFO, "飞书访问令牌获取完成", stage="feishu_auth")
    base_info = client.parse_base_info(client.build_base_url(), access_token)
    log_event(logging.INFO, "飞书Base信息解析完成", stage="feishu_base")
    advanced_permission_enabled = client.enable_advanced_permission(access_token, base_info["app_token"] or "")
    tables = client.list_tables(access_token, base_info["app_token"] or "")
    log_event(
        logging.INFO,
        "飞书Base表列表读取完成",
        stage="feishu_tables",
        table_count=len(tables),
        advanced_permission_enabled=advanced_permission_enabled,
    )
    return {
        "auth_mode": "tenant_access_token",
        "advanced_permission_enabled": advanced_permission_enabled,
        "tables": [{"name": table.get("name"), "revision": table.get("revision")} for table in tables],
        "table_count": len(tables),
    }


def sync_brand_target(
    client: FeishuClient,
    access_token: str,
    app_token: str,
    tables: list[dict[str, Any]],
    target: BrandSyncTarget,
    postgres_rows: list[dict[str, Any]] | None = None,
) -> dict[str, Any]:
    log_event(
        logging.INFO,
        "开始同步目标飞书表",
        stage="sync_target",
        brand_name=target.brand_name,
        table_name=target.table_name,
        source_rows=len(postgres_rows or []),
    )
    target_table = next(
        (table for table in tables if table.get("name") == target.table_name),
        None,
    )
    if not target_table:
        raise FeishuApiError(f"未找到目标飞书表: {target.table_name}")
    table_id = target_table.get("table_id")
    if not table_id:
        raise FeishuApiError(f"目标飞书表缺少 table_id: {target.table_name}")

    target_rows = postgres_rows or []
    available_fields = client.ensure_target_fields(access_token, app_token, table_id)
    existing_records = client.list_records(access_token, app_token, table_id)
    existing_record_ids = [record.get("record_id") for record in existing_records if record.get("record_id")]
    log_event(
        logging.INFO,
        "目标飞书表已有记录读取完成",
        stage="sync_target",
        brand_name=target.brand_name,
        table_name=target.table_name,
        existing_records=len(existing_record_ids),
    )
    deleted_count = client.batch_delete_records(access_token, app_token, table_id, existing_record_ids) if existing_record_ids else 0
    created_count = client.batch_create_records(
        access_token,
        app_token,
        table_id,
        [build_feishu_record(row) for row in target_rows],
    ) if target_rows else 0
    log_event(
        logging.INFO,
        "目标飞书表同步完成",
        stage="sync_target",
        brand_name=target.brand_name,
        table_name=target.table_name,
        deleted_records=deleted_count,
        created_records=created_count,
    )

    return {
        "brand_name": target.brand_name,
        "warehouse_keys": target.warehouse_keys,
        "target_table_name": target.table_name,
        "target_table_id": table_id,
        "available_fields": available_fields,
        "source_row_count": len(target_rows),
        "filtered_row_count": len(target_rows),
        "deleted_record_count": deleted_count,
        "created_record_count": created_count,
    }


def run_sync_brand(config: AppConfig, client: FeishuClient, postgres_result: dict[str, Any] | None = None) -> dict[str, Any]:
    log_event(logging.INFO, "开始准备品牌同步", stage="sync_prepare", target_count=len(BRAND_SYNC_TARGETS))
    access_token = client.get_tenant_access_token()
    base_info = client.parse_base_info(client.build_base_url(), access_token)
    app_token = base_info["app_token"] or ""
    client.enable_advanced_permission(access_token, app_token)
    tables = client.list_tables(access_token, app_token)
    log_event(logging.INFO, "品牌同步准备完成", stage="sync_prepare", table_count=len(tables))

    results = []
    source_row_count = 0
    for index, target in enumerate(BRAND_SYNC_TARGETS):
        if postgres_result is not None and index == 0:
            postgres_payload = postgres_result
        else:
            postgres_payload = query_postgres(config, target=target)
        postgres_rows = postgres_payload["rows"]
        log_event(
            logging.INFO,
            "目标品牌PostgreSQL数据已准备",
            stage="sync_prepare",
            brand_name=target.brand_name,
            table_name=target.table_name,
            rows=len(postgres_rows or []),
        )
        source_row_count += len(postgres_rows or [])
        results.append(sync_brand_target(client, access_token, app_token, tables, target, postgres_rows))

    return {
        "target_count": len(BRAND_SYNC_TARGETS),
        "source_row_count": source_row_count,
        "targets": results,
    }