CameraMachine/python/api.py

import uuid
from re import search, match
from natsort.natsort import order_by_index, natsorted
from sqlalchemy import func
from models import *
import requests
import json
from logger import logger
from serial.tools import list_ports
from model import PhotoRecord
import settings, datetime
import pandas as pd
from utils.hlm_http_request import forward_request
from utils.utils_func import check_path
from sockets.socket_client import socket_manager
from mcu.DeviceControl import DeviceControl
import time, shutil, os
from io import BytesIO
from sqlalchemy import and_, asc, desc
from functools import partial
from service.deal_image import DealImage
from databases import DeviceConfig, SysConfigs, SqlQuery, CRUD, select, DeviceConfigTabs
from service.run_main import RunMain
import importlib
from service.auto_deal_pics.upload_pic import UploadPic
from service.OnePicTest import OnePicTest
from service.base import check_move_goods_art_no_folder
import win32api, win32gui, win32con
from win32gui import EnumWindows, GetWindowText
from service.online_request.module_online_data import OnlineDataRequest
from concurrent.futures import ThreadPoolExecutor
from functools import partial
from service.online_request.module_online_data import AIGCDataRequest
import asyncio
from fastapi import BackgroundTasks
import functools
import traceback, stat
import concurrent.futures
from sockets.message_handler import handlerFolderDelete
from service.remove_bg_ali import RemoveBgALi
import uuid as mine_uuid
from utils import common


def log_exception_with_context(context_message=""):
    """装饰器：为函数添加异常日志上下文"""

    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            try:
                return func(*args, **kwargs)
            except Exception as e:
                logger.error(f"=== 异常发生在函数: {func.__name__} ===")
                if context_message:
                    logger.error(f"上下文信息: {context_message}")
                logger.error(f"函数参数: args={args}, kwargs={kwargs}")
                logger.error(f"异常类型: {type(e).__name__}")
                logger.error(f"异常信息: {str(e)}")
                logger.error("完整堆栈跟踪:")
                logger.error(traceback.format_exc())
                raise  # 重新抛出异常

        return wrapper

    return decorator


def parserGoodsDict2Aigc(return_data_check_before_detail):
    """获取商品组装数据"""
    print("获取商品组装数据===========>return_data_check_before_detail", return_data_check_before_detail)
    goods_no_dict = return_data_check_before_detail.get("data", {}).get(
        "goods_no_dict", {}
    )
    return goods_no_dict


async def sendAsyncMessage(msg="", goods_arts=[], status="", msg_type="", data=None, progress=None):
    """异步发送消息"""
    mapping = {"segment_progress": "抠图", "scene_progress": "场景图", "upper_footer_progress": "模特图",
               "detail_progress": "详情页", "upload_goods_progress": "上传第三方商品"}
    if progress is not None:
        progress["msg_type"] = msg_type
        name = mapping.get(msg_type, None)
        if name:
            progress["name"] = name
    data = {
        "code": 0,
        "msg": msg,
        "status": 2,
        "data": (
            data
            if data is not None
            else {
                "status": status,
                "goods_art_nos": goods_arts,
            }
        ),
        "progress": None if progress is None else progress,
        "msg_type": msg_type,
    }
    await message_queue.put(data)
    # message_queue.put_nowait(data)


@app.get("/")
async def index():
    # await socket_manager.send_message(msg="测试")
    return {"message": "Hello World"}


@app.get("/scan_serials", description="扫描可用的设备端口")
async def scanSerials():
    """扫描串口"""
    ports = list_ports.comports()
    print("Scanning", ports)
    return {"message": "Hello World"}


@app.api_route(
    "/forward_request", methods=["GET", "POST"], description="代理转发hlm项目得请求"
)
async def forwardRequest(request: HlmForwardRequest):
    """
    转发HTTP请求到目标URL

    :param request: FastAPI Request对象
    :return: 目标接口的响应
    """
    try:
        if request.method == "GET":
            params = request.query_params
        elif request.method == "POST":
            params = json.dump(request.query_params)
        else:
            raise UnicornException("仅支持GET和POST方法")
        target_url = request.target_url
        method = request.method.upper()
        headers = request.headers
        if not target_url:
            raise UnicornException("目标url地址不能为空")
        # 调用 hlm_http_request 中的 forward_request 函数
        response = forward_request(
            target_url, params=params, method=method, headers=headers
        )
        return response
    except requests.RequestException as e:
        raise UnicornException(e)
    except Exception as e:
        raise UnicornException(e)


def __createExcelGoodsArray(excel_path):
    '''创建通过excel形式得货号组数据'''
    try:
        excel_df = pd.read_excel(excel_path, sheet_name=0, header=0, dtype={
            "款号": str,
            "商品货号": str,
        })
        if "商品货号" not in excel_df.columns:
            raise UnicornException("缺失 [商品货号] 列")
        if "款号" not in excel_df.columns:
            raise UnicornException("缺失 [款号] 列")
        goods_art_dirs = excel_df.groupby(excel_df["款号"])
        # 抠图时用到的货号列表,与生成详情图有所区别
        goods_art_no_arrays = []
        # # 详情图生成需要对同款商品进行分组，保证详情图可以生成多个色
        goods_art_no_group_arrays = []
        for _, goods_row in excel_df.iterrows():
            goods_art_no = str(goods_row["商品货号"])
            goods_art_no_arrays.append(goods_art_no)
            goods_no = str(goods_row["款号"])
            a001_df = goods_art_dirs.get_group(goods_no)
            goods_art_groups = a001_df["商品货号"].tolist()
            if goods_art_groups in goods_art_no_group_arrays:
                continue
            goods_art_no_group_arrays.append(goods_art_groups)
    except Exception as e:
        raise UnicornException("Excel文件解析失败,请检查是否缺少列")
    return goods_art_no_arrays, excel_df, goods_art_no_group_arrays


def group_by_style_number(data):
    result = {}
    for goods_id, info in data.items():
        style_number = info["款号"]

        if style_number not in result:
            result[style_number] = []
        result[style_number].append(goods_id)

    return result


@app.post("/handle_detail")
async def handle_detail_background(
        request: Request, params: HandlerDetail, background_tasks: BackgroundTasks
):
    goods_art_no_arrays = params.goods_art_no
    is_check = params.is_check
    obj = None
    token = "Bearer " + params.token
    uuid = params.uuid
    run_main = RunMain(obj, token, uuid)
    online_stores = params.online_stores  # 上传第三方的店铺名称数组
    is_detail = params.is_detail  # 上传第三方的店铺名称数组
    is_product_scene = params.is_product_scene  # 上传第三方的店铺名称数组
    is_upper_footer = params.is_upper_footer  # 上传第三方的店铺名称数组
    # 该数组表示是否需要后面的移动文件夹操作，减少重复抠图，提升抠图时间和速度
    if online_stores:
        """如果上传第三方，则需要强制生成详情页"""
        params.is_detail = 1
        is_detail = 1
    try:
        excel_path = params.excel_path.strip()
        print("excel信息打印输出:", excel_path)
        if excel_path:
            goods_art_no_arrays, excel_df, _ = __createExcelGoodsArray(excel_path)
            await _process_excel_mode(
                goods_art_no_arrays, excel_df
            )
        else:
            if is_detail == 1:
                remote_data = run_main.data_mode_generate_detail.get_goods_art_no_info(
                    goods_art_list=goods_art_no_arrays)
                if remote_data == {}:
                    raise UnicornException("所有货号在商品档案资料中不存在，请检查货号是否正确")
                error_goods_art_no = []
                for goods_art_no_check in goods_art_no_arrays:
                    check_item = remote_data.get(goods_art_no_check, None)
                    if not check_item:
                        error_goods_art_no.append(goods_art_no_check)
                if len(error_goods_art_no) > 0:
                    raise UnicornException(
                        "以下货号在商品档案资料中不存在，请检查货号是否正确:{}".format(error_goods_art_no))
            await _process_non_excel_mode(
                params, goods_art_no_arrays
            )
    except Exception as e:
        raise UnicornException(str(e))

    progress = [
        {"msg_type": "segment_progress", "name": "抠图", "status": "等待处理", "current": 0, "total": 0, "error": 0}]
    if is_product_scene == 1:
        progress.append({"msg_type": "scene_progress", "name": "场景图", "status": "等待处理", "current": 0, "total": 0,
                         "error": 0})
    if is_upper_footer == 1:
        progress.append(
            {"msg_type": "upper_footer_progress", "name": "模特图", "status": "等待处理", "current": 0, "total": 0,
             "error": 0})
    if is_detail == 1 or (params.excel_path != "" and params.excel_path != None):
        progress.append(
            {"msg_type": "detail_progress", "name": "详情页", "status": "等待处理", "current": 0, "total": 0,
             "error": 0})
    if len(online_stores) > 0:
        progress.append(
            {"msg_type": "upload_goods_progress", "name": "上传第三方商品", "status": "等待处理", "current": 0,
             "total": 0, "error": 0})
    if is_check == 1:
        return {
            "code": 0,
            "msg": "检测通过",
            "data": {"progress": progress},
        }
    asyncio.create_task(process_handle_detail(request, params))
    return {"code": 0, "msg": "任务已提交后台处理", "data": {"status": "processing"}}


# 重构后的简化版本
async def process_handle_detail(request: Request, params: HandlerDetail):
    """处理商品详情图生成的主要函数"""
    try:
        # 初始化基础变量
        handler_result = []
        handler_result_folder = ""
        # 处理参数
        obj, token, uuid = None, "Bearer " + params.token, params.uuid
        aigc_clazz = AIGCDataRequest(token)
        run_main = RunMain(obj, token, uuid)
        onlineData = OnlineDataRequest(token)

        # 提取参数
        goods_art_no_arrays = params.goods_art_no
        online_stores = params.online_stores
        is_detail = params.is_detail
        temp_name = params.temp_name
        is_product_scene = params.is_product_scene
        is_upper_footer = params.is_upper_footer
        upper_footer_params = params.upper_footer_params
        product_scene_prompt = params.product_scene_prompt
        product_scene_image = params.product_scene_image

        if params.excel_path and params.excel_path.strip():
            # 处理Excel模式
            is_detail = 1  # 强制处理详情页
            goods_art_no_arrays, excel_df, _ = __createExcelGoodsArray(params.excel_path)
            move_folder_array = await _process_excel_mode(
                goods_art_no_arrays, excel_df
            )
        else:
            # 处理非Excel模式
            move_folder_array = await _process_non_excel_mode(
                params, goods_art_no_arrays
            )

        # 构建配置数据
        config_data = await _build_config_data(params, goods_art_no_arrays)

        # 执行抠图处理
        handler_result_folder, handler_result = await _process_cutout(
            run_main, config_data, goods_art_no_arrays, move_folder_array
        )
        # 处理场景图和模特图
        loop = asyncio.get_event_loop()
        return_data_check_before_detail = await loop.run_in_executor(
            None,
            partial(run_main.check_before_detail, config_data, is_detail)
        )

        # 检查处理结果
        success_handler = return_data_check_before_detail.get("data", {}).get("config_data", {}).get("success_handler",
                                                                                                     [])
        failed_items = [item for item in success_handler if item.get('success') == False]
        if failed_items:
            await sendAsyncMessage(
                msg="处理结束",
                data={"output_folder": handler_result_folder, "list": failed_items},
                status="处理结束",
                msg_type="detail_result_progress",
            )

        # 如果全部失败，直接终止
        if failed_items and len(failed_items) == len(success_handler):
            check_progress = {
                "status": "处理失败",
                "current": 0,
                "total": len(success_handler),
                "error": len(failed_items)
            }

            await sendAsyncMessage(
                msg="检查失败",
                goods_arts=[],
                status="检查失败",
                msg_type="segment_progress",
                progress=check_progress
            )
            return True

        # 处理场景图
        if is_product_scene == 1:
            return_data_check_before_detail = await _process_scene_images(
                aigc_clazz, run_main, return_data_check_before_detail, product_scene_prompt, product_scene_image
            )

        # 处理模特图
        if is_upper_footer == 1:
            return_data_check_before_detail = await _process_model_images(
                aigc_clazz, run_main, return_data_check_before_detail, upper_footer_params
            )
        current_day = time.strftime("%Y-%m-%d", time.localtime(time.time()))
        # 处理详情页
        if is_detail == 1:
            handler_result_folder, handler_result = await _process_detail_pages(
                run_main, return_data_check_before_detail, onlineData,
                online_stores, goods_art_no_arrays, handler_result_folder,
                params
            )
            # 如果需要上传到第三方平台
            if online_stores:
                await _upload_to_third_party(
                    onlineData, return_data_check_before_detail,
                    config_data, online_stores, temp_name
                )
            await sendAsyncMessage(
                msg="处理结束",
                data={"output_folder": f"{handler_result_folder}/{current_day}", "list": handler_result},
                status="处理结束",
                msg_type="detail_result_progress",
            )
        else:
            await sendAsyncMessage(
                msg="处理结束",
                data={"output_folder": f"{handler_result_folder}", "list": handler_result},
                status="处理结束",
                msg_type="detail_result_progress",
            )

    except UnicornException as e:
        logger.info(f"错误信息:{e}")
        line = traceback.extract_tb(e.__traceback__)[0][1]
        logger.info(f"错误发生在行号:{line}")
        await _handle_exception(e.msg, handler_result_folder)
    except Exception as e:
        logger.info(f"错误信息:{e}")
        line = traceback.extract_tb(e.__traceback__)[0][1]
        logger.info(f"错误发生在行号:{line}")
        await _handle_exception(str(e), handler_result_folder)

    return True


async def _process_non_excel_mode(params, goods_art_no_arrays):
    """处理非Excel模式的准备工作"""
    limit_path = "{}/{}".format(settings.OUTPUT_DIR, time.strftime("%Y-%m-%d", time.localtime(time.time())))
    check_path(limit_path)

    move_folder_array = check_move_goods_art_no_folder(settings.OUTPUT_DIR, goods_art_no_arrays, limit_path)

    for goods_art_no in goods_art_no_arrays:
        if not goods_art_no:
            raise UnicornException("货号不能为空")

        session = SqlQuery()
        pr = CRUD(PhotoRecord)
        images = pr.read_all(session, conditions={"goods_art_no": goods_art_no, "delete_time": None})
        session.close()
        if not images:
            raise UnicornException(
                f"商品货号【{goods_art_no}】未查询到拍摄记录，请检查货号是否正确"
            )

        detail_counts = len(params.template_image_order.split(","))
        image_counts = len(images)
        if image_counts < detail_counts:
            raise UnicornException(
                f"货号:[{goods_art_no}],实际照片数量:{image_counts}张,小于详情图要求数量:{detail_counts}张"
            )

        if move_folder_array.get(goods_art_no) is None:
            await _process_image_copy_and_move(goods_art_no, images, False)
    return move_folder_array


async def _process_excel_mode(goods_art_no_arrays, excel_df):
    """处理非Excel模式的准备工作"""
    limit_path = "{}/{}".format(settings.OUTPUT_DIR, time.strftime("%Y-%m-%d", time.localtime(time.time())))
    check_path(limit_path)

    move_folder_array = check_move_goods_art_no_folder("output", goods_art_no_arrays, limit_path)
    session = SqlQuery()
    for index, row in excel_df.iterrows():
        goods_art_no = str(row["商品货号"])
        print("货号数据", goods_art_no)
        if not goods_art_no:
            raise UnicornException("货号不能为空")
        pr = CRUD(PhotoRecord)
        images = pr.read_all(session, conditions={"goods_art_no": goods_art_no, "delete_time": None})
        if not images:
            raise UnicornException(
                f"商品货号【{goods_art_no}】未查询到拍摄记录,请检查表格中的货号数据列"
            )
        # 货号目录不存在再去进行移动和创建操作
        if move_folder_array.get(goods_art_no) is None:
            await _process_image_copy_and_move(goods_art_no, images, True)
    session.close()
    return move_folder_array


async def _process_image_copy_and_move(goods_art_no, images, is_excel):
    """处理图片复制和移动"""
    image_dir = "{}/data/".format(os.getcwd()).replace("\\", "/")
    check_path(image_dir)

    for idx, itemImg in enumerate(images):
        if not itemImg.image_path:
            raise UnicornException(
                f"货号【{goods_art_no}】存在没有拍摄完成的图片,请重拍或删除后重试"
            )

        # new_file_name = str(itemImg.goods_art_no) + "_" + str(idx) + ".jpg"
        # if not os.path.exists(image_dir + "/" + os.path.basename(new_file_name)):
        #     shutil.copy(itemImg.image_path, image_dir + new_file_name)

    dealImage = DealImage(image_dir)
    resFlag, path = dealImage.dealMoveImageV2(
        goods_art_no=goods_art_no
    )
    if not resFlag:
        raise UnicornException(path)
    if is_excel:
        try:
            shutil.rmtree(image_dir, onerror=settings.handle_remove_readonly)
        except Exception as e:
            logger.info(f"删除图片失败:{str(e)}")


async def _build_config_data(params, goods_art_no_arrays):
    """构建配置数据"""
    temp_class = {}
    temp_name_list = []
    # 模板类型;0系统模板;1自定义模板
    for tempItem in params.temp_list:
        temp_class[tempItem.template_id] = {"class_path": tempItem.template_local_classes,
                                            "template_type": tempItem.template_type if tempItem.template_type else 0}
        temp_name_list.append(tempItem.template_id)
    # 旗舰 AI 抠图
    cutout_mode = settings.getSysConfigs("other_configs", "cutout_mode", "普通抠图")
    match cutout_mode:
        case "普通抠图":
            cutOutMode = "1"
        case "精细化抠图":
            cutOutMode = "2"
        case "旗舰AI抠图":
            cutOutMode = "3"
        case "旗舰AI抠图-精细":
            cutOutMode = "4"
        case "旗舰AI抠图-透明物品":
            cutOutMode = "5"
        case _:
            cutOutMode = "1"

    limit_path = "{}/{}".format(settings.OUTPUT_DIR, time.strftime("%Y-%m-%d", time.localtime(time.time())))

    config_data = {
        "image_dir": limit_path,
        "image_order": (
            "俯视,侧视,后跟,鞋底,内里,组合,组合2,组合3,组合4,组合5,组合6,组合7,组合8,组合9,组合10,组合11,组合12,组合13,组合14,组合15,组合16,组合17,组合18,组合19,组合20,组合21,组合22,组合23,组合24,组合25,组合26"
            if not params.template_image_order
            else params.template_image_order
        ),
        "goods_art_no": "",
        "goods_art_nos": goods_art_no_arrays,
        "is_check_number": False,
        "resize_image_view": "后跟",
        "cutout_mode": cutOutMode,
        "logo_path": params.logo_path,
        "special_goods_art_no_folder_line": "",
        "is_use_excel": (False if params.excel_path == "" else True),  # 是否使用excel
        "excel_path": params.excel_path,  # excel路径
        "is_check_color_is_all": False,
        "cutout_is_pass": True,
        "assigned_page_dict": {},
        "detail_is_pass": False,
        "upload_is_pass": False,
        "upload_is_enable": False,
        "is_filter": False,
        "temp_class": temp_class,
        "temp_name": params.temp_name,
        "temp_name_list": temp_name_list,
        "target_error_folder": f"{limit_path}/软件-生成详情错误",
        "success_handler": [],
    }
    temp_class_dict = {}
    try:
        print("configdata 模板信息", config_data["temp_class"])
        for key, val in config_data["temp_class"].items():
            class_path = val.get("class_path")
            template_type = val.get("template_type", 0)
            if template_type == 0:
                # 如果是系统模板，才进行动态类导入操作
                module_path, class_name = class_path.rsplit(".", 1)
                module = importlib.import_module(module_path)
                cls = getattr(module, class_name)
                temp_class_dict[key] = {"cls": cls, "template_type": template_type}
            else:
                temp_class_dict[key] = {"cls": class_path, "template_type": template_type}
    except:
        raise UnicornException("详情页模板不存在或未下载完成，请重启软件后重试")
    config_data["temp_class"] = temp_class_dict
    return config_data


async def _process_cutout(run_main, config_data, goods_art_no_arrays, move_folder_array):
    """处理抠图"""
    handler_result = []
    handler_result_folder = ""
    have_handler_keys = move_folder_array.keys()
    if len(have_handler_keys) > 0:
        progress = {
            "status": "正在处理",
            "current": len(have_handler_keys),
            "total": len(goods_art_no_arrays),
            "error": 0,
            "goods_art_no": None
        }
        await sendAsyncMessage(
            msg="正在处理",
            data=None,
            status="正在处理",
            msg_type="segment_progress",
            progress=progress
        )
    loop = asyncio.get_event_loop()

    # 【修复】将同步耗时操作放入线程池
    # 注意：check_before_cutout 和 check_for_cutout_image_first_call_back 必须是线程安全的
    return_data = await loop.run_in_executor(
        None,
        partial(run_main.check_before_cutout, config_data)
    )

    cutout_res = await loop.run_in_executor(
        None,
        partial(run_main.check_for_cutout_image_first_call_back, return_data)
    )
    if cutout_res:
        # sys_path = format(os.getcwd()).replace("\\", "/")
        handler_result_folder = f"{config_data['image_dir']}"

        for goods_art_item in goods_art_no_arrays:
            handler_result.append({
                "goods_art_no": goods_art_item,
                "success": True,
                "info": "处理成功",
            })
    # print("抠图是否完成",len(have_handler_keys) == len(goods_art_no_arrays) or (len(have_handler_keys) == 0  and cutout_res),handler_result)        
    if len(have_handler_keys) == len(goods_art_no_arrays) or (len(have_handler_keys) == 0 and cutout_res):
        handler_result_folder = handler_result_folder.replace("\\", "/")
        success_items = [item for item in handler_result if item.get('success') == True]
        cutout_folder = handler_result_folder + "/" + success_items[0].get("goods_art_no") + "/800x800" if len(
            success_items) > 0 else ""
        progress = {
            "status": "处理完成",
            "current": len(goods_art_no_arrays),
            "total": len(goods_art_no_arrays),
            "error": 0,
            "folder": cutout_folder,
        }
        await sendAsyncMessage(
            msg="抠图完成",
            data={"output_folder": handler_result_folder, "list": handler_result},
            status="抠图完成",
            msg_type="segment_progress",
            progress=progress
        )
    return handler_result_folder, handler_result


async def _process_single_scene_item(aigc_clazz, goods_art_dict_info_item, product_scene_prompt, save_root_path,
                                     product_scene_image):
    """将单个货号的场景图生成逻辑提取出来，放在线程池中运行"""

    def sync_generate():
        ceshi_image_path = goods_art_dict_info_item.get("pics").get("侧视-抠图")
        save_image_path = f"{save_root_path}场景图.jpg"

        if os.path.isfile(save_image_path):
            return save_image_path

        aigc_clazz.center_paste_image(ceshi_image_path, save_image_path)
        image_path = aigc_clazz.generateProductScene(save_image_path, product_scene_prompt, save_image_path,
                                                     product_scene_image)
        return image_path

    loop = asyncio.get_event_loop()
    try:
        image_path = await loop.run_in_executor(None, sync_generate)
        return {"success": True, "path": image_path}
    except Exception as e:
        return {"success": False, "error": str(e)}


async def _process_scene_images(aigc_clazz, run_main, return_data_check_before_detail, product_scene_prompt,
                                product_scene_image):
    """处理场景图生成"""
    # 参数验证
    if not product_scene_prompt:
        raise UnicornException("请填写场景描述")

    goods_dict = parserGoodsDict2Aigc(return_data_check_before_detail)
    new_goods_dict = {}
    goods_art_counts = {key: len(value.get('货号资料', [])) for key, value in goods_dict.items()}
    product_scene_total_progress = sum(goods_art_counts.values())
    product_scene_finish_progress = 0
    product_scene_error_progress = 0

    product_scene_progress = {
        "status": "正在处理",
        "current": product_scene_finish_progress,
        "total": product_scene_total_progress,
        "error": product_scene_error_progress
    }

    await sendAsyncMessage(
        msg="开始处理场景图",
        goods_arts=[goods_art_no for goods_art_no in goods_dict.keys()],
        status="开始处理",
        msg_type="scene_progress",
        progress=product_scene_progress
    )
    # loop = asyncio.get_event_loop()
    for goods_art_no_info in goods_dict.keys():
        goods_art_dict_info = goods_dict.get(goods_art_no_info, None)
        new_goods_dict.setdefault(goods_art_no_info, goods_art_dict_info)
        if goods_art_dict_info is None: continue
        for idx_key, goods_art_dict_info_item in enumerate(goods_art_dict_info.get("货号资料", [])):
            goods_art_no = goods_art_dict_info_item.get("货号")
            product_scene_finish_progress += 1
            folder = ""
            product_scene_progress = {
                "status": "正在处理",
                "goods_art_no": goods_art_no,
                "current": product_scene_finish_progress,
                "total": product_scene_total_progress,
                "error": product_scene_error_progress,
                "folder": folder,
            }

            await sendAsyncMessage(
                msg="正在处理场景图",
                goods_arts=[goods_art_no],
                status="正在处理场景图",
                msg_type="scene_progress",
                progress=product_scene_progress
            )
            first_pics = goods_art_dict_info_item.get("pics")
            if len(first_pics.items()) == 1:
                ceshi_image_path = first_pics.get("俯视-抠图")
            else:
                ceshi_image_path = first_pics.get("侧视-抠图")
            save_root_path = ceshi_image_path.split("阴影图处理")[0]
            save_image_path = f"{save_root_path}场景图.jpg"
            # 【修复】异步等待单个货号的 AI 处理完成
            # 这样在处理一个货号时，事件循环可以去发送其他货号的消息
            result = await _process_single_scene_item(aigc_clazz, goods_art_dict_info_item, product_scene_prompt,
                                                      save_root_path, product_scene_image)

            if result["success"]:
                goods_art_dict_info_item["场景图"] = result["path"]
                new_goods_dict[goods_art_no_info]["货号资料"][idx_key] = goods_art_dict_info_item
                product_scene_progress["folder"] = save_image_path.replace("场景图.jpg", "")
                await sendAsyncMessage(
                    msg="场景图处理完成",
                    goods_arts=[goods_art_no],
                    status="场景图处理完成",
                    msg_type="scene_progress",
                    progress=product_scene_progress
                )
            else:
                goods_art_dict_info_item["场景图"] = ""
                new_goods_dict[goods_art_no_info]["货号资料"][idx_key] = goods_art_dict_info_item
                os.remove(save_image_path)
                # product_scene_finish_progress -= 1
                product_scene_error_progress += 1

                product_scene_progress = {
                    "status": "处理失败",
                    "goods_art_no": goods_art_no,
                    "current": product_scene_finish_progress,
                    "total": product_scene_total_progress,
                    "error": product_scene_error_progress,
                    "folder": ""
                }

                await sendAsyncMessage(
                    msg="场景图处理失败",
                    goods_arts=[goods_art_no],
                    status="场景图处理失败",
                    msg_type="scene_progress",
                    progress=product_scene_progress
                )

    status_text = "处理完成" if product_scene_finish_progress > 0 else "处理失败"
    product_scene_progress = {
        "status": status_text,
        "current": product_scene_finish_progress,
        "total": product_scene_total_progress,
        "error": product_scene_error_progress
    }

    await sendAsyncMessage(
        msg="场景图处理结束",
        goods_arts=[],
        status="场景图处理结束",
        msg_type="scene_progress",
        progress=product_scene_progress
    )
    print("场景图 new_goods_dict", new_goods_dict)
    if new_goods_dict:
        return_data_check_before_detail["data"]["goods_no_dict"] = new_goods_dict

    return return_data_check_before_detail


async def _process_model_images(aigc_clazz, run_main, return_data_check_before_detail, upper_footer_params):
    """处理模特图生成"""
    # 参数验证
    if not upper_footer_params:
        raise UnicornException("请选择模特")

    man_id = upper_footer_params.get("man_id")
    women_id = upper_footer_params.get("women_id")

    if not man_id:
        raise UnicornException("请选择男模特")
    if not women_id:
        raise UnicornException("请选择女模特")

    goods_dict = parserGoodsDict2Aigc(return_data_check_before_detail)
    new_goods_dict = {}
    goods_art_counts = {key: len(value.get('货号资料', [])) for key, value in goods_dict.items()}
    upper_footer_total_progress = sum(goods_art_counts.values())
    upper_footer_finish_progress = 0
    upper_footer_error_progress = 0

    upper_footer_progress = {
        "status": "正在处理",
        "current": upper_footer_finish_progress,
        "total": upper_footer_total_progress,
        "error": upper_footer_error_progress
    }

    await sendAsyncMessage(
        msg="开始处理模特图",
        goods_arts=list(goods_dict.keys()),
        status="开始处理模特图",
        msg_type="upper_footer_progress",
        progress=upper_footer_progress
    )
    print("上脚图=====>>>>", goods_dict, return_data_check_before_detail)
    loop = asyncio.get_event_loop()

    for goods_art_no_info in goods_dict.keys():
        goods_art_dict_info = goods_dict.get(goods_art_no_info, None)
        new_goods_dict.setdefault(goods_art_no_info, goods_art_dict_info)
        if goods_art_dict_info is None: continue

        # 获取该款号的性别，用于选择模特
        gender = goods_art_dict_info.get("性别", "女")
        model_id = man_id if "男" in gender else women_id

        for idx_key, goods_art_dict_info_item in enumerate(goods_art_dict_info.get("货号资料", [])):
            goods_art_no = goods_art_dict_info_item.get("货号")
            upper_footer_finish_progress += 1
            folder = ""
            upper_footer_progress = {
                "status": "正在处理",
                "goods_art_no": goods_art_no,
                "current": upper_footer_finish_progress,
                "total": upper_footer_total_progress,
                "error": upper_footer_error_progress,
                "folder": folder,
            }

            await sendAsyncMessage(
                msg="正在处理模特图",
                goods_arts=[goods_art_no],
                status="正在处理模特图",
                msg_type="upper_footer_progress",
                progress=upper_footer_progress
            )
            gender = goods_art_dict_info.get("性别", "女")
            model_id = man_id if "男" in gender else women_id
            first_pics = goods_art_dict_info_item.get("pics")
            if len(first_pics.items()) == 1:
                ceshi_image_path = first_pics.get("俯视-抠图")
            else:
                ceshi_image_path = first_pics.get("侧视-抠图")
            save_root_path = ceshi_image_path.split("阴影图处理")[0]
            save_image_path = f"{save_root_path}模特图.jpg"

            # 2. 【核心修复】将耗时的 复制+AI生成 放入线程池
            def sync_model_task():
                if os.path.isfile(save_image_path):
                    return {"success": True, "path": save_image_path}
                try:
                    shutil.copy(ceshi_image_path, save_image_path)
                    image_path = aigc_clazz.generateUpperShoes(save_image_path, model_id, save_image_path)
                    return {"success": True, "path": image_path}
                except Exception as e:
                    if os.path.exists(save_image_path):
                        try:
                            os.remove(save_image_path)
                        except:
                            pass
                    return {"success": False, "error": str(e)}

            result = await loop.run_in_executor(None, sync_model_task)

            # 3. 处理结果并发送消息
            if result["success"]:
                goods_art_dict_info_item["模特图"] = result["path"]
                new_goods_dict[goods_art_no_info]["货号资料"][idx_key] = goods_art_dict_info_item
                upper_footer_progress["folder"] = save_image_path.replace("模特图.jpg", "")
                await sendAsyncMessage(
                    msg="模特图处理成功",
                    goods_arts=[goods_art_no],
                    status="模特图处理成功",
                    msg_type="upper_footer_progress",
                    progress=upper_footer_progress
                )
            else:
                upper_footer_error_progress += 1
                goods_art_dict_info_item["模特图"] = ""
                new_goods_dict[goods_art_no_info]["货号资料"][idx_key] = goods_art_dict_info_item
                upper_footer_progress["status"] = "处理失败"
                upper_footer_progress["error"] = upper_footer_error_progress
                await sendAsyncMessage(
                    msg="模特图处理失败",
                    goods_arts=[goods_art_no],
                    status="模特图处理失败",
                    msg_type="upper_footer_progress",
                    progress=upper_footer_progress
                )
    status_text = "处理完成" if upper_footer_finish_progress > 0 else "处理失败"
    upper_footer_progress = {
        "status": status_text,
        "current": upper_footer_finish_progress,
        "total": upper_footer_total_progress,
        "error": upper_footer_error_progress
    }

    await sendAsyncMessage(
        msg="模特图处理结束",
        goods_arts=[],
        status="模特图处理结束",
        msg_type="upper_footer_progress",
        progress=upper_footer_progress
    )

    if new_goods_dict:
        return_data_check_before_detail["data"]["goods_no_dict"] = new_goods_dict

    return return_data_check_before_detail


async def _process_detail_pages(run_main, return_data_check_before_detail, onlineData,
                                online_stores, goods_art_no_arrays, handler_result_folder, request_params):
    """处理详情页生成和上传"""
    # check_for_detail_first_res = run_main.check_for_detail_first_call_back(
    #     return_data_check_before_detail,request_params
    # )
    loop = asyncio.get_event_loop()
    # 将整个 detail_run_by_thread 放入线程池执行
    check_for_detail_first_res = await loop.run_in_executor(
        None,
        run_main.check_for_detail_first_call_back,
        return_data_check_before_detail,
        request_params,
        # ... 其他参数
    )
    print("<======>check_for_detail_first_res<======>", check_for_detail_first_res)
    if isinstance(check_for_detail_first_res, partial):
        try:
            result = check_for_detail_first_res()
            config_data = result["config_data"]
        except:
            config_data = result
    else:
        config_data = check_for_detail_first_res
    out_put_dir = config_data.get("out_put_dir")
    success_handler = config_data.get("success_handler")
    if not out_put_dir:
        handler_result_folder = ""
        # 处理失败情况
    else:
        out_put_dir_path = "{}".format(out_put_dir).replace("\\", "/")
        handler_result_folder = os.path.dirname(out_put_dir_path)
    if handler_result_folder:
        handler_result_folder = os.path.dirname(handler_result_folder)
    return handler_result_folder, success_handler


async def _upload_to_third_party(onlineData, return_data_check_before_detail,
                                 config_data, online_stores, temp_name):
    """上传到第三方平台"""
    result_goods_no_dict = return_data_check_before_detail["data"]["goods_no_dict"]

    for goods_idx, goods_no_dict in enumerate(result_goods_no_dict.keys()):
        all_detail_path_list = config_data["all_detail_path_list"]
        for detail_path in all_detail_path_list:
            if goods_no_dict in detail_path:
                detail_path_replace = detail_path.replace("\\", "/")
                result_goods_no_dict[goods_no_dict]["detail_path"] = f"{detail_path_replace}/详情页-{temp_name}.jpg"

    upload_total_progress = len(result_goods_no_dict.keys())
    upload_finish_progress = 0
    upload_error_progress = 0

    upload_progress = {
        "status": "开始处理",
        "current": upload_finish_progress,
        "total": upload_total_progress,
        "error": upload_error_progress
    }

    await sendAsyncMessage(
        msg="开始上传商品数据",
        goods_arts=[],
        status="开始上传商品数据",
        msg_type="upload_goods_progress",
        progress=upload_progress
    )

    try:
        onlineData.uploadGoods2ThirdParty(
            result_goods_no_dict, online_stores=online_stores
        )
    except Exception as e:
        upload_error_progress = upload_total_progress
        print(f"上传任务出现错误:{e}")

    upload_finish_progress = upload_total_progress
    if upload_error_progress > 0:
        upload_finish_progress = 0

    upload_progress = {
        "status": "处理完成",
        "current": upload_finish_progress,
        "total": upload_total_progress,
        "error": upload_error_progress
    }

    await sendAsyncMessage(
        msg="商品上传第三方成功",
        goods_arts=[],
        status="商品上传第三方成功",
        msg_type="upload_goods_progress",
        progress=upload_progress
    )


async def _handle_exception(error_msg, handler_result_folder):
    """处理异常情况"""
    handler_result = [{"goods_art_no": "", "success": False, "info": error_msg}]

    await sendAsyncMessage(
        msg="处理结束",
        data={"output_folder": handler_result_folder, "list": handler_result},
        status="处理结束",
        msg_type="detail_result_progress",
    )


@app.get("/get_device_tabs", description="获取可执行程序命令列表")
def get_device_tabs(type: int):
    session = SqlQuery()
    statement = (
        select(DeviceConfigTabs)
        .where(DeviceConfigTabs.mode_type == type)
        .order_by(asc("id"))
    )
    result = session.exec(statement).all()
    sys = CRUD(SysConfigs)
    action_configs = sys.read(session, conditions={"key": "action_configs"})
    session.close()
    return {
        "code": 0,
        "msg": "",
        "data": {"tabs": result, "select_configs": json.loads(action_configs.value)},
    }


@app.post("/update_tab_name", description="更改tab名称")
def update_tab_name(params: DeviceConfigTabsReq):
    if params.mode_name == "":
        return {"code": 1, "msg": "名称不能为空", "data": {}}
    session = SqlQuery()
    tabModel = CRUD(DeviceConfigTabs)
    kwargs = {"mode_name": params.mode_name}
    tabModel.updateConditions(session, conditions={"id": params.id}, **kwargs)
    session.close()
    return {
        "code": 0,
        "msg": "",
        "data": None,
    }


@app.post("/get_device_configs", description="获取可执行程序命令列表")
def get_device_configs(params: ModelGetDeviceConfig):
    tab_id = params.tab_id
    session = SqlQuery()
    configModel = CRUD(DeviceConfig)
    configList = configModel.read_all(
        session,
        conditions={"tab_id": tab_id},
        order_by="action_index",
        ascending=True,
    )
    session.close()
    return {
        "code": 0,
        "msg": "",
        "data": {"list": configList},
    }


@app.post("/device_config_detail", description="获取可执行程序详情")
def device_config_detail(params: ModelGetDeviceConfigDetail):
    action_id = params.id
    session = SqlQuery()
    configModel = CRUD(DeviceConfig)
    model = configModel.read(session, conditions={"id": action_id})
    session.close()
    if model == None:
        return {"code": 1, "msg": "相关配置不存在,请删除当前货号后重新拍摄", "data": None}
    return {"code": 0, "msg": "", "data": model}


@app.post("/device_config_detail_query", description="通过条件获取可执行程序详情")
def device_config_detail_query():
    # tab_id = params.tab_id
    # action_name = params.action_name
    session = SqlQuery()
    sys = CRUD(SysConfigs)
    action_configs = sys.read(session, conditions={"key": "action_configs"})
    action_configs_value = json.loads(action_configs.value)
    left_config = action_configs_value.get("left")
    configModel = CRUD(DeviceConfig)
    model = configModel.read(
        session, conditions={"tab_id": left_config, "action_name": "侧视"}
    )
    if model == None:
        model = configModel.read(session, conditions={"tab_id": left_config})
    session.close()
    return {"code": 0, "msg": "", "data": model}


@app.post("/remove_config", description="删除一条可执行命令")
def get_device_configs(params: ModelGetDeviceConfigDetail):
    action_id = params.id
    session = SqlQuery()
    configModel = CRUD(DeviceConfig)
    model = configModel.read(session, conditions={"id": action_id})
    if model == None:
        return {"code": 1, "msg": "数据不存在", "data": None}
    if model.is_system == True:
        return {"code": 1, "msg": "系统配置不允许删除", "data": None}
    configArray = configModel.read_all(session, conditions={"tab_id": model.tab_id})
    if len(configArray) == 1:
        return {"code": 1, "msg": "请至少保留一个配置", "data": None}
    configModel.delete(session, obj_id=action_id)
    session.close()
    return {"code": 0, "msg": "删除成功", "data": None}


@app.post("/save_device_config", description="创建或修改一条可执行命令")
def save_device_config(params: SaveDeviceConfig):
    action_id = params.id
    session = SqlQuery()
    deviceConfig = CRUD(DeviceConfig)
    if action_id == None or action_id == 0:
        # 走新增逻辑
        params.id = None
        save_device_config = deviceConfig.create(session, obj_in=params)
    else:
        model = deviceConfig.read(session, conditions={"id": action_id})
        if model == None:
            return {"code": 1, "msg": "数据不存在", "data": None}
        # 走编辑逻辑
        kwargs = params.__dict__
        save_device_config = deviceConfig.update(session, obj_id=action_id, **kwargs)
    session.close()
    return {"code": 0, "msg": "操作成功", "data": save_device_config}


@app.post("/reset_config", description="创建或修改一条可执行命令")
def reset_config(params: ModelGetDeviceConfig):
    tab_id = params.tab_id
    if tab_id == None or tab_id == "":
        return {"code": 1, "msg": "参数错误", "data": None}
    session = SqlQuery()
    deviceConfig = CRUD(DeviceConfig)
    first_config = deviceConfig.read(session, conditions={"tab_id": tab_id})
    res = deviceConfig.deleteConditions(session, conditions={"tab_id": tab_id})
    if res is False:
        return {"code": 1, "msg": "操作失败", "data": None}
    actions = json.load(open("action.json", encoding="utf-8"))
    for data in actions:
        data["tab_id"] = tab_id
        data["is_system"] = first_config.is_system
        device_config = DeviceConfig(**data)
        session.add(device_config)
    session.commit()
    session.close()
    return {"code": 0, "msg": "操作成功", "data": None}


@app.get("/get_photo_records", description="获取拍照记录")
def get_photo_records(page: int = 1, size: int = 5, goods_art_no: str = None):
    session = SqlQuery()
    current_page = page
    # photos = CRUD(PhotoRecord)
    print("准备查询拍摄记录", datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
    # 构建基础查询条件
    base_conditions = [PhotoRecord.delete_time == None]
    if goods_art_no:
        base_conditions.append(PhotoRecord.goods_art_no.like(f"%{goods_art_no}%"))
    # 首先统计总数
    count_statement = select(func.count(PhotoRecord.goods_art_no.distinct())).where(
        *base_conditions
    )
    total_count = session.exec(count_statement).one()

    # 查询所有不重复的货号及对应的最大时间，进行分页
    base_statement = (
        select(PhotoRecord.goods_art_no, func.max(PhotoRecord.id).label("max_id"))
        .where(*base_conditions)
        .group_by(PhotoRecord.goods_art_no)
        .order_by(desc("max_id"))
        .offset((page - 1) * size)
        .limit(size)
    )
    paginated_results = session.exec(base_statement).all()

    # 获取这些货号的详细记录
    list_data = []
    if paginated_results:
        # 获取当前页的货号列表
        current_goods_art_nos = [item.goods_art_no for item in paginated_results]

        # 查询这些货号的所有记录
        query = (
            select(PhotoRecord, DeviceConfig.action_name)
            .outerjoin(DeviceConfig, PhotoRecord.action_id == DeviceConfig.id)
            .where(PhotoRecord.goods_art_no.in_(current_goods_art_nos))
            .where(PhotoRecord.delete_time == None)
            .order_by(asc("image_index"))  # 按货号分组并按ID倒序
        )
        all_items = session.exec(query).mappings().all()

        # 按货号分组
        items_by_goods = {}
        for item in all_items:
            # print("all_items", all_items)
            goods_art_no = item.PhotoRecord.goods_art_no
            if goods_art_no not in items_by_goods:
                items_by_goods[goods_art_no] = []
            items_by_goods[goods_art_no].append(item)

        # 构建结果列表，保持分页的顺序
        for item in paginated_results:
            goods_art_no = item.goods_art_no
            if goods_art_no in items_by_goods:
                # 获取该货号下时间最新的记录作为action_time
                latest_record = items_by_goods[goods_art_no][0].PhotoRecord
                extras = latest_record.extras
                # extras 存储的是 json 字符串，解析成对象返回给前端
                if extras:
                    try:
                        extras = json.loads(extras)
                    except (json.JSONDecodeError, TypeError):
                        extras = None
                list_data.append(
                    {
                        "goods_art_no": goods_art_no,
                        "action_time": latest_record.create_time,
                        "extras": extras,
                        "items": items_by_goods[goods_art_no],
                    }
                )

    session.close()
    print("循环查询 完成 ", datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))

    # 计算分页信息
    total_pages = (total_count + size - 1) // size  # 向上取整
    has_prev = page > 1
    has_next = page < total_pages

    return {
        "code": 0,
        "msg": "",
        "data": {
            "list": list_data,
            "current_page": current_page,
            "size": size,
            "total_count": total_count,
            "total_pages": total_pages,
            "has_prev": has_prev,
            "has_next": has_next
        },
    }


@app.get("/get_last_photo_record", description="获取最后一条拍照记录")
def get_last_photo_record():
    session = SqlQuery()
    statement = (
        select(PhotoRecord)
        .where(PhotoRecord.image_path != None)
        .where(PhotoRecord.delete_time == None)
        .order_by(desc("photo_create_time"))
    )
    result = session.exec(statement).first()
    session.close()
    return {
        "code": 0,
        "msg": "",
        "data": result,
    }


@app.get("/get_photo_record_detail", description="通过货号获取拍照记录详情")
def get_photo_record_detail(goods_art_no: str = None):
    if goods_art_no == None:
        return {"code": 1, "msg": "参数错误", "data": None}
    session = SqlQuery()
    photos = CRUD(PhotoRecord)
    items = photos.read_all(session, conditions={"goods_art_no": goods_art_no, "delete_time": None})
    session.close()
    return {
        "code": 0,
        "msg": "",
        "data": {"list": items},
    }


@app.get("/get_action_names_by_goods", description="通过货号获取动作名称列表")
def get_action_names_by_goods(goods_art_no: str = None):
    """
    通过货号查询PhotoRecord表，按自然排序获取action_id，
    再查询DeviceConfig获取对应的action_name，按顺序返回action_name数组
    
    Args:
        goods_art_no: 货号
        
    Returns:
        如果货号不存在: {"code": 1, "msg": "货号不存在", "data": None}
        如果货号存在: {"code": 0, "msg": "", "data": [action_name1, action_name2, ...]}
    """
    if goods_art_no is None or goods_art_no.strip() == "":
        return {"code": 1, "msg": "参数错误", "data": None}

    session = SqlQuery()
    try:
        # 1. 查询该货号的所有记录
        photos = CRUD(PhotoRecord)
        photo_records = photos.read_all(
            session,
            conditions={"goods_art_no": goods_art_no, "delete_time": None}
        )

        # 2. 如果货号不存在，返回错误
        if not photo_records or len(photo_records) == 0:
            return {"code": 1, "msg": "货号不存在", "data": None}

        # 3. 按自然排序对记录进行排序（基于image_index或其他字段）
        # 使用natsort对image_index进行自然排序
        from natsort import natsorted, ns

        # 将记录转换为可排序的列表，按image_index排序
        sorted_records = natsorted(
            photo_records,
            key=lambda x: str(x.image_index) if x.image_index is not None else "",
            alg=ns.PATH | ns.IGNORECASE
        )

        # 4. 提取排序后的action_id列表
        action_ids = [record.action_id for record in sorted_records if record.action_id is not None]

        if not action_ids:
            return {"code": 0, "msg": "", "data": []}

        # 5. 根据action_id查询DeviceConfig获取action_name
        device_config_crud = CRUD(DeviceConfig)
        action_names = []

        for action_id in action_ids:
            device_config = device_config_crud.read(
                session,
                conditions={"id": action_id, 'take_picture': True}
            )
            if device_config and device_config.action_name:
                action_names.append(device_config.action_name)

        return {"code": 0, "msg": "", "data": action_names}

    except Exception as e:
        logger.error(f"查询货号 {goods_art_no} 的动作名称失败: {str(e)}")
        return {"code": 1, "msg": f"查询失败: {str(e)}", "data": None}
    finally:
        session.close()


@app.post("/delect_goods_arts", description="通过货号删除记录")
def delect_goods_arts(params: PhotoRecordDelete):
    limit_path = "{}/{}".format(settings.OUTPUT_DIR,
                                time.strftime("%Y-%m-%d", time.localtime(time.time()))
                                )
    handlerFolderDelete(limit_path, params.goods_art_nos, False)
    session = SqlQuery()
    photos = CRUD(PhotoRecord)
    for item in params.goods_art_nos:
        settings.syncPhotoRecord({"goods_art_no": item}, action_type=2)
        photos.deleteConditions(session, conditions={"goods_art_no": item, "delete_time": None})
    session.close()
    return {
        "code": 0,
        "msg": "操作成功",
        "data": None,
    }


@app.post("/delete_all_goods_arts", description="删除所有拍照记录")
def delete_all_goods_arts():
    """
    删除数据库中所有未删除的拍照记录，并清理对应的文件目录
    """
    session = SqlQuery()
    try:
        # 1. 获取所有存在的货号
        photos = CRUD(PhotoRecord)
        # 查询所有 distinct 的 goods_art_no
        statement = select(PhotoRecord.goods_art_no).where(PhotoRecord.delete_time == None).distinct()
        all_goods_art_nos = session.exec(statement).all()

        if not all_goods_art_nos:
            raise UnicornException("没有可删除的货号")

        # 2. 清理文件目录 (复用现有的 handlerFolderDelete 逻辑)
        # limit_path = "{}/{}".format(settings.OUTPUT_DIR,
        #                 time.strftime("%Y-%m-%d", time.localtime(time.time()))
        #             )
        # 注意：handlerFolderDelete 内部可能涉及大量IO操作，如果数据量极大可能需要异步或后台任务
        # 这里保持同步以符合原接口风格，但需注意超时风险
        # handlerFolderDelete(limit_path, list(all_goods_art_nos), False)

        # 3. 同步线上状态 (如果需要)
        settings.syncBatchPhotoRecordDelete()
        # 4. 批量删除数据库记录
        # 使用 deleteConditions 一次性删除所有符合条件的记录，比循环删除效率高
        photos.deleteConditions(session, conditions={"delete_time": None})

        session.commit()  # 确保事务提交

        return {
            "code": 0,
            "msg": f"成功删除 {len(all_goods_art_nos)} 个货号的所有记录",
            "data": None,
        }

    except Exception as e:
        session.rollback()
        logger.error(f"删除所有记录失败: {str(e)}")
        raise UnicornException(f"删除失败: {str(e)}")
    finally:
        session.close()


def query_config_by_key(key_name):
    """
    在sys_configs.json格式的数据中查询指定的key，如果匹配则返回整个对象

    Args:
        key_name (str): 要查询的key名称

    Returns:
        dict or None: 匹配的对象或None（如果没有找到）
    """
    try:
        # 获取所有配置数据
        configs = json.load(open("sys_configs.json", encoding="utf-8"))

        # 遍历配置数据查找匹配的key
        for config in configs:
            if config.get("key") == key_name:
                return config

        return None
    except Exception as e:
        print(f"查询配置时出错: {e}")
        return None


@app.get("/get_sys_config", description="查询系统配置")
def get_sys_config(key: str = None):
    if key == None:
        return {"code": 1, "msg": "参数错误", "data": None}
    session = SqlQuery()
    photos = CRUD(SysConfigs)
    item = photos.read(session, conditions={"key": key})
    search_data = None if item == None else json.loads(item.value)
    if search_data == None:
        sys_config_json = query_config_by_key(key)
        if sys_config_json != None:
            config = SysConfigs(**sys_config_json)
            session.add(config)
            session.commit()  # 合并事务提交
            search_data = json.loads(sys_config_json.get("value"))
    session.close()
    return {
        "code": 0,
        "msg": "",
        "data": search_data,
    }


@app.post("/update_left_right_config", description="更新左右脚配置")
def update_left_right_config(params: LeftRightParams):
    session = SqlQuery()
    sysConfig = CRUD(SysConfigs)
    model = sysConfig.read(session, conditions={"key": "action_configs"})
    if model == None:
        return {"code": 1, "msg": "配置不存在", "data": None}
    config_value = json.loads(model.value)
    config_value[params.type] = params.id
    update_value = json.dumps(config_value)
    # 走编辑逻辑
    kwargs = {"key": "action_configs", "value": update_value}
    save_device_config = sysConfig.updateConditions(
        session, conditions={"key": "action_configs"}, **kwargs
    )
    session.close()
    return {"code": 0, "msg": "操作成功", "data": None}


@app.post("/update_record", description="更新拍照记录")
def update_record(params: RecordUpdate):
    session = SqlQuery()
    photoRecord = CRUD(PhotoRecord)
    model = photoRecord.read(session, conditions={"id": params.id, "delete_time": None})
    if model == None:
        return {"code": 1, "msg": "记录不存在", "data": None}
    kwargs = params.__dict__
    save_device_config = photoRecord.update(session, obj_id=params.id, **kwargs)
    session.close()
    return {"code": 0, "msg": "操作成功", "data": save_device_config}


@app.post("/update_sys_configs", description="创建或修改系统配置")
def save_sys_configs(params: SysConfigParams):
    session = SqlQuery()
    sysConfig = CRUD(SysConfigs)
    model = sysConfig.read(session, conditions={"key": params.key})
    if model == None:
        return {"code": 1, "msg": "配置不存在", "data": None}
    # 走编辑逻辑
    kwargs = params.__dict__
    save_device_config = sysConfig.updateConditions(
        session, conditions={"key": params.key}, **kwargs
    )
    session.close()
    return {"code": 0, "msg": "操作成功", "data": save_device_config}


@app.post("/create_main_image", description="创建主图测试")
def create_main_image(params: MaineImageTest):
    file_path = params.file_path
    onePic = OnePicTest(pic_path=file_path)
    main_out_path = onePic.HandlerMainImage()
    return {"code": 0, "msg": "操作成功", "data": {"main_out_path": main_out_path}}


def insertEmptyLogoList(session):
    """插入空logo列表"""
    data = {"key": "logo_configs", "value": "[]"}
    config = SysConfigs(**data)
    session.add(config)
    session.commit()
    item = SysConfigs()
    item.key = "logo_configs"
    item.value = "[]"
    return item


@app.get("/logo_list", description="logo列表")
def logo_list():
    logo_dir = "{}/data/logo/".format(os.getcwd()).replace("\\", "/")
    check_path(logo_dir)
    logo_files = os.listdir(logo_dir)
    logo_list = []
    for logoItem in logo_files:
        logo_list.append(f"{logo_dir}{logoItem}")
    return {"code": 0, "msg": "操作成功", "data": logo_list}


@app.post("/add_logo", description="添加logo")
def add_logo(params: LogoParams):
    logo_path = params.logo_path.replace("\\", "/")
    session = SqlQuery()
    sysConfig = CRUD(SysConfigs)
    item = sysConfig.read(session, conditions={"key": "logo_configs"})
    if item == None:
        item = insertEmptyLogoList(session)
    if os.path.isfile(logo_path) == False:
        return {"code": 1, "msg": "logo文件不存在", "data": None}
    logo_dir = "{}/data/logo/".format(os.getcwd()).replace("\\", "/")
    check_path(logo_dir)
    session.close()
    fpath, fname = os.path.split(logo_path)
    logo_path_info = logo_dir + fname
    shutil.copy(logo_path, logo_path_info)  # 复制文件
    logo_files = os.listdir(logo_dir)
    logo_list = []
    for logoItem in logo_files:
        logo_list.append(f"{logo_dir}{logoItem}")
    return {
        "code": 0,
        "msg": "",
        "data": {"logo": logo_path_info},
    }


@app.post("/delete_logo", description="删除logo")
def delete_logo(params: LogoParamsupdate):
    logo_path = params.path
    if os.path.isfile(logo_path) == False:
        return {"code": 1, "msg": "logo文件不存在", "data": None}
    os.remove(logo_path)
    logo_dir = "{}/data/logo/".format(os.getcwd()).replace("\\", "/")
    check_path(logo_dir)
    logo_files = os.listdir(logo_dir)
    logo_list = []
    for logoItem in logo_files:
        logo_list.append(f"{logo_dir}{logoItem}")
    return {"code": 0, "msg": "操作成功", "data": logo_list}


@app.post("/close_other_window", description="关闭窗口")
def close_other_window():
    hwnd_list = []

    def callback(hwnd, _):
        title = GetWindowText(hwnd)
        if title == "digiCamControl by Duka Istvan":
            hwnd_list.append(hwnd)

    EnumWindows(callback, None)
    if hwnd_list:
        hwnd = hwnd_list[0]
        win32gui.PostMessage(hwnd, win32con.WM_CLOSE, 0, 0)
        return {"code": 0, "msg": "关闭成功", "data": {"status": True}}
    return {"code": 0, "msg": "关闭失败", "data": {"status": False}}


def syncUserJsonConfigs(token):
    hlm_token = token
    headers = {
        "Authorization": f"Bearer {hlm_token}",
        "content-type": "application/json",
    }
    # 追加配置参数 machine_type 拍照机设备类型;0鞋;1服装
    url = settings.DOMAIN + f"/api/ai_image/camera_machine/get_all_user_configs?machine_type={MACHINE_TYPE}"
    result = requests.get(url=url, headers=headers)
    sys_configs = result.json().get("data", {}).get("configs")
    session = SqlQuery()
    sysConfigs = CRUD(SysConfigs)
    if sys_configs:
        sysConfigs.deleteConditions(session, {})
        configList = []
        for config_keys in sys_configs.keys():
            sys_configs[config_keys]
            configList.append(
                {
                    "key": config_keys,
                    "value": json.dumps(sys_configs[config_keys], ensure_ascii=False),
                }
            )
        batch_insert_sys_configs(session, configList)
    session.close()


@app.post("/sync_sys_configs", description="同步线上配置到本地")
def sync_sys_configs(params: SyncLocalConfigs):
    hlm_token = params.token
    env = params.env
    settings.USER_TOKEN = hlm_token
    settings.USER_ENV = env
    settings.USER_CAMERAS = params.camera_counts
    headers = {
        "Authorization": f"Bearer {hlm_token}",
        "content-type": "application/json",
    }
    # 追加配置参数 machine_type 拍照机设备类型;0鞋;1服装
    url = settings.getDoman(env) + f"/api/ai_image/camera_machine/get_all_user_configs?machine_type={MACHINE_TYPE}"
    result = requests.get(url=url, headers=headers)
    sys_configs = result.json().get("data", {}).get("configs")
    session = SqlQuery()
    sysConfigs = CRUD(SysConfigs)
    if sys_configs:
        sysConfigs.deleteConditions(session, {})
        configList = []
        for config_keys in sys_configs.keys():
            sys_configs[config_keys]
            configList.append(
                {
                    "key": config_keys,
                    "value": json.dumps(sys_configs[config_keys], ensure_ascii=False),
                }
            )
        batch_insert_sys_configs(session, configList)
    else:
        all_configs = sysConfigs.read_all(session)
        localConfigData = {}
        for local_config in all_configs:
            localConfigData[local_config.key] = json.loads(local_config.value)
        data_json = json.dumps({"configs": localConfigData, "machine_type": MACHINE_TYPE}, ensure_ascii=False)
        # 同步本地到线上
        url = settings.DOMAIN + "/api/ai_image/camera_machine/update_all_user_configs"
        requests.post(url=url, headers=headers, data=data_json)
    session.close()
    return {"code": 0, "msg": "操作成功", "data": None}


@app.post("/sync_actions", description="同步左右脚配置到本地")
def sync_action_configs(params: SyncLocalConfigs):
    hlm_token = params.token
    env = params.env
    settings.USER_TOKEN = hlm_token
    settings.USER_ENV = env
    settings.USER_CAMERAS = params.camera_counts
    headers = {
        "Authorization": f"Bearer {hlm_token}",
        "content-type": "application/json",
    }
    url = settings.getDoman(env) + f"/api/ai_image/camera_machine/get_all_user_tabs?machine_type={MACHINE_TYPE}"
    result = requests.get(url=url, headers=headers)
    session = SqlQuery()
    deviceConfigs = CRUD(DeviceConfig)
    deviceConfigTabs = CRUD(DeviceConfigTabs)
    tabs = result.json().get("data", {}).get("tabs")
    actions = result.json().get("data", {}).get("actions")
    if tabs:
        # 先删除再创建
        deviceConfigTabs.deleteConditions(session, {})
        deviceConfigs.deleteConditions(session, {}, False)
        batch_insert_device_configsNew(session, tabs, actions)
    else:
        all_actions = deviceConfigs.read_all(session)
        all_tabs = deviceConfigTabs.read_all(session)
        all_tabs_json = [item.model_dump(mode='json') for item in all_tabs]
        all_actions_json = [item.model_dump(mode="json") for item in all_actions]
        data_json = json.dumps(
            {"tabs": all_tabs_json, "actions": all_actions_json, "machine_type": MACHINE_TYPE}, ensure_ascii=False
        )
        sync_url = settings.DOMAIN + "/api/ai_image/camera_machine/sync_actions"
        result = requests.post(url=sync_url, headers=headers, data=data_json)
        print("result<><><>", result.content)
        tabs = result.json().get("data", {}).get("tabs")
        actions = result.json().get("data", {}).get("actions")
        insert_action_ids = result.json().get("data", {}).get("insert_action_ids")
        if tabs:
            deviceConfigTabs.deleteConditions(session, {})
            deviceConfigs.deleteConditions(session, {})
            batch_insert_device_configsNew(session, tabs, actions)
        if insert_action_ids:
            for action_item in insert_action_ids:
                photos = CRUD(PhotoRecord)
                old_id = action_item.get("old_id")
                new_id = action_item.get("new_id")
                kwargs = {"action_id": new_id}
                photos.updateConditionsAll(
                    session, conditions={"action_id": old_id}, **kwargs
                )
    # 因为左右脚线上id可能会发生变化  所以需要重新同步一下本地得配置信息
    # syncUserJsonConfigs(hlm_token)
    session.close()
    return {"code": 0, "msg": "操作成功", "data": None}


@app.get("/get_goods_image_json", description="关闭窗口")
def get_goods_image_json(goods_art_no: str, token: str):
    remove_pic_ins = RemoveBgALi()
    if goods_art_no == None or goods_art_no == "":
        # 判断货号是否存在
        raise UnicornException("货号不能为空")
    session = SqlQuery()
    photoRecord = CRUD(PhotoRecord)
    goods_art_record = photoRecord.read_all(
        session, conditions={"goods_art_no": goods_art_no, "delete_time": None}
    )
    if not goods_art_record:
        raise UnicornException("该货号拍摄记录不存在")
    action_id_array = [record.action_id for record in goods_art_record]
    devices = CRUD(DeviceConfig)
    devices_record = devices.read_all(session, conditions={"id": action_id_array})
    # 提取 action_name 字段并拼接
    action_names = [str(record.action_name) for record in devices_record]
    action_names_str = ",".join(action_names)
    image_arrays = []
    for goods_art_record_item in goods_art_record:
        image_path = goods_art_record_item.image_path
        try:
            image_url = uploadImage(remove_pic_ins=remove_pic_ins, token=token, local_path=image_path)
        except Exception as e:
            raise UnicornException("网络异常，请重试")
        image_arrays.append(image_url)
    session.close()
    return {"code": 0, "msg": "关闭失败",
            "data": {"customer_template_images": image_arrays, "template_image_order": action_names_str}}


def uploadImage(remove_pic_ins, token: str, local_path: str) -> str:
    im = remove_pic_ins.get_image_cut_new(file_path=local_path)
    post_headers = {"Authorization": "Bearer " + token}
    url = settings.DOMAIN + "/api/upload"
    resultData = requests.post(
        url, files={"file": im}, headers=post_headers
    ).json()
    return resultData["data"]["url"]


@app.post("/remove_background", description="图片抠图-http请求")
async def remove_background(params: PhotoRecordRemoveBackground):
    # await socket_manager.send_message(msg="测试")
    executor = ThreadPoolExecutor(max_workers=4)
    obj = None
    token = params.token
    token = "Bearer " + token
    uuid = mine_uuid.uuid4().hex
    run_main = RunMain(obj, token, uuid)
    goods_art_no_arrays = params.goods_art_nos
    limit_path = "{}/{}".format(settings.OUTPUT_DIR,
                                time.strftime("%Y-%m-%d", time.localtime(time.time()))
                                )
    try:
        move_folder_array = handlerFolderDelete(limit_path, goods_art_no_arrays, True)
    except UnicornException as e:
        raise UnicornException(e.msg)
    # 该数组表示是否需要后面的移动文件夹操作，减少重复抠图，提升抠图时间和速度
    session = SqlQuery()
    for goods_art_no in goods_art_no_arrays:
        pr = CRUD(PhotoRecord)
        images = pr.read_all(session, conditions={"goods_art_no": goods_art_no, "delete_time": None})
        if not images:
            raise UnicornException(f"商品货号【{goods_art_no}】在商品档案资料中不存在，请检查货号是否正确")
        if move_folder_array.get(goods_art_no) == None:
            image_dir = "{}/data/".format(os.getcwd()).replace("\\", "/")
            check_path(image_dir)
            for idx, itemImg in enumerate(images):
                if itemImg.image_path == "" or itemImg.image_path == None:
                    raise UnicornException(f"货号【{goods_art_no}】存在没有拍摄完成的图片,请重拍或删除后重试")
                # new_file_name = (
                #     str(idx)+"_"+str(itemImg.goods_art_no) + "_" + str(idx) + ".jpg"
                # )
                # if not os.path.exists(
                #     image_dir + "/" + os.path.basename(new_file_name)
                # ):
                #     shutil.copy(itemImg.image_path, image_dir + new_file_name)
            dealImage = DealImage(image_dir)
            resFlag, path = dealImage.dealMoveImageV2(
                goods_art_no=goods_art_no,
            )
            if not resFlag:
                raise UnicornException(f"抠图操作异常,请检查目录是否存在，或者权限不足")
    session.close()
    # try:
    cutout_mode = settings.getSysConfigs("other_configs", "cutout_mode", "普通抠图")
    match cutout_mode:
        case "普通抠图":
            cutOutMode = "1"
        case "精细化抠图":
            cutOutMode = "2"
        case "旗舰AI抠图":
            cutOutMode = "3"
        case "旗舰AI抠图-精细":
            cutOutMode = "4"
        case "旗舰AI抠图-透明物品":
            cutOutMode = "5"
        case _:
            cutOutMode = "1"
    config_data = {
        "image_dir": limit_path,
        "image_order": (
            "俯视,侧视,后跟,鞋底,内里,组合,组合2,组合3,组合4,组合5,组合6,组合7,组合8,组合9,组合10,组合11,组合12,组合13,组合14,组合15,组合16,组合17,组合18,组合19,组合20,组合21,组合22,组合23,组合24,组合25,组合26"
        ),
        "goods_art_no": "",
        "goods_art_nos": goods_art_no_arrays,
        "is_check_number": False,
        "resize_image_view": "后跟",
        "cutout_mode": cutOutMode,
        "logo_path": "",
        "special_goods_art_no_folder_line": "",
        "is_use_excel": False,  # 是否使用excel
        "excel_path": "",  # excel路径
        "is_check_color_is_all": False,
        "cutout_is_pass": True,
        "assigned_page_dict": {},
        "detail_is_pass": True,
        "upload_is_pass": False,
        "upload_is_enable": settings.IS_UPLOAD_HLM,  # 是否上传到惠利玛商品库，通过config.ini得is_upload开启
        "is_filter": False,
        "temp_class": {},
        "temp_name": "",
        "temp_name_list": [],
        "target_error_folder": f"{limit_path}/软件-生成详情错误",
        "success_handler": [],
    }
    try:
        loop = asyncio.get_event_loop()
        return_data = await loop.run_in_executor(
            executor, partial(run_main.check_before_cutout, config_data)
        )
        cutout_res = await loop.run_in_executor(
            executor,
            partial(run_main.check_for_cutout_image_first_call_back, return_data),
        )
        handler_result = []
        have_handler_keys = move_folder_array.keys()
        if cutout_res:
            handler_result_folder = f"{config_data['image_dir']}"
            for goods_art_item in goods_art_no_arrays:
                handler_result.append({
                    "goods_art_no": goods_art_item,
                    "success": True,
                    "info": "处理成功",
                })
        else:
            return {"code": 1, "message": "抠图失败", "data": None}
        if len(have_handler_keys) == len(goods_art_no_arrays) or (len(have_handler_keys) == 0 and cutout_res):
            handler_result_folder = handler_result_folder.replace("\\", "/")
            success_items = [item for item in handler_result if item.get('success') == True]
            cutout_folder = handler_result_folder + "/" + success_items[0].get("goods_art_no") + "/800x800" if len(
                success_items) > 0 else ""
            progress = {
                "status": "处理完成",
                "current": len(goods_art_no_arrays),
                "total": len(goods_art_no_arrays),
                "error": 0,
                "folder": cutout_folder,
            }
            return {"code": 0, "message": "抠图完成",
                    "data": {"output_folder": handler_result_folder, "list": handler_result, "progress": progress}}
    except UnicornException as e:
        raise UnicornException(e.msg)
    except Exception as e:
        print("error", e)
        raise UnicornException(f"抠图异常,请稍后重试:{e}")


@app.post("/syncPhotoRecord", description="同步本地拍照记录-和output目录")
async def syncPhotoRecord(params: SyncPhotoRecord):
    # 查询所有不重复的货号及对应的最大时间，进行分页
    settings.USER_TOKEN = params.token
    settings.USER_ENV = params.env
    settings.USER_CAMERAS = params.camera_counts
    syncStatus = settings.checkRecordSyncStatus()
    if syncStatus == True:
        # 同步过就无需再同步
        return {"code": 0, "message": "同步完成", "data": None}
    session = SqlQuery()
    base_statement = (
        select(PhotoRecord)
        .where(PhotoRecord.delete_time == None)
    )
    paginated_results = session.exec(base_statement).all()

    def model_to_dict(model):
        """将SQLAlchemy模型对象转换为字典，排除_sa_instance_state"""
        result = {}
        for column in model.__table__.columns:
            result[column.name] = getattr(model, column.name)
        return result

    json_results = []
    for result in paginated_results:
        # 使用自定义函数将SQLAlchemy对象转换为字典
        json_results.append(model_to_dict(result))
    # 最终转换为JSON字符串
    settings.syncPhotoRecord(json_results, action_type=0)
    session.close()
    return {"code": 0, "message": "同步完成", "data": None}


def copy_directory_walk(src, dst):
    """
    使用 os.walk() 遍历并复制目录
    """
    for root, dirs, files in os.walk(src):
        # 计算相对路径
        rel_path = os.path.relpath(root, src)
        dst_dir = os.path.join(dst, rel_path) if rel_path != '.' else dst
        # 创建目标目录
        if not os.path.exists(dst_dir):
            os.makedirs(dst_dir)
        # 复制文件
        for file in files:
            src_file = os.path.join(root, file)
            dst_file = os.path.join(dst_dir, file)
            shutil.copy2(src_file, dst_file)


def rename_file_safe(src, dst, overwrite=True):
    """
    安全地重命名文件
    
    Args:
        src: 源文件路径
        dst: 新文件路径
        overwrite: 是否覆盖已存在的文件
    """
    try:
        # 检查源文件是否存在
        if not os.path.exists(src):
            return False, f"源文件 {src} 不存在"

        # 检查目标文件是否存在
        if os.path.exists(dst) and not overwrite:
            return False, f"目标文件 {dst} 已存在，设置 overwrite=True 以覆盖"

        # 执行重命名
        os.rename(src, dst)
        return True, f"文件已成功从 {src} 重命名为 {dst}"
    except OSError as e:
        return False, f"重命名失败: {str(e)}"


@app.post("/rename_shadow_folder", description="同步本地拍照记录-和output目录")
async def rename_shadow_folder(params: RenameShadow):
    # 货号数组
    goods_art_nos = params.goods_art_nos
    # for goods_art_no in goods_art_nos:
    # 查询这些货号的所有记录
    goods_art_dict = {}
    for goods in goods_art_nos:
        query = (
            select(PhotoRecord, DeviceConfig.action_name)
            .outerjoin(DeviceConfig, PhotoRecord.action_id == DeviceConfig.id)
            .where(PhotoRecord.goods_art_no.in_(goods_art_nos))
            .where(PhotoRecord.delete_time == None)
            .order_by(PhotoRecord.goods_art_no, asc("id"))  # 按货号分组并按ID倒序
        )
        all_items = session.exec(query).mappings().all()
        if len(all_items) == 0:  # 如果没有记录则返回
            # raise UnicornException("暂无可用货号")
            continue
        goods_art_rename_list = []
        for item in all_items:
            if item["action_name"] == None:
                continue
            data = {"goods_art_no": item.PhotoRecord.goods_art_no, "action_name": item["action_name"],
                    "image_index": item.PhotoRecord.image_index}
            goods_art_rename_list.append(data)
        goods_art_dict[goods] = goods_art_rename_list
    outputDir = settings.OUTPUT_DIR
    if not os.path.exists(outputDir):
        raise UnicornException(f"生成目录[{outputDir}]暂无文件,请拍摄或抠图后处理")
    outputList = os.listdir(outputDir)
    success_result = []
    for firstDir in outputList:
        secondPath = f"{outputDir}\\{firstDir}"
        for goodsArt in goods_art_dict:
            goods_art_no_obj = goods_art_dict[goodsArt]
            goodsArtPath = f"{secondPath}\\{goodsArt}"
            if not os.path.exists(goodsArtPath):
                continue
            renameSrcPath = f"{goodsArtPath}\\阴影图处理"
            renameDstPath = f"{goodsArtPath}\\阴影图处理-重命名"
            if not os.path.exists(renameSrcPath):
                print("阴影图目录不存在...", "不处理")
                continue
            if len(os.listdir(renameSrcPath)) == 0:
                print("阴影图处理目录无内容...", "不处理")
                continue
            if not os.path.exists(renameDstPath):
                try:
                    copy_directory_walk(renameSrcPath, renameDstPath)
                except Exception as e:
                    print("重命名失败", e)
                    continue
            dstPath = os.listdir(renameDstPath)
            for dts_files in dstPath:
                for goods_obj in goods_art_no_obj:
                    goods_art_no_name = goods_obj["goods_art_no"]
                    image_index = goods_obj["image_index"]
                    action_name = goods_obj["action_name"]
                    image_index += 1
                    basic_name = f"{goods_art_no_name}（{image_index}）"
                    if basic_name in dts_files:
                        if "抠图" in dts_files:
                            is_ok, msg = rename_file_safe(f"{renameDstPath}\\{dts_files}",
                                                          f"{renameDstPath}\\{basic_name}_{action_name}_抠图.png")
                            print(is_ok, msg)
                        if "阴影" in dts_files:
                            is_ok, msg = rename_file_safe(f"{renameDstPath}\\{dts_files}",
                                                          f"{renameDstPath}\\{basic_name}_{action_name}_阴影.png")
                            print(is_ok, msg)
                        print("goods_obj", goods_obj)
            success_result.append({"goods_art_no": goodsArt, "path": renameDstPath})
    return {"code": 0, "message": "重命名完成", "data": {"result": success_result}}


@app.get("/minimize_window", description="最小化窗口")
def minimize_window(window_title: str):
    hwnd_list = []
    if window_title == "" or window_title == None:
        window_title = "Smart Shooter"
    window_title = window_title.lower()

    def callback(hwnd, _):
        try:
            title = GetWindowText(hwnd)
            if not title:
                return True
            title = title.lower()
            if window_title in title or title == window_title:
                hwnd_list.append(hwnd)
        except Exception as e:
            print("最小化异常", e)
            pass
        return True

    EnumWindows(callback, None)
    # print("hwnd_list", hwnd_list)
    if hwnd_list:
        for hwnd in hwnd_list:
            win32gui.ShowWindow(hwnd, win32con.SW_MINIMIZE)
        return {"code": 0, "msg": "最小化成功", "data": {"status": True}}
    return {"code": 0, "msg": "最小化失败", "data": {"status": False}}


def _sync_import_images_logic(dir_path: str, goods_art_nos: str = None):
    """
    同步执行的文件遍历和数据库插入逻辑
    :param dir_path: 图片根目录
    :param goods_art_nos: 指定货号。
    """
    if not os.path.exists(dir_path):
        raise UnicornException(f"目录不存在: {dir_path}")

    session = SqlQuery()
    # photo_record_crud = CRUD(PhotoRecord)

    # 支持的图片扩展名
    image_extensions = ('.jpg', '.jpeg', '.png', '.bmp', '.gif', '.webp')

    success_count = 0
    fail_count = 0

    try:
        # ================== 阶段 1: 收集所有待处理的唯一货号 ==================
        goods_art_nos_to_check = set()

        # 用于后续遍历时的映射关系: {root_path: goods_art_no}
        # 避免在第二阶段再次进行复杂的路径解析
        dir_goods_map = {}

        for root, dirs, files in os.walk(dir_path):
            current_goods_art_no = None

            # 如果没有指定全局货号，尝试从相对路径提取货号
            if not current_goods_art_no:
                relative_path = os.path.relpath(root, dir_path)
                parts = relative_path.split(os.sep)

                # 跳过根目录本身，只处理子目录作为货号的情况
                if relative_path == ".":
                    continue

                    # 取第一层目录名作为货号
                current_goods_art_no = parts[0]

            if current_goods_art_no:
                if current_goods_art_no not in goods_art_nos:
                    raise UnicornException(f"可用货号超出权限范围: {root}")
                goods_art_nos_to_check.add(current_goods_art_no)
                # 记录该目录下对应的货号，方便后续直接使用，无需再次计算
                dir_goods_map[root] = current_goods_art_no

        # ================== 阶段 2: 批量查询数据库中已存在的货号 ==================
        existing_goods_nos = set()
        if goods_art_nos_to_check:
            # 使用 in_ 进行批量查询，只获取货号字段即可，减少数据传输
            # 注意：这里假设 PhotoRecord 有 goods_art_no 字段
            statement = select(PhotoRecord.goods_art_no).where(
                and_(
                    PhotoRecord.goods_art_no.in_(list(goods_art_nos_to_check)),
                    PhotoRecord.delete_time == None
                )
            ).distinct()

            db_results = session.exec(statement).all()
            existing_goods_nos = set(db_results)

        # ================== 阶段 3: 预校验，如果有已存在的货号，直接报错 ==================
        if existing_goods_nos:
            # 将集合转换为列表或字符串展示给用户
            existing_list = ", ".join(existing_goods_nos)
            raise UnicornException(f"以下货号在数据库中已存在，请删除后重新导入: [{existing_list}]")

        # ================== 阶段 4: 执行文件遍历和数据插入 ==================
        # 此时可以确定所有待处理的货号都是干净的，无需再在循环中查库

        for root, dirs, files in os.walk(dir_path):
            # 获取当前目录对应的货号
            current_goods_art_no = dir_goods_map.get(root)

            # 如果是根目录且没有指定特定货号，或者映射中找不到（理论上不会发生，因为上面已经过滤），则跳过
            if not current_goods_art_no:
                continue

            for idx, file in enumerate(files):
                if file.lower().endswith(image_extensions):
                    full_path = os.path.join(root, file)

                    try:
                        data_to_insert = {
                            "image_path": full_path,
                            "goods_art_no": current_goods_art_no,
                            "action_id": 0,
                            "image_index": idx,
                            'image_deal_mode': 0,
                            'photo_create_time': datetime.datetime.now(),
                            "create_time": datetime.datetime.now(),
                            "update_time": datetime.datetime.now(),
                        }

                        new_record = PhotoRecord(**data_to_insert)
                        session.add(new_record)
                        success_count += 1

                    except Exception as e:
                        logger.error(f"导入图片失败 {full_path}: {str(e)}")
                        fail_count += 1

        # 提交事务
        session.commit()
        logger.info(f"导入完成: 成功 {success_count}, 失败 {fail_count}")

        return {
            "message": "导入完成",
            "success": success_count,
            "failed": fail_count,
        }

    except UnicornException:
        # 重新抛出自定义异常
        raise
    except Exception as e:
        session.rollback()
        logger.error(f"导入过程发生严重错误: {str(e)}")
        raise e
    finally:
        session.close()


@app.post("/import_dirs")
async def import_images_from_dir(params: ImportDirs):
    """
    遍历指定目录及其子目录，将图片路径导入数据库
    """
    dir_path = params.dir_path
    goods_art_nos = params.goods_art_nos
    # 基本安全检查，防止路径遍历攻击或无效路径
    if not os.path.isdir(dir_path):
        raise UnicornException(f"无效目录: {dir_path}")

    try:
        # 将阻塞的 IO 和 DB 操作放在线程池中执行
        result = _sync_import_images_logic(dir_path, goods_art_nos)
        return {"code": 0, "msg": "操作成功", "data": result}

    except FileNotFoundError as e:
        raise UnicornException(str(e))
    except Exception as e:
        logger.error(f"API 调用异常: {str(e)}")
        raise UnicornException(f"{str(e)}")


def check_goods_art_no_cutout_dir(goods_art_no):
    """
    遍历settings.OUTPUT_DIR子目录，检查货号目录及已抠图目录是否存在且有文件
    :param goods_art_no: 货号
    :return: 存在则返回货号目录地址，不存在或无文件返回None
    """
    if not goods_art_no or not os.path.exists(settings.OUTPUT_DIR):
        return None
    try:
        for date_dir in os.listdir(settings.OUTPUT_DIR):
            date_path = os.path.join(settings.OUTPUT_DIR, date_dir)
            if not os.path.isdir(date_path):
                continue
            goods_art_no_path = os.path.join(date_path, goods_art_no)
            if not os.path.isdir(goods_art_no_path):
                continue
            cutout_path = os.path.join(goods_art_no_path, "原始图_已抠图")
            if not os.path.isdir(cutout_path):
                continue
            if os.listdir(cutout_path):
                return goods_art_no_path
    except Exception as e:
        logger.error(f"检查货号已抠图目录异常: {str(e)}")
    return None


@app.post("/generate_calib")
async def import_images_from_dir(params: CalibRequest):
    goods_art_no = params.goods_art_no
    goods_path = check_goods_art_no_cutout_dir(goods_art_no)
    if not goods_path:
        raise UnicornException("请先对图像进行抠图")
    cutout_path = f"{goods_path}/原始图_已抠图/"
    goods_nobg_fileds = natsorted(os.listdir(cutout_path))
    print("goods_nobg_fileds", goods_nobg_fileds)
    '''生成标定物像素宽高'''
    from service.measure.objmark_api import Calibrator
    calib = Calibrator(
        topdown_png=cutout_path + goods_nobg_fileds[2],
        topdown_known_length_mm=params.topdown_known_length_mm,
        side_png=cutout_path + goods_nobg_fileds[0],
        side_known_height_mm=params.side_known_height_mm,
        front_png=cutout_path + goods_nobg_fileds[1],  # 可选，单独标定宽度方向kw
        front_known_width_mm=params.front_known_width_mm,
    ).calibrate()
    return {"code": 0, "msg": "操作成功", "data": calib}


@app.post("/measurer_object")
async def import_images_from_dir(params: MeasurerRequest):
    '''生成标定物像素宽高'''
    from service.measure.objmark_api import ShoeMeasurer
    goods_art_no = params.goods_art_no
    goods_path = check_goods_art_no_cutout_dir(goods_art_no)
    if not goods_path:
        raise UnicornException("请先对图像进行抠图")
    cutout_path = f"{goods_path}/原始图_已抠图/"
    goods_nobg_fileds = natsorted(os.listdir(cutout_path))
    result = ShoeMeasurer(
        topdown_png=cutout_path + goods_nobg_fileds[2],
        side_png=cutout_path + goods_nobg_fileds[0],
        front_png=cutout_path + goods_nobg_fileds[1],  # 可选，单独标定宽度方向kw
        calib=params.calib,
        debug=False,  # 保存 result_*.jpg 标注图
    ).measure()
    result["goods_path"] = goods_path
    return {"code": 0, "msg": "操作成功", "data": result}


OPEN_API_BASE_URL = "https://zjai.pubdata.cn/api/v1/open"
OPEN_API_APP_KEY = "ak_5e8b417bbeb581ad"
OPEN_API_APP_SECRET = "P3gxaIINUhXRrF4bND5EUwpH"


def _get_open_api_headers():
    return {
        "X-App-Key": OPEN_API_APP_KEY,
        "X-App-Secret": OPEN_API_APP_SECRET,
    }


@app.get("/open_api/companies", description="企业列表")
async def get_open_api_companies(
        q: str = "",
        page: int = 1,
        page_size: int = 100,
):
    """查询开放平台企业列表"""
    try:
        params = {"page": page, "page_size": page_size}
        if q:
            params["q"] = q
        resp = requests.get(
            f"{OPEN_API_BASE_URL}/companies",
            headers=_get_open_api_headers(),
            params=params,
            timeout=15,
        )
        return resp.json()
    except Exception as e:
        raise UnicornException(f"请求企业列表接口失败: {str(e)}")


@app.post("/open_api/upload_item", description="拍照机商品资料上传")
async def upload_item_to_open_api(params: OpenApiUploadItem):
    """将货号800x800目录下已抠图图片上传到开放平台商品档案"""
    goods_art_no = params.goods_art_no
    company_id = params.company_id
    item_type = params.item_type
    if not goods_art_no:
        raise UnicornException("货号不能为空")
    if not company_id:
        raise UnicornException("企业ID不能为空")
    if item_type not in (1, 2):
        raise UnicornException("上传类型item_type必须为1(商品)或2(材料)")

    goods_path = check_goods_art_no_cutout_dir(goods_art_no)
    if not goods_path:
        raise UnicornException("请先对图像进行抠图")

    cutout_dir = os.path.join(goods_path, "800x800")
    if not os.path.isdir(cutout_dir):
        raise UnicornException("800x800抠图目录不存在")

    image_files = natsorted([
        f for f in os.listdir(cutout_dir)
        if os.path.isfile(os.path.join(cutout_dir, f))
    ])
    if not image_files:
        raise UnicornException("800x800目录下无图片文件")

    create_date = time.strftime("%Y-%m-%d")
    upload_results = []

    try:
        for image_name in image_files:
            image_path = os.path.join(cutout_dir, image_name)
            file_ext = os.path.splitext(image_name)[1].lower()
            content_type_map = {
                ".jpg": "image/jpeg",
                ".jpeg": "image/jpeg",
                ".png": "image/png",
                ".gif": "image/gif",
                ".webp": "image/webp",
                ".bmp": "image/bmp",
            }
            content_type = content_type_map.get(file_ext, "image/jpeg")
            image_type = os.path.splitext(image_name)[0]

            with open(image_path, "rb") as f:
                files = [
                    ("File", (image_name, f, content_type)),
                ]
                data = {
                    "Key": goods_art_no,
                    "ImageType": image_type,
                    "CreateDate": create_date,
                    "CompanyId": company_id,
                    "ItemType": item_type,
                }
                resp = requests.post(
                    f"{OPEN_API_BASE_URL}/camera/items",
                    headers=_get_open_api_headers(),
                    data=data,
                    files=files,
                    timeout=30,
                )
                result = resp.json()
                upload_results.append({
                    "image": image_name,
                    "status_code": resp.status_code,
                    "result": result,
                })

        success_count = sum(1 for r in upload_results if r.get("result", {}).get("code") == "OK")
        return {
            "code": 0,
            "msg": f"上传完成，成功{success_count}/{len(upload_results)}",
            "data": {
                "total": len(upload_results),
                "success": success_count,
                "details": upload_results,
            },
        }
    except requests.RequestException as e:
        raise UnicornException(f"请求开放平台接口失败: {str(e)}")
    except Exception as e:
        raise UnicornException(f"上传异常: {str(e)}")


async def cutOutImage(original_image_path):
    from service.remove_bg_ali import RemoveUltraBackground
    try:
        remove_pic_ins = RemoveUltraBackground()
        im_pillow = remove_pic_ins.ultra_segment_fast_pil(
            file_path=original_image_path,
        )
    except Exception as e:
        print("抠图异常", e)
        raise UnicornException("抠图异常")
    return im_pillow


def uploadImageIM(im) -> str:
    img_byte_io = BytesIO()
    # 根据图片模式选择保存格式
    if im.mode == 'RGBA':
        im.save(img_byte_io, format='PNG')
    else:
        im.save(img_byte_io, format='JPEG')
    img_byte_io.seek(0)  # 重置指针到开头

    post_headers = {"Authorization": settings.USER_TOKEN}
    url = settings.DOMAIN + "/api/upload"

    # 使用字节流上传
    resultData = requests.post(
        url,
        files={"file": ("image.jpg", img_byte_io, "image/jpeg")},
        headers=post_headers
    ).json()

    return resultData["data"]["url"]


@app.post("/shoes_compose", description="拍照机商品资料上传")
async def shoeCompose(params: ShoesComposes):
    from service.shoe_main_image_compose import compose_shoe_main_image  # noqa: E402
    # settings.USER_TOKEN = "60db012c9dd228dd0b08bea6e6fc915d1b495d8f"
    # token = "Bearer " + settings.USER_TOKEN
    tpl = "resources/detail_temp/scene/tpl_1.png"  # 图2：底图模板
    postData = []
    for itemIdx, item in enumerate(params.data):
        print("item", item)
        main_image_path = item.image_path
        reference_image = item.reference_image
        logo = item.logo
        params.data[itemIdx].logo = logo
        main_image_pil = await cutOutImage(main_image_path)
        main_image_url = uploadImageIM(main_image_pil) + "?x-oss-process=image/format,jpg"
        params.data[itemIdx].image_path = main_image_pil
        for img in item.images:
            sub_image_path = img.get("image_path")
            img['image_path'] = await cutOutImage(sub_image_path)
        # print("item dict", item.__dict__)
        result_url = compose_shoe_main_image(template=tpl,
                                             data=item.__dict__,
                                             label_pos="bottom-right",
                                             shoe_scale=0.9,
                                             font_path="resources/ttl/MiSans-Light.ttf",
                                             upload=True,
                                             info_bottom_margin=20,
                                             label_font_size=30,
                                             info_bar_height=40,
                                             info_font_size=34,
                                             label_offset=(0, 0)
                                             )
        postData.append({"base_image": main_image_url, "reference_image": reference_image, 'past_image': result_url})
    headers = {
        "Authorization": f"Bearer {settings.USER_TOKEN}",
        "Content-Type": "application/json",
    }

    response = requests.request(
        "POST",
        f"{settings.DOMAIN}/api/ai_image/main/auto_photo_scene_images_zj",
        headers=headers,
        json={"data": postData},
    )
    print("response", response.content)
    responseData = response.json()
    return {"code": 0, "msg": "操作成功", "data": responseData.get("data", None)}