增加组装推送消息的逻辑

2025-12-08 09:49:36 +08:00
parent 038363a17e
commit 43ff4aa5f9
6 changed files with 1096 additions and 53 deletions
--- a/app/callback_service.py
+++ b/app/callback_service.py
@@ -0,0 +1,497 @@
+"""
+回调处理服务模块
+包含与回调处理相关的业务逻辑函数
+"""
+import json
+import time
+import httpx
+from datetime import datetime
+from typing import Optional, Tuple, Dict, Any
+from sqlalchemy import text
+from fastapi import Request
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.config import settings
+from app.logger import get_logger
+from app.database import CallbackFailureLog
+
+logger = get_logger("callback_service")
+
+
+async def log_callback_request(
+    db: AsyncSession,
+    request: Request,
+    site_id: str,
+    callback_data: dict
+) -> bool:
+    """记录回调请求到数据库，返回操作是否成功"""
+    import json
+    
+    # 获取客户端IP地址
+    client_ip = request.client.host if request.client else None
+    client_port = request.client.port if request.client else None
+    
+    # 获取服务器IP地址
+    server_ip = None
+    server_port = None
+    if hasattr(request, 'scope') and 'server' in request.scope:
+        server_host, server_port_info = request.scope['server']
+        server_ip = server_host
+        server_port = server_port_info
+    
+    # 准备请求头信息（直接记录原始请求头）
+    request_headers = dict(request.headers)
+
+    # 准备请求体信息（直接记录原始请求体）
+    request_body = callback_data
+
+    # 记录请求URL（JSON格式）
+    logger.info(f"🌐 请求URL: {request.url}")
+    
+    # 记录site_id（JSON格式）
+    logger.info(f"📝 site_id: {site_id}")
+    
+        # 记录server_ip（JSON格式）
+    server_info = {
+        "ip": server_ip,
+        "port": server_port
+    }
+    logger.info(f"🏠 server_ip: {server_info}")
+    
+    # 记录client_ip（JSON格式）
+    client_info = {
+        "ip": client_ip,
+        "port": client_port
+    }
+    logger.info(f"🖥️ client_ip: {client_info}")
+
+    # 记录请求头（JSON格式）
+    logger.info(f"📋 请求头: {json.dumps(request_headers, ensure_ascii=False, indent=2)}")
+    
+    # 记录请求体（JSON格式）
+    logger.info(f"📄 请求体: {json.dumps(callback_data, ensure_ascii=False, indent=2)}")
+        
+    try:
+        # 保存到数据库
+        callback_log = CallbackFailureLog(
+            site_id=site_id,
+            remote_address=f"{client_ip}:{client_port}" if client_ip and client_port else client_ip,
+            server_ip=f"{server_ip}:{server_port}" if server_ip and server_port else server_ip,
+            request_url=str(request.url),
+            request_headers=request_headers,  # 保存原始请求头
+            request_body=request_body  # 保存从request.body获取的原始请求体
+        )
+        
+        db.add(callback_log)
+        await db.commit()
+        
+        logger.info(f"✅ 回调请求记录成功保存到数据库，ID: {callback_log.id}")
+        
+        # 返回成功标识
+        return True
+        
+    except Exception as e:
+        logger.error(f"❌ 保存回调请求到数据库失败: {e}", exc_info=True)
+        # 返回失败标识
+        return False
+
+
+def save_callback_data_items(
+    conn,
+    callback_data_items: list,
+    callback_failure_log_id: int
+) -> bool:
+    """保存callback_data.data中的数据到数据库
+    
+    Returns:
+        bool: 保存是否成功，True表示成功，False表示失败或跳过保存
+    """
+    try:
+
+        logger.info(f"📊 共传入callback_log_id {callback_failure_log_id} 的 {len(callback_data_items)} 条数据")
+        
+        # 检查是否已经存在该callback_log_id的数据
+        existing_data_result = conn.execute(
+            text("SELECT * FROM callback_failure_data WHERE callback_failure_log_id = :log_id"),
+            {"log_id": callback_failure_log_id}
+        )
+        existing_data_list = existing_data_result.fetchall()
+        
+        if existing_data_list:
+            logger.warning(f"⚠️ callback_log_id {callback_failure_log_id} 已存在 {len(existing_data_list)} 条数据，跳过保存")
+            return False
+        
+        for item in callback_data_items:
+            # 获取手机号
+            number_data = item.get('number_data', {})
+            phone_number = number_data.get('number')
+            
+            if not phone_number:
+                continue
+            
+            # 获取任务ID
+            task = item.get('task', {})
+            task_id = task.get('id', '')
+            
+            # 获取用户ID
+            user_id = item.get('user_id', '')
+            
+            # 获取状态信息
+            status = item.get('status', 0)
+            status_description = item.get('status_str', '')
+            
+            # 获取通话日期，默认使用当前时间
+            calldate = datetime.now()
+            if 'calldate' in item:
+                try:
+                    # 如果calldate是字符串，尝试解析为datetime
+                    if isinstance(item['calldate'], str):
+                        calldate = datetime.fromisoformat(item['calldate'].replace('Z', '+00:00'))
+                    elif isinstance(item['calldate'], (int, float)):
+                        # 如果是时间戳，转换为datetime
+                        calldate = datetime.fromtimestamp(item['calldate'])
+                except (ValueError, TypeError) as e:
+                    logger.warning(f"⚠️ 解析calldate失败: {item.get('calldate')}, 使用当前时间, 错误: {e}")
+                    calldate = datetime.now()
+            
+            # 将整个item转换为JSON字符串保存
+            raw_data_json = json.dumps(item, ensure_ascii=False)
+            
+            # 直接插入数据库
+            conn.execute(
+                text("""
+                    INSERT INTO callback_failure_data 
+                    (callback_failure_log_id, phone_number, task_id, user_id, status, status_description, raw_data, calldate)
+                    VALUES (:log_id, :phone_number, :task_id, :user_id, :status, :status_description, :raw_data, :calldate)
+                """),
+                {
+                    "log_id": callback_failure_log_id,
+                    "phone_number": phone_number,
+                    "task_id": task_id,
+                    "user_id": user_id,
+                    "status": status,
+                    "status_description": status_description,
+                    "raw_data": raw_data_json,
+                    "calldate": calldate
+                }
+            )
+        
+        conn.commit()
+        logger.info(f"✅ 成功保存 {len(callback_data_items)} 条callback_data记录到数据库")
+        return True
+        
+    except Exception as e:
+        logger.error(f"❌ 保存callback_data到数据库失败: {e}", exc_info=True)
+        # 不重新抛出异常，避免影响主业务流程
+        return False
+
+
+def get_uncompleted_callback_log(conn) -> Tuple[bool, Optional[Tuple[int, str, str, str]]]:
+    """获取一条未完成的回调请求（按创建时间取最小值）
+    
+    Returns:
+        Tuple[bool, Optional[Tuple[int, str, str, str]]]: 
+            - 第一个值表示查询是否成功（True表示成功，False表示失败）
+            - 第二个值为回调日志数据元组或None
+    """
+    try:
+        # 查询一条未完成的回调日志（按创建时间升序排列，取第一条）
+        result = conn.execute(
+            text("""
+                SELECT id, site_id, request_headers, request_body 
+                FROM callback_failure_logs 
+                WHERE is_completed = false 
+                ORDER BY created_at ASC 
+                LIMIT 1
+            """)
+        )
+        row = result.fetchone()
+        
+        if not row:
+            logger.info("📋 没有找到未完成的回调日志")
+            return True, None
+        
+        callback_log_id, site_id, request_headers, request_body = row
+        request_headers_json = json.dumps(request_headers, ensure_ascii=False)
+        request_body_json = json.dumps(request_body, ensure_ascii=False)
+        
+        return True, (callback_log_id, site_id, request_headers_json, request_body_json)
+        
+    except Exception as e:
+        logger.error(f"❌ 查询未完成回调日志失败: {e}", exc_info=True)
+        return False, None
+
+
+def get_callback_log_data(conn, callback_log_id: int) -> Tuple[bool, Optional[str], Optional[str]]:
+    """获取回调日志数据"""
+    try:
+        # 查询回调日志
+        result = conn.execute(
+            text("SELECT request_headers, request_body FROM callback_failure_logs WHERE id = :log_id"),
+            {"log_id": callback_log_id}
+        )
+        row = result.fetchone()
+        
+        if not row:
+            logger.error(f"❌ 未找到回调日志: {callback_log_id}")
+            return False, None, None
+        
+        request_headers_json = json.dumps(row[0], ensure_ascii=False)
+        request_body_json = json.dumps(row[1], ensure_ascii=False)
+        
+        return True, request_headers_json, request_body_json
+        
+    except Exception as e:
+        logger.error(f"❌ 获取回调日志数据失败: {e}", exc_info=True)
+        return False, None, None
+
+
+def call_external_api_with_retry(
+    conn,
+    request_body: dict,
+    request_headers: Dict[str, str],
+    max_retries: int,
+    callback_failure_log_id: int
+) -> Tuple[bool, int]:
+    """带重试的调用外部API接口"""
+    for attempt in range(1, max_retries + 1):
+        try:
+            logger.info(f"🌐 尝试调用外部API接口，第{attempt}次")
+            
+            with httpx.Client(timeout=30.0) as client:
+                response = client.post(
+                    settings.external_api_url,
+                    json=request_body,
+                    headers=request_headers
+                )
+                
+                # 记录推送日志
+                _log_dtc_push_call(
+                    conn=conn,
+                    callback_failure_log_id=callback_failure_log_id,
+                    request_url=settings.external_api_url,
+                    request_headers=request_headers,
+                    request_body=request_body,
+                    response_status=response.status_code,
+                    response_headers=dict(response.headers),
+                    response_body=response.text,
+                    retry_count=attempt - 1
+                )
+                
+                if response.status_code == 200:
+                    logger.info(f"✅ 调用外部API接口成功，状态码: {response.status_code}")
+                    return True, attempt - 1
+                else:
+                    logger.warning(f"⚠️ 外部API返回非成功状态码: {response.status_code}")
+                    
+                    # 如果是客户端错误（4xx），不重试
+                    if 400 <= response.status_code < 500:
+                        logger.error(f"❌ 客户端错误，不重试: {response.status_code}")
+                        return False, attempt - 1
+        
+        except httpx.TimeoutException:
+            logger.warning(f"⏰ 调用外部API接口超时，第{attempt}次尝试")
+        except httpx.RequestError as e:
+            logger.warning(f"🌐 调用外部API接口请求错误，第{attempt}次尝试: {e}")
+        except Exception as e:
+            logger.error(f"❌ 调用外部API接口异常，第{attempt}次尝试: {e}", exc_info=True)
+        
+        # 如果不是最后一次尝试，等待一段时间再重试
+        if attempt < max_retries:
+            time.sleep(2 ** attempt)  # 指数退避
+    
+    # 所有重试都失败了
+    logger.error(f"❌ 调用外部API接口失败，已重试{max_retries}次")
+    return False, max_retries
+
+
+def mark_callback_log_completed(conn, callback_log_id: int) -> bool:
+    """标记CallbackFailureLog记录为已完成"""
+    try:
+        # 先检查推送日志中是否有响应成功的记录
+        success_result = conn.execute(
+            text("""
+                SELECT COUNT(*) as success_count
+                FROM external_api_logs 
+                WHERE callback_failure_log_id = :log_id 
+                AND response_status = 200
+            """),
+            {"log_id": callback_log_id}
+        )
+        success_count = success_result.fetchone()[0]
+        
+        if success_count == 0:
+            logger.warning(f"⚠️ 回调日志 {callback_log_id} 没有成功的推送记录，不标记为完成")
+            return False
+        
+        logger.info(f"✅ 回调日志 {callback_log_id} 找到 {success_count} 条成功推送记录，开始标记为完成")
+        
+        # 更新指定日志记录为已完成
+        result = conn.execute(
+            text("""
+                UPDATE callback_failure_logs 
+                SET is_completed = true 
+                WHERE id = :log_id 
+                AND is_completed = false
+            """),
+            {"log_id": callback_log_id}
+        )
+        
+        # 检查是否真的更新了记录
+        if result.rowcount == 0:
+            logger.warning(f"⚠️ 回调日志 {callback_log_id} 已标记为完成或不存在")
+            return False
+        
+        conn.commit()
+        logger.info(f"✅ 回调日志 {callback_log_id} 已标记为完成")
+        return True
+        
+    except Exception as e:
+        logger.error(f"❌ 标记回调日志 {callback_log_id} 完成失败: {e}", exc_info=True)
+        conn.rollback()
+        return False
+
+
+def get_related_records_by_unique_data_list(
+    conn,
+    unique_data_list: list,
+    callback_log_id: int,
+    limit_count: int
+) -> Tuple[bool, list]:
+    """根据unique_data_list中的数据查询相关记录，按创建时间排序
+    
+    Args:
+        conn: 数据库连接
+        unique_data_list: 包含手机号、task_id、user_id的数据项列表
+        callback_log_id: 回调日志ID，作为过滤条件
+        limit_count: 获取记录数量限制
+    
+    Returns:
+        Tuple[bool, list]: 
+            - 第一个值表示查询是否成功（True表示成功，False表示失败）
+            - 第二个值为查询到的相关记录列表，失败时返回空列表
+    """
+    related_records = []
+    
+    try:
+        # 遍历unique_data_list查询相关记录
+        for item in unique_data_list:
+            # 提取手机号
+            number_data = item.get('number_data', {})
+            phone_number = number_data.get('number')
+            
+            # 提取task_id
+            task = item.get('task', {})
+            task_id = task.get('id', '')
+            
+            # 提取user_id
+            user_id = item.get('user_id', '')
+            
+            if phone_number and task_id and user_id:
+                result = conn.execute(
+                    text("""
+                        SELECT phone_number, task_id, user_id, created_at
+                        FROM callback_failure_data 
+                        WHERE phone_number = :phone_number 
+                        AND task_id = :task_id 
+                        AND user_id = :user_id
+                        AND callback_failure_log_id = :callback_log_id
+                        ORDER BY created_at DESC 
+                        LIMIT :limit_count
+                    """),
+                    {
+                        "phone_number": phone_number,
+                        "task_id": task_id,
+                        "user_id": user_id,
+                        "callback_log_id": callback_log_id,
+                        "limit_count": limit_count
+                    }
+                )
+                records = result.fetchall()
+                if records:
+                    related_records.extend([{
+                        "phone_number": record[0],
+                        "task_id": record[1], 
+                        "user_id": record[2],
+                        "created_at": record[3]
+                    } for record in records])
+        
+        logger.info(f"📊 查询到相关记录数量: {len(related_records)} (阈值: {limit_count})")
+        if related_records:
+            for i, record in enumerate(related_records):
+                logger.info(f"📋 记录{i+1}: 手机号={record['phone_number']}, task_id={record['task_id']}, 用户ID={record['user_id']}, 创建时间={record['created_at']}")
+        
+        return True, related_records
+        
+    except Exception as e:
+        logger.error(f"❌ 查询相关记录失败: {e}", exc_info=True)
+        return False, []
+
+
+def _log_dtc_push_call(
+    conn,
+    callback_failure_log_id: int,
+    request_url: str,
+    request_headers: Dict[str, Any],
+    request_body: Dict[str, Any],
+    response_status: int,
+    response_headers: Dict[str, str],
+    response_body: str,
+    retry_count: int
+) -> bool:
+    """记录DTC推送调用日志"""
+    try:
+        # 提取手机号从请求体中
+        phone_number = None
+        if 'data' in request_body and isinstance(request_body['data'], list) and len(request_body['data']) > 0:
+            first_item = request_body['data'][0]
+            if 'number_data' in first_item and 'number' in first_item['number_data']:
+                phone_number = first_item['number_data']['number']
+        
+        # 记录到external_api_logs表
+        conn.execute(
+            text("""
+                INSERT INTO external_api_logs (
+                    callback_failure_log_id,
+                    phone_number,
+                    request_url,
+                    request_headers,
+                    request_body,
+                    response_status,
+                    response_headers,
+                    response_body,
+                    retry_count,
+                    created_at
+                ) VALUES (
+                    :callback_failure_log_id,
+                    :phone_number,
+                    :request_url,
+                    :request_headers,
+                    :request_body,
+                    :response_status,
+                    :response_headers,
+                    :response_body,
+                    :retry_count,
+                    datetime('now')
+                )
+            """),
+            {
+                "callback_failure_log_id": callback_failure_log_id,
+                "phone_number": phone_number,
+                "request_url": request_url,
+                "request_headers": json.dumps(request_headers, ensure_ascii=False),
+                "request_body": json.dumps(request_body, ensure_ascii=False),
+                "response_status": response_status,
+                "response_headers": json.dumps(response_headers, ensure_ascii=False),
+                "response_body": response_body,
+                "retry_count": retry_count
+            }
+        )
+        
+        conn.commit()
+        logger.debug(f"📝 DTC推送调用日志记录成功，状态码: {response_status}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"❌ 记录DTC推送调用日志失败: {e}", exc_info=True)
+        conn.rollback()
+        return False