后端优化，增加新需求

# Conflicts:
#	app/web_source/admin.html
#	app/web_source/brand-旧.html
#	app/web_source/home.html
#	app/web_source/index.html
#	app/web_source/login.html
#	backend/web_source/login.html
#	web_source/templates_backup/login.html

.gitignore

@@ -1,41 +1,112 @@
-# frontend-vue dependencies
+# ===== frontend-vue =====
 frontend-vue/node_modules/
-
-# frontend-vue build output
 frontend-vue/dist/
 frontend-vue/new_web_source
-
-# generated type declarations
 frontend-vue/auto-imports.d.ts
 frontend-vue/components.d.ts
-
-# logs
 frontend-vue/npm-debug.log*
 frontend-vue/yarn-debug.log*
 frontend-vue/yarn-error.log*
 frontend-vue/pnpm-debug.log*
 
-# backend-java build output
+# ===== backend-java =====
 backend-java/target/
-
-# backend-java runtime data
 backend-java/data/
 backend-java/*.log
 backend-java/logs/
-
-# backend-java local config
 backend-java/src/main/resources/application-local.yml
-
-# backend-java IDE files
 backend-java/.idea/
 backend-java/*.iml
 
-# desktop app
+# ===== backend / app =====
+__pycache__/
+backend/tmp/
+backend/__pycache__
+app/__pycache__
+app/new_web_source
+app/user_data/
+
+# ===== logs =====
+logs/
+aiimage-backend.log*
+
+# ===== Python =====
+__pycache__/
+**/__pycache__/
+*.py[cod]
+*$py.class
+*.pyo
+.Python
+*.egg-info/
+*.egg
+MANIFEST
+.installed.cfg
+
+# Build / packaging
+app.zip
+build/
+dist/
+develop-eggs/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+
+# Virtual environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+.python-version
+
+# Testing
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+htmlcov/
+
+# Type checking
+.mypy_cache/
+.dmypy.json
+dmypy.json
+.pyre/
+.pytype/
+
+# Jupyter
+.ipynb_checkpoints
+*.ipynb_checkpoints/
+profile_default/
+ipython_config.py
+
+# ===== Database =====
+*.db
+*.sqlite3
+
+# ===== Misc =====
 desktop/
 ERP-Demo/
 xlsx/
-app/__pycache__
+.omx/
-backend/__pycache__
+.codex
-app/assets/
+.rtk
-app/new_web_source
+OPS_REDIS_MYSQL_OPTIMIZATION_NOTES.md
-app/user_data/
+架构.md
+*ts.%
+.omc

app/.env

@@ -1,15 +0,0 @@
-base_url=http://8.136.19.173:15124
-workflow_id=7608812635877900322
-mysql_host=8.136.19.173
-mysql_user=aiimage
-
-proxy_url=https://api.jikip.com/ip-get?num=1&minute=1&format=json&area=all&protocol=1&mode=2&key=t24g6gi44ubufd8
-proxy_mode=2
-
-client_name=ShuFuAI
-
-
-java_api_base=http://127.0.0.1:18080
-# java_api_base=http://8.136.19.173:18080
-
-

app/ali_oss.py

@@ -1,73 +0,0 @@
-import argparse
-import base64
-import re
-import time
-import alibabacloud_oss_v2 as oss
-import requests
-
-from config import region, endpoint, bucket, file_url_pre, bucket_path
-
-
-def upload_file(file_content: bytes, key: str):
-    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()
-    cfg = oss.config.load_default()
-    cfg.credentials_provider = credentials_provider
-    cfg.region = region
-    cfg.endpoint = endpoint
-    cfg.retry_max_attempts = 3
-    client = oss.Client(cfg)
-
-    result = client.put_object(
-        oss.PutObjectRequest(
-            bucket=bucket,  # 存储空间名称
-            key=key,        # 对象名称
-            body=file_content    # 读取文件内容
-        )
-    )
-    # print(result)
-    return file_url_pre + key
-
-
-def upload_data_url(data_url: str, prefix: str = "history", key_hint: str = "") -> str:
-    """
-    将 base64 data URL 上传到 OSS，返回图片链接
-    data_url: data:image/png;base64,xxxx 或 data:image/jpeg;base64,xxxx
-    prefix: OSS key 前缀
-    key_hint: 可选后缀避免重名，如 "_0", "_1"
-    """
-    match = re.match(r'data:image/(\w+);base64,(.+)', data_url)
-    if not match:
-        raise ValueError('无效的 data URL 格式')
-    ext = 'png' if match.group(1).lower() in ('png', 'webp') else 'jpg'
-    file_content = base64.b64decode(match.group(2))
-    ts = int(time.time() * 1000)
-    key = f"{bucket_path}{prefix}/{ts}{key_hint}.{ext}"
-    return upload_file(file_content, key)
-
-
-def upload_data_urls(data_urls: list, prefix: str = "history") -> list:
-    """批量上传 base64 图片到 OSS，返回图片链接列表"""
-    urls = []
-    ts = int(time.time() * 1000)
-    for i, data_url in enumerate(data_urls or []):
-        if not data_url or not isinstance(data_url, str):
-            continue
-        if not data_url.startswith("http"):
-            match = re.match(r'data:image/(\w+);base64,(.+)', data_url)
-            if not match:
-                continue
-            ext = 'png' if match.group(1).lower() in ('png', 'webp') else 'jpg'
-            file_content = base64.b64decode(match.group(2))
-        else:
-            file_content = requests.get(data_url).content
-            ext = "png"
-        key = f"{bucket_path}{prefix}/{ts}_{i}.{ext}"
-        urls.append(upload_file(file_content, key))
-    return urls
-
-
-# 脚本入口，当文件被直接运行时调用main函数
-if __name__ == "__main__":
-    with open("测试图片数据/IMG_2685.JPG", "rb") as f:
-        file_content = f.read()
-    upload_file(file_content,key=bucket_path+"test.png")

app/amazon/del_brand.py

@@ -1,519 +0,0 @@
-import traceback
-import winreg
-import subprocess
-import time
-import uuid
-import requests
-import json
-import os
-
-from typing import Literal
-from DrissionPage import Chromium
-from DrissionPage.common import By
-
-
-def kill_process(version: Literal["v5", "v6"]):
-    """杀紫鸟客户端进程（独立函数版本）"""
-    driver = ZiniaoDriver({})
-    driver.kill_process(version)
-
-
-class ZiniaoDriver:
-    """紫鸟浏览器自动化驱动类"""
-
-    def __init__(self, user_info: dict, socket_port: int = 19890):
-        """
-        初始化紫鸟浏览器驱动
-
-        Args:
-            user_info: 用户信息字典，包含 company, username, password
-            socket_port: 客户端通信端口，默认 19890
-        """
-        self.user_info = user_info
-        self.socket_port = socket_port
-        self.client_path = None
-        self.browser = None
-        self.tab = None
-        self.store_id = None
-
-    def get_zinaio_exe(self, protocol_name: str = "superbrowser"):
-        """
-        获取紫鸟安装目录
-
-        Args:
-            protocol_name: 协议名称，默认 "superbrowser"
-
-        Returns:
-            exe_path: 紫鸟浏览器可执行文件路径
-        """
-        try:
-            key_path = rf"SOFTWARE\Classes\{protocol_name}\shell\open\command"
-            key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, key_path)
-            command, _ = winreg.QueryValueEx(key, "")
-            winreg.CloseKey(key)
-            if isinstance(command, str):
-                exe_path = command.split()[0]
-            else:
-                exe_path = command[0]
-            return exe_path
-        except FileNotFoundError:
-            try:
-                key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, key_path)
-                command, _ = winreg.QueryValueEx(key, "")
-                winreg.CloseKey(key)
-                if isinstance(command, str):
-                    exe_path = command.split()[0]
-                else:
-                    exe_path = command[0]
-                return exe_path
-            except FileNotFoundError:
-                return None
-
-    def update_core(self):
-        """
-        下载所有内核，打开店铺前调用，需客户端版本5.285.7以上
-        因为http有超时时间，所以这个action适合循环调用，直到返回成功
-        """
-        data = {
-            "action": "updateCore",
-            "requestId": str(uuid.uuid4()),
-        }
-        data.update(self.user_info)
-        while True:
-            url = f'http://127.0.0.1:{self.socket_port}'
-            response = requests.post(url, json.dumps(data).encode('utf-8'), timeout=120)
-            result = response.json()
-            print(result)
-            if result is None:
-                print("等待客户端启动...")
-                time.sleep(2)
-                continue
-            if result.get("statusCode") is None or result.get("statusCode") == -10003:
-                print("当前版本不支持此接口，请升级客户端")
-                return
-            elif result.get("statusCode") == 0:
-                print("更新内核完成")
-                return
-            else:
-                print(f"等待更新内核: {json.dumps(result)}")
-                time.sleep(2)
-
-    def kill_process(self, version: Literal["v5", "v6"]):
-        """
-        杀紫鸟客户端进程
-
-        Args:
-            version: 客户端版本
-        """
-        if version == "v5":
-            process_name = 'SuperBrowser.exe'
-        else:
-            process_name = 'ziniao.exe'
-        os.system('taskkill /f /t /im ' + process_name)
-        time.sleep(3)
-
-    def get_browser_list(self) -> list:
-        """
-        获取浏览器列表
-
-        Returns:
-            list: 浏览器列表
-        """
-        request_id = str(uuid.uuid4())
-        data = {
-            "action": "getBrowserList",
-            "requestId": request_id
-        }
-        data.update(self.user_info)
-
-        url = f'http://127.0.0.1:{self.socket_port}'
-        response = requests.post(url, json.dumps(data).encode('utf-8'), timeout=120)
-        r = response.json()
-        if str(r.get("statusCode")) == "0":
-            print(r)
-            return r.get("browserList")
-        elif str(r.get("statusCode")) == "-10003":
-            print(f"login Err {json.dumps(r, ensure_ascii=False)}")
-            exit()
-        else:
-            print(f"Fail {json.dumps(r, ensure_ascii=False)} ")
-            exit()
-
-    def open_store(self, store_info, isWebDriverReadOnlyMode=0, isprivacy=0,
-                   isHeadless=0, cookieTypeSave=0, jsInfo=""):
-        """
-        打开店铺
-
-        Args:
-            store_info: 店铺信息（browserId 或 browserOauth）
-            isWebDriverReadOnlyMode: 是否只读模式，默认 0
-            isprivacy: 隐私模式，默认 0
-            isHeadless: 无头模式，默认 0
-            cookieTypeSave: cookie保存类型，默认 0
-            jsInfo: 注入的JS信息，默认 ""
-
-        Returns:
-            dict: 返回结果
-        """
-        request_id = str(uuid.uuid4())
-        data = {
-            "action": "startBrowser",
-            "isWaitPluginUpdate": 0,
-            "isHeadless": isHeadless,
-            "requestId": request_id,
-            "isWebDriverReadOnlyMode": isWebDriverReadOnlyMode,
-            "cookieTypeLoad": 0,
-            "cookieTypeSave": cookieTypeSave,
-            "runMode": "1",
-            "isLoadUserPlugin": False,
-            "pluginIdType": 1,
-            "privacyMode": isprivacy
-        }
-        data.update(self.user_info)
-
-        if store_info.isdigit():
-            data["browserId"] = store_info
-        else:
-            data["browserOauth"] = store_info
-
-        if len(str(jsInfo)) > 2:
-            data["injectJsInfo"] = json.dumps(jsInfo)
-
-        url = f'http://127.0.0.1:{self.socket_port}'
-        response = requests.post(url, json.dumps(data).encode('utf-8'), timeout=120)
-        r = response.json()
-        if str(r.get("statusCode")) == "0":
-            return r
-        elif str(r.get("statusCode")) == "-10003":
-            print(f"login Err {json.dumps(r, ensure_ascii=False)}")
-            exit()
-        else:
-            print(f"Fail {json.dumps(r, ensure_ascii=False)} ")
-            exit()
-
-    def get_browser(self, port) -> Chromium:
-        """
-        获取浏览器实例
-
-        Args:
-            port: 调试端口
-
-        Returns:
-            Chromium: DrissionPage浏览器实例
-        """
-        browser = Chromium(port)
-        return browser
-
-    def start_client(self):
-        """启动紫鸟客户端"""
-        self.client_path = self.get_zinaio_exe("superbrowser").strip('"')
-        print(self.client_path)
-        cmd = [self.client_path, '--run_type=web_driver', '--ipc_type=http',
-               '--port=' + str(self.socket_port)]
-        print(" ".join(cmd))
-        subprocess.Popen(cmd)
-        time.sleep(5)
-
-    def open_shop(self, shop_name: str):
-        """
-        打开指定店铺
-
-        Args:
-            shop_name: 店铺名称
-
-        Returns:
-            Chromium or str: 成功返回浏览器实例，失败返回错误信息
-        """
-        # 启动客户端
-        self.start_client()
-
-        # 更新内核
-        self.update_core()
-
-        # 获取店铺列表
-        shop_ls = self.get_browser_list()
-        self.store_id = None
-        # print(shop_ls)
-        for shop in shop_ls:
-            if shop.get("browserName") == shop_name:
-                self.store_id = shop.get('browserOauth')
-                break
-
-        if not self.store_id:
-            print("店铺不存在")
-            return "店铺不存在"
-
-        # 打开店铺
-        ret_json = self.open_store(self.store_id)
-        print(ret_json)
-        self.store_id = ret_json.get("browserOauth")
-        if self.store_id is None:
-            self.store_id = ret_json.get("browserId")
-
-        # 获取drissionpage浏览器会话
-        self.browser = self.get_browser(ret_json.get('debuggingPort'))
-
-        ip_check_url = ret_json.get("ipDetectionPage")
-        if not ip_check_url:
-            print("ip检测页地址为空，请升级紫鸟浏览器到最新版")
-            print(f"=====关闭店铺：{shop_name}=====")
-            self.close_store(self.store_id)
-            exit()
-        ip_usable = self.open_ip_check(self.browser, ip_check_url)
-        if ip_usable:
-            print("ip检测通过，打开店铺平台主页")
-            self.open_launcher_page(ret_json.get("launcherPage"), self.browser)
-        else:
-            print("IP检测不通过")
-        return self.browser
-
-    def close_store(self, browser_oauth=None):
-        """
-        关闭店铺
-
-        Args:
-            browser_oauth: 店铺OAuth标识，如果不提供则使用当前打开的店铺
-
-        Returns:
-            dict: 返回结果
-        """
-        if browser_oauth is None:
-            browser_oauth = self.store_id
-
-        request_id = str(uuid.uuid4())
-        data = {
-            "action": "stopBrowser",
-            "requestId": request_id,
-            "duplicate": 0,
-            "browserOauth": browser_oauth
-        }
-        data.update(self.user_info)
-
-        url = f'http://127.0.0.1:{self.socket_port}'
-        response = requests.post(url, json.dumps(data).encode('utf-8'), timeout=120)
-        r = response.json()
-        if str(r.get("statusCode")) == "0":
-            return r
-        elif str(r.get("statusCode")) == "-10003":
-            print(f"login Err {json.dumps(r, ensure_ascii=False)}")
-            exit()
-        else:
-            print(f"Fail {json.dumps(r, ensure_ascii=False)} ")
-            exit()
-
-    def open_launcher_page(self, launcher_page: str, browser: Chromium = None):
-        """
-        打开启动页面
-
-        Args:
-            launcher_page: 要打开的页面URL
-            browser: 浏览器实例，如果不提供则使用当前浏览器实例
-        """
-        if browser is None:
-            browser = self.browser
-
-        tab = browser.new_tab(url=launcher_page)
-        self.tab = tab
-        return tab
-
-    def open_ip_check(self, browser: Chromium, ip_check_url: str):
-        """
-        打开ip检测页检测ip是否正常
-        :param browser: drissionpage浏览器会话
-        :param ip_check_url ip检测页地址
-        :return 检测结果
-        """
-        try:
-            tab = browser.latest_tab
-            tab.get(ip_check_url)
-            success_button = tab.ele((By.XPATH, '//button[contains(@class, "styles_btn--success")]'),
-                                     timeout=60)  # 等待查找元素60秒
-            if success_button:
-                print("ip检测成功")
-                return True
-            else:
-                print("ip检测超时")
-                return False
-        except Exception as e:
-            print("ip检测异常:" + traceback.format_exc())
-            return False
-
-
-class AmazoneDriver(ZiniaoDriver):
-    """亚马逊专用驱动类，继承自ZiniaoDriver"""
-
-    def SwitchingCountries(self, country_name: str):
-        """
-        切换国家
-        操作：
-        1、//div[@class="dropdown-account-switcher-header-label"]/span[last()] 获取此元素文本，判断当前国家，如果与目标国家相同则不操作，否则执行下一步
-        2、点击 //div[@class="dropdown-account-switcher-header-label"] 打开下拉框
-        3、点击 //div[@class="dropdown-account-switcher-list-item"] 第一个展开国家列表
-        4、点击 //div[@class="dropdown-account-switcher-list-item dropdown-account-switcher-list-item-indented" and @title="国家名"] 切换到目标国家
-        5、等待页面加载完成，判断国家是否切换成功，成功则返回True，否则返回False
-
-        Args:
-            country_name: 目标国家名称
-
-        Returns:
-            bool: 切换成功返回True，失败返回False
-        """
-        try:
-            if self.browser is None:
-                print("浏览器实例不存在，请先打开店铺")
-                return False
-
-            # 获取当前标签页
-            tab = self.tab
-
-            # 步骤1：获取当前国家名称
-            print(f"正在检查当前国家...")
-            current_country_ele = tab.ele('xpath://div[@class="dropdown-account-switcher-header-label"]/span[last()]',
-                                          timeout=10)
-            if current_country_ele:
-                current_country = current_country_ele.text.strip()
-                print(f"当前国家：{current_country}")
-
-                # 判断是否与目标国家相同
-                if current_country == country_name:
-                    print(f"当前已经是目标国家 {country_name}，无需切换")
-                    return True
-            else:
-                print("无法获取当前国家信息")
-                return False
-
-            # 步骤2：点击打开下拉框
-            print(f"正在打开国家切换下拉框...")
-            dropdown_header = tab.ele('xpath://div[@class="dropdown-account-switcher-header-label"]', timeout=10)
-            if not dropdown_header:
-                print("找不到国家切换下拉框")
-                return False
-            dropdown_header.click()
-            time.sleep(1)  # 等待下拉框展开
-
-            # 步骤3：点击第一个展开国家列表
-            print(f"正在展开国家列表...")
-            first_item = tab.ele('xpath://div[@class="dropdown-account-switcher-list-item"]', timeout=10)
-            if not first_item:
-                print("找不到国家列表项")
-                return False
-            first_item.click()
-            time.sleep(1)  # 等待国家列表展开
-
-            # 步骤4：点击目标国家
-            print(f"正在切换到国家：{country_name}")
-            target_country_xpath = f'//div[@class="dropdown-account-switcher-list-item dropdown-account-switcher-list-item-indented" and @title="{country_name}"]'
-            target_country = tab.ele(f'xpath:{target_country_xpath}', timeout=10)
-            if not target_country:
-                print(f"找不到目标国家：{country_name}")
-                return False
-            target_country.click()
-
-            # 步骤5：等待页面加载完成并验证切换结果
-            print(f"等待页面加载...")
-            # time.sleep(3)  # 等待页面加载
-            self.tab.wait.doc_loaded()
-
-            # 再次检查当前国家
-            new_country_ele = tab.ele('xpath://div[@class="dropdown-account-switcher-header-label"]/span[last()]',
-                                      timeout=10)
-            if new_country_ele:
-                new_country = new_country_ele.text.strip()
-                if new_country == country_name:
-                    print(f"国家切换成功：{new_country}")
-                    return True
-                else:
-                    print(f"国家切换失败，当前国家：{new_country}，目标国家：{country_name}")
-                    return False
-            else:
-                print("无法验证切换结果")
-                return False
-
-        except Exception as e:
-            print(f"切换国家时发生异常：{traceback.format_exc()}")
-            return False
-
-    def SwitchPage(self):
-        """
-        切换至 管理所有库存页面
-        1、等待 //navigation-favorites-bar[@class="hydrated"] 出现
-        """
-        navigation = self.tab.ele('xpath://navigation-favorites-bar[@class="hydrated"]')
-        navigation.wait.displayed(raise_err=False)
-        page_btn = navigation.sr('xpath://internal-fav-bar-links[@data-internal="navigation"]').sr(
-            'xpath://a[@data-page-id="ezdpc-gui-inventory-mons"]')
-        page_btn.wait.displayed(raise_err=False)
-        page_btn.click(timeout=5)
-
-        self.tab.wait.doc_loaded()
-        # 等待搜索框出现
-        search_region = self.tab.ele('xpath://div[@id="searchBoxContainer"]//kat-input-group')
-        search_region.wait.displayed(raise_err=False)
-
-    def search(self, asin):
-        search_region = self.tab.ele('xpath://div[@id="searchBoxContainer"]//kat-input-group')
-        search_region.wait.displayed(raise_err=False)
-        time.sleep(0.6)
-        search_input = self.tab.ele("xpath://kat-input[contains(@class,'SearchBox-module__searchInput')]").sr(
-            'xpath://span[@class="container"]//input[@part="input"]')
-        search_input.input(asin)
-
-        for _ in range(3):
-            search_btn = self.tab.ele("xpath://kat-icon[@name='search']")
-            search_btn.click()
-
-            load_ele = self.tab.ele("xpath://div[contains(@class,'Loader-module__loader')]")
-            load_ele.wait.hidden(timeout=20)
-            time.sleep(1)
-        sku_ls = self.tab.eles("//div[@data-sku]")
-        return sku_ls
-
-    def del_action(self, sku_ele):
-        dropdown = sku_ele.ele('xpath:.//kat-dropdown-button[@variant="secondary"]')
-        dropdown.click()
-        time.sleep(1)
-
-        del_btn = dropdown.ele("xpath:.//button[@role='menuitem' and text()='删除商品信息']")
-        del_btn.wait.displayed(raise_err=False)
-        del_btn.click()
-
-        confirm_btn = self.tab.ele('xpath://kat-modal[@data-testid="action-modal"]//kat-button[@variant="primary"]')
-        confirm_btn.wait.displayed(raise_err=False)
-        confirm_btn.wait.enabled()
-        confirm_btn.click()
-
-        suc_alert = self.tab.ele("xpath://kat-alert[@variant='success']")
-        suc = suc_alert.wait.displayed(raise_err=False, timeout=5)
-        return suc
-
-
-if __name__ == '__main__':
-    # 使用示例
-    user_info = {
-        "company": "rongchuang123",
-        "username": "自动化_Robot",
-        "password": "#20zsg25"
-    }
-    shop_name = "郭亚芳"
-    kill_process("v6")
-
-    # 创建驱动实例
-    driver = AmazoneDriver(user_info)
-
-    # 打开店铺并获取浏览器实例
-    browser = driver.open_shop(shop_name)
-
-    country = "西班牙"
-    asin = "Voanos"
-
-    sw_suc = driver.SwitchingCountries(country)
-    driver.SwitchPage()
-    sku_ls = driver.search(asin=asin)
-    print("查询结果有：", len(sku_ls))
-
-    for sku in sku_ls:
-        suc = driver.del_action(sku)
-        print(sku, "删除结果", suc)
-
-
-

app/amazon/main.py

@@ -1,421 +0,0 @@
-import time
-import traceback
-import requests
-from datetime import datetime
-from typing import Dict, Any, List
-from config import JSON_TASK_QUEUE, runing_task, runing_shop, DELETE_BRAND_API_BASE, ZN_COMPANY, ZN_USERNAME, ZN_PASSWORD
-from amazon.del_brand import AmazoneDriver, kill_process
-
-
-class TaskMonitor:
-    """任务监控器：负责监控队列并执行品牌删除任务"""
-    
-    def __init__(self):
-        """初始化任务监控器"""
-        self.running = True
-        self.user_info = {
-            "company": ZN_COMPANY,
-            "username": ZN_USERNAME,
-            "password": ZN_PASSWORD
-        }
-        
-        self.chunk_index = 1  # 当前处理的分块索引
-
-    def log(self, message: str, level: str = "INFO"):
-        """日志输出
-        
-        Args:
-            message: 日志消息
-            level: 日志级别
-        """
-        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        print(f"[{timestamp}] [{level}] {message}")
-        
-    def start(self):
-        """启动任务监控（阻塞式循环）"""
-        self.log("任务监控器启动，开始监听队列...")
-        
-        while self.running:
-            try:
-                # 阻塞式获取任务，避免CPU空转
-                task_data = JSON_TASK_QUEUE.get(block=True, timeout=1)
-                
-                # 检查任务类型
-                task_type = task_data.get("type", "")
-                if task_type != "delete-brand-run":
-                    self.log(f"未知任务类型: {task_type}，跳过", "WARNING")
-                    continue
-                
-                # 处理任务
-                self.log(f"接收到删除品牌任务，开始处理...")
-                self.process_task(task_data)
-                
-            except Exception as e:
-                if "Empty" not in str(e):  # 忽略队列为空的超时异常
-                    self.log(f"任务处理异常: {traceback.format_exc()}", "ERROR")
-                time.sleep(0.1)  # 短暂等待避免异常循环
-                
-    def process_task(self, task_data: Dict[str, Any]):
-        """处理单个任务
-        
-        Args:
-            task_data: 任务数据
-        """
-        try:
-            data = task_data.get("data", {})
-            task_id = data.get("taskId")
-            items = data.get("items", [])
-            
-            if not task_id:
-                self.log("任务ID为空，跳过", "WARNING")
-                return
-                
-            # 初始化任务状态
-            self.update_task_status(
-                task_id,
-                status="running",
-                start_time=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                total_shops=len(items),
-                processed_shops=0,
-                total_asins=sum(shop.get("totalRows", 0) for shop in items),
-                processed_asins=0,
-                success_count=0,
-                failed_count=0,
-                stop_requested=False  # 暂停请求标志
-            )
-            
-            self.log(f"开始处理任务 {task_id}，共 {len(items)} 个店铺")
-            
-            # 遍历处理每个店铺
-            for idx, shop_data in enumerate(items, 1):
-                shop_name = shop_data.get("shopName", "未知店铺")
-                self.log(f"[{idx}/{len(items)}] 开始处理店铺: {shop_name}")
-                
-                try:
-                    self.process_shop(shop_data, task_id)
-                    # 更新已处理店铺数
-                    if task_id in runing_task:
-                        runing_task[task_id]["processed_shops"] += 1
-                except Exception as e:
-                    self.log(f"处理店铺 {shop_name} 失败: {str(e)}", "ERROR")
-                    self.log(traceback.format_exc(), "ERROR")
-                    
-            # 检查任务最终状态
-            if task_id in runing_task and runing_task[task_id].get("stop_requested", False):
-                self.update_task_status(task_id, status="stopped")
-                self.log(f"任务 {task_id} 已被暂停！")
-            else:
-                self.update_task_status(task_id, status="completed")
-                self.log(f"任务 {task_id} 处理完成！")
-            
-        except Exception as e:
-            self.log(f"任务处理失败: {traceback.format_exc()}", "ERROR")
-            if task_id:
-                self.update_task_status(task_id, status="failed", error=str(e))
-                
-    def process_shop(self, shop_data: Dict[str, Any], task_id: int):
-        """处理单个店铺（包含重试逻辑）
-        
-        Args:
-            shop_data: 店铺数据
-            task_id: 任务ID
-        """
-        shop_name = shop_data.get("shopName", "未知店铺")
-        result_id = shop_data.get("resultId")
-        countries = shop_data.get("countries", [])
-        
-        if not countries:
-            self.log(f"店铺 {shop_name} 没有国家数据，跳过", "WARNING")
-            return
-            
-        # 更新当前处理的店铺
-        self.update_task_status(task_id, current_shop=shop_name)
-        
-        # 将店铺添加到正在执行中的店铺列表
-        start_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        runing_shop[shop_name] = start_time
-        self.log(f"店铺 {shop_name} 已添加到执行列表，开始时间: {start_time}")
-        
-        # 店铺打开重试最多3次
-        driver = None
-        browser = None
-        max_retries = 3
-        
-        for retry in range(max_retries):
-            try:
-                self.log(f"尝试打开店铺 {shop_name} (第 {retry + 1}/{max_retries} 次)")
-                
-                # 如果不是第一次尝试，先杀进程
-                if retry > 0:
-                    self.log("重试前先杀掉浏览器进程...")
-                    kill_process("v6")
-                    time.sleep(2)
-                
-                # 创建驱动并打开店铺
-                driver = AmazoneDriver(self.user_info)
-                browser = driver.open_shop(shop_name)
-                
-                if browser and browser != "店铺不存在":
-                    self.log(f"成功打开店铺 {shop_name}")
-                    break
-                else:
-                    self.log(f"打开店铺失败: {browser}", "WARNING")
-                    driver = None
-                    
-            except Exception as e:
-                self.log(f"打开店铺异常: {str(e)}", "ERROR")
-                driver = None
-                
-            # 如果还有重试机会，等待后继续
-            if retry < max_retries - 1:
-                time.sleep(3)
-                
-        # 检查是否成功打开
-        if not driver or not browser or browser == "店铺不存在":
-            self.log(f"店铺 {shop_name} 打开失败，已重试 {max_retries} 次，跳过该店铺", "ERROR")
-            return
-            
-        try:
-            # 处理每个国家
-            for country_data in countries:
-                # 检查是否收到暂停请求
-                if task_id in runing_task and runing_task[task_id].get("stop_requested", False):
-                    self.log(f"检测到任务 {task_id} 的暂停请求，停止处理国家", "WARNING")
-                    break  # 跳出循环，进入finally关闭店铺
-                
-                try:
-                    self.process_country(driver, country_data, task_id, result_id, shop_data)
-                except Exception as e:
-                    country_name = country_data.get("country", "未知")
-                    self.log(f"处理国家 {country_name} 失败: {str(e)}", "ERROR")
-                    self.log(traceback.format_exc(), "ERROR")
-                    
-        finally:
-            # 关闭店铺
-            try:
-                if driver:
-                    self.log(f"关闭店铺 {shop_name}")
-                    driver.close_store()
-                    time.sleep(2)
-            except Exception as e:
-                self.log(f"关闭店铺失败: {str(e)}", "WARNING")
-            
-            # 从正在执行中的店铺列表中移除
-            if shop_name in runing_shop:
-                del runing_shop[shop_name]
-                self.log(f"店铺 {shop_name} 已从执行列表中移除")
-                
-    def process_country(self, driver: AmazoneDriver, country_data: Dict[str, Any], 
-                       task_id: int, result_id: int, shop_data: Dict[str, Any]):
-        """处理单个国家的所有ASIN
-        
-        Args:
-            driver: 亚马逊驱动实例
-            country_data: 国家数据
-            task_id: 任务ID
-            result_id: 结果ID
-            shop_data: 店铺数据
-        """
-        country = country_data.get("country", "未知")
-        items = country_data.get("items", [])
-        
-        self.log(f"开始处理国家: {country}，共 {len(items)} 个ASIN")
-        self.update_task_status(task_id, current_country=country)
-        
-        # 切换国家
-        try:
-            switch_success = driver.SwitchingCountries(country)
-            if not switch_success:
-                self.log(f"切换到国家 {country} 失败，跳过该国家", "ERROR")
-                return
-        except Exception as e:
-            self.log(f"切换国家 {country} 异常: {str(e)}", "ERROR")
-            return
-            
-        # 切换到库存管理页面
-        try:
-            driver.SwitchPage()
-            self.log(f"已切换到库存管理页面")
-        except Exception as e:
-            self.log(f"切换页面失败: {str(e)}", "ERROR")
-            return
-            
-        # 处理每个ASIN
-        file_key = shop_data.get("fileKey", "")
-        source_filename = shop_data.get("sourceFilename", "")
-        total_rows = shop_data.get("totalRows", 0)
-        
-        for idx, asin_item in enumerate(items, 1):
-            # 检查是否收到暂停请求
-            if task_id in runing_task and runing_task[task_id].get("stop_requested", False):
-                self.log(f"检测到任务 {task_id} 的暂停请求，停止处理", "WARNING")
-                return  # 返回到上层，会触发店铺关闭
-            
-            try:
-                self.log(f"[{idx}/{len(items)}] 处理ASIN: {asin_item.get('asin', '')}")
-                self.process_asin(driver, asin_item, country, task_id, result_id, 
-                                file_key, source_filename, total_rows, idx)
-            except Exception as e:
-                asin = asin_item.get("asin", "未知")
-                self.log(f"处理ASIN {asin} 失败: {str(e)}", "ERROR")
-                # 继续处理下一个ASIN
-                
-    def process_asin(self, driver: AmazoneDriver, asin_item: Dict[str, Any], 
-                    country: str, task_id: int, result_id: int, file_key: str, 
-                    source_filename: str, total_rows: int):
-        """处理单个ASIN并回传结果
-        
-        Args:
-            driver: 亚马逊驱动实例
-            asin_item: ASIN数据项
-            country: 国家名称
-            task_id: 任务ID
-            result_id: 结果ID
-            file_key: 文件KEY
-            source_filename: 源文件名
-            total_rows: 总行数
-            chunk_index: 当前处理索引
-        """
-        asin = asin_item.get("asin", "")
-        row_index = asin_item.get("rowIndex", 0)
-        
-        # 更新当前处理的ASIN
-        self.update_task_status(task_id, current_asin=asin)
-        
-        status = "失败"
-        
-        try:
-            # 搜索ASIN
-            sku_ls = driver.search(asin=asin)
-            self.log(f"搜索到 {len(sku_ls)} 个SKU")
-            
-            if len(sku_ls) == 0:
-                status = "查询不到"
-                self.log(f"ASIN {asin} 未找到商品", "WARNING")
-            else:
-                # 删除所有找到的SKU
-                success_count = 0
-                for sku in sku_ls:
-                    try:
-                        suc = driver.del_action(sku)
-                        if suc:
-                            success_count += 1
-                            self.log(f"SKU 删除成功")
-                        else:
-                            self.log(f"SKU 删除失败", "WARNING")
-                    except Exception as e:
-                        self.log(f"删除SKU异常: {str(e)}", "ERROR")
-                        
-                if success_count > 0:
-                    status = "成功"
-                    self.log(f"ASIN {asin} 删除成功 ({success_count}/{len(sku_ls)})")
-                    # 更新成功计数
-                    if task_id in runing_task:
-                        runing_task[task_id]["success_count"] += 1
-                else:
-                    status = "失败"
-                    self.log(f"ASIN {asin} 所有SKU删除失败", "ERROR")
-                    # 更新失败计数
-                    if task_id in runing_task:
-                        runing_task[task_id]["failed_count"] += 1
-                        
-        except Exception as e:
-            status = "删除异常"
-            self.log(f"处理ASIN {asin} 异常: {str(e)}", "ERROR")
-            # 更新失败计数
-            if task_id in runing_task:
-                runing_task[task_id]["failed_count"] += 1
-                
-        # 更新已处理ASIN计数
-        if task_id in runing_task:
-            runing_task[task_id]["processed_asins"] += 1
-            
-        # 回传结果到API
-        try:
-            payload = {
-                "submissionId": "",
-                "files": [{
-                    "fileKey": file_key,
-                    "sourceFilename": source_filename,
-                    "chunkIndex": self.chunk_index,
-                    "chunkTotal": total_rows,
-                    "processedRows": self.chunk_index,
-                    "totalRows": total_rows,
-                    "currentCountry": country,
-                    "currentAsin": asin,
-                    "countries": [{
-                        "country": country,
-                        "items": [{
-                            "asin": asin,
-                            "status": status
-                        }]
-                    }]
-                }]
-            }
-            
-            self.post_result(task_id, payload)
-            self.log(f"ASIN {asin} 结果已回传，状态: {status}")
-            
-        except Exception as e:
-            self.log(f"回传结果失败: {str(e)}", "ERROR")
-            
-    def post_result(self, task_id: int, payload: Dict[str, Any]):
-        """回传结果到API
-        
-        Args:
-            task_id: 任务ID
-            payload: 结果数据
-        """
-        url = f"{DELETE_BRAND_API_BASE}/newApi/api/delete-brand/tasks/{task_id}/result"
-        
-        try:
-            response = requests.post(
-                url,
-                json=payload,
-                headers={"Content-Type": "application/json"},
-                timeout=30,
-                verify=False  # 忽略SSL证书验证
-            )
-            
-            if response.status_code == 200:
-                self.log(f"结果回传成功: {url}")
-            else:
-                self.log(f"结果回传失败，状态码: {response.status_code}", "WARNING")
-                
-        except Exception as e:
-            self.log(f"调用API异常: {str(e)}", "ERROR")
-            
-    def update_task_status(self, task_id: int, **kwargs):
-        """更新任务状态
-        
-        Args:
-            task_id: 任务ID
-            **kwargs: 要更新的字段
-        """
-        if task_id not in runing_task:
-            runing_task[task_id] = {}
-            
-        runing_task[task_id].update(kwargs)
-        
-    def stop(self):
-        """停止监控"""
-        self.running = False
-        self.log("任务监控器已停止")
-
-
-def main():
-    """主函数：启动任务监控"""
-    # 创建并启动任务监控器
-    monitor = TaskMonitor()
-    
-    try:
-        monitor.start()
-    except KeyboardInterrupt:
-        monitor.log("接收到中断信号，正在停止...")
-        monitor.stop()
-    except Exception as e:
-        monitor.log(f"监控器异常退出: {traceback.format_exc()}", "ERROR")
-
-
-if __name__ == "__main__":
-    main()

app/app.py

@@ -1,57 +0,0 @@
-"""
-卖相AI - Flask 后端
-按功能拆分为蓝图：认证(auth)、主页面(main)、管理员(admin)、图片(image)、品牌(brand)
-"""
-import os
-import secrets
-from datetime import timedelta
-
-from flask import Flask
-from flask_cors import CORS
-
-from app_common import init_db, BASE_DIR
-from blueprints.auth import auth_bp
-from blueprints.main import main_bp
-from blueprints.admin import admin_bp
-from blueprints.image import image_bp
-from blueprints.brand import brand_bp
-from blueprints.communication import communication_bp
-
-
-def create_app():
-    app = Flask(__name__, template_folder=BASE_DIR, static_folder=BASE_DIR)
-    frontend_origin = os.environ.get('FRONTEND_ORIGIN', '*')
-    cors_origins = frontend_origin if frontend_origin != '*' else '*'
-    CORS(
-        app,
-        supports_credentials=True,
-        resources={r"/api/*": {"origins": cors_origins}, r"/login": {"origins": cors_origins}},
-    )
-    # 生产环境必须通过环境变量注入固定 SECRET_KEY；否则服务重启会使旧会话失效。
-    app.secret_key = os.environ.get('SECRET_KEY', 'dev-secret-key-change-me')
-    app.config['PERMANENT_SESSION_LIFETIME'] = timedelta(days=7)
-    app.config['SESSION_COOKIE_HTTPONLY'] = True
-    app.config['SESSION_COOKIE_SAMESITE'] = os.environ.get('SESSION_COOKIE_SAMESITE', 'Lax')
-    app.config['SESSION_COOKIE_SECURE'] = os.environ.get('SESSION_COOKIE_SECURE', '0') == '1'
-
-    # 注册蓝图（不设 url_prefix，保持原有 URL 路径不变，前端无需改动）
-    app.register_blueprint(auth_bp)
-    app.register_blueprint(main_bp)
-    app.register_blueprint(admin_bp)
-    app.register_blueprint(image_bp)
-    app.register_blueprint(brand_bp)
-    app.register_blueprint(communication_bp)
-
-    return app
-
-
-app = create_app()
-
-
-def run_app(host='127.0.0.1', port=5123):
-    # init_db()
-    app.run(host=host, port=port, threaded=True, use_reloader=False)
-
-
-if __name__ == '__main__':
-    run_app()

app/app_common.py

@@ -1,278 +0,0 @@
-"""
-公共模块：数据库连接、初始化、会话校验、装饰器、模板渲染
-供各蓝图复用
-"""
-import os
-import secrets
-from datetime import timedelta
-from functools import wraps
-
-import pymysql
-from flask import request, redirect, url_for, session, jsonify, render_template, render_template_string
-
-from config import mysql_host, mysql_user, mysql_password, mysql_database
-
-BASE_DIR = os.path.dirname(os.path.abspath(__file__))
-STATIC_DIR = os.path.join(BASE_DIR, 'static')
-ASSETS_DIR = os.path.join(BASE_DIR, 'assets')
-
-
-def get_db():
-    return pymysql.connect(
-        host=mysql_host,
-        user=mysql_user,
-        password=mysql_password,
-        database=mysql_database,
-        charset='utf8mb4',
-        cursorclass=pymysql.cursors.DictCursor
-    )
-
-
-def _render_html(template_name: str, **context):
-    """读取 HTML 模板：若为加密文件则先解密，再渲染。未加密或解密失败时按明文渲染。"""
-    path = os.path.join(BASE_DIR, "web_source", template_name)
-    if not os.path.isfile(path):
-        return render_template(template_name, **context)
-    with open(path, "rb") as f:
-        raw = f.read()
-    try:
-        from html_crypto import decrypt
-        content = decrypt(raw).decode("utf-8")
-    except Exception:
-        content = raw.decode("utf-8", errors="replace")
-    return render_template_string(content, **context)
-
-
-def _render_html_new(template_name: str, **context):
-    """读取 HTML 模板：若为加密文件则先解密，再渲染。未加密或解密失败时按明文渲染。"""
-    path = os.path.join(BASE_DIR, "web_source", template_name)
-    if not os.path.isfile(path):
-        return render_template(template_name, **context)
-    with open(path, "rb") as f:
-        raw = f.read()
-    try:
-        from html_crypto import decrypt
-        content = decrypt(raw).decode("utf-8")
-    except Exception:
-        content = raw.decode("utf-8", errors="replace")
-    return render_template_string(content, **context)
-
-
-
-def _is_session_user_valid():
-    """校验 session 中的 user_id 是否在数据库中仍存在；不存在则清除 session 并返回 False"""
-    uid = session.get('user_id')
-    if not uid:
-        return False
-    try:
-        conn = get_db()
-        with conn.cursor() as cur:
-            cur.execute("SELECT id FROM users WHERE id = %s", (uid,))
-            row = cur.fetchone()
-        conn.close()
-        if not row:
-            session.clear()
-            return False
-        return True
-    except Exception:
-        session.clear()
-        return False
-
-
-def _get_current_admin_role():
-    """获取当前登录用户的管理角色：super_admin / admin / None（非管理员）"""
-    try:
-        conn = get_db()
-        with conn.cursor() as cur:
-            cur.execute(
-                "SELECT id, username, is_admin, role, created_by_id FROM users WHERE id = %s",
-                (session['user_id'],)
-            )
-            row = cur.fetchone()
-        conn.close()
-        if not row or not row.get('is_admin'):
-            return None, None
-        return row.get('role') or ('super_admin' if row.get('created_by_id') is None else 'admin'), row
-    except Exception:
-        return None, None
-
-
-def login_required(f):
-    @wraps(f)
-    def decorated(*args, **kwargs):
-        if not session.get('user_id') or not _is_session_user_valid():
-            if request.headers.get('X-Requested-With') == 'XMLHttpRequest':
-                return jsonify({'success': False, 'error': '未登录'}), 401
-            return redirect(url_for('auth.login'))
-        return f(*args, **kwargs)
-    return decorated
-
-
-def admin_required(f):
-    @wraps(f)
-    def decorated(*args, **kwargs):
-        if not session.get('user_id'):
-            if request.headers.get('X-Requested-With') == 'XMLHttpRequest':
-                return jsonify({'success': False, 'error': '未登录'}), 401
-            return redirect(url_for('auth.login'))
-        try:
-            conn = get_db()
-            with conn.cursor() as cur:
-                cur.execute("SELECT is_admin, role FROM users WHERE id = %s", (session['user_id'],))
-                row = cur.fetchone()
-            conn.close()
-            if not row or not row.get('is_admin'):
-                if request.headers.get('X-Requested-With') == 'XMLHttpRequest':
-                    return jsonify({'success': False, 'error': '需要管理员权限'}), 403
-                return redirect(url_for('main.home'))
-        except Exception as e:
-            if request.headers.get('X-Requested-With') == 'XMLHttpRequest':
-                return jsonify({'success': False, 'error': str(e)}), 500
-            return redirect(url_for('main.home'))
-        return f(*args, **kwargs)
-    return decorated
-
-
-def init_db():
-    """初始化数据库表，若不存在则创建"""
-    from werkzeug.security import generate_password_hash
-    conn = pymysql.connect(
-        host=mysql_host,
-        user=mysql_user,
-        password=mysql_password,
-        charset='utf8mb4'
-    )
-    try:
-        with conn.cursor() as cur:
-            cur.execute(f"CREATE DATABASE IF NOT EXISTS `{mysql_database}` DEFAULT CHARSET utf8mb4")
-            cur.execute(f"USE `{mysql_database}`")
-            cur.execute("""
-                CREATE TABLE IF NOT EXISTS users (
-                    id INT AUTO_INCREMENT PRIMARY KEY,
-                    username VARCHAR(64) NOT NULL UNIQUE,
-                    password_hash VARCHAR(256) NOT NULL,
-                    is_admin TINYINT(1) DEFAULT 0,
-                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-                )
-            """)
-            cur.execute("""
-                CREATE TABLE IF NOT EXISTS image_history (
-                    id INT AUTO_INCREMENT PRIMARY KEY,
-                    user_id INT NOT NULL,
-                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-                    panel_type VARCHAR(64) DEFAULT '',
-                    original_urls JSON,
-                    params JSON,
-                    result_urls JSON,
-                    long_image_url VARCHAR(1024) DEFAULT NULL,
-                    INDEX idx_user_created (user_id, created_at DESC)
-                )
-            """)
-            try:
-                cur.execute("ALTER TABLE image_history ADD COLUMN long_image_url VARCHAR(1024) DEFAULT NULL")
-            except Exception:
-                pass
-            try:
-                cur.execute("ALTER TABLE users ADD COLUMN machine VARCHAR(64) DEFAULT NULL")
-            except Exception:
-                pass
-            try:
-                cur.execute("ALTER TABLE users ADD COLUMN role VARCHAR(20) DEFAULT 'normal'")
-            except Exception:
-                pass
-            try:
-                cur.execute("ALTER TABLE users ADD COLUMN created_by_id INT NULL")
-            except Exception:
-                pass
-            cur.execute("""
-                CREATE TABLE IF NOT EXISTS brand_crawl_tasks (
-                    id INT AUTO_INCREMENT PRIMARY KEY,
-                    user_id INT NOT NULL,
-                    file_paths JSON NOT NULL,
-                    status VARCHAR(20) DEFAULT 'pending',
-                    task_type TINYINT DEFAULT 1 COMMENT '1=立即执行,2=添加任务执行',
-                    result_paths JSON NULL,
-                    error_message TEXT NULL,
-                    progress_current INT DEFAULT 0,
-                    progress_total INT DEFAULT 0,
-                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-                    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
-                    INDEX idx_user_status (user_id, status)
-                )
-            """)
-            try:
-                cur.execute("ALTER TABLE brand_crawl_tasks ADD COLUMN progress_current INT DEFAULT 0")
-            except Exception:
-                pass
-            try:
-                cur.execute("ALTER TABLE brand_crawl_tasks ADD COLUMN progress_total INT DEFAULT 0")
-            except Exception:
-                pass
-            try:
-                cur.execute("ALTER TABLE brand_crawl_tasks ADD COLUMN `desc` VARCHAR(500) NULL COMMENT '上传文件名描述'")
-            except Exception:
-                pass
-            try:
-                cur.execute("ALTER TABLE brand_crawl_tasks ADD COLUMN strategy VARCHAR(20) DEFAULT 'Terms' COMMENT '品牌匹配方式: Terms/Simple'")
-            except Exception:
-                pass
-            try:
-                cur.execute("ALTER TABLE brand_crawl_tasks ADD COLUMN task_type TINYINT DEFAULT 1 COMMENT '1=立即执行,2=添加任务执行'")
-            except Exception:
-                pass
-            cur.execute("""
-                CREATE TABLE IF NOT EXISTS columns (
-                    id INT AUTO_INCREMENT PRIMARY KEY,
-                    name VARCHAR(128) NOT NULL COMMENT '栏目名',
-                    column_key VARCHAR(64) NOT NULL COMMENT '栏目标识',
-                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-                    UNIQUE KEY uk_column_key (column_key)
-                )
-            """)
-            cur.execute("""
-                CREATE TABLE IF NOT EXISTS user_column_permission (
-                    user_id INT NOT NULL,
-                    column_id INT NOT NULL,
-                    PRIMARY KEY (user_id, column_id),
-                    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
-                    FOREIGN KEY (column_id) REFERENCES columns(id) ON DELETE CASCADE
-                )
-            """)
-            try:
-                cur.execute("UPDATE users SET role = 'normal' WHERE (role IS NULL OR role = '') AND (is_admin = 0 OR is_admin IS NULL)")
-                cur.execute("SELECT MIN(id) AS mid FROM users WHERE is_admin = 1")
-                row = cur.fetchone()
-                if row and row.get('mid'):
-                    mid = row['mid']
-                    cur.execute("UPDATE users SET role = 'super_admin' WHERE id = %s", (mid,))
-                    cur.execute("UPDATE users SET role = 'admin' WHERE is_admin = 1 AND id != %s", (mid,))
-                    cur.execute("UPDATE users SET created_by_id = %s WHERE role = 'admin' AND (created_by_id IS NULL)", (mid,))
-            except Exception:
-                pass
-        conn.commit()
-    finally:
-        conn.close()
-    _create_initial_admin()
-
-
-def _create_initial_admin():
-    """若没有任何管理员，则创建默认超级管理员（首次启动时，仅一个）"""
-    from werkzeug.security import generate_password_hash
-    try:
-        conn = get_db()
-        with conn.cursor() as cur:
-            cur.execute("SELECT id FROM users WHERE role = 'super_admin' LIMIT 1")
-            if cur.fetchone():
-                conn.close()
-                return
-            admin_user = os.environ.get('ADMIN_USER', 'admin')
-            admin_pwd = os.environ.get('ADMIN_PASSWORD', 'admin123')
-            pwd_hash = generate_password_hash(admin_pwd, method='pbkdf2:sha256')
-            cur.execute(
-                "INSERT INTO users (username, password_hash, is_admin, role) VALUES (%s, %s, 1, 'super_admin')",
-                (admin_user, pwd_hash)
-            )
-        conn.commit()
-        conn.close()
-    except Exception:
-        pass

app/blueprints/__init__.py

@@ -1 +0,0 @@
-# 蓝图包

app/blueprints/admin.py

@@ -1,362 +0,0 @@
-"""
-管理员蓝图：用户管理（列表/创建/更新/删除）、生成历史、管理页
-"""
-import json
-import pymysql
-from flask import Blueprint, request, jsonify
-from werkzeug.security import generate_password_hash
-
-from app_common import get_db, _render_html, _get_current_admin_role, admin_required, login_required
-from flask import session
-
-admin_bp = Blueprint('admin', __name__)
-
-
-def _parse_json(val, default=None):
-    if val is None:
-        return default if default is not None else []
-    if isinstance(val, (list, dict)):
-        return val
-    try:
-        return json.loads(val)
-    except Exception:
-        return default if default is not None else []
-
-
-@admin_bp.route('/admin')
-@login_required
-@admin_required
-def admin_page():
-    return _render_html('admin.html')
-
-
-@admin_bp.route('/api/admin/users')
-@admin_required
-def admin_list_users():
-    """分页获取用户列表；支持用户名模糊搜索、指定管理员所属普通用户筛选"""
-    role, current_row = _get_current_admin_role()
-    if not role:
-        return jsonify({'success': False, 'error': '需要管理员权限'}), 403
-    page = max(1, int(request.args.get('page', 1)))
-    page_size = min(50, max(5, int(request.args.get('page_size', 15))))
-    offset = (page - 1) * page_size
-    search_username = (request.args.get('username') or request.args.get('search') or '').strip()
-    created_by_id_arg = request.args.get('created_by_id') or request.args.get('admin_id')
-    created_by_id = int(created_by_id_arg) if created_by_id_arg and str(created_by_id_arg).isdigit() else None
-    if role != 'super_admin':
-        created_by_id = None
-    try:
-        conn = get_db()
-        with conn.cursor() as cur:
-            if role == 'super_admin':
-                where_parts = ["1=1"]
-                params = []
-                if search_username:
-                    where_parts.append("u.username LIKE %s")
-                    params.append("%" + search_username + "%")
-                if created_by_id is not None:
-                    where_parts.append("u.created_by_id = %s")
-                    params.append(created_by_id)
-                where_sql = " AND ".join(where_parts)
-                cur.execute(
-                    """SELECT u.id, u.username, u.is_admin, u.role, u.created_at, u.created_by_id,
-                          creator.username AS creator_username
-                   FROM users u
-                   LEFT JOIN users creator ON creator.id = u.created_by_id
-                   WHERE """ + where_sql + """ ORDER BY u.id LIMIT %s OFFSET %s""",
-                    tuple(params) + (page_size, offset),
-                )
-                rows = cur.fetchall()
-                cur.execute("SELECT COUNT(*) as total FROM users u WHERE " + where_sql, tuple(params))
-                total = cur.fetchone()['total']
-                cur.execute("SELECT id, username FROM users WHERE role = 'admin' ORDER BY id")
-                admins = [{'id': r['id'], 'username': r['username']} for r in cur.fetchall()]
-            else:
-                admin_id = current_row['id']
-                where_parts = ["(u.id = %s OR (u.role = 'normal' AND u.created_by_id = %s))"]
-                params = [admin_id, admin_id]
-                if search_username:
-                    where_parts.append("u.username LIKE %s")
-                    params.append("%" + search_username + "%")
-                where_sql = " AND ".join(where_parts)
-                cur.execute(
-                    """SELECT u.id, u.username, u.is_admin, u.role, u.created_at, u.created_by_id,
-                          creator.username AS creator_username
-                   FROM users u
-                   LEFT JOIN users creator ON creator.id = u.created_by_id
-                   WHERE """ + where_sql + """ ORDER BY u.id LIMIT %s OFFSET %s""",
-                    tuple(params) + (page_size, offset),
-                )
-                rows = cur.fetchall()
-                cur.execute(
-                    "SELECT COUNT(*) as total FROM users u WHERE " + where_sql,
-                    tuple(params),
-                )
-                total = cur.fetchone()['total']
-                admins = []
-            items = [
-                {
-                    'id': r['id'],
-                    'username': r['username'],
-                    'is_admin': bool(r.get('is_admin')),
-                    'role': r.get('role') or 'normal',
-                    'created_by_id': r.get('created_by_id'),
-                    'creator_username': r.get('creator_username') or '',
-                    'created_at': r['created_at'].strftime('%Y-%m-%d %H:%M') if r.get('created_at') else '',
-                }
-                for r in rows
-            ]
-        conn.close()
-        payload = {
-            'success': True,
-            'items': items,
-            'total': total,
-            'page': page,
-            'page_size': page_size,
-            'current_user_role': role,
-            'admins': admins,
-        }
-        return jsonify(payload)
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)})
-
-
-@admin_bp.route('/api/admin/user', methods=['POST'])
-@admin_required
-def admin_create_user():
-    data = request.get_json() or {}
-    username = (data.get('username') or '').strip()
-    password = data.get('password') or ''
-    role, current_row = _get_current_admin_role()
-    if not role:
-        return jsonify({'success': False, 'error': '需要管理员权限'}), 403
-    want_role = (data.get('role') or 'normal').strip() or 'normal'
-    if want_role not in ('admin', 'normal'):
-        want_role = 'normal'
-    if role == 'admin' and want_role == 'admin':
-        return jsonify({'success': False, 'error': '仅超级管理员可创建管理员'})
-    if want_role == 'admin':
-        want_created_by = current_row['id']
-    elif role == 'super_admin':
-        want_created_by = data.get('created_by_id')
-    else:
-        want_created_by = current_row['id']
-    if not username or not password:
-        return jsonify({'success': False, 'error': '用户名和密码不能为空'})
-    if len(username) < 2:
-        return jsonify({'success': False, 'error': '用户名至少2个字符'})
-    if len(password) < 6:
-        return jsonify({'success': False, 'error': '密码至少6个字符'})
-    if want_role == 'normal' and role == 'super_admin' and want_created_by is None:
-        try:
-            conn = get_db()
-            with conn.cursor() as cur:
-                cur.execute("SELECT id FROM users WHERE role = 'admin' ORDER BY id LIMIT 1")
-                r = cur.fetchone()
-            conn.close()
-            want_created_by = r['id'] if r else current_row['id']
-        except Exception:
-            want_created_by = current_row['id']
-    if want_role == 'normal' and want_created_by is None:
-        want_created_by = current_row['id']
-    is_admin = 1 if want_role in ('super_admin', 'admin') else 0
-    pwd_hash = generate_password_hash(password, method='pbkdf2:sha256')
-    try:
-        conn = get_db()
-        with conn.cursor() as cur:
-            cur.execute(
-                "INSERT INTO users (username, password_hash, is_admin, role, created_by_id) VALUES (%s, %s, %s, %s, %s)",
-                (username, pwd_hash, is_admin, want_role, want_created_by),
-            )
-        conn.commit()
-        conn.close()
-        return jsonify({'success': True, 'msg': '用户创建成功'})
-    except pymysql.IntegrityError:
-        return jsonify({'success': False, 'error': '用户名已存在'})
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)})
-
-
-@admin_bp.route('/api/admin/user/<int:uid>', methods=['PUT'])
-@admin_required
-def admin_update_user(uid):
-    data = request.get_json() or {}
-    password = data.get('password')
-    want_role = (data.get('role') or '').strip() or data.get('role')
-    role, current_row = _get_current_admin_role()
-    if not role:
-        return jsonify({'success': False, 'error': '需要管理员权限'}), 403
-    if want_role is None and not password:
-        return jsonify({'success': False, 'error': '请提供要修改的内容'})
-    try:
-        conn = get_db()
-        with conn.cursor() as cur:
-            cur.execute("SELECT id, role, created_by_id FROM users WHERE id = %s", (uid,))
-            target = cur.fetchone()
-            if not target:
-                conn.close()
-                return jsonify({'success': False, 'error': '用户不存在'})
-            if role == 'admin':
-                if target['role'] != 'normal' or target.get('created_by_id') != current_row['id']:
-                    conn.close()
-                    return jsonify({'success': False, 'error': '只能编辑自己创建的普通用户'}), 403
-                want_role = None
-            else:
-                if target.get('role') == 'super_admin':
-                    conn.close()
-                    return jsonify({'success': False, 'error': '不能修改超级管理员'})
-                if want_role == 'super_admin':
-                    return jsonify({'success': False, 'error': '不能将用户设为超级管理员'})
-                if want_role not in ('admin', 'normal', None, ''):
-                    want_role = None
-            if password:
-                if len(password) < 6:
-                    conn.close()
-                    return jsonify({'success': False, 'error': '密码至少6个字符'})
-                pwd_hash = generate_password_hash(password, method='pbkdf2:sha256')
-                cur.execute("UPDATE users SET password_hash = %s WHERE id = %s", (pwd_hash, uid))
-            if want_role is not None and want_role != '':
-                is_admin = 1 if want_role == 'admin' else 0
-                cur.execute(
-                    "UPDATE users SET is_admin = %s, role = %s WHERE id = %s",
-                    (is_admin, want_role, uid),
-                )
-        conn.commit()
-        conn.close()
-        return jsonify({'success': True, 'msg': '更新成功'})
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)})
-
-
-@admin_bp.route('/api/admin/user/<int:uid>', methods=['DELETE'])
-@admin_required
-def admin_delete_user(uid):
-    from flask import session
-    if session.get('user_id') == uid:
-        return jsonify({'success': False, 'error': '不能删除当前登录账号'})
-    role, current_row = _get_current_admin_role()
-    if not role:
-        return jsonify({'success': False, 'error': '需要管理员权限'}), 403
-    try:
-        conn = get_db()
-        with conn.cursor() as cur:
-            cur.execute("SELECT id, role, created_by_id FROM users WHERE id = %s", (uid,))
-            target = cur.fetchone()
-            if not target:
-                conn.close()
-                return jsonify({'success': False, 'error': '用户不存在'})
-            if target.get('role') == 'super_admin':
-                conn.close()
-                return jsonify({'success': False, 'error': '不能删除超级管理员'})
-            if role == 'admin':
-                if target.get('role') != 'normal' or target.get('created_by_id') != current_row['id']:
-                    conn.close()
-                    return jsonify({'success': False, 'error': '只能删除自己创建的普通用户'}), 403
-            cur.execute("DELETE FROM users WHERE id = %s", (uid,))
-            affected = cur.rowcount
-        conn.commit()
-        conn.close()
-        if affected == 0:
-            return jsonify({'success': False, 'error': '用户不存在'})
-        return jsonify({'success': True, 'msg': '删除成功'})
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)})
-
-
-@admin_bp.route('/api/admin/user/<int:uid>/column-permissions')
-@login_required
-def admin_user_column_permissions(uid):
-    """获取指定用户的栏目权限列表：当前用户只能查自己，管理员可查任意用户。超级管理员返回全部栏目。"""
-    current_uid = session.get('user_id')
-    if current_uid != uid:
-        role, _ = _get_current_admin_role()
-        if not role:
-            return jsonify({'success': False, 'error': '无权查看该用户的栏目权限'}), 403
-    try:
-        conn = get_db()
-        with conn.cursor() as cur:
-            cur.execute("SELECT role FROM users WHERE id = %s", (uid,))
-            user_row = cur.fetchone()
-            if user_row and (user_row.get('role') or '').strip() == 'super_admin':
-                cur.execute("""
-                    SELECT id, name, column_key, created_at FROM columns ORDER BY id
-                """)
-                rows = cur.fetchall()
-            else:
-                cur.execute("""
-                    SELECT c.id, c.name, c.column_key, c.created_at
-                    FROM columns c
-                    INNER JOIN user_column_permission ucp ON ucp.column_id = c.id
-                    WHERE ucp.user_id = %s
-                    ORDER BY c.id
-                """, (uid,))
-                rows = cur.fetchall()
-        conn.close()
-        items = [
-            {
-                'id': r['id'],
-                'name': r['name'],
-                'column_key': r['column_key'],
-                'created_at': r['created_at'].strftime('%Y-%m-%d %H:%M') if r.get('created_at') else '',
-            }
-            for r in rows
-        ]
-        return jsonify({'success': True, 'items': items})
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)})
-
-
-@admin_bp.route('/api/admin/history')
-@admin_required
-def admin_history():
-    """管理员分页获取所有生成记录，支持按用户和时间筛选"""
-    page = max(1, int(request.args.get('page', 1)))
-    page_size = min(50, max(10, int(request.args.get('page_size', 15))))
-    offset = (page - 1) * page_size
-    user_id = request.args.get('user_id', type=int)
-    time_start = (request.args.get('time_start') or '').strip()
-    time_end = (request.args.get('time_end') or '').strip()
-    conditions, params = [], []
-    if user_id:
-        conditions.append("h.user_id = %s")
-        params.append(user_id)
-    if time_start:
-        conditions.append("h.created_at >= %s")
-        params.append(time_start)
-    if time_end:
-        conditions.append("h.created_at <= %s")
-        params.append(time_end + ' 23:59:59' if len(time_end) <= 10 else time_end)
-    where_clause = " AND ".join(conditions) if conditions else "1=1"
-    params_count = params[:]
-    params.extend([page_size, offset])
-    try:
-        conn = get_db()
-        with conn.cursor() as cur:
-            cur.execute(
-                """SELECT h.id, h.user_id, h.created_at, h.panel_type, h.original_urls, h.params, h.result_urls,
-                          h.long_image_url, u.username
-                   FROM image_history h
-                   LEFT JOIN users u ON h.user_id = u.id
-                   WHERE """ + where_clause + """ ORDER BY h.created_at DESC LIMIT %s OFFSET %s""",
-                params,
-            )
-            rows = cur.fetchall()
-            cur.execute("SELECT COUNT(*) as total FROM image_history h WHERE " + where_clause, params_count)
-            total = cur.fetchone()['total']
-        conn.close()
-        items = []
-        for r in rows:
-            items.append({
-                'id': r['id'],
-                'user_id': r['user_id'],
-                'username': r.get('username') or '-',
-                'created_at': r['created_at'].strftime('%Y-%m-%d %H:%M') if r['created_at'] else '',
-                'panel_type': r['panel_type'] or '',
-                'original_urls': _parse_json(r['original_urls'], []),
-                'params': _parse_json(r['params'], {}),
-                'result_urls': _parse_json(r['result_urls'], []),
-                'long_image_url': (r.get('long_image_url') or '').strip() or None,
-            })
-        return jsonify({'success': True, 'items': items, 'total': total, 'page': page, 'page_size': page_size})
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)})

app/blueprints/auth.py

@@ -1,107 +0,0 @@
-"""
-认证蓝图：登录、登出、登录状态校验
-"""
-from flask import Blueprint, request, redirect, url_for, session, jsonify
-from werkzeug.security import check_password_hash
-
-from app_common import (
-    get_db,
-    _render_html,
-    _is_session_user_valid,
-    login_required,
-    BASE_DIR,
-)
-from tool.devices import DeviceIDGenerator
-
-auth_bp = Blueprint('auth', __name__)
-
-
-@auth_bp.route('/login', methods=['GET', 'POST'])
-def login():
-    if session.get('user_id') and _is_session_user_valid():
-        return redirect(url_for('main.home'))
-    if request.method == 'POST':
-        data = request.get_json() if request.is_json else request.form
-        username = (data.get('username') or '').strip()
-        password = data.get('password') or ''
-        if not username or not password:
-            if request.is_json:
-                return jsonify({'success': False, 'error': '请输入用户名和密码'})
-            return _render_html('login.html', error='请输入用户名和密码')
-        try:
-            conn = get_db()
-            with conn.cursor() as cur:
-                cur.execute(
-                    "SELECT id, password_hash, machine, is_admin FROM users WHERE username = %s",
-                    (username,)
-                )
-                row = cur.fetchone()
-            if row and check_password_hash(row['password_hash'], password):
-                current_machine = DeviceIDGenerator().get_device_id()
-                stored_machine = (row.get('machine') or '').strip()
-                if not stored_machine:
-                    with conn.cursor() as cur:
-                        cur.execute("UPDATE users SET machine = %s WHERE id = %s", (current_machine, row['id']))
-                    conn.commit()
-                    conn.close()
-                    session.permanent = True
-                    session['user_id'] = row['id']
-                    session['username'] = username
-                    if request.is_json:
-                        return jsonify({'success': True, 'redirect': url_for('main.home')})
-                    return redirect(url_for('main.home'))
-                print("验证设备",stored_machine)
-                print("当前设备",current_machine)
-                if stored_machine != current_machine and row.get("is_admin") != 1:
-                    conn.close()
-                    err_msg = '当前设备与首次登录设备不一致，请在原设备上登录'
-                    if request.is_json:
-                        return jsonify({'success': False, 'error': err_msg})
-                    return _render_html('login.html', error=err_msg)
-                conn.close()
-                session.permanent = True
-                session['user_id'] = row['id']
-                session['username'] = username
-                if request.is_json:
-                    return jsonify({'success': True, 'redirect': url_for('main.home')})
-                return redirect(url_for('main.home'))
-            conn.close()
-        except Exception as e:
-            if request.is_json:
-                return jsonify({'success': False, 'error': str(e)})
-            return _render_html('login.html', error='登录失败，请稍后重试')
-        if request.is_json:
-            return jsonify({'success': False, 'error': '用户名或密码错误'})
-        return _render_html('login.html', error='用户名或密码错误')
-    return _render_html('login.html')
-
-
-@auth_bp.route('/api/auth/check')
-@login_required
-def api_auth_check():
-    """校验登录状态，用于页面加载时判断是否已登录；同时校验机器码是否与首次登录设备一致"""
-    if not session.get('user_id'):
-        return jsonify({'logged_in': False})
-    try:
-        conn = get_db()
-        with conn.cursor() as cur:
-            cur.execute("SELECT machine, is_admin FROM users WHERE id = %s", (session['user_id'],))
-            row = cur.fetchone()
-        conn.close()
-        if not row:
-            return jsonify({'logged_in': False})
-        stored_machine = (row.get('machine') or '').strip()
-        if stored_machine:
-            current_machine = DeviceIDGenerator().get_device_id()
-            if stored_machine != current_machine and row.get("is_admin") != 1:
-                session.clear()
-                return jsonify({'logged_in': False, 'error': '当前设备与首次登录设备不一致'})
-    except Exception:
-        return jsonify({'logged_in': False})
-    return jsonify({'logged_in': True, 'redirect': url_for('main.home')})
-
-
-@auth_bp.route('/logout')
-def logout():
-    session.clear()
-    return redirect(url_for('auth.login'))

app/blueprints/brand.py

@@ -1,728 +0,0 @@
-"""
-品牌爬虫蓝图：展开文件夹、运行任务、任务列表/详情、下载结果
-"""
-import os
-import json
-import threading
-import traceback
-import zipfile
-import io
-import time
-import requests
-from queue import Queue, Empty
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from urllib.parse import urlparse
-
-from flask import Blueprint, request, jsonify, session, send_file, redirect, Response
-
-from app_common import get_db, login_required, BASE_DIR
-from config import bucket_path,JAVA_API_BASE
-from brand_spider.main import single_file_handle, TaskCancelledError
-
-brand_bp = Blueprint('brand', __name__)
-BRAND_OUTPUT_DIR = os.path.join(BASE_DIR, 'brand_output')
-OSS_PREFIX = "brand_results"
-
-# 任务完成时推送给前端的 SSE 队列：task_id -> [Queue, ...]
-_task_event_queues = {}
-_task_event_lock = threading.Lock()
-
-# 任务行级进度（当前处理文件的行数/总行数），仅存内存，不落库：
-# task_id -> {
-#   'file_index': int,      # 当前处理第几个文件
-#   'file_total': int,      # 总文件数
-#   'file_path': str,       # 当前文件路径
-#   'current_line': int,    # 当前行号（或当前品牌序号）
-#   'total_lines': int,     # 总行数（或总品牌数）
-# }
-_task_line_progress = {}
-_task_line_progress_lock = threading.Lock()
-_cancelled_brand_tasks = set()
-_cancelled_brand_tasks_lock = threading.Lock()
-
-
-def _mark_task_cancelled(task_id):
-    with _cancelled_brand_tasks_lock:
-        _cancelled_brand_tasks.add(task_id)
-
-
-def _is_task_cancelled(task_id):
-    with _cancelled_brand_tasks_lock:
-        return task_id in _cancelled_brand_tasks
-
-
-def _get_uid_from_request_headers():
-    """
-    从请求头读取 uid。
-    前端会在 headers 里携带 uid，用于确定本次请求的归属用户。
-    """
-    uid = request.headers.get('uid')
-    if uid is None:
-        return None
-    uid = str(uid).strip()
-    if not uid:
-        return None
-    try:
-        return int(uid)
-    except Exception:
-        return None
-
-
-def _resolve_user_id():
-    """
-    优先使用请求头 uid；没有请求头 uid 时回退到 session['user_id']。
-    若二者同时存在但不一致，则视为无效请求并返回 None。
-    """
-    req_uid = _get_uid_from_request_headers()
-    if req_uid is not None:
-        sess_uid = session.get('user_id')
-        if sess_uid is not None:
-            try:
-                if int(sess_uid) != int(req_uid):
-                    return None
-            except Exception:
-                if str(sess_uid) != str(req_uid):
-                    return None
-        return req_uid
-    return session.get('user_id')
-
-
-def _get_user_id_or_error():
-    user_id = _resolve_user_id()
-    if not user_id:
-        return None, (jsonify({'success': False, 'error': '未登录或缺少uid'}), 401)
-    try:
-        return int(user_id), None
-    except Exception:
-        return None, (jsonify({'success': False, 'error': 'uid无效'}), 400)
-
-
-def _push_task_event(task_id, event):
-    """向订阅了该任务的所有 SSE 连接推送事件，并移除该任务的队列列表。
-    同时清理内存中的行级进度，不通过数据库中转行级进度。"""
-    with _task_event_lock:
-        queues = _task_event_queues.pop(task_id, [])
-    for q in queues:
-        try:
-            q.put_nowait(event)
-        except Exception:
-            pass
-    # 任务进入终态时，顺便清理行级进度缓存
-    with _task_line_progress_lock:
-        _task_line_progress.pop(task_id, None)
-    status = (event or {}).get('status') if isinstance(event, dict) else None
-    if status in ('success', 'failed', 'cancelled'):
-        with _cancelled_brand_tasks_lock:
-            _cancelled_brand_tasks.discard(task_id)
-
-
-def _expand_folder_xlsx(folder_path):
-    """返回文件夹下所有 .xlsx 文件的绝对路径列表"""
-    if not folder_path or not os.path.isdir(folder_path):
-        return []
-    paths = []
-    for name in os.listdir(folder_path):
-        if name.endswith('.xlsx') or name.endswith('.XLSX'):
-            paths.append(os.path.normpath(os.path.join(folder_path, name)))
-    return paths
-
-
-def _upload_local_xlsx_to_oss(local_path, user_id):
-    """将本地 xlsx 文件上传到 OSS，返回 (url, None) 或 (None, error_message)。"""
-    if not local_path or not os.path.isfile(local_path):
-        return None, "文件不存在"
-    try:
-        from ali_oss import upload_file as oss_upload_file
-    except ImportError:
-        return None, "OSS 模块未配置"
-    base = os.path.basename(local_path)
-    safe_base = "".join(c if c.isalnum() or c in '-_.' else '_' for c in base)
-    if not safe_base.endswith('.xlsx'):
-        safe_base = safe_base + '.xlsx'
-    key = f"{bucket_path}brand_input/{user_id}/{int(time.time() * 1000)}/{safe_base}"
-    try:
-        with open(local_path, "rb") as f:
-            content = f.read()
-        url = oss_upload_file(content, key)
-        return url, None
-    except Exception as e:
-        return None, str(e)
-
-
-def _run_brand_single(taskid,brand_ls, fileUrl,strategy,totalLines,chunkTotal,chunkIndex):
-    """"""
-    invalidBrands = [] # 不符合品牌的数据
-    queryFailedBrands = [] # 查询失败的数据
-    keptRows = []
-    for brand in brand_ls:
-        if _is_task_cancelled(taskid):
-            raise TaskCancelledError("任务已取消")
-        faild_data,query_faild_data = single_file_handle(brand,strategy)
-        invalidBrands.extend(faild_data)
-        queryFailedBrands.extend(query_faild_data)
-        if len(faild_data) == 0 and len(query_faild_data) == 0:
-            keptRows.append(brand)
-
-    data = { "strategy": strategy ,
-                          "files": [
-                            {
-                              "fileUrl": fileUrl,
-                              "originalFilename": "",
-                              "relativePath": "",
-                              "mainSheetName": "",
-                              "chunkIndex": chunkIndex,
-                              "chunkTotal": chunkTotal,
-                              "totalLines": totalLines,
-                              "keptRows": keptRows,
-                              "invalidBrands": invalidBrands,
-                              "queryFailedBrands": queryFailedBrands
-                            }
-                          ]
-                        }
-    resp = requests.post(f"{JAVA_API_BASE}/api/brand/tasks/{taskid}/result",headers={"accept":"application/json"},
-                         # json={ "strategy": strategy ,
-                         #  "files": [
-                         #    {  "fileUrl": fileUrl,"originalFilename": "","relativePath": "",
-                         #      "mainSheetName": "","columns": [],"keptRows": [],
-                         #      "invalidBrands": invalidBrands,"queryFailedBrands": queryFailedBrands
-                         #    }]})
-                         json=data)
-    # print(data)
-    # print(taskid,brand_ls, fileUrl)
-    print("提交结果",data,"\n-->",resp.text)
-    return True
-
-
-
-def _background_brand_task(task_id,data):
-    """
-        后台执行爬虫任务
-        参数示例：
-            data : {
-            "taskId": 348,
-            "strategy": "Terms",
-            "files": [
-              {
-                "fileIndex": 1,
-                "fileUrl": "ab8cce4878754bfd89b4cd3ed20e1395",
-                "originalFilename": "品牌样例.xlsx",
-                "relativePath": "店铺A/品牌样例.xlsx",
-                "sheetName": "Sheet1",
-                "columns": [
-                  "品牌",
-                  "ASIH",
-                  "状态",
-                  "时间"
-                ],
-                "rows": [
-                  {
-                    "品牌": "YQAUTEC",
-                    "ASIH": "B0F28NZ752",
-                    "状态": "",
-                    "时间": "",
-                    "__rowIndex": 2
-                  }
-                ],
-                "uniqueBrands": [
-                  "YQAUTEC"
-                ]
-              }
-            ]
-          }
-    """
-    try:
-        file_ls = data.get("files")
-        strategy = data.get("strategy")
-        if not isinstance(file_ls, list):
-            file_ls = []
-        tasks = []
-        for file_data in file_ls:
-            rows = file_data.get("rows") or []
-            brand_ls = [i.get("品牌") for i in rows if i.get("品牌")]
-            fileUrl = file_data.get("fileUrl")
-            if not brand_ls:
-                continue
-            file_chunks = [brand_ls[i:i + 5] for i in range(0, len(brand_ls), 5)]
-            chunk_total = len(file_chunks)
-            total_lines = len(brand_ls)
-            for chunk_index, chunk in enumerate(file_chunks, start=1):
-                tasks.append((chunk, fileUrl, total_lines, chunk_total, chunk_index))
-
-        if tasks:
-            max_workers = min(8, len(tasks))
-            with ThreadPoolExecutor(max_workers=max_workers) as executor:
-                if _is_task_cancelled(task_id):
-                    _push_task_event(task_id, {'status': 'cancelled'})
-                    return
-                futures = [
-                    executor.submit(_run_brand_single, task_id, chunk, file_url, strategy, total_lines, chunk_total, chunk_index)
-                    for chunk, file_url, total_lines, chunk_total, chunk_index in tasks
-                ]
-                for future in as_completed(futures):
-                    if _is_task_cancelled(task_id):
-                        for f in futures:
-                            f.cancel()
-                        _push_task_event(task_id, {'status': 'cancelled'})
-                        return
-                    future.result()
-        _push_task_event(task_id, {'status': 'success'})
-    except Exception as e:
-        print("执行出错",traceback.format_exc())
-        _push_task_event(task_id, {'status': 'failed', 'error_message': str(e)})
-    print("执行完成")
-
-
-def _parse_json(val, default=None):
-    if val is None:
-        return default if default is not None else []
-    if isinstance(val, (list, dict)):
-        return val
-    try:
-        return json.loads(val)
-    except Exception:
-        return default if default is not None else []
-
-
-def _is_url(s):
-    if not isinstance(s, str) or not s.strip():
-        return False
-    return s.strip().startswith('http://') or s.strip().startswith('https://')
-
-
-def _normalize_result_paths(raw):
-    """
-    将 result_paths 规范化为 (url_list, zip_url)。
-    支持旧格式 list 或新格式 dict {"urls": [...], "zip_url": "..."}。
-    """
-    if not raw:
-        return [], None
-    if isinstance(raw, dict):
-        urls = raw.get('urls') or []
-        if not isinstance(urls, list):
-            urls = []
-        zip_url = raw.get('zip_url')
-        if zip_url and not isinstance(zip_url, str):
-            zip_url = None
-        return urls, zip_url
-    if isinstance(raw, list):
-        return raw, None
-    return [], None
-
-
-@brand_bp.route('/api/brand/expand-folder', methods=['POST'])
-@login_required
-def api_brand_expand_folder():
-    """展开文件夹，返回其下所有 .xlsx 文件路径列表"""
-    try:
-        _, err = _get_user_id_or_error()
-        if err:
-            return err
-        data = request.get_json() or {}
-        folder = (data.get('folder') or '').strip()
-        if not folder:
-            return jsonify({'success': False, 'error': '请提供 folder 路径'}), 400
-        paths = _expand_folder_xlsx(folder)
-        return jsonify({'success': True, 'paths': paths})
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)}), 500
-
-def _expand_folder_xlsx_recursive_items(folder_path):
-    """返回文件夹下所有 .xlsx 文件的绝对路径和相对路径列表（递归）"""
-    if not folder_path or not os.path.isdir(folder_path):
-        return []
-    items = []
-    root = os.path.normpath(folder_path)
-    for current_root, _, filenames in os.walk(root):
-        for name in filenames:
-            if not (name.endswith('.xlsx') or name.endswith('.XLSX')):
-                continue
-            absolute_path = os.path.normpath(os.path.join(current_root, name))
-            relative_path = os.path.relpath(absolute_path, root).replace('\\', '/')
-            items.append({
-                'absolutePath': absolute_path,
-                'relativePath': relative_path,
-            })
-    items.sort(key=lambda item: item['relativePath'])
-    return items
-
-@brand_bp.route('/api/brand/expand-folder-recursive', methods=['POST'])
-@login_required
-def api_brand_expand_folder_recursive():
-    """递归展开文件夹，返回 .xlsx 文件绝对路径及相对路径列表"""
-    try:
-        _, err = _get_user_id_or_error()
-        if err:
-            return err
-        data = request.get_json() or {}
-        folder = (data.get('folder') or '').strip()
-        if not folder:
-            return jsonify({'success': False, 'error': '请提供 folder 路径'}), 400
-        items = _expand_folder_xlsx_recursive_items(folder)
-        return jsonify({'success': True, 'items': items})
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)}), 500
-
-
-@brand_bp.route('/api/brand/run', methods=['POST'])
-# @login_required
-def api_brand_run():
-    """立即运行：创建任务并后台执行，立即返回 task_id，前端可轮询进度与取消"""
-    try:
-        data = request.get_json() or {}
-        paths = data.get('paths') or []
-        # task_type: 1=立即执行，2=添加任务；此接口默认 1
-        try:
-            task_type = int(data.get('task_type') or 1)
-        except Exception:
-            task_type = 1
-        if task_type not in (1, 2):
-            task_type = 1
-        strategy = (data.get('strategy') or 'Terms').strip()
-        if strategy not in ('Terms', 'Simple'):
-            strategy = 'Terms'
-        if not isinstance(paths, list):
-            paths = []
-        paths = [p.strip() for p in paths if p and isinstance(p, str) and os.path.isfile(p.strip())]
-        if not paths:
-            return jsonify({'success': False, 'error': '没有有效的 xlsx 文件路径'}), 400
-        # 先上传到 OSS，获取链接再入库
-        user_id, err = _get_user_id_or_error()
-        if err:
-            return err
-        urls = []
-        for p in paths:
-            url, err = _upload_local_xlsx_to_oss(p, user_id)
-            if err:
-                return jsonify({'success': False, 'error': f'上传文件失败: {os.path.basename(p)} - {err}'}), 500
-            base_name = os.path.basename(p)
-            urls.append({"fileUrl": url,"originalFilename": base_name,"relativePath": p })
-
-        # 请求提交
-        resp = requests.post(f"{JAVA_API_BASE}/api/brand/tasks?userId={user_id}",headers={
-            "content-type":"application/json",
-        },data=json.dumps({ "files": urls, "strategy": strategy,"taskType": 1,"archiveName": ""}))
-        print({ "files": urls, "strategy": strategy,"taskType": 1,"archiveName": ""})
-        print(f"{JAVA_API_BASE}/api/brand/tasks?userId={user_id}")
-        resp_data = resp.json()
-        # print(f"{JAVA_API_BASE}/api/brand/tasks?userId={user_id} 返回：",resp_data,"状态：",resp.status_code)
-        if resp_data.get("success"):
-            task_id = resp_data.get("data").get("taskId")
-            data = resp_data.get("data")
-            threading.Thread(target=_background_brand_task, args=(task_id,data), daemon=True).start()
-            return jsonify({'success': True, 'task_id': task_id})
-        else:
-            print(resp_data)
-            return jsonify({'success': False, 'error': "请求接口失败"}), 500
-
-    except Exception as e:
-        traceback.print_exc()
-        return jsonify({'success': False, 'error': str(e)}), 500
-
-
-@brand_bp.route('/api/brand/tasks', methods=['GET', 'POST'])
-# @login_required
-def api_brand_tasks():
-    """GET: 获取当前用户的任务列表；POST: 添加任务（后台执行）"""
-    if request.method == 'GET':
-        try:
-            user_id, err = _get_user_id_or_error()
-            if err:
-                return err
-            resp = requests.get(f"{JAVA_API_BASE}/api/brand/tasks", params={
-                "userId": user_id
-            })
-            resp_data = resp.json()
-            print("获取列表",resp.text)
-            if resp_data.get("success"):
-                items = resp_data.get("data").get("items")
-                return jsonify({'success': True, 'items': items})
-            return jsonify({'success': True, 'items': []})
-        except Exception as e:
-            traceback.print_exc()
-            print("获取列表失败",e)
-            return jsonify({'success': False, 'error': str(e)}), 500
-    # POST
-    try:
-        data = request.get_json() or {}
-        paths = data.get('paths') or []
-        # task_type: 1=立即执行，2=添加任务；此接口默认 2
-        try:
-            task_type = int(data.get('task_type') or 2)
-        except Exception:
-            task_type = 2
-        if task_type not in (1, 2):
-            task_type = 2
-        strategy = (data.get('strategy') or 'Terms').strip()
-        if strategy not in ('Terms', 'Simple'):
-            strategy = 'Terms'
-        if not isinstance(paths, list):
-            paths = []
-        paths = [p.strip() for p in paths if p and isinstance(p, str)]
-        if not paths:
-            return jsonify({'success': False, 'error': '请提供至少一个文件路径或链接'}), 400
-        user_id, err = _get_user_id_or_error()
-        if err:
-            return err
-        urls = []
-        for p in paths:
-            url, err = _upload_local_xlsx_to_oss(p, user_id)
-            if err:
-                return jsonify({'success': False, 'error': f'上传文件失败: {os.path.basename(p)} - {err}'}), 500
-            base_name = os.path.basename(p)
-            urls.append({"fileUrl": url, "originalFilename": base_name, "relativePath": p})
-        params = {
-            "userId": user_id
-        }
-        # resp = requests.post(f"{JAVA_API_BASE}/api/brand/tasks?userId={user_id}",headers={
-        #     "content-type":"application/json",
-        # },data=json.dumps({ "files": urls, "strategy": strategy,"taskType": 1,"archiveName": ""}))
-        req_data = {"files": urls, "strategy": strategy, "taskType": 2, "archiveName": ""}
-        resp = requests.post(f"{JAVA_API_BASE}/api/brand/tasks?userId={user_id}", headers={"content-type": "application/json"},
-                             data=json.dumps(req_data))
-        print(req_data)
-        # print(f"{JAVA_API_BASE}/api/brand/tasks?userId={user_id}，返回", resp.text)
-        resp_data = resp.json()
-        if resp_data.get("success"):
-            task_id = resp_data.get("data").get("taskId")
-            data = resp_data.get("data")
-            return jsonify({'success': True, 'task_id': task_id})
-        return jsonify({'success': False, 'task_id': "请求异常"})
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)}), 500
-
-
-@brand_bp.route('/api/brand/tasks/<int:task_id>')
-# @login_required
-def api_brand_task_detail(task_id):
-    """获取单个任务详情（用于轮询状态）"""
-    try:
-        resp = requests.get(f"{JAVA_API_BASE}/api/brand/tasks/{task_id}")
-        resp_data = resp.json()
-        if resp_data.get("success"):
-            task = resp_data["data"]["task"]
-            return jsonify({
-                'success': True,
-                'task': task
-            })
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)}), 500
-
-
-@brand_bp.route('/api/brand/tasks/<int:task_id>/line-progress')
-# @login_required
-def api_brand_task_line_progress(task_id):
-    """
-    获取任务的“当前文件行级进度”（当前行数/总行数）。
-    该信息仅存放在内存字典 _task_line_progress 中，不写入数据库。
-    """
-    try:
-        resp = requests.get(f"{JAVA_API_BASE}/api/brand/tasks/{task_id}")
-        resp_data = resp.json()
-        if resp_data.get("success"):
-            if resp_data["data"]["line_progress"]["has_progress"]:
-                info = resp_data["data"]["line_progress"]["info"]
-                resp = {
-                    'file_index': int(info.get('file_index') or 0),
-                    'file_total': int(info.get('file_total') or 0),
-                    'file_name': info.get("file_name",""),
-                    'current_line': int(info.get('current_line') or 0),
-                    'total_lines': int(info.get('total_lines') or 0),
-                }
-                return jsonify({'success': True, 'has_progress': True, 'info': resp})
-        raise RuntimeError("获取进度失败")
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)}), 500
-
-
-@brand_bp.route('/api/brand/tasks/<int:task_id>/events')
-# @login_required
-def api_brand_task_events(task_id):
-    """SSE：任务完成时后端主动推送事件，前端监听后隐藏进度条与取消按钮"""
-    user_id, err = _get_user_id_or_error()
-    if err:
-        return err
-
-    def _task_status_event():
-        conn = get_db()
-        try:
-            with conn.cursor() as cur:
-                cur.execute(
-                    "SELECT status, error_message FROM brand_crawl_tasks WHERE id = %s AND user_id = %s",
-                    (task_id, user_id)
-                )
-                row = cur.fetchone()
-        finally:
-            conn.close()
-        if not row:
-            return None
-        st = (row.get('status') or '').lower()
-        if st in ('success', 'failed', 'cancelled'):
-            return {'status': st, 'error_message': (row.get('error_message') or '').strip() or None}
-        return None
-
-    # 若任务已处于终态，直接返回一条事件后结束
-    ev = _task_status_event()
-    if ev is not None:
-        def _one_shot():
-            yield "data: " + json.dumps(ev, ensure_ascii=False) + "\n\n"
-        return Response(
-            _one_shot(),
-            mimetype='text/event-stream',
-            headers={'Cache-Control': 'no-cache', 'X-Accel-Buffering': 'no'}
-        )
-
-    # 否则注册队列，等待后台任务完成时推送
-    q = Queue()
-    with _task_event_lock:
-        _task_event_queues.setdefault(task_id, []).append(q)
-
-    def _stream():
-        try:
-            while True:
-                try:
-                    event = q.get(timeout=20)
-                    yield "data: " + json.dumps(event, ensure_ascii=False) + "\n\n"
-                    return
-                except Empty:
-                    yield ": keepalive\n\n"
-        finally:
-            with _task_event_lock:
-                lst = _task_event_queues.get(task_id, [])
-                if q in lst:
-                    lst.remove(q)
-                if not lst:
-                    _task_event_queues.pop(task_id, None)
-
-    return Response(
-        _stream(),
-        mimetype='text/event-stream',
-        headers={'Cache-Control': 'no-cache', 'X-Accel-Buffering': 'no'}
-    )
-
-
-@brand_bp.route('/api/brand/tasks/<int:task_id>/cancel', methods=['POST'])
-# @login_required
-def api_brand_task_cancel(task_id):
-    """取消正在执行或等待中的任务（pending/running 均可取消）"""
-    try:
-        user_id, err = _get_user_id_or_error()
-        if err:
-            return err
-
-
-        resp = requests.post(
-            f"{JAVA_API_BASE}/api/brand/tasks/{task_id}/cancel",
-            headers={"accept": "application/json"},
-            timeout=20
-        )
-        try:
-            resp_data = resp.json()
-        except Exception:
-            return jsonify({'success': False, 'error': '取消接口返回非 JSON'}), 500
-        if not resp_data.get('success'):
-            return jsonify({'success': False, 'error': '第三方取消任务失败'}), 400
-
-        _mark_task_cancelled(task_id)
-        _push_task_event(task_id, {'status': 'cancelled'})
-        return jsonify({'success': True})
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)}), 500
-
-
-@brand_bp.route('/api/brand/tasks/<int:task_id>', methods=['DELETE'])
-@login_required
-def api_brand_task_delete(task_id):
-    """删除任务（仅限非 running 状态）"""
-    try:
-        user_id, err = _get_user_id_or_error()
-        if err:
-            return err
-
-        resp = requests.delete(
-            f"{JAVA_API_BASE}/api/brand/tasks/{task_id}",
-            headers={"accept": "application/json"},
-            timeout=20
-        )
-        try:
-            resp_data = resp.json()
-        except Exception:
-            return jsonify({'success': False, 'error': '取消接口返回非 JSON'}), 500
-        if not resp_data.get('success'):
-            return jsonify({'success': False, 'error': '第三方取消任务失败'}), 400
-        return jsonify({'success': True})
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)}), 500
-
-
-@brand_bp.route('/api/brand/download/<int:task_id>')
-@login_required
-def api_brand_download(task_id):
-    """下载任务结果：优先使用 OSS zip_url 重定向；否则本地/单链接/多链接按原逻辑处理"""
-    try:
-        user_id, err = _get_user_id_or_error()
-        if err:
-            return err
-
-        conn = get_db()
-        with conn.cursor() as cur:
-            cur.execute(
-                "SELECT result_paths FROM brand_crawl_tasks WHERE id = %s AND user_id = %s",
-                (task_id, user_id)
-            )
-            row = cur.fetchone()
-        conn.close()
-        if not row or not row.get('result_paths'):
-            return jsonify({'success': False, 'error': '无结果可下载'}), 404
-        raw = row['result_paths']
-        if isinstance(raw, str):
-            raw = _parse_json(raw)
-        url_list, zip_url = _normalize_result_paths(raw)
-        # 新格式：有 zip_url 直接重定向到 OSS
-        if zip_url and _is_url(zip_url):
-            return redirect(zip_url, code=302)
-
-        # 兼容旧格式：result_paths 可能为 list（本地路径或 url）
-        if not url_list and isinstance(raw, list):
-            url_list = raw
-        local_paths = [p for p in url_list if isinstance(p, str) and not _is_url(p) and os.path.isfile(p)]
-        url_paths = [p.strip() for p in url_list if isinstance(p, str) and _is_url(p)]
-
-        if len(url_paths) == 1 and not local_paths:
-            return redirect(url_paths[0], code=302)
-
-        if len(local_paths) == 1 and not url_paths:
-            return send_file(
-                local_paths[0],
-                as_attachment=True,
-                download_name=os.path.basename(local_paths[0])
-            )
-
-        if local_paths or url_paths:
-            buf = io.BytesIO()
-            with zipfile.ZipFile(buf, 'w', zipfile.ZIP_DEFLATED) as zf:
-                for p in local_paths:
-                    zf.write(p, os.path.basename(p))
-                for url in url_paths:
-                    try:
-                        import requests as req
-                        r = req.get(url, timeout=30, stream=True)
-                        r.raise_for_status()
-                        name = os.path.basename(urlparse(url).path) or ('file_%s' % (url_paths.index(url)))
-                        if not name or name == 'file_%s' % url_paths.index(url):
-                            name = 'download_%s' % url_paths.index(url)
-                        zf.writestr(name, r.content)
-                    except Exception:
-                        pass
-            buf.seek(0)
-            return send_file(
-                buf,
-                mimetype='application/zip',
-                as_attachment=True,
-                download_name='brand_task_%s.zip' % task_id
-            )
-
-        return jsonify({'success': False, 'error': '结果文件不存在或链接不可用'}), 404
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)}), 500
-
-

app/blueprints/brand_备份.py

@@ -1,726 +0,0 @@
-"""
-品牌爬虫蓝图：展开文件夹、运行任务、任务列表/详情、下载结果
-"""
-import os
-import json
-import threading
-import traceback
-import zipfile
-import io
-import time
-import requests
-from queue import Queue, Empty
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from urllib.parse import urlparse
-
-from flask import Blueprint, request, jsonify, session, send_file, redirect, Response
-
-from app_common import get_db, login_required, BASE_DIR
-from config import bucket_path,JAVA_API_BASE
-from brand_spider.main import single_file_handle, TaskCancelledError
-
-brand_bp = Blueprint('brand', __name__)
-BRAND_OUTPUT_DIR = os.path.join(BASE_DIR, 'brand_output')
-OSS_PREFIX = "brand_results"
-
-# 任务完成时推送给前端的 SSE 队列：task_id -> [Queue, ...]
-_task_event_queues = {}
-_task_event_lock = threading.Lock()
-
-# 任务行级进度（当前处理文件的行数/总行数），仅存内存，不落库：
-# task_id -> {
-#   'file_index': int,      # 当前处理第几个文件
-#   'file_total': int,      # 总文件数
-#   'file_path': str,       # 当前文件路径
-#   'current_line': int,    # 当前行号（或当前品牌序号）
-#   'total_lines': int,     # 总行数（或总品牌数）
-# }
-_task_line_progress = {}
-_task_line_progress_lock = threading.Lock()
-_cancelled_brand_tasks = set()
-_cancelled_brand_tasks_lock = threading.Lock()
-
-
-def _mark_task_cancelled(task_id):
-    with _cancelled_brand_tasks_lock:
-        _cancelled_brand_tasks.add(task_id)
-
-
-def _is_task_cancelled(task_id):
-    with _cancelled_brand_tasks_lock:
-        return task_id in _cancelled_brand_tasks
-
-
-def _get_uid_from_request_headers():
-    """
-    从请求头读取 uid。
-    前端会在 headers 里携带 uid，用于确定本次请求的归属用户。
-    """
-    uid = request.headers.get('uid')
-    if uid is None:
-        return None
-    uid = str(uid).strip()
-    if not uid:
-        return None
-    try:
-        return int(uid)
-    except Exception:
-        return None
-
-
-def _resolve_user_id():
-    """
-    优先使用请求头 uid；没有请求头 uid 时回退到 session['user_id']。
-    若二者同时存在但不一致，则视为无效请求并返回 None。
-    """
-    req_uid = _get_uid_from_request_headers()
-    if req_uid is not None:
-        sess_uid = session.get('user_id')
-        if sess_uid is not None:
-            try:
-                if int(sess_uid) != int(req_uid):
-                    return None
-            except Exception:
-                if str(sess_uid) != str(req_uid):
-                    return None
-        return req_uid
-    return session.get('user_id')
-
-
-def _get_user_id_or_error():
-    user_id = _resolve_user_id()
-    if not user_id:
-        return None, (jsonify({'success': False, 'error': '未登录或缺少uid'}), 401)
-    try:
-        return int(user_id), None
-    except Exception:
-        return None, (jsonify({'success': False, 'error': 'uid无效'}), 400)
-
-
-def _push_task_event(task_id, event):
-    """向订阅了该任务的所有 SSE 连接推送事件，并移除该任务的队列列表。
-    同时清理内存中的行级进度，不通过数据库中转行级进度。"""
-    with _task_event_lock:
-        queues = _task_event_queues.pop(task_id, [])
-    for q in queues:
-        try:
-            q.put_nowait(event)
-        except Exception:
-            pass
-    # 任务进入终态时，顺便清理行级进度缓存
-    with _task_line_progress_lock:
-        _task_line_progress.pop(task_id, None)
-    status = (event or {}).get('status') if isinstance(event, dict) else None
-    if status in ('success', 'failed', 'cancelled'):
-        with _cancelled_brand_tasks_lock:
-            _cancelled_brand_tasks.discard(task_id)
-
-
-def _expand_folder_xlsx(folder_path):
-    """返回文件夹下所有 .xlsx 文件的绝对路径列表"""
-    if not folder_path or not os.path.isdir(folder_path):
-        return []
-    paths = []
-    for name in os.listdir(folder_path):
-        if name.endswith('.xlsx') or name.endswith('.XLSX'):
-            paths.append(os.path.normpath(os.path.join(folder_path, name)))
-    return paths
-
-
-def _upload_local_xlsx_to_oss(local_path, user_id):
-    """将本地 xlsx 文件上传到 OSS，返回 (url, None) 或 (None, error_message)。"""
-    if not local_path or not os.path.isfile(local_path):
-        return None, "文件不存在"
-    try:
-        from ali_oss import upload_file as oss_upload_file
-    except ImportError:
-        return None, "OSS 模块未配置"
-    base = os.path.basename(local_path)
-    safe_base = "".join(c if c.isalnum() or c in '-_.' else '_' for c in base)
-    if not safe_base.endswith('.xlsx'):
-        safe_base = safe_base + '.xlsx'
-    key = f"{bucket_path}brand_input/{user_id}/{int(time.time() * 1000)}/{safe_base}"
-    try:
-        with open(local_path, "rb") as f:
-            content = f.read()
-        url = oss_upload_file(content, key)
-        return url, None
-    except Exception as e:
-        return None, str(e)
-
-
-def _run_brand_single(taskid,brand_ls, fileUrl,strategy,totalLines,chunkTotal,chunkIndex):
-    """"""
-    invalidBrands = [] # 不符合品牌的数据
-    queryFailedBrands = [] # 查询失败的数据
-    keptRows = []
-    for brand in brand_ls:
-        if _is_task_cancelled(taskid):
-            raise TaskCancelledError("任务已取消")
-        faild_data,query_faild_data = single_file_handle(brand,strategy)
-        invalidBrands.extend(faild_data)
-        queryFailedBrands.extend(query_faild_data)
-        if len(faild_data) == 0 and len(query_faild_data) == 0:
-            keptRows.append(brand)
-
-    data = { "strategy": strategy ,
-                          "files": [
-                            {
-                              "fileUrl": fileUrl,
-                              "originalFilename": "",
-                              "relativePath": "",
-                              "mainSheetName": "",
-                              "chunkIndex": chunkIndex,
-                              "chunkTotal": chunkTotal,
-                              "totalLines": totalLines,
-                              "keptRows": keptRows,
-                              "invalidBrands": invalidBrands,
-                              "queryFailedBrands": queryFailedBrands
-                            }
-                          ]
-                        }
-    resp = requests.post(f"{JAVA_API_BASE}/api/brand/tasks/{taskid}/result",headers={"accept":"application/json"},
-                         # json={ "strategy": strategy ,
-                         #  "files": [
-                         #    {  "fileUrl": fileUrl,"originalFilename": "","relativePath": "",
-                         #      "mainSheetName": "","columns": [],"keptRows": [],
-                         #      "invalidBrands": invalidBrands,"queryFailedBrands": queryFailedBrands
-                         #    }]})
-                         json=data)
-    # print(data)
-    # print(taskid,brand_ls, fileUrl)
-    print("提交结果",data,"\n-->",resp.text)
-    return True
-
-
-
-def _background_brand_task(task_id,data):
-    """
-        后台执行爬虫任务
-        参数示例：
-            data : {
-            "taskId": 348,
-            "strategy": "Terms",
-            "files": [
-              {
-                "fileIndex": 1,
-                "fileUrl": "ab8cce4878754bfd89b4cd3ed20e1395",
-                "originalFilename": "品牌样例.xlsx",
-                "relativePath": "店铺A/品牌样例.xlsx",
-                "sheetName": "Sheet1",
-                "columns": [
-                  "品牌",
-                  "ASIH",
-                  "状态",
-                  "时间"
-                ],
-                "rows": [
-                  {
-                    "品牌": "YQAUTEC",
-                    "ASIH": "B0F28NZ752",
-                    "状态": "",
-                    "时间": "",
-                    "__rowIndex": 2
-                  }
-                ],
-                "uniqueBrands": [
-                  "YQAUTEC"
-                ]
-              }
-            ]
-          }
-    """
-    try:
-        file_ls = data.get("files")
-        strategy = data.get("strategy")
-        if not isinstance(file_ls, list):
-            file_ls = []
-        tasks = []
-        for file_data in file_ls:
-            rows = file_data.get("rows") or []
-            brand_ls = [i.get("品牌") for i in rows if i.get("品牌")]
-            fileUrl = file_data.get("fileUrl")
-            if not brand_ls:
-                continue
-            for i in range(0, len(brand_ls), 5):
-                chunk = brand_ls[i:i + 5]
-                tasks.append((chunk, fileUrl))
-
-        if tasks:
-            max_workers = min(8, len(tasks))
-            with ThreadPoolExecutor(max_workers=max_workers) as executor:
-                if _is_task_cancelled(task_id):
-                    _push_task_event(task_id, {'status': 'cancelled'})
-                    return
-                futures = [
-                    executor.submit(_run_brand_single, task_id, chunk, file_url, strategy,len(brand_ls),len(tasks),chunkIndex+1)
-                    for chunkIndex,(chunk, file_url) in enumerate(tasks)
-                ]
-                for future in as_completed(futures):
-                    if _is_task_cancelled(task_id):
-                        for f in futures:
-                            f.cancel()
-                        _push_task_event(task_id, {'status': 'cancelled'})
-                        return
-                    future.result()
-        _push_task_event(task_id, {'status': 'success'})
-    except Exception as e:
-        print("执行出错",traceback.format_exc())
-        _push_task_event(task_id, {'status': 'failed', 'error_message': str(e)})
-    print("执行完成")
-
-
-def _parse_json(val, default=None):
-    if val is None:
-        return default if default is not None else []
-    if isinstance(val, (list, dict)):
-        return val
-    try:
-        return json.loads(val)
-    except Exception:
-        return default if default is not None else []
-
-
-def _is_url(s):
-    if not isinstance(s, str) or not s.strip():
-        return False
-    return s.strip().startswith('http://') or s.strip().startswith('https://')
-
-
-def _normalize_result_paths(raw):
-    """
-    将 result_paths 规范化为 (url_list, zip_url)。
-    支持旧格式 list 或新格式 dict {"urls": [...], "zip_url": "..."}。
-    """
-    if not raw:
-        return [], None
-    if isinstance(raw, dict):
-        urls = raw.get('urls') or []
-        if not isinstance(urls, list):
-            urls = []
-        zip_url = raw.get('zip_url')
-        if zip_url and not isinstance(zip_url, str):
-            zip_url = None
-        return urls, zip_url
-    if isinstance(raw, list):
-        return raw, None
-    return [], None
-
-
-@brand_bp.route('/api/brand/expand-folder', methods=['POST'])
-@login_required
-def api_brand_expand_folder():
-    """展开文件夹，返回其下所有 .xlsx 文件路径列表"""
-    try:
-        _, err = _get_user_id_or_error()
-        if err:
-            return err
-        data = request.get_json() or {}
-        folder = (data.get('folder') or '').strip()
-        if not folder:
-            return jsonify({'success': False, 'error': '请提供 folder 路径'}), 400
-        paths = _expand_folder_xlsx(folder)
-        return jsonify({'success': True, 'paths': paths})
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)}), 500
-
-def _expand_folder_xlsx_recursive_items(folder_path):
-    """返回文件夹下所有 .xlsx 文件的绝对路径和相对路径列表（递归）"""
-    if not folder_path or not os.path.isdir(folder_path):
-        return []
-    items = []
-    root = os.path.normpath(folder_path)
-    for current_root, _, filenames in os.walk(root):
-        for name in filenames:
-            if not (name.endswith('.xlsx') or name.endswith('.XLSX')):
-                continue
-            absolute_path = os.path.normpath(os.path.join(current_root, name))
-            relative_path = os.path.relpath(absolute_path, root).replace('\\', '/')
-            items.append({
-                'absolutePath': absolute_path,
-                'relativePath': relative_path,
-            })
-    items.sort(key=lambda item: item['relativePath'])
-    return items
-
-@brand_bp.route('/api/brand/expand-folder-recursive', methods=['POST'])
-@login_required
-def api_brand_expand_folder_recursive():
-    """递归展开文件夹，返回 .xlsx 文件绝对路径及相对路径列表"""
-    try:
-        _, err = _get_user_id_or_error()
-        if err:
-            return err
-        data = request.get_json() or {}
-        folder = (data.get('folder') or '').strip()
-        if not folder:
-            return jsonify({'success': False, 'error': '请提供 folder 路径'}), 400
-        items = _expand_folder_xlsx_recursive_items(folder)
-        return jsonify({'success': True, 'items': items})
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)}), 500
-
-
-@brand_bp.route('/api/brand/run', methods=['POST'])
-# @login_required
-def api_brand_run():
-    """立即运行：创建任务并后台执行，立即返回 task_id，前端可轮询进度与取消"""
-    try:
-        data = request.get_json() or {}
-        paths = data.get('paths') or []
-        # task_type: 1=立即执行，2=添加任务；此接口默认 1
-        try:
-            task_type = int(data.get('task_type') or 1)
-        except Exception:
-            task_type = 1
-        if task_type not in (1, 2):
-            task_type = 1
-        strategy = (data.get('strategy') or 'Terms').strip()
-        if strategy not in ('Terms', 'Simple'):
-            strategy = 'Terms'
-        if not isinstance(paths, list):
-            paths = []
-        paths = [p.strip() for p in paths if p and isinstance(p, str) and os.path.isfile(p.strip())]
-        if not paths:
-            return jsonify({'success': False, 'error': '没有有效的 xlsx 文件路径'}), 400
-        # 先上传到 OSS，获取链接再入库
-        user_id, err = _get_user_id_or_error()
-        if err:
-            return err
-        urls = []
-        for p in paths:
-            url, err = _upload_local_xlsx_to_oss(p, user_id)
-            if err:
-                return jsonify({'success': False, 'error': f'上传文件失败: {os.path.basename(p)} - {err}'}), 500
-            base_name = os.path.basename(p)
-            urls.append({"fileUrl": url,"originalFilename": base_name,"relativePath": p })
-
-        # 请求提交
-        resp = requests.post(f"{JAVA_API_BASE}/api/brand/tasks?userId={user_id}",headers={
-            "content-type":"application/json",
-        },data=json.dumps({ "files": urls, "strategy": strategy,"taskType": 1,"archiveName": ""}))
-        print({ "files": urls, "strategy": strategy,"taskType": 1,"archiveName": ""})
-        print(f"{JAVA_API_BASE}/api/brand/tasks?userId={user_id}")
-        resp_data = resp.json()
-        # print(f"{JAVA_API_BASE}/api/brand/tasks?userId={user_id} 返回：",resp_data,"状态：",resp.status_code)
-        if resp_data.get("success"):
-            task_id = resp_data.get("data").get("taskId")
-            data = resp_data.get("data")
-            threading.Thread(target=_background_brand_task, args=(task_id,data), daemon=True).start()
-            return jsonify({'success': True, 'task_id': task_id})
-        else:
-            print(resp_data)
-            return jsonify({'success': False, 'error': "请求接口失败"}), 500
-
-    except Exception as e:
-        traceback.print_exc()
-        return jsonify({'success': False, 'error': str(e)}), 500
-
-
-@brand_bp.route('/api/brand/tasks', methods=['GET', 'POST'])
-# @login_required
-def api_brand_tasks():
-    """GET: 获取当前用户的任务列表；POST: 添加任务（后台执行）"""
-    if request.method == 'GET':
-        try:
-            user_id, err = _get_user_id_or_error()
-            if err:
-                return err
-            resp = requests.get(f"{JAVA_API_BASE}/api/brand/tasks", params={
-                "userId": user_id
-            })
-            resp_data = resp.json()
-            print("获取列表",resp.text)
-            if resp_data.get("success"):
-                items = resp_data.get("data").get("items")
-                return jsonify({'success': True, 'items': items})
-            return jsonify({'success': True, 'items': []})
-        except Exception as e:
-            traceback.print_exc()
-            print("获取列表失败",e)
-            return jsonify({'success': False, 'error': str(e)}), 500
-    # POST
-    try:
-        data = request.get_json() or {}
-        paths = data.get('paths') or []
-        # task_type: 1=立即执行，2=添加任务；此接口默认 2
-        try:
-            task_type = int(data.get('task_type') or 2)
-        except Exception:
-            task_type = 2
-        if task_type not in (1, 2):
-            task_type = 2
-        strategy = (data.get('strategy') or 'Terms').strip()
-        if strategy not in ('Terms', 'Simple'):
-            strategy = 'Terms'
-        if not isinstance(paths, list):
-            paths = []
-        paths = [p.strip() for p in paths if p and isinstance(p, str)]
-        if not paths:
-            return jsonify({'success': False, 'error': '请提供至少一个文件路径或链接'}), 400
-        user_id, err = _get_user_id_or_error()
-        if err:
-            return err
-        urls = []
-        for p in paths:
-            url, err = _upload_local_xlsx_to_oss(p, user_id)
-            if err:
-                return jsonify({'success': False, 'error': f'上传文件失败: {os.path.basename(p)} - {err}'}), 500
-            base_name = os.path.basename(p)
-            urls.append({"fileUrl": url, "originalFilename": base_name, "relativePath": p})
-        params = {
-            "userId": user_id
-        }
-        # resp = requests.post(f"{JAVA_API_BASE}/api/brand/tasks?userId={user_id}",headers={
-        #     "content-type":"application/json",
-        # },data=json.dumps({ "files": urls, "strategy": strategy,"taskType": 1,"archiveName": ""}))
-        req_data = {"files": urls, "strategy": strategy, "taskType": 2, "archiveName": ""}
-        resp = requests.post(f"{JAVA_API_BASE}/api/brand/tasks?userId={user_id}", headers={"content-type": "application/json"},
-                             data=json.dumps(req_data))
-        print(req_data)
-        # print(f"{JAVA_API_BASE}/api/brand/tasks?userId={user_id}，返回", resp.text)
-        resp_data = resp.json()
-        if resp_data.get("success"):
-            task_id = resp_data.get("data").get("taskId")
-            data = resp_data.get("data")
-            return jsonify({'success': True, 'task_id': task_id})
-        return jsonify({'success': False, 'task_id': "请求异常"})
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)}), 500
-
-
-@brand_bp.route('/api/brand/tasks/<int:task_id>')
-# @login_required
-def api_brand_task_detail(task_id):
-    """获取单个任务详情（用于轮询状态）"""
-    try:
-        resp = requests.get(f"{JAVA_API_BASE}/api/brand/tasks/{task_id}")
-        resp_data = resp.json()
-        if resp_data.get("success"):
-            task = resp_data["data"]["task"]
-            return jsonify({
-                'success': True,
-                'task': task
-            })
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)}), 500
-
-
-@brand_bp.route('/api/brand/tasks/<int:task_id>/line-progress')
-# @login_required
-def api_brand_task_line_progress(task_id):
-    """
-    获取任务的“当前文件行级进度”（当前行数/总行数）。
-    该信息仅存放在内存字典 _task_line_progress 中，不写入数据库。
-    """
-    try:
-        resp = requests.get(f"{JAVA_API_BASE}/api/brand/tasks/{task_id}")
-        resp_data = resp.json()
-        if resp_data.get("success"):
-            if resp_data["data"]["line_progress"]["has_progress"]:
-                info = resp_data["data"]["line_progress"]["info"]
-                resp = {
-                    'file_index': int(info.get('file_index') or 0),
-                    'file_total': int(info.get('file_total') or 0),
-                    'file_name': info.get("file_name",""),
-                    'current_line': int(info.get('current_line') or 0),
-                    'total_lines': int(info.get('total_lines') or 0),
-                }
-                return jsonify({'success': True, 'has_progress': True, 'info': resp})
-        raise RuntimeError("获取进度失败")
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)}), 500
-
-
-@brand_bp.route('/api/brand/tasks/<int:task_id>/events')
-# @login_required
-def api_brand_task_events(task_id):
-    """SSE：任务完成时后端主动推送事件，前端监听后隐藏进度条与取消按钮"""
-    user_id, err = _get_user_id_or_error()
-    if err:
-        return err
-
-    def _task_status_event():
-        conn = get_db()
-        try:
-            with conn.cursor() as cur:
-                cur.execute(
-                    "SELECT status, error_message FROM brand_crawl_tasks WHERE id = %s AND user_id = %s",
-                    (task_id, user_id)
-                )
-                row = cur.fetchone()
-        finally:
-            conn.close()
-        if not row:
-            return None
-        st = (row.get('status') or '').lower()
-        if st in ('success', 'failed', 'cancelled'):
-            return {'status': st, 'error_message': (row.get('error_message') or '').strip() or None}
-        return None
-
-    # 若任务已处于终态，直接返回一条事件后结束
-    ev = _task_status_event()
-    if ev is not None:
-        def _one_shot():
-            yield "data: " + json.dumps(ev, ensure_ascii=False) + "\n\n"
-        return Response(
-            _one_shot(),
-            mimetype='text/event-stream',
-            headers={'Cache-Control': 'no-cache', 'X-Accel-Buffering': 'no'}
-        )
-
-    # 否则注册队列，等待后台任务完成时推送
-    q = Queue()
-    with _task_event_lock:
-        _task_event_queues.setdefault(task_id, []).append(q)
-
-    def _stream():
-        try:
-            while True:
-                try:
-                    event = q.get(timeout=20)
-                    yield "data: " + json.dumps(event, ensure_ascii=False) + "\n\n"
-                    return
-                except Empty:
-                    yield ": keepalive\n\n"
-        finally:
-            with _task_event_lock:
-                lst = _task_event_queues.get(task_id, [])
-                if q in lst:
-                    lst.remove(q)
-                if not lst:
-                    _task_event_queues.pop(task_id, None)
-
-    return Response(
-        _stream(),
-        mimetype='text/event-stream',
-        headers={'Cache-Control': 'no-cache', 'X-Accel-Buffering': 'no'}
-    )
-
-
-@brand_bp.route('/api/brand/tasks/<int:task_id>/cancel', methods=['POST'])
-# @login_required
-def api_brand_task_cancel(task_id):
-    """取消正在执行或等待中的任务（pending/running 均可取消）"""
-    try:
-        user_id, err = _get_user_id_or_error()
-        if err:
-            return err
-
-
-        resp = requests.post(
-            f"{JAVA_API_BASE}/api/brand/tasks/{task_id}/cancel",
-            headers={"accept": "application/json"},
-            timeout=20
-        )
-        try:
-            resp_data = resp.json()
-        except Exception:
-            return jsonify({'success': False, 'error': '取消接口返回非 JSON'}), 500
-        if not resp_data.get('success'):
-            return jsonify({'success': False, 'error': '第三方取消任务失败'}), 400
-
-        _mark_task_cancelled(task_id)
-        _push_task_event(task_id, {'status': 'cancelled'})
-        return jsonify({'success': True})
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)}), 500
-
-
-@brand_bp.route('/api/brand/tasks/<int:task_id>', methods=['DELETE'])
-@login_required
-def api_brand_task_delete(task_id):
-    """删除任务（仅限非 running 状态）"""
-    try:
-        user_id, err = _get_user_id_or_error()
-        if err:
-            return err
-
-        resp = requests.delete(
-            f"{JAVA_API_BASE}/api/brand/tasks/{task_id}",
-            headers={"accept": "application/json"},
-            timeout=20
-        )
-        try:
-            resp_data = resp.json()
-        except Exception:
-            return jsonify({'success': False, 'error': '取消接口返回非 JSON'}), 500
-        if not resp_data.get('success'):
-            return jsonify({'success': False, 'error': '第三方取消任务失败'}), 400
-        return jsonify({'success': True})
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)}), 500
-
-
-@brand_bp.route('/api/brand/download/<int:task_id>')
-@login_required
-def api_brand_download(task_id):
-    """下载任务结果：优先使用 OSS zip_url 重定向；否则本地/单链接/多链接按原逻辑处理"""
-    try:
-        user_id, err = _get_user_id_or_error()
-        if err:
-            return err
-
-        conn = get_db()
-        with conn.cursor() as cur:
-            cur.execute(
-                "SELECT result_paths FROM brand_crawl_tasks WHERE id = %s AND user_id = %s",
-                (task_id, user_id)
-            )
-            row = cur.fetchone()
-        conn.close()
-        if not row or not row.get('result_paths'):
-            return jsonify({'success': False, 'error': '无结果可下载'}), 404
-        raw = row['result_paths']
-        if isinstance(raw, str):
-            raw = _parse_json(raw)
-        url_list, zip_url = _normalize_result_paths(raw)
-        # 新格式：有 zip_url 直接重定向到 OSS
-        if zip_url and _is_url(zip_url):
-            return redirect(zip_url, code=302)
-
-        # 兼容旧格式：result_paths 可能为 list（本地路径或 url）
-        if not url_list and isinstance(raw, list):
-            url_list = raw
-        local_paths = [p for p in url_list if isinstance(p, str) and not _is_url(p) and os.path.isfile(p)]
-        url_paths = [p.strip() for p in url_list if isinstance(p, str) and _is_url(p)]
-
-        if len(url_paths) == 1 and not local_paths:
-            return redirect(url_paths[0], code=302)
-
-        if len(local_paths) == 1 and not url_paths:
-            return send_file(
-                local_paths[0],
-                as_attachment=True,
-                download_name=os.path.basename(local_paths[0])
-            )
-
-        if local_paths or url_paths:
-            buf = io.BytesIO()
-            with zipfile.ZipFile(buf, 'w', zipfile.ZIP_DEFLATED) as zf:
-                for p in local_paths:
-                    zf.write(p, os.path.basename(p))
-                for url in url_paths:
-                    try:
-                        import requests as req
-                        r = req.get(url, timeout=30, stream=True)
-                        r.raise_for_status()
-                        name = os.path.basename(urlparse(url).path) or ('file_%s' % (url_paths.index(url)))
-                        if not name or name == 'file_%s' % url_paths.index(url):
-                            name = 'download_%s' % url_paths.index(url)
-                        zf.writestr(name, r.content)
-                    except Exception:
-                        pass
-            buf.seek(0)
-            return send_file(
-                buf,
-                mimetype='application/zip',
-                as_attachment=True,
-                download_name='brand_task_%s.zip' % task_id
-            )
-
-        return jsonify({'success': False, 'error': '结果文件不存在或链接不可用'}), 404
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)}), 500
-
-

app/blueprints/communication.py

@@ -1,82 +0,0 @@
-import threading
-import time
-from queue import Empty, Full
-
-from flask import Blueprint, jsonify, request
-
-from config import JSON_TASK_QUEUE,runing_task
-
-
-communication_bp = Blueprint('communication', __name__)
-
-_del_brand_cache = {}
-_del_brand_cache_lock = threading.Lock()
-_latest_del_brand_item = None
-_latest_del_brand_ts = 0.0
-
-
-def _resolve_request_id():
-    rid = request.args.get('id')
-    if rid is not None and str(rid).strip() != '':
-        return str(rid)
-    if request.method == 'POST':
-        body = request.get_json(silent=True) or {}
-        rid = body.get('id')
-        if rid is not None and str(rid).strip() != '':
-            return str(rid)
-    return None
-
-
-@communication_bp.route('/api/amazon/del_brand', methods=['GET', 'POST'])
-def del_brand():
-    """返回队列中的一个元素；同一 id 重复请求返回已缓存的同一元素；2分钟内不同 id 也返回最近元素。"""
-    global _latest_del_brand_item, _latest_del_brand_ts
-    request_id = _resolve_request_id()
-    if not request_id:
-        return jsonify({'success': False, 'message': '缺少参数 id', 'data': None}), 400
-
-    with _del_brand_cache_lock:
-        if request_id in _del_brand_cache:
-            item = _del_brand_cache[request_id]
-            print("【删除品牌】缓存命中", request_id, item)
-            return jsonify({'success': True, 'data': item})
-        if _latest_del_brand_item is not None and (time.time() - _latest_del_brand_ts) <= 120:
-            _del_brand_cache[request_id] = _latest_del_brand_item
-            print("【删除品牌】2分钟窗口命中", request_id, _latest_del_brand_item)
-            return jsonify({'success': True, 'data': _latest_del_brand_item})
-
-    try:
-        item = JSON_TASK_QUEUE.get_nowait()
-    except Empty:
-        print("队列为空")
-        return jsonify({'success': False, 'message': '队列为空', 'data': None})
-
-    with _del_brand_cache_lock:
-        if request_id in _del_brand_cache:
-            try:
-                JSON_TASK_QUEUE.put_nowait(item)
-            except Full:
-                print("【删除品牌】队列已满，无法归还重复拉取的任务")
-            item = _del_brand_cache[request_id]
-            print("【删除品牌】并发归并", request_id, item)
-            return jsonify({'success': True, 'data': item})
-        _del_brand_cache[request_id] = item
-        _latest_del_brand_item = item
-        _latest_del_brand_ts = time.time()
-        print("【删除品牌】返回任务数据", item)
-        return jsonify({'success': True, 'data': item})
-    
-
-@communication_bp.route('/api/amazon/get_all_detail', methods=['GET', 'POST'])
-def get_all_detail():
-    """获取正在执行的删除品牌任务详情"""
-    request_id = _resolve_request_id()
-    if not request_id:  #如果没有提供 id 参数，直接返回所有正在执行的任务详情
-        return jsonify({'success': True, 'data': runing_task})
-    task_info = runing_task.get(request_id)
-    if not task_info:
-        return jsonify({'success': False, 'message': '任务不存在', 'data': None})
-    return jsonify({'success': True, 'data': task_info})
-
-
-

app/blueprints/image.py

@@ -1,411 +0,0 @@
-"""
-图片生成蓝图：生成、历史、下载、拼接、版本
-"""
-import os
-import sys
-import json
-import re
-import io
-import base64
-import tempfile
-import threading
-import subprocess
-import requests
-from urllib.parse import urlparse, quote
-
-from flask import Blueprint, request, jsonify, Response, session, send_file
-from PIL import Image
-
-from app_common import get_db, login_required, BASE_DIR
-from config import STITCH_WORKFLOW_ID,client_name
-
-image_bp = Blueprint('image', __name__)
-
-
-def _load_image_from_url_or_data(url_or_data):
-    """从 http(s) URL 或 data URL 加载为 PIL Image，失败返回 None"""
-    if not url_or_data or not isinstance(url_or_data, str):
-        return None
-    try:
-        if url_or_data.startswith('data:'):
-            m = re.match(r'data:image/[^;]+;base64,(.+)', url_or_data, re.DOTALL)
-            if not m:
-                return None
-            raw = base64.b64decode(m.group(1).strip())
-            img = Image.open(io.BytesIO(raw))
-        elif url_or_data.startswith(('http://', 'https://')):
-            resp = requests.get(url_or_data, timeout=15)
-            resp.raise_for_status()
-            img = Image.open(io.BytesIO(resp.content))
-        else:
-            return None
-        if img.mode != 'RGB':
-            img = img.convert('RGB')
-        return img
-    except Exception:
-        return None
-
-
-def _stitch_and_upload_long_image(urls):
-    """将多张图片 URL 先上传获取 file_id，再调用 workflow_run 拼接长图，返回 data.merged_image_url；失败返回 None。"""
-    if not urls or not isinstance(urls, (list, tuple)):
-        return None
-    from coze import upload_file as coze_upload_file, workflow_run
-    file_ids = []
-    temp_paths = []
-    try:
-        for u in urls:
-            img = _load_image_from_url_or_data(u)
-            if img is None:
-                continue
-            fd, path = tempfile.mkstemp(suffix='.png')
-            try:
-                os.close(fd)
-                img.save(path)
-                temp_paths.append(path)
-                resp = coze_upload_file(path)
-                if resp.get('code') == 0 and resp.get('data', {}).get('id'):
-                    file_ids.append(resp['data']['id'])
-            except Exception:
-                pass
-        if not file_ids:
-            return None
-        parameters = {"images": [{"file_id": fid} for fid in file_ids]}
-        resp = workflow_run(STITCH_WORKFLOW_ID, parameters, is_async=False)
-        if resp.get('code') != 0:
-            return None
-        data = resp.get('data') or {}
-        data = json.loads(data)
-        merged_image_url = data.get('merged_image_url')
-        if merged_image_url:
-            return merged_image_url
-        output_str = data.get('output') or ''
-        if output_str:
-            try:
-                outer = json.loads(output_str)
-                inner_str = outer.get('Output', '{}')
-                inner = json.loads(inner_str)
-                data_str = inner.get('data', '[]')
-                inner_data = json.loads(data_str)
-                merged_image_url = inner_data.get('merged_image_url')
-                return merged_image_url
-            except Exception:
-                pass
-        return None
-    except Exception:
-        return None
-    finally:
-        for p in temp_paths:
-            try:
-                os.unlink(p)
-            except Exception:
-                pass
-
-
-def _sanitize_params_for_history(params):
-    """移除 base64 大字段及敏感字段，仅保留可存储的请求参数"""
-    exclude = ('ref_images', 'proc_images', 'layout_image')
-    out = {}
-    for k, v in (params or {}).items():
-        if k == 'api_key':
-            continue
-        if k in exclude:
-            if isinstance(v, list):
-                out[f'{k}_count'] = len(v)
-            else:
-                out[f'{k}_count'] = 1 if v else 0
-        elif isinstance(v, (str, int, float, bool, type(None))):
-            out[k] = v
-        elif isinstance(v, list) and not v:
-            out[k] = []
-        elif isinstance(v, list) and isinstance(v[0], (str, int, float, bool)):
-            out[k] = v
-        else:
-            out[k] = str(v)[:200] if v else None
-    return out
-
-
-@image_bp.route('/api/generate', methods=['POST'])
-@login_required
-def api_generate():
-    """生成图片：调用 generate_api，上传原图到 OSS，保存历史记录"""
-    try:
-        params = request.get_json() or {}
-        from generate_api import generate
-        result = generate(params)
-        if result.get('success') and result.get('urls'):
-            long_image_url = result.get("long_image_url")
-            result["long_image_url"] = long_image_url
-            import json as _json
-            history_id = None
-            try:
-                hid = params.get('history_id')
-                if hid is not None:
-                    try:
-                        hid = int(hid)
-                    except (TypeError, ValueError):
-                        hid = None
-                conn = get_db()
-                with conn.cursor() as cur:
-                    if hid is not None and hid > 0:
-                        cur.execute(
-                            "SELECT result_urls FROM image_history WHERE id=%s AND user_id=%s",
-                            (hid, session['user_id']),
-                        )
-                        row = cur.fetchone()
-                        existing_urls = []
-                        if row and row.get('result_urls'):
-                            try:
-                                existing_urls = _json.loads(row['result_urls'])
-                            except Exception:
-                                existing_urls = []
-                        new_urls = result.get('urls') or []
-                        new_url = new_urls[0] if new_urls else None
-                        idx = params.get('history_index', 0)
-                        try:
-                            idx = int(idx)
-                        except (TypeError, ValueError):
-                            idx = 0
-                        if new_url:
-                            if not isinstance(existing_urls, list):
-                                existing_urls = []
-                            while len(existing_urls) <= idx:
-                                existing_urls.append(existing_urls[-1] if existing_urls else new_url)
-                            existing_urls[idx] = new_url
-                        merged_result_urls = existing_urls or new_urls
-                        cur.execute(
-                            """UPDATE image_history SET panel_type=%s, original_urls=%s, params=%s, result_urls=%s
-                               WHERE id=%s AND user_id=%s""",
-                            (
-                                params.get('panel_type', ''),
-                                _json.dumps(result.get('original_urls') or []),
-                                _json.dumps(_sanitize_params_for_history(params)),
-                                _json.dumps(merged_result_urls),
-                                hid,
-                                session['user_id'],
-                            ),
-                        )
-                        if cur.rowcount > 0:
-                            history_id = hid
-                    else:
-                        cur.execute(
-                            """INSERT INTO image_history (user_id, panel_type, original_urls, params, result_urls, long_image_url)
-                               VALUES (%s, %s, %s, %s, %s, %s)""",
-                            (
-                                session['user_id'],
-                                params.get('panel_type', ''),
-                                _json.dumps(result.get('original_urls') or []),
-                                _json.dumps(_sanitize_params_for_history(params)),
-                                _json.dumps(result.get('urls') or []),
-                                long_image_url,
-                            ),
-                        )
-                        history_id = cur.lastrowid
-                conn.commit()
-                conn.close()
-            except Exception:
-                pass
-            if history_id is not None:
-                result['history_id'] = history_id
-        return jsonify(result)
-    except Exception as e:
-        import traceback
-        traceback.print_exc()
-        return jsonify({'success': False, 'urls': [], 'error': str(e)})
-
-
-@image_bp.route('/api/version')
-def api_version():
-    """检测更新：请求 APP_UPDATE_URL 获取最新版本信息，与当前版本比较"""
-    current_version = (os.environ.get('APP_VERSION', '1.0.0') or '1.0.0').strip()
-    update_url = (os.environ.get('APP_UPDATE_URL', '') or '').strip()
-    result = {
-        'version': current_version,
-        'desc': '',
-        'url': '',
-        'has_update': False,
-        'latest_version': current_version,
-        'file_url': '',
-    }
-    if not update_url:
-        return jsonify(result)
-    try:
-        resp = requests.get(update_url, timeout=10)
-        resp.raise_for_status()
-        data = resp.json() or {}
-        latest_version = (data.get('version') or '').strip()
-        file_url = (data.get('file_url') or '').strip()
-        result['latest_version'] = latest_version
-        result['file_url'] = file_url
-        result['url'] = file_url
-        # 版本不一致则视为有更新
-        if latest_version and latest_version != current_version:
-            result['has_update'] = True
-    except Exception:
-        pass
-    return jsonify(result)
-
-
-def _run_update_and_exit(zip_path, target_dir):
-    """在后台延迟后启动 update.exe（脱离当前进程），然后退出当前程序"""
-    def _do():
-        import time
-        time.sleep(1.5)  # 确保 HTTP 响应已发送
-        # exe_dir = target_dir
-        # exe_dir = "D:\\pack\\nanri\\update_exe\\main.dist"
-        exe_dir = os.path.join(BASE_DIR,"update")
-        update_exe = os.path.join(exe_dir, 'update.exe')
-        if not os.path.isfile(update_exe):
-            return
-        try:
-            creationflags = 0
-            if sys.platform == 'win32':
-                creationflags = subprocess.DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP
-            subprocess.Popen(
-                [update_exe, '--zip', zip_path, '--target', target_dir, '--process',client_name],
-                cwd=exe_dir,
-                creationflags=creationflags,
-                stdin=subprocess.DEVNULL,
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-                close_fds=True,
-            )
-        except Exception:
-            pass
-        os._exit(0)
-    t = threading.Thread(target=_do, daemon=False)
-    t.start()
-
-
-@image_bp.route('/api/update/do', methods=['POST'])
-def api_update_do():
-    """执行更新：下载 zip 到 tmp，启动 update.exe 后退出程序"""
-    data = request.get_json() or {}
-    file_url = (data.get('file_url') or '').strip()
-    if not file_url:
-        return jsonify({'success': False, 'error': '缺少 file_url'}), 400
-    parsed = urlparse(file_url)
-    if parsed.scheme not in ('http', 'https'):
-        return jsonify({'success': False, 'error': '无效的下载地址'}), 400
-    tmp_dir = os.path.join(BASE_DIR, 'tmp')
-    try:
-        os.makedirs(tmp_dir, exist_ok=True)
-    except Exception as e:
-        return jsonify({'success': False, 'error': f'创建 tmp 目录失败: {e}'}), 500
-    # 使用 URL 中的文件名或默认版本名
-    filename = os.path.basename(parsed.path) or 'update.zip'
-    zip_path = os.path.join(tmp_dir, filename)
-    try:
-        resp = requests.get(file_url, timeout=300, stream=True)
-        resp.raise_for_status()
-        with open(zip_path, 'wb') as f:
-            for chunk in resp.iter_content(chunk_size=65536):
-                if chunk:
-                    f.write(chunk)
-    except requests.RequestException as e:
-        return jsonify({'success': False, 'error': f'下载失败: {e}'}), 502
-    _run_update_and_exit(zip_path, BASE_DIR)
-    return jsonify({'success': True, 'message': '更新已启动，程序即将退出'})
-
-
-@image_bp.route('/api/download')
-@login_required
-def api_download():
-    """代理下载图片，解决跨域 fetch 无法下载的问题"""
-    url = request.args.get('url', '').strip()
-    filename = request.args.get('filename', 'image.png')
-    if not url:
-        return jsonify({'success': False, 'error': '缺少 url 参数'}), 400
-    parsed = urlparse(url)
-    if parsed.scheme not in ('http', 'https'):
-        return jsonify({'success': False, 'error': '仅支持 http/https 链接'}), 400
-    try:
-        resp = requests.get(url, timeout=30, stream=True)
-        resp.raise_for_status()
-        content_type = resp.headers.get('Content-Type', 'image/png')
-        encoded = quote(filename, safe='')
-        disposition = f"attachment; filename*=UTF-8''{encoded}"
-        return Response(
-            resp.iter_content(chunk_size=8192),
-            mimetype=content_type,
-            headers={'Content-Disposition': disposition}
-        )
-    except requests.RequestException as e:
-        return jsonify({'success': False, 'error': str(e)}), 502
-
-
-@image_bp.route('/api/stitch/save', methods=['POST'])
-@login_required
-def api_stitch_save():
-    """手动拼接：接收图片 URL 列表（支持 http 或 data URL），拼接并上传，返回长图 URL"""
-    try:
-        data = request.get_json() or {}
-        urls = data.get('urls')
-        if not urls or not isinstance(urls, list):
-            return jsonify({'success': False, 'error': '请提供 urls 数组'}), 400
-        urls = [u for u in urls if u and isinstance(u, str)]
-        if not urls:
-            return jsonify({'success': False, 'error': '没有有效的图片'}), 400
-        long_image_url = _stitch_and_upload_long_image(urls)
-        if not long_image_url:
-            return jsonify({'success': False, 'error': '拼接或上传失败'}), 500
-        return jsonify({'success': True, 'long_image_url': long_image_url})
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)}), 500
-
-
-@image_bp.route('/api/history')
-@login_required
-def api_history():
-    """分页获取当前用户的历史图库，支持按 panel_type 栏目筛选"""
-    page = max(1, int(request.args.get('page', 1)))
-    page_size = min(50, max(10, int(request.args.get('page_size', 20))))
-    panel_type = (request.args.get('panel_type') or '').strip()
-    offset = (page - 1) * page_size
-    try:
-        conn = get_db()
-        with conn.cursor() as cur:
-            where_user = "user_id = %s"
-            params_where = [session['user_id']]
-            if panel_type:
-                where_user += " AND panel_type = %s"
-                params_where.append(panel_type)
-            cur.execute(
-                """SELECT id, created_at, panel_type, original_urls, params, result_urls, long_image_url
-                   FROM image_history WHERE """ + where_user + """ ORDER BY created_at DESC LIMIT %s OFFSET %s""",
-                params_where + [page_size, offset],
-            )
-            rows = cur.fetchall()
-            cur.execute("SELECT COUNT(*) as total FROM image_history WHERE " + where_user, params_where)
-            total = cur.fetchone()['total']
-        conn.close()
-
-        def _parse_json(val, default=None):
-            if val is None:
-                return default if default is not None else []
-            if isinstance(val, (list, dict)):
-                return val
-            try:
-                return json.loads(val)
-            except Exception:
-                return default if default is not None else []
-
-        items = []
-        for r in rows:
-            items.append({
-                'id': r['id'],
-                'created_at': r['created_at'].strftime('%Y-%m-%d %H:%M') if r['created_at'] else '',
-                'panel_type': r['panel_type'] or '',
-                'original_urls': _parse_json(r['original_urls'], []),
-                'params': _parse_json(r['params'], {}),
-                'result_urls': _parse_json(r['result_urls'], []),
-                'long_image_url': (r.get('long_image_url') or '').strip() or None,
-            })
-        return jsonify({'success': True, 'items': items, 'total': total, 'page': page, 'page_size': page_size})
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)})
-
-
-
-
-

app/blueprints/main.py

@@ -1,159 +0,0 @@
-"""
-主页面蓝图：首页、home、图片工作台、品牌页、静态文件、Logo
-"""
-import os
-from flask import Blueprint, send_file
-
-from app_common import (
-    get_db,
-    _render_html,
-    _is_session_user_valid,
-    login_required,
-    admin_required,
-    STATIC_DIR,
-    BASE_DIR,
-    ASSETS_DIR
-)
-from flask import redirect, url_for, session
-from flask import Flask, request, Response, stream_with_context
-import requests
-
-from config import base_url,version,JAVA_API_BASE
-
-main_bp = Blueprint('main', __name__)
-
-
-@main_bp.route('/')
-def index():
-    if session.get('user_id') and _is_session_user_valid():
-        return redirect(url_for('main.home'))
-    return redirect(url_for('auth.login'))
-
-
-@main_bp.route('/home')
-@login_required
-def home():
-    try:
-        conn = get_db()
-        with conn.cursor() as cur:
-            cur.execute("SELECT username, is_admin FROM users WHERE id = %s", (session['user_id'],))
-            row = cur.fetchone()
-        conn.close()
-        return _render_html('home.html', username=row.get('username', ''), is_admin=bool(row.get('is_admin')), user_id=session.get('user_id'),baseUrl=base_url,version=version)
-    except Exception:
-        return _render_html('home.html', username=session.get('username', ''), is_admin=False, user_id=session.get('user_id'),baseUrl=base_url,version=version)
-
-
-@main_bp.route('/image')
-@login_required
-def wb():
-    return _render_html('index.html')
-
-
-@main_bp.route('/brand')
-@login_required
-def brand_page():
-    return _render_html('brand.html')
-
-
-
-
-@main_bp.route('/static/<path:filename>')
-def serve_static(filename):
-    """提供 static 目录及子目录下的静态文件访问。"""
-    filepath = os.path.normpath(os.path.join(STATIC_DIR, filename))
-    static_abs = os.path.abspath(STATIC_DIR)
-    file_abs = os.path.abspath(filepath)
-    if not file_abs.startswith(static_abs) or not os.path.isfile(file_abs):
-        return '', 404
-    return send_file(file_abs, as_attachment=False)
-
-
-@main_bp.route('/assets/<path:filename>')
-def serve_assets(filename):
-    """提供 static 目录及子目录下的静态文件访问。"""
-    filepath = os.path.normpath(os.path.join(ASSETS_DIR, filename))
-    static_abs = os.path.abspath(ASSETS_DIR)
-    file_abs = os.path.abspath(filepath)
-    if not file_abs.startswith(static_abs) or not os.path.isfile(file_abs):
-        return '', 404
-    return send_file(file_abs, as_attachment=False)
-
-
-@main_bp.route('/new_web_source/<path:filename>')
-def serve_new_web_source(filename):
-    """提供 static 目录及子目录下的静态文件访问。"""
-    filepath = os.path.normpath(os.path.join("new_web_source", filename))
-    static_abs = os.path.abspath("new_web_source")
-    file_abs = os.path.abspath(filepath)
-    if not file_abs.startswith(static_abs) or not os.path.isfile(file_abs):
-        return '', 404
-    return send_file(file_abs, as_attachment=False)
-
-
-
-@main_bp.route('/logo.jpg', methods=['GET'])
-def get_logo_image():
-    return send_file(os.path.join(BASE_DIR, "logo.jpg"), mimetype='image/jpeg')
-
-
-@main_bp.route('/newApi/<path:path>', methods=['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'])
-def proxy(path):
-    target_url = f"{JAVA_API_BASE}/{path}"
-
-    # 复制请求参数
-    params = request.args.to_dict()
-
-    # 处理请求头
-    headers = {}
-    for key, value in request.headers:
-        if key.lower() in ['host', 'content-length', 'connection']:
-            continue
-        headers[key] = value
-    try:
-        print("=============================")
-        print("target_url：",target_url)
-        print("params：",params)
-        print("data：",request.get_data())
-        print("=============================")
-    except Exception as e:
-        print("打印失败",e)
-
-    try:
-        # 使用流式请求
-        req = requests.request(
-            method=request.method,
-            url=target_url,
-            params=params,
-            headers=headers,
-            data=request.get_data() if request.get_data() else None,
-            cookies=request.cookies,
-            stream=True,  # 启用流式传输
-            timeout=30
-        )
-
-        # 流式响应
-        def generate():
-            for chunk in req.iter_content(chunk_size=8192):
-                if chunk:
-                    yield chunk
-
-        # 构建响应
-        response = Response(stream_with_context(generate()), status=req.status_code)
-
-        # 复制响应头
-        for key, value in req.headers.items():
-            if key.lower() not in ['content-encoding', 'content-length', 'transfer-encoding', 'connection']:
-                response.headers[key] = value
-
-        return response
-
-    except requests.exceptions.Timeout:
-        print("后端服务超时")
-        return Response("后端服务超时", status=504)
-    except requests.exceptions.ConnectionError:
-        print("无法连接到后端服务")
-        return Response("无法连接到后端服务", status=502)
-    except Exception as e:
-        print(f"代理请求失败: {e}")
-        return Response(f"代理错误: {str(e)}", status=500)

app/brand_spider/main.py

@@ -1,604 +0,0 @@
-import json
-import re
-import random
-import requests
-import time
-import unicodedata
-
-from brand_spider.web_dec import decrypt_via_service, get_guid
-
-try:
-    from config import proxy_url as CONFIG_PROXY_URL, proxy_mode as CONFIG_PROXY_MODE
-except ImportError:
-    CONFIG_PROXY_URL = None
-    CONFIG_PROXY_MODE = 1
-
-# Forbidden 后 3 分钟内统一使用代理：记录代理生效截止时间与当前代理
-_FORBIDDEN_PROXY_UNTIL = 0.0
-_FORBIDDEN_PROXY_DICT = None
-_FORBIDDEN_PROXY_MINUTES = 0.5
-
-
-special_char_pattern = re.compile(r'[^\w\s]')
-
-def remove_accents(input_str):
-    # 将字符分解为基础字符和重音符号
-    nksel = unicodedata.normalize('NFKD', input_str)
-    # 过滤掉非间距重音符号，并重新编码
-    return "".join([c for c in nksel if not unicodedata.combining(c)])
-
-
-def clean_text(text):
-    text = remove_accents(text)
-    return special_char_pattern.sub(' ', text).replace(" ","")
-
-
-def create_code_generator():
-    counter = random.randint(0, 0xFFFFFF)
-    def get_code():
-        nonlocal counter
-        counter = (counter + 1) % 0xFFFFFF
-        low_16_bits = counter & 0xFFFF
-        return f"{low_16_bits:04x}"
-    return get_code()
-
-
-def search(hashsearch, data, proxies=None):
-    global _FORBIDDEN_PROXY_UNTIL, _FORBIDDEN_PROXY_DICT
-
-    url = "https://api.branddb.wipo.int/search"
-    headers = {
-        "accept": "application/json, text/plain, */*",
-        "accept-language": "zh-CN,zh;q=0.9,en;q=0.8",
-        "cache-control": "no-cache",
-        "content-type": "application/json",
-        "hashsearch": hashsearch,
-        "origin": "https://branddb.wipo.int",
-        "pragma": "no-cache",
-        "priority": "u=1, i",
-        "referer": "https://branddb.wipo.int/",
-        "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36"
-    }
-
-
-
-    # 若 3 分钟内曾出现 Forbidden，则直接使用当时保存的代理
-    now = time.time()
-    if now < _FORBIDDEN_PROXY_UNTIL and _FORBIDDEN_PROXY_DICT:
-        proxies = _FORBIDDEN_PROXY_DICT
-        print("处于 Forbidden 代理窗口内，直接使用代理",proxies)
-
-    # 发送 POST 请求
-    response = requests.post(url, headers=headers, json=data, proxies=proxies)
-    enc_text = response.text
-    # print("原始结果", enc_text)
-
-    # 若返回 Forbidden，则从 config 的 proxy_url 获取代理 IP 后重试，并开启 3 分钟代理窗口
-    if (enc_text.strip() == '{"message":"Forbidden"}' or "Too Many Requests" in enc_text) and CONFIG_PROXY_URL:
-        try:
-            proxy_resp = requests.get(CONFIG_PROXY_URL, timeout=10)
-            print("代理请求结果->：", proxy_resp.text)
-            # 模式 2：账号密码代理，接口返回 JSON
-            if CONFIG_PROXY_MODE == 2:
-                resp_json = proxy_resp.json()
-                proxy_list = resp_json.get("data", {}).get("list") or []
-                first_item = proxy_list[0] if proxy_list else None
-                if first_item:
-                    ip = first_item.get("ip")
-                    port = first_item.get("port")
-                    account = first_item.get("account")
-                    password = first_item.get("password")
-                    if ip and port and account and password:
-                        auth_proxy = f"{account}:{password}@{ip}:{port}"
-                        print("获取到账号密码代理：", auth_proxy)
-                        proxies = {
-                            "http": f"http://{auth_proxy}",
-                            "https": f"http://{auth_proxy}",
-                        }
-            # 默认模式 1：普通 IP:port 文本
-            if CONFIG_PROXY_MODE != 2:
-                proxy_ip = (proxy_resp.text or "").strip()
-                if proxy_ip:
-                    proxies = {
-                        "http": f"http://{proxy_ip}",
-                        "https": f"http://{proxy_ip}",
-                    }
-
-            if proxies:
-                response = requests.post(url, headers=headers, json=data, proxies=proxies)
-                enc_text = response.text
-                print("代理重试结果", enc_text)
-                # 记录 3 分钟内都使用该代理
-                _FORBIDDEN_PROXY_UNTIL = now + _FORBIDDEN_PROXY_MINUTES * 60
-                _FORBIDDEN_PROXY_DICT = proxies
-        except Exception as e:
-            print("获取代理或重试失败:", e)
-
-    return enc_text
-
-
-class TaskCancelledError(Exception):
-    """用户取消任务时抛出，供上层捕获并中止"""
-    pass
-
-
-def single_file_handle(brand, strategy="Terms"):
-    status_info = {
-        "Ended": "已结束",
-        "Expired": "已过期的",
-        "Pending": "待决",
-        "Registered": "已注册",
-        "RegisteredMadrid": "国际注册有效",
-        "Unknown": "未知"
-    }
-    country_info = {
-        "AB": "ARABPAT",
-        "AD": "安道尔",
-        "AE": "UAE",
-        "AF": "阿富汗",
-        "AFR": "非洲",
-        "AG": "安提瓜和巴布达",
-        "AI": "安圭拉",
-        "AL": "阿尔巴尼亚",
-        "AM": "亚美尼亚",
-        "AN": "荷属安的列斯",
-        "ANT": "南极洲",
-        "AO": "安哥拉",
-        "AP": "非洲地区知识产权组织 ",
-        "AQ": "南极洲",
-        "AR": "阿根廷",
-        "AS": "美属萨摩亚",
-        "ASI": "亚洲",
-        "AT": "奥地利",
-        "AU": "澳大利亚",
-        "AW": "阿鲁巴",
-        "AX": "奥兰群岛",
-        "AZ": "阿塞拜疆",
-        "BA": "波斯尼亚和黑塞哥维纳",
-        "BB": "巴巴多斯",
-        "BD": "孟加拉国",
-        "BE": "比利时",
-        "BF": "布基纳法索",
-        "BG": "保加利亚",
-        "BH": "巴林",
-        "BI": "布隆迪",
-        "BJ": "贝宁",
-        "BL": "圣巴泰勒米",
-        "BM": "百慕大",
-        "BN": "文莱达鲁萨兰国",
-        "BO": "多民族玻利维亚国",
-        "BQ": "博纳尔、圣俄斯塔休斯和萨巴",
-        "BR": "巴西",
-        "BS": "巴哈马",
-        "BT": "不丹",
-        "BV": "布韦岛",
-        "BW": "博茨瓦纳",
-        "BX": "比荷卢知识产权局",
-        "BY": "白俄罗斯",
-        "BZ": "伯利兹",
-        "CA": "加拿大",
-        "CC": "科科斯群岛（基灵群岛）",
-        "CD": "刚果民主共和国",
-        "CF": "中非共和国",
-        "CG": "刚果",
-        "CH": "瑞士",
-        "CI": "科特迪瓦",
-        "CK": "库克群岛",
-        "CL": "智利",
-        "CM": "喀麦隆",
-        "CN": "中国",
-        "CO": "哥伦比亚",
-        "CR": "哥斯达黎加",
-        "CS": "捷克斯洛伐克",
-        "CU": "古巴",
-        "CV": "佛得角",
-        "CW": "库拉索",
-        "CX": "圣诞岛",
-        "CY": "塞浦路斯",
-        "CZ": "捷克共和国",
-        "DD": "德意志民主共和国",
-        "DE": "德国",
-        "DJ": "吉布提",
-        "DK": "丹麦",
-        "DM": "多米尼克",
-        "DO": "多米尼加",
-        "DT": "西德",
-        "DZ": "阿尔及利亚",
-        "EA": "欧亚专利组织",
-        "EC": "厄瓜多尔",
-        "EE": "爱沙尼亚",
-        "EG": "埃及",
-        "EH": "西撒哈拉",
-        "EM": "欧洲联盟",
-        "EP": "欧洲专利局",
-        "ER": "厄立特里亚",
-        "ES": "西班牙",
-        "ET": "埃塞俄比亚",
-        "EUR": "欧洲",
-        "FI": "芬兰",
-        "FJ": "斐济",
-        "FK": "福克兰群岛（马尔维纳斯群岛）",
-        "FM": "密克罗尼西亚联邦",
-        "FO": "法罗群岛",
-        "FR": "法国",
-        "GA": "加蓬",
-        "GB": "英国",
-        "GC": "海湾阿拉伯国家合作委员会专利局",
-        "GD": "格林纳达",
-        "GE": "格鲁吉亚",
-        "GF": "法属圭亚那",
-        "GG": "格恩西岛",
-        "GH": "加纳",
-        "GI": "直布罗陀",
-        "GL": "格陵兰",
-        "GM": "冈比亚",
-        "GN": "几内亚",
-        "GP": "瓜德罗普",
-        "GQ": "赤道几内亚",
-        "GR": "希腊",
-        "GS": "南乔治亚和南桑威奇群岛",
-        "GT": "危地马拉",
-        "GU": "关岛",
-        "GW": "几内亚比绍",
-        "GY": "圭亚那",
-        "HK": "香港",
-        "HM": "赫德岛和麦克唐纳群岛",
-        "HN": "洪都拉斯",
-        "HR": "克罗地亚",
-        "HT": "海地",
-        "HU": "匈牙利",
-        "IB": "世界知识产权组织国际局",
-        "ID": "印度尼西亚",
-        "IE": "爱尔兰",
-        "IL": "以色列",
-        "IM": "马恩岛",
-        "IN": "印度",
-        "INN": "世界卫生组织",
-        "IO": "英属印度洋领地",
-        "IQ": "伊拉克",
-        "IR": "伊朗伊斯兰共和国",
-        "IS": "冰岛",
-        "IT": "意大利",
-        "JE": "泽西岛",
-        "JM": "牙买加",
-        "JO": "约旦",
-        "JP": "日本",
-        "KE": "肯尼亚",
-        "KG": "吉尔吉斯斯坦",
-        "KH": "柬埔寨",
-        "KI": "基里巴斯",
-        "KM": "科摩罗",
-        "KN": "圣基茨和尼维斯",
-        "KP": "朝鲜民主主义人民共和国",
-        "KR": "大韩民国",
-        "KW": "科威特",
-        "KY": "开曼群岛",
-        "KZ": "哈萨克斯坦",
-        "LA": "老挝人民民主共和国",
-        "LB": "黎巴嫩",
-        "LC": "圣卢西亚",
-        "LI": "列支敦士登",
-        "LISBON": "WIPO",
-        "LK": "斯里兰卡",
-        "LP": "LATIPAT",
-        "LR": "利比里亚",
-        "LS": "莱索托",
-        "LT": "立陶宛",
-        "LU": "卢森堡",
-        "LV": "拉脱维亚",
-        "LY": "利比亚",
-        "MA": "摩洛哥",
-        "MC": "摩纳哥",
-        "MD": "摩尔多瓦共和国",
-        "ME": "黑山",
-        "MF": "圣马丁（法国部分）",
-        "MG": "马达加斯加",
-        "MH": "马绍尔群岛",
-        "MK": "北马其顿共和国",
-        "ML": "马里",
-        "MM": "缅甸",
-        "MN": "蒙古",
-        "MO": "澳门",
-        "MP": "北马里亚纳群岛",
-        "MQ": "马提尼克",
-        "MR": "毛里塔尼亚",
-        "MS": "蒙特塞拉特",
-        "MT": "马耳他",
-        "MU": "毛里求斯",
-        "MV": "马尔代夫",
-        "MW": "马拉维",
-        "MX": "墨西哥",
-        "MY": "马来西亚",
-        "MZ": "莫桑比克",
-        "NA": "纳米比亚",
-        "NAM": "北美洲",
-        "NC": "新喀里多尼亚",
-        "NE": "尼日尔",
-        "NF": "诺福克岛",
-        "NG": "尼日利亚",
-        "NI": "尼加拉瓜",
-        "NL": "荷兰",
-        "NO": "挪威",
-        "NP": "尼泊尔",
-        "NR": "瑙鲁",
-        "NU": "纽埃",
-        "NZ": "新西兰",
-        "OA": "非洲知识产权组织",
-        "OCE": "大洋洲",
-        "OM": "阿曼",
-        "PA": "巴拿马",
-        "PE": "秘鲁",
-        "PF": "法属波利尼西亚",
-        "PG": "巴布亚新几内亚",
-        "PH": "菲律宾",
-        "PK": "巴基斯坦",
-        "PL": "波兰",
-        "PM": "圣皮埃尔和密克隆",
-        "PN": "皮特凯恩",
-        "PR": "波多黎各",
-        "PS": "巴勒斯坦",
-        "PT": "葡萄牙",
-        "PW": "帕劳",
-        "PY": "巴拉圭",
-        "QA": "卡塔尔",
-        "QO": "没有ST.3代码的组织",
-        "QZ": "欧洲联盟",
-        "RE": "留尼汪",
-        "RO": "罗马尼亚",
-        "RS": "塞尔维亚",
-        "RU": "俄罗斯联邦",
-        "RW": "卢旺达",
-        "SA": "沙特阿拉伯",
-        "SAM": "南美洲",
-        "SB": "所罗门群岛",
-        "SC": "塞舌尔",
-        "SD": "苏丹",
-        "SE": "瑞典",
-        "SG": "新加坡",
-        "SH": "圣赫勒拿、阿森松和特里斯坦-达库尼亚",
-        "SI": "斯洛文尼亚",
-        "SIXTER": "WIPO",
-        "SJ": "斯瓦尔巴和扬马延",
-        "SK": "斯洛伐克",
-        "SL": "塞拉里昂",
-        "SM": "圣马力诺",
-        "SN": "塞内加尔",
-        "SO": "索马里",
-        "SR": "苏里南",
-        "SS": "南苏丹",
-        "ST": "圣多美和普林西比",
-        "SU": "苏联",
-        "SV": "萨尔瓦多",
-        "SX": "圣马丁（荷兰部分）",
-        "SY": "阿拉伯叙利亚共和国",
-        "SZ": "斯威士兰",
-        "TC": "特克斯和凯科斯群岛",
-        "TD": "乍得",
-        "TF": "法属南部领地",
-        "TG": "多哥",
-        "TH": "泰国",
-        "TJ": "塔吉克斯坦",
-        "TK": "托克劳",
-        "TL": "东帝汶",
-        "TM": "土库曼斯坦",
-        "TN": "突尼斯",
-        "TO": "汤加",
-        "TR": "土耳其",
-        "TT": "特立尼达和多巴哥",
-        "TV": "图瓦卢",
-        "TW": "台湾（中国的省）",
-        "TZ": "坦桑尼亚联合共和国",
-        "UA": "乌克兰",
-        "UG": "乌干达",
-        "UK": "UK",
-        "UM": "美国本土外小岛屿",
-        "US": "USA",
-        "UY": "乌拉圭",
-        "UZ": "乌兹别克斯坦",
-        "VA": "罗马教廷",
-        "VC": "圣文森特和格林纳丁斯",
-        "VE": "委内瑞拉玻利瓦尔共和国",
-        "VG": "英属维尔京群岛",
-        "VI": "美属维尔京群岛",
-        "VN": "越南",
-        "VU": "瓦努阿图",
-        "WF": "瓦利斯和富图纳",
-        "WHO": "世界卫生组织",
-        "WO": "WIPO",
-        "WS": "萨摩亚",
-        "XK": "科索沃共和国",
-        "XN": "北欧专利局",
-        "XX": "国际",
-        "XXX": "跨国和国际局",
-        "YD": "民主也门",
-        "YE": "也门",
-        "YT": "马约特岛",
-        "YU": "塞尔维亚和黑山",
-        "ZA": "南非",
-        "ZM": "赞比亚",
-        "ZW": "津巴布韦"
-    }
-
-    check_value = [
-        "瑞典",
-        "芬兰",
-        "丹麦",
-        "挪威",
-        "冰岛",
-        "法国",
-        "爱尔兰",
-        "荷兰",
-        "比利时",
-        "卢森堡",
-        "英国",
-        "摩纳哥",
-        "德国",
-        "波兰",
-        "捷克",
-        "斯洛伐克",
-        "匈牙利",
-        "奥地利",
-        "瑞士",
-        "列支敦士登",
-        "爱沙尼亚",
-        "拉脱维亚",
-        "立陶宛",
-        "俄罗斯",
-        "白俄罗斯",
-        "乌克兰",
-        "摩尔多瓦",
-        "西班牙",
-        "葡萄牙",
-        "意大利",
-        "希腊",
-        "斯洛文尼亚",
-        "克罗地亚",
-        "罗马尼亚",
-        "保加利亚",
-        "塞尔维亚",
-        "阿尔巴尼亚",
-        "黑山",
-        "马耳他",
-        "塞浦路斯",
-        "北马其顿",
-        "梵蒂冈",
-        "圣马力诺",
-        "安道尔",
-        "波黑",
-        "欧洲联盟"
-    ]
-    check_staus = ["已过期的","已结束"]
-
-    # 5. 初始化不符合品牌的数据列表
-    faild_data = []
-    # 初始化查询失败的品牌的数据列表
-    query_faild_data = []
-
-
-    # Simple 策略下最多翻 3 页（0,30,60），直到命中 554 行判断
-    max_pages = 3 if strategy == "Simple" else 1
-    page = 0
-    matched = False
-
-    while page < max_pages and not matched:
-        try:
-            as_structure_dict = {
-                "_id": create_code_generator(),
-                "boolean": "AND",
-                "bricks": [
-                    {
-                        "_id": create_code_generator(),
-                        "key": "brandName",
-                        "value": brand,
-                        "strategy": strategy
-                    }
-                ]
-            }
-            # 构造 asStructure 内部 JSON 对象
-            as_structure_dict = as_structure_dict
-            # print(as_structure_dict)
-
-            # 将内部对象转为 JSON 字符串（作为 asStructure 字段的值）
-            as_structure_str = json.dumps(as_structure_dict, ensure_ascii=False)
-            data = {
-                "sort": "score desc",
-                "rows": "30",
-                "asStructure": as_structure_str,
-                "fg": "_void_"
-            }
-
-            # 翻页：第二页 start=30，第三页 start=60（仅 Simple 策略）
-            if strategy == "Simple" and page > 0:
-                data["start"] = str(30 * page)
-
-            # print("请求参数", as_structure_dict, "页码:", page)
-            hashsearch = get_guid()
-            enc_text = search(hashsearch, data)
-            print(f"【{hashsearch}】待解密-->", enc_text)
-            dec_text = decrypt_via_service(hashsearch, enc_text)
-            # print(type(dec_text))
-            dec_text = str(dec_text)
-            # print(f"解密之后的结果-->", dec_text)
-            data = json.loads(dec_text)
-        except Exception as e:
-            # 仅第一页请求失败时记录为查询失败品牌
-            if page == 0:
-                import traceback
-                traceback.print_exc()
-                safe_brand = brand.encode('gbk', errors='replace').decode('gbk')
-                print(f"品牌：{safe_brand},处理失败:{e}")
-                # query_faild_data.append({"brand": brand, "time": datetime.datetime.now().strftime("%y-%m-%d %H:%M:%S")})
-                query_faild_data.append(brand)
-            break
-
-        # print(data)
-
-        if data.get("response", {}).get("numFound", 0) > 0:
-            if strategy == "Simple":
-                new_brand_name = clean_text(brand)
-                _brand = new_brand_name.lower()
-            else:
-                _brand = brand
-
-            docs = data["response"]["docs"]
-            for d in docs:
-                office = d.get("office")
-                status = d.get("status")
-                registrationDate = d.get("registrationDate")
-                status_name = status_info.get(status, status)
-                brand_name = d.get("brandName")
-                if isinstance(brand_name, list):
-                    brand_name = "|".join(brand_name)
-
-                if strategy == "Simple":
-                    new_brand_name = clean_text(brand_name)
-                    new_brand_name = new_brand_name.lower()
-                    if _brand != new_brand_name:
-                        continue
-
-                check_office = d.get("designation")
-
-                check_office.append(office)
-                for i in set(check_office):
-                    office_name = country_info.get(i, i)
-                    # print(office_name,office_name in check_value and status_name not in check_staus)
-                    if office_name in check_value and status_name not in check_staus:
-                        # 命中 554 行判断，记录并结束当前品牌后续翻页
-                        # data_rows = [row for row in data_rows if row.get("品牌") != brand]
-                        # print(office_name, office in ["EM","QZ"] and i not in ["EM","QZ"])
-                        if office in ["EM","QZ"] and i not in ["EM","QZ"]:
-                            continue
-
-                        if strategy == "Simple":
-                            faild_data.append({"brand": brand, "country": office_name, "status": status_name}) # "reason":"|".join(d.get("brandName","")
-                            matched = True
-                        else:
-                            # print("添加",brand,office_name)
-                            faild_data.append({"brand": brand, "country": office_name, "status": status_name})
-                        # break
-                if matched:
-                    break
-
-        # 如果 Simple 策略下本页未命中，则翻下一页；其他策略不翻页
-        if not matched:
-            page += 1
-
-
-    return faild_data,query_faild_data
-
-
-if __name__ == '__main__':
-    file_path = r"D:\\私单交付\\maixiang_AI\\测试图片数据\\品牌采集测试\\brand_task_73\\源文件\\brand_task_75\\源文件\\3.10.xlsx"
-    res = single_file_handle(file_path,"结果.xlsx")
-    print(res)
-
-
-
-
-
-
-
-
-
-
-

app/brand_spider/web_dec.py

@@ -1,126 +0,0 @@
-"""
-通过 pywebview 加载本地 HTML，执行 JS 实现解密与 GUID 生成。
-"""
-import json
-import threading
-import traceback
-
-import webview
-
-# 内嵌 HTML：加载 CryptoJS 并定义 decryptWithHashSearches、guid
-_DECRYPT_HTML = """
-<!DOCTYPE html>
-<html>
-<head>
-    <meta charset="utf-8">
-    <script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/4.1.1/crypto-js.min.js"></script>
-</head>
-<body>
-<script>
-function decryptWithHashSearches(ciphertext, hashSearches) {
-    try {
-        var baseKey = "8?)i_~Nk6qv0IX;2";
-        var keyStr = baseKey + (hashSearches || "");
-        var key = CryptoJS.enc.Utf8.parse(keyStr);
-
-        var decrypted = CryptoJS.AES.decrypt(ciphertext, key, {
-            mode: CryptoJS.mode.ECB
-        });
-
-        return decrypted.toString(CryptoJS.enc.Utf8);
-    } catch (error) {
-        console.error('解密失败:', error.message);
-        return '';
-    }
-}
-
-function guid() {
-    function _p8(s) {
-        var p = (Math.random().toString(16) + "000000000").substr(2, 8);
-        return s ? "-" + p.substr(0, 4) + "-" + p.substr(4, 4) : p;
-    }
-    return _p8() + _p8(true) + _p8(true) + _p8();
-}
-</script>
-</body>
-</html>
-"""
-
-_window = None
-_window_ready = threading.Event()
-_init_lock = threading.Lock()
-
-
-def _ensure_window():
-    """首次调用时在后台线程启动 pywebview 并等待页面加载完成。"""
-    global _window
-    with _init_lock:
-        if _window is not None:
-            return
-        _window = webview.create_window(
-            "",
-            html=_DECRYPT_HTML,
-            width=1,
-            height=1,
-            hidden=True,
-        )
-
-        def run():
-            webview.start(debug=False)
-
-        t = threading.Thread(target=run, daemon=True)
-        t.start()
-        _window.events.loaded.wait()
-        _window_ready.set()
-    _window_ready.wait()
-
-
-def decrypt_via_service(hash_searches, ciphertext):
-    """
-    通过 pywebview 执行 JS decryptWithHashSearches 进行 AES-ECB 解密。
-
-    :param hash_searches: 对应 JS 的 hashSearches（密钥后缀，可为空串）
-    :param ciphertext: Base64 密文
-    :return: 解密后的 UTF-8 字符串，失败返回空串
-    """
-    _ensure_window()
-    # 将参数安全注入 JS（避免注入与引号问题）
-    ciphertext_js = json.dumps(ciphertext)
-    hash_searches_js = json.dumps(hash_searches or "")
-    js = f"(function(){{ return decryptWithHashSearches({ciphertext_js}, {hash_searches_js}); }})();"
-    try:
-        result = _window.evaluate_js(js)
-        return result if result is not None else ""
-    except Exception as e:
-        raise RuntimeError(f"解密失败: {e}") from e
-
-
-def get_guid():
-    """通过 pywebview 执行 JS guid() 生成 UUID 格式字符串。"""
-    _ensure_window()
-    try:
-        result = _window.evaluate_js("(function(){ return guid(); })();")
-        if result is None:
-            raise RuntimeError("guid() 返回为空")
-        return result
-    except Exception as e:
-        raise RuntimeError(f"获取 GUID 失败: {e}") from e
-
-
-# 使用示例
-if __name__ == "__main__":
-    # 参数含义：hash_searches 对应原 key，ciphertext 对应原 data
-    hash_searches = "a6efb809-b714-7efd-4b64-8c650b9030f0"
-    ciphertext = "SEsfpOGa8B+sWk0ncknTNh/HNHbGiEVi/RNKxBvyHmAE5VjHonPi202c6VicC/GKfA8mLsIC5mGEpSaH2DdCaEJKeOTWD9SBHHbgtyS1O60VqjgAaptYe9LivvWKc/BU8sZOqhxPMzGUHDcKUts7d0p+hCc80XCXyM2ZT80smM1twndcDfpGkLDk2kJbzl2bGzIc60sl9MzKWfZA2sE0ztFjQ9wD2uhn5LrwoN8NnpiPLNbviMMGtHh4N6Dc0xtPzkzgfkiuxBfWnN1SeM9XVgujHvAGea/dqUWIJqLo26fZIOEFJ0MYL4c8CGLYIeP/70cT2IqJdf+IPBWsCiP29zSyAiQd3yLNvd8+xBLky7lR4ng3MZizn/vhW/5BSg1FtVglbAmNbKgHOIbtpP197Lv+uahx2IpsSPqpy4j2O2VV25YzBk9JpJ4WGG/SvF3f2ZYKKepEQ+kGmBxAfG/5Z8DTNIwnOpXhyjFpJb+fUdPV6LTCK/yFc8g31bNFAJkLW7y/VjewjFravZ3VfQjNAHCvifnrIxGG22MZ3TLVnlbh6ye6vTnd+v9GzqXu+ISR7vQGL/ZSM/bJIjuVkP2XnNUPf+NFdt75gyDmTylFmmbpg7WHaBjinPcyVjeZ38+quJhT8yEk66BOjBM47mVdfU8JLK3ToghxQ54dKWGUbc9HRzYIAQ0rIBBExcOcPM4J9DpufvajmEygoDaws4CxOQDlFoFLwNBYorJsKzAoDe1Cu8oFtk4x190Vd+leRKq6DQSNJwEmyrVkWyFpiuywSMaixFlSqve0lRs50FclXfV7gkBAAvz/DJp90i9yCJdMaihP5ZCvbhKxFGMowkU+tx5Ptnxd9hq6tUxHmuiwDI1eyY8EyjB+3MbrC3H/GY39Z5Qhkj5tkSBm4oGA/h6YjeunBlfMU/QGP3hyZIYALh/YmBlZxAcglWwcqlISUhcx1L3Dbw6ZQbpAmYHmA421xIlRJkdJuPmGoopcoFEVdIO0Ov3uP2JL5ybvUgCBMnbwcYRK9qRmvn2b8jHKch55YXerHBDCEMHz88rfgNIEL8DIAp+wMuIyJ0VrV0BwAXioLYNvMcggBp06gghq2NykGiXRZ/dz8nffFqPVkDNjzcPSGrml9fpKdO8x/GannMNBsA+oHlO2/d4dyo+Q2dZCarQ5UB/N1p+UsTW90kvITKwCbZfV/YY2NRm7HrXq+wLS1vY4mChY82Ybc3cYQT653Q=="
-
-    try:
-        decrypted_text = decrypt_via_service(hash_searches, ciphertext)
-        print("解密结果:", decrypted_text)
-    except Exception as e:
-        print("错误:", e)
-
-    try:
-        g = get_guid()
-        print("GUID:", g)
-    except Exception as e:
-        print("GUID 错误:", e)

app/config.py

@@ -1,95 +0,0 @@
-base_url = "https://api.coze.cn/v1"
-coze_token = "sat_12nW40INoJxArrDXbY4lSCoudbqkOYTcphC99BP2efWyzxmsk4q81WDX3ezWgqZ5"
-workflow_id = "7608812635877900322"
-STITCH_WORKFLOW_ID = "7608813873483300907"
-
-import os
-from dotenv import load_dotenv
-from queue import Queue
-load_dotenv()
-_base_url = os.getenv("base_url","http://159.75.121.33:15124")
-
-# MySQL 配置
-mysql_host = os.getenv("mysql_host")
-mysql_user = os.getenv("mysql_user")
-mysql_password = os.getenv("mysql_password","WTFrb5y6hNLz6hNy")
-mysql_database = os.getenv("mysql_database","aiimage")
-proxy_url = os.getenv("proxy_url")
-proxy_mode = int(os.getenv("proxy_mode",1))
-
-client_name=os.getenv("client_name") + ".exe"
-JAVA_API_BASE = os.getenv("java_api_base", "http://127.0.0.1:18080")
-
-# 紫鸟浏览器配置
-ZN_COMPANY = os.getenv("zn_company", "")
-ZN_USERNAME = os.getenv("zn_username", "")
-ZN_PASSWORD = os.getenv("zn_password", "")
-
-# 删除品牌API配置
-DELETE_BRAND_API_BASE = os.getenv("DELETE_BRAND_API_BASE", JAVA_API_BASE)
-
-
-cache_path = "./user_data"
-
-region = "cn-hangzhou"
-endpoint = "oss-cn-hangzhou.aliyuncs.com"
-bucket = "nanri-ai-images"
-accessKeyId = "LTAI5tNpyvzMNz9f2dHarsm8"
-accessKeySecret = "bQSZnFH455i8tzyOgeahJmUzwmhynz"
-bucket_path = "nanri-image/"
-
-file_url_pre = f"https://{bucket}.oss-cn-hangzhou.aliyuncs.com/"
-
-
-
-os.environ['OSS_ACCESS_KEY_ID'] = accessKeyId
-os.environ['OSS_ACCESS_KEY_SECRET'] = accessKeySecret
-os.environ['SECRET_KEY'] = "ddffc7c1d02121d9554d7b080b2511b6"
-
-
-debug = True
-version = "1.0.13"
-APP_UPDATE_URL = f"{_base_url}/api/version/latest"  # 检测更新接口地址，返回 { "file_url": "...", "version": "x.x.x" }
-os.environ['APP_VERSION'] = version
-os.environ['APP_UPDATE_URL'] = APP_UPDATE_URL
-
-
-# 队列
-JSON_TASK_QUEUE = Queue()
-
-#删除品牌，正在执行中的任务
-runing_task = {
-
-}
-# 正在执行中的店铺
-runing_shop = {}
-
-# 
-# runing_task = {
-#     "497": {
-#         "status": "running",              # running/completed/failed
-#         "start_time": "2026-04-01 10:00:00",
-#         "stop_requested": False,
-#         "current_shop": "魏振峰",
-#         "current_country": "德国",
-#         "current_asin": "B0D451RQRG",
-#         "total_shops": 1,
-#         "processed_shops": 0,
-#         "total_asins": 14,
-#         "processed_asins": 3,
-#         "success_count": 2,
-#         "failed_count": 1
-#     }
-# }
-
-
-
-
-
-
-
-
-
-
-
-

app/coze.py

@@ -1,92 +0,0 @@
-import requests
-import time
-
-from config import base_url, coze_token
-
-
-
-
-
-def upload_file(file_path,_coze_token =coze_token):
-    url = f"{base_url}/files/upload"
-    headers = {
-        "Authorization": f"Bearer {_coze_token}"
-    }
-    print(file_path)
-    with open(file_path, 'rb') as f:
-        files = {
-            'file': f
-        }
-        # with open(f"{time.time()".replace(".","_")+".png","wb") as file:
-        #     file.write(f.read())
-        # allow_redirects=True 模拟 curl 的 --location，默认即为 True
-        response = requests.post(url, headers=headers, files=files, allow_redirects=True)
-    data = response.json()
-    print("上传图片->>",data)
-    return data
-
-def workflow_run(workflow_id, parameters,_coze_token = coze_token,is_async=True):
-    url = f"{base_url}/workflow/run"
-    headers = {
-        "Authorization": f"Bearer {_coze_token}",
-        "Content-Type": "application/json"
-    }
-
-    # 请求体（JSON 格式）
-    payload = {
-        "parameters": parameters,
-        # "parameters": {
-        #     "name": "包包",
-        #     "ratio": "3:4",
-        #     "menu": 3,
-        #     "resolution": "2K",
-        #     "count": 1,
-        #     "desc": "1、一个中国美女手上挎着这个包，2、站在商场内",
-        #     "language": "中文",
-        #     "style": "极简高级"
-        # },
-        "workflow_id": workflow_id,
-        "is_async" : is_async,
-    }
-    # 发送 POST 请求（使用 json 参数自动序列化并设置 Content-Type）
-    response = requests.post(url, headers=headers, json=payload)
-    data = response.json()
-
-    print("图片生成参数->>",payload)
-    print("图片生成->>",data)
-    return data
-
-
-def query_result(workflow_id, execute_id,_coze_token=coze_token):
-    url = f"{base_url}/workflows/{workflow_id}/run_histories/{execute_id}"
-    headers = {
-        "Authorization": f"Bearer {_coze_token}",
-        "Content-Type": "application/json"
-    }
-    response = requests.get(url, headers=headers)
-    data = response.json()
-    print(f"【{execute_id}】结果查询->>",data)
-    return data
-
-if __name__ == '__main__':
-    from config import  workflow_id
-
-    parameters = {
-    "images": [
-      {
-        "file_id": "7612667079497613350",
-
-      },{
-            "file_id": "7612667042990768174",
-        },{
-            "file_id": "7612667111332577332",
-        }
-    ]
-  }
-    # resp = workflow_run("7607680760402100258",parameters,_coze_token="sat_ZVNLR9Om54A3iMlJWAasHF9kbtDZnR3BjwjAxRwe8x7igEW446y5ROyVlW1UlpVX")
-    # print(resp)
-
-    # resp = query_result("7607680760402100258","7612668958797447187",_coze_token="sat_ZVNLR9Om54A3iMlJWAasHF9kbtDZnR3BjwjAxRwe8x7igEW446y5ROyVlW1UlpVX")
-    # print(resp)
-    resp = upload_file("D:\私单交付\maixiang_AI\测试图片数据\IMG_2686.JPG",_coze_token="sat_ZVNLR9Om54A3iMlJWAasHF9kbtDZnR3BjwjAxRwe8x7igEW446y5ROyVlW1UlpVX")
-    print(resp)

app/generate_api.py

@@ -1,261 +0,0 @@
-"""
-生成图片 API - 供 pywebview 前端调用
-流程：上传图片 -> workflow_run -> 轮询 query_result -> 解析返回图片 URL
-"""
-
-import base64
-import json
-import os
-import tempfile
-import time
-import re
-import traceback
-
-import requests
-
-from coze import upload_file, workflow_run, query_result
-from config import workflow_id
-from ali_oss import upload_data_urls as oss_upload_data_urls
-
-
-def _data_url_to_temp_file(data_url: str, allow_video: bool = False) -> str:
-    """将 base64 data URL 转为临时文件路径"""
-    # data:image/png;base64,xxxx 或 data:video/mp4;base64,xxxx
-    if allow_video:
-        match = re.match(r'data:(?:image|video)/(\w+);base64,(.+)', data_url)
-    else:
-        match = re.match(r'data:image/(\w+);base64,(.+)', data_url)
-    if not match:
-        raise ValueError('无效的 data URL 格式')
-    mime = match.group(1).lower()
-    ext_map = {'png': 'png', 'webp': 'png', 'jpeg': 'jpg', 'jpg': 'jpg', 'mp4': 'mp4', 'webm': 'webm'}
-    ext = ext_map.get(mime, 'jpg')
-    data = base64.b64decode(match.group(2))
-    fd, path = tempfile.mkstemp(suffix=f'.{ext}')
-    try:
-        os.write(fd, data)
-    finally:
-        os.close(fd)
-    return path
-
-
-def _upload_video(video_data_url: str) -> str:
-    """上传视频，返回 file_id"""
-    if not video_data_url or not isinstance(video_data_url, str):
-        raise ValueError('无效的视频数据')
-    path = _data_url_to_temp_file(video_data_url, allow_video=True)
-    try:
-        resp = upload_file(path)
-        if resp.get('code') == 0 and resp.get('data', {}).get('id'):
-            return resp['data']['id']
-        raise RuntimeError(f'视频上传失败: {resp.get("msg", resp)}')
-    finally:
-        try:
-            os.unlink(path)
-        except Exception:
-            pass
-
-
-def _upload_images(image_data_urls: list) -> list:
-    """上传多张图片，返回 file_id 列表"""
-    file_ids = []
-    temp_paths = []
-    try:
-        for data_url in (image_data_urls or []):
-            if not data_url or not isinstance(data_url, str):
-                continue
-            if data_url.startswith("http"):
-                fd, path = tempfile.mkstemp(suffix=f'.png')
-                data_content = requests.get(data_url).content
-                os.write(fd, data_content)
-            else:
-                path = _data_url_to_temp_file(data_url)
-            temp_paths.append(path)
-            resp = upload_file(path)
-            if resp.get('code') == 0 and resp.get('data', {}).get('id'):
-                file_ids.append(resp['data']['id'])
-            else:
-                raise RuntimeError(f'上传失败: {resp.get("msg", resp)}')
-        return file_ids
-    finally:
-        for p in temp_paths:
-            try:
-                os.unlink(p)
-            except Exception:
-                pass
-
-
-def _parse_output(output_str: str) -> list:
-    """解析 query_result 中的 output，提取图片 URL 列表"""
-    try:
-        outer = json.loads(output_str)
-        inner_str = outer.get('Output', '{}')
-        inner = json.loads(inner_str)
-        data_str = inner.get('data', '[]')
-        data = json.loads(data_str)
-        urls = data.get("images")
-        long_image_url = data.get("merged_image_url")
-        return urls if isinstance(urls, list) else [],long_image_url
-    except Exception:
-        return [],None
-
-
-def _parse_output_text(output_str: str) -> list:
-    """解析 query_result 中的 output，提取图片 URL 列表"""
-    try:
-        outer = json.loads(output_str)
-        inner_str = outer.get('Output', '{}')
-        inner = json.loads(inner_str)
-        data_str = inner.get('data', '')
-        if isinstance(data_str,str):
-            data = json.loads(data_str).get("reverse_prompt")
-            return [data]
-        pattern = r'【?图像 \d+】.*?(?=【?图像 \d+】|$)'
-        segments = re.findall(pattern, data_str, re.DOTALL)
-        return segments
-    except Exception:
-        return ""
-
-
-def _poll_until_done(wf_id: str, execute_id: str, interval: float =10, timeout: int = 600*2, is_text: bool = False) -> list:
-    """轮询直到成功或超时，返回图片 URL 列表"""
-    start = time.time()
-    while time.time() - start < timeout:
-        resp = query_result(wf_id, execute_id)
-        if resp.get('code') != 0:
-            raise RuntimeError(f'查询失败: {resp.get("msg", resp)}')
-        items = resp.get('data') or []
-        if not items:
-            time.sleep(interval)
-            continue
-        item = items[0]
-        status = item.get('execute_status', '')
-        if status == 'Success':
-            output = item.get('output', '{}')
-            if is_text:
-                return _parse_output_text(output)
-            return _parse_output(output)
-        if status and status not in ('Running', 'Pending', ''):
-            raise RuntimeError(f'执行失败: {status}')
-        time.sleep(interval)
-    raise RuntimeError('生成超时')
-
-
-def _res_to_2k(res: str) -> str:
-    """统一分辨率为 2K/4K"""
-    r = (res or '2k').strip().upper()
-    return '4K' if r == '4K' else '2K'
-
-
-def generate(params: dict) -> dict:
-    """
-    生成图片
-    params: {
-        menu: int,  # 1=图片反推 2=图片编辑 3=随机海报 4=克隆海报 5=服饰穿搭
-        prompt: str,  # 用户自定义指令 (menu=1 必填)
-        ref_images: list,  # base64 data URLs - 参考图
-        video: str,  # base64 data URL - 视频 (menu=1 可选，仅支持1个)
-        model_images: list,  # base64 data URLs - 多模特图 (menu!=1，最多5张)
-        name: str, desc: str, ratio: str, resolution: str, count: int,
-        language: str, style: str, batch_prompt: list, brand_name: str,
-        Ingredients: str, activity: str, mode: str, texts: list,
-        proc_images: list, layout_image: str,
-    }
-    返回: { success: bool, urls: list, prompts: list, error: str }
-    """
-    original_urls = []
-    api_key = (params.get('api_key') or '').strip()
-    try:
-        menu = int(params.get('menu', 2))
-        ref_data = params.get('ref_images') or []
-        proc_data = params.get('proc_images') or []
-        layout_data = params.get('layout_image')
-        video_data = params.get('video')
-        model_data = params.get('model_images') or []
-
-        # menu 1: 反推词，简化参数
-        if menu == 1:
-            base_params = {'menu': 1, 'prompt': str(params.get('prompt', '')).strip() or ''}
-
-            ref_ids = _upload_images(ref_data) if ref_data else []
-            if ref_ids:
-                base_params['ref_images'] = [{'file_id': fid} for fid in ref_ids]
-            if video_data:
-                try:
-                    vid = _upload_video(video_data)
-                    base_params['video'] = {'file_id': vid}
-                except Exception as ve:
-                    return {'success': False, 'urls': [], 'prompts': [], 'error': f'视频上传失败: {ve}'}
-            base_params = {k: v for k, v in base_params.items() if v is not None and v != ''}
-            base_params["api_key"] = api_key
-            resp = workflow_run(workflow_id, base_params)
-            if resp.get('code') != 0:
-                return {'success': False, 'urls': [], 'prompts': [], 'error': resp.get('msg', str(resp))}
-            execute_id = resp.get('execute_id')
-            if not execute_id:
-                return {'success': False, 'urls': [], 'prompts': [], 'error': '未返回 execute_id'}
-            prompts = _poll_until_done(workflow_id, str(execute_id), is_text=True)
-            # menu 1 返回提示词列表，统一转为字符串
-            # prompts = [str(x) for x in result_list] if result_list else []
-            # prompts = [prompts]
-            return {'success': True, 'urls': [], 'prompts': prompts, 'error': ''}
-
-        # menu != 1: 原有逻辑
-        all_ref = list(ref_data)
-        if layout_data:
-            all_ref = [layout_data] + list(ref_data)
-        all_originals = list(all_ref) + list(proc_data) + list(model_data)
-
-        if all_originals:
-            try:
-                original_urls = oss_upload_data_urls(all_originals, prefix="originals")
-            except Exception:
-                traceback.print_exc()
-                pass
-
-        ref_ids = _upload_images(all_ref) if all_ref else []
-        proc_ids = _upload_images(proc_data) if proc_data else []
-        model_ids = _upload_images(model_data) if model_data else []
-
-        res = _res_to_2k(params.get('resolution', '2K'))
-
-        base_params = {
-            'name': str(params.get('name', '')).strip(),
-            'ratio': str(params.get('ratio', '')).strip(),
-            'menu': menu,
-            'resolution': res,
-            'count': int(params.get('count', 1)),
-            'desc': str(params.get('desc', '')).strip(),
-            'language': str(params.get('language', '中文')).strip() or '中文',
-            'style': str(params.get('style', '')).strip(),
-            'prompt': str(params.get('prompt', '')).strip(),
-            'batch_prompt': params.get('batch_prompt') or [],
-            'brand_name': str(params.get('brand_name', '')).strip(),
-            'Ingredients': str(params.get('Ingredients', '')).strip(),
-            'activity': str(params.get('activity', '')).strip(),
-            'mode': str(params.get('mode', '1')).strip() or '1',
-            'texts': params.get('text') or [],
-            "api_key" : api_key
-        }
-
-        if ref_ids:
-            base_params['ref_images'] = [{'file_id': fid} for fid in ref_ids]
-        if proc_ids:
-            base_params['proc_images'] = [{'file_id': fid} for fid in proc_ids]
-        if model_ids:
-            base_params['model_images'] = [{'file_id': fid} for fid in model_ids]
-        base_params = {k: v for k, v in base_params.items() if v is not None and v != ''}
-
-        resp = workflow_run(workflow_id, base_params)
-        if resp.get('code') != 0:
-            return {'success': False, 'urls': [], 'error': resp.get('msg', str(resp))}
-        execute_id = resp.get('execute_id')
-        if not execute_id:
-            return {'success': False, 'urls': [], 'error': '未返回 execute_id'}
-
-        urls,long_image_url = _poll_until_done(workflow_id, str(execute_id))
-        return {'success': True, 'urls': urls, 'original_urls': original_urls, 'error': '',"long_image_url":long_image_url}
-    except Exception as e:
-        return {'success': False, 'urls': [], 'prompts': [], 'original_urls': [], 'error': str(e),"long_image_url":""}
-
-

app/html_crypto.py

@@ -1,68 +0,0 @@
-"""
-HTML 模板加密/解密模块
-使用 AES (Fernet) 对 HTML 资源进行加密存储，运行时解密后渲染
-"""
-
-import base64
-import os
-
-from cryptography.fernet import Fernet
-from cryptography.hazmat.primitives import hashes
-from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
-
-
-def _get_fernet_key() -> bytes:
-    """从环境变量 HTML_ENCRYPT_KEY 派生 Fernet 密钥，若未设置则使用默认开发密钥"""
-    raw = os.environ.get(
-        "HTML_ENCRYPT_KEY",
-        "maixiang_html_encrypt_default_key_change_in_production",
-    )
-    # 使用 PBKDF2 派生 32 字节密钥，再转为 Fernet 所需的 base64url
-    kdf = PBKDF2HMAC(
-        algorithm=hashes.SHA256(),
-        length=32,
-        salt=b"maixiang_html_salt",
-        iterations=100000,
-    )
-    key_bytes = kdf.derive(raw.encode("utf-8"))
-    return base64.urlsafe_b64encode(key_bytes)
-
-
-def encrypt(plain_data: bytes) -> bytes:
-    """加密原始数据，返回密文（bytes）"""
-    key = _get_fernet_key()
-    f = Fernet(key)
-    return f.encrypt(plain_data)
-
-
-def decrypt(encrypted_data: bytes) -> bytes:
-    """解密数据，返回明文（bytes）"""
-    key = _get_fernet_key()
-    f = Fernet(key)
-    return f.decrypt(encrypted_data)
-
-
-def encrypt_file(path: str) -> None:
-    """就地加密文件：读取 UTF-8 内容，加密后写回同一路径"""
-    with open(path, "rb") as f:
-        plain = f.read()
-    encrypted = encrypt(plain)
-    with open(path, "wb") as f:
-        f.write(encrypted)
-
-
-def decrypt_file(path: str) -> None:
-    """就地解密文件：读取密文，解密后以 UTF-8 写回同一路径"""
-    with open(path, "rb") as f:
-        encrypted = f.read()
-    plain = decrypt(encrypted)
-    with open(path, "wb") as f:
-        f.write(plain)
-
-
-def is_encrypted(data: bytes) -> bool:
-    """简单启发式：Fernet 密文以 b'gAAAAA' 开头（base64 编码后）"""
-    try:
-        return data[:7] == b"gAAAAAB"
-    except Exception:
-        return False

app/main.py

@@ -1,334 +0,0 @@
-"""
-基于 pywebview 实现的跨平台 UI，需先登录方可使用
-"""
-from config import  cache_path,debug,version,JAVA_API_BASE,JSON_TASK_QUEUE,runing_task,runing_shop
-import datetime
-import json
-import sys
-import shutil
-import os
-os.makedirs(cache_path,exist_ok=True)
-if not debug:
-    today = datetime.datetime.now().strftime("%Y_%m_%d")
-    sys.stdout = open(os.path.join(cache_path,f'{today}.log'), 'a',buffering=1)
-    sys.stderr = sys.stdout
-
-import webview
-import threading
-import time
-import requests
-import subprocess
-
-
-with open("version.txt","w",encoding="utf-8") as file:
-    file.write(json.dumps({"version":version}))
-
-print(f"""
-========================================================
-版本： {version}
-========================================================
-
-""")
-
-
-# 获取当前脚本所在目录
-BASE_DIR = os.path.dirname(os.path.abspath(__file__))
-APP_URL = "http://127.0.0.1:5123"
-PORT = 5123
-
-
-def generate_images(params):
-    """供前端调用的生成图片接口"""
-    from generate_api import generate
-    return generate(params)
-
-
-class WindowAPI:
-    """暴露给 JavaScript 的窗口控制 API"""
-
-    def __init__(self, window):
-        self._window = window
-        self._is_maximized = False
-        window.events.maximized += lambda _: setattr(self, '_is_maximized', True)
-        window.events.restored += lambda _: setattr(self, '_is_maximized', False)
-
-    def close(self):
-        sys.exit(1)
-        self._window.destroy()
-
-    def minimize(self):
-        self._window.minimize()
-
-    def maximize(self):
-        self._window.maximize()
-
-    def toggle_maximize(self):
-        if self._is_maximized:
-            self._window.restore()
-        else:
-            self._window.maximize()
-
-    def save_image(self, url_or_data, filename='image.png'):
-        """弹窗选择保存位置并下载图片。url_or_data 可为 http(s) 链接或 data:  base64"""
-        import base64
-        import re
-        result = self._window.create_file_dialog(
-            webview.SAVE_DIALOG,
-            save_filename=filename,
-            file_types=('图片文件 (*.png;*.jpg;*.jpeg)', '所有文件 (*.*)')
-        )
-        if not result:
-            return {'success': False, 'error': '用户取消'}
-        path = result[0] if isinstance(result, (list, tuple)) else result
-        try:
-            if url_or_data.startswith('data:'):
-                match = re.match(r'data:image/\w+;base64,(.+)', url_or_data)
-                if not match:
-                    print(url_or_data)
-                    print('无效的 data URL')
-                    return {'success': False, 'error': '无效的 data URL'}
-                data = base64.b64decode(match.group(1))
-            else:
-                import requests
-                resp = requests.get(url_or_data, timeout=30)
-                resp.raise_for_status()
-                data = resp.content
-            with open(path, 'wb') as f:
-                f.write(data)
-            return {'success': True, 'path': path}
-        except Exception as e:
-            return {'success': False, 'error': str(e)}
-
-    def save_image_to_folder(self, url_or_data, dir_path, filename='image.png'):
-        """将图片保存到指定文件夹。url_or_data 可为 http(s) 链接或 data: base64"""
-        import base64
-        import re
-        path = os.path.join(dir_path, filename)
-        try:
-            if url_or_data.startswith('data:'):
-                match = re.match(r'data:image/\w+;base64,(.+)', url_or_data)
-                if not match:
-                    return {'success': False, 'error': '无效的 data URL'}
-                data = base64.b64decode(match.group(1))
-            else:
-                import requests
-                resp = requests.get(url_or_data, timeout=30)
-                resp.raise_for_status()
-                data = resp.content
-            os.makedirs(dir_path, exist_ok=True)
-            with open(path, 'wb') as f:
-                f.write(data)
-            return {'success': True, 'path': path}
-        except Exception as e:
-            return {'success': False, 'error': str(e)}
-
-    def select_folder(self):
-        # 此方法会在 JavaScript 中被调用，返回选择的文件夹路径
-        result = webview.windows[0].create_file_dialog(
-            webview.FOLDER_DIALOG,  # 指定为文件夹对话框
-            allow_multiple=False,  # 是否允许多选
-            directory=''  # 初始目录
-        )
-        # create_file_dialog 返回的是列表（多选时）或 None
-        return result[0] if result else ''
-
-    def select_brand_xlsx_files(self):
-        """品牌爬虫：选择 .xlsx 文件，允许多选，返回路径列表"""
-        result = webview.windows[0].create_file_dialog(
-            webview.OPEN_DIALOG,
-            allow_multiple=True,
-            file_types=('Excel 文件 (*.xlsx)', '所有文件 (*.*)')
-        )
-        print("选择的excel 文件",result)
-        if not result:
-            return []
-        return result if isinstance(result, list) or isinstance(result, tuple) else [result]
-
-    def select_brand_folder(self):
-        """品牌爬虫：选择文件夹，返回文件夹路径（前端再请求后端展开该目录下所有 xlsx）"""
-        result = webview.windows[0].create_file_dialog(
-            webview.FOLDER_DIALOG,
-            allow_multiple=False,
-            directory=''
-        )
-        return result[0] if result else ''
-
-    def save_file_from_url(self, url, default_filename='download.zip'):
-        """弹窗选择保存位置，从 url 下载文件并保存。用于品牌任务结果 zip 等。"""
-        if not url or not url.strip():
-            return {'success': False, 'error': '下载地址为空'}
-        result = self._window.create_file_dialog(
-            webview.SAVE_DIALOG,
-            save_filename=default_filename,
-            file_types=('ZIP 压缩包 (*.zip)', '所有文件 (*.*)')
-        )
-        if not result:
-            return {'success': False, 'error': '用户取消'}
-        path = result[0] if isinstance(result, (list, tuple)) else result
-        try:
-            import requests
-            resp = requests.get(url.strip(), timeout=120, stream=True)
-            resp.raise_for_status()
-            with open(path, 'wb') as f:
-                for chunk in resp.iter_content(chunk_size=65536):
-                    if chunk:
-                        f.write(chunk)
-            return {'success': True, 'path': path}
-        except Exception as e:
-            return {'success': False, 'error': str(e)}
-
-    def save_template_xlsx(self):
-        """弹窗选择保存位置，将品牌文档格式模板 xlsx 保存到用户选择的位置。"""
-        template_name = '品牌文档格式_模板.xlsx'
-        template_path = os.path.join(BASE_DIR, 'static', template_name)
-        if not os.path.isfile(template_path):
-            return {'success': False, 'error': '模板文件不存在'}
-        result = self._window.create_file_dialog(
-            webview.SAVE_DIALOG,
-            save_filename=template_name,
-            file_types=('Excel 文件 (*.xlsx)', '所有文件 (*.*)')
-        )
-        if not result:
-            return {'success': False, 'error': '用户取消'}
-        path = result[0] if isinstance(result, (list, tuple)) else result
-        try:
-            shutil.copy2(template_path, path)
-            return {'success': True, 'path': path}
-        except Exception as e:
-            return {'success': False, 'error': str(e)}
-
-    def save_template_zip(self):
-        """弹窗选择保存位置，将品牌文档格式模板 xlsx 保存到用户选择的位置。"""
-        import shutil
-        template_name = '模板2-以文件夹方式上传.zip'
-        template_path = os.path.join(BASE_DIR, 'static', template_name)
-        if not os.path.isfile(template_path):
-            return {'success': False, 'error': '模板文件不存在'}
-        result = self._window.create_file_dialog(
-            webview.SAVE_DIALOG,
-            save_filename=template_name,
-            file_types=('ZIP 文件 (*.zip)', '所有文件 (*.*)')
-        )
-        if not result:
-            return {'success': False, 'error': '用户取消'}
-        path = result[0] if isinstance(result, (list, tuple)) else result
-        try:
-            shutil.copy2(template_path, path)
-            return {'success': True, 'path': path}
-        except Exception as e:
-            return {'success': False, 'error': str(e)}
-
-    def upload_file_to_java(self, file_path, relative_path=None):
-        """按本地路径读取文件并上传到 Java 后端临时目录。"""
-        if not file_path or not str(file_path).strip():
-            return {'success': False, 'error': '文件路径为空'}
-        normalized_path = os.path.abspath(str(file_path).strip())
-        if not os.path.isfile(normalized_path):
-            return {'success': False, 'error': '文件不存在'}
-        try:
-            with open(normalized_path, 'rb') as file_obj:
-                response = requests.post(
-                    f"{JAVA_API_BASE}/api/files/upload",
-                    files={'file': (os.path.basename(normalized_path), file_obj)},
-                    data={'relativePath': str(relative_path).strip()} if relative_path else None,
-                    timeout=120,
-                )
-            response.raise_for_status()
-            payload = response.json()
-            if not isinstance(payload, dict):
-                return {'success': False, 'error': 'Java 返回格式错误'}
-            return payload
-        except Exception as e:
-            return {'success': False, 'error': str(e)}
-
-    def open_external_url(self, url):
-        if not url or not str(url).strip():
-            return {'success': False, 'error': '链接为空'}
-        target = str(url).strip()
-        try:
-            if sys.platform.startswith('win'):
-                os.startfile(target)
-            elif sys.platform == 'darwin':
-                subprocess.Popen(['open', target])
-            else:
-                subprocess.Popen(['xdg-open', target])
-            return {'success': True}
-        except Exception as e:
-            return {'success': False, 'error': str(e)}
-
-    def enqueue_json(self, data):
-        """保存任务到队列"""
-        try:
-            print("==============================")
-            print(datetime.datetime.now().strftime( "%Y-%m-%d %H:%M:%S"),"调用传入",data)
-            print("==================================")
-            payload = data
-            if isinstance(data, str):
-                payload = json.loads(data)
-            if not isinstance(payload, (dict, list)):
-                return {'success': False, 'error': '仅支持 JSON 对象或数组'}
-            if payload.get("type") == "delete-brand-run" and payload.get("data").get("taskId") in runing_task:
-                return {'success': False, 'error': '已存在正在执行的删除品牌任务'}
-            # 判断当前店铺是否正在运行中
-            if payload.get("data").get("items"):
-                shop_name = payload["data"]["items"][0]["shopName"]
-                if shop_name in runing_shop:
-                    return {'success': False, 'error': '当前店铺正在执行中,请等待店铺完成之后重试'}
-            JSON_TASK_QUEUE.put(payload)
-            return {'success': True, 'queue_size': JSON_TASK_QUEUE.qsize()}
-        except Exception as e:
-            return {'success': False, 'error': str(e)}
-
-    def get_detail_del(self,task_id):
-        """获取正在执行的删除品牌任务详情"""
-        task_info = runing_task.get(task_id)
-        if not task_info:
-            return {'success': False, 'error': '任务不存在'}
-        return {'success': True, 'task_info': task_info}
-    
-    def stop_task(self,task_id):
-        """停止正在执行的删除品牌任务"""
-        task_info = runing_task.get(task_id)
-        if not task_info:
-            return {'success': False, 'error': '任务不存在'}
-        # 这里可以设置一个标志位，实际的删除品牌任务需要定期检查这个标志位来决定是否停止
-        task_info['stop_requested'] = True
-        return {'success': True, 'message': '已请求停止任务'}
-
-
-def start_flask():
-    from app import run_app
-    run_app(host='127.0.0.1', port=PORT)
-
-
-def main():
-    if not os.path.exists(cache_path):
-        os.makedirs(cache_path,exist_ok=True)
-    t = threading.Thread(target=start_flask, daemon=True)
-    t.start()
-    # 等待 Flask 启动
-    time.sleep(2)
-
-    window = webview.create_window(
-        title="数富AI",
-        url=APP_URL,
-        width=1400,
-        height=900,
-        resizable=True,
-        min_size=(1200, 700),
-        background_color="#1a1a1a",
-        frameless=False,
-        easy_drag=True
-    )
-    api = WindowAPI(window)
-    window.expose(api.close, api.minimize, api.maximize, api.toggle_maximize, generate_images, api.save_image, api.save_image_to_folder, api.select_folder, api.select_brand_xlsx_files, api.select_brand_folder,
-                  api.save_file_from_url, api.save_template_xlsx,api.save_template_zip,api.upload_file_to_java,api.open_external_url,api.enqueue_json,api.get_detail_del)
-    webview.start(
-        debug=True,
-        storage_path=cache_path,
-        private_mode=False
-    )
-
-
-if __name__ == "__main__":
-    main()

app/new_web_source/convert.html

@@ -1,15 +0,0 @@
-<!doctype html>
-<html lang="zh-CN">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>格式转换 - 数富AI</title>
-    <script type="module" crossorigin src="/assets/convert.js"></script>
-    <link rel="modulepreload" crossorigin href="/assets/pywebview-Dee3nQjE.js">
-    <link rel="stylesheet" crossorigin href="/assets/pywebview-MkjZQlBu.css">
-    <link rel="stylesheet" crossorigin href="/assets/convert-Cfr3mUjs.css">
-  </head>
-  <body>
-    <div id="app"></div>
-  </body>
-</html>

app/new_web_source/dedupe.html

@@ -1,15 +0,0 @@
-<!doctype html>
-<html lang="zh-CN">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>数据去重 - 数富AI</title>
-    <script type="module" crossorigin src="/assets/dedupe.js"></script>
-    <link rel="modulepreload" crossorigin href="/assets/pywebview-Dee3nQjE.js">
-    <link rel="stylesheet" crossorigin href="/assets/pywebview-MkjZQlBu.css">
-    <link rel="stylesheet" crossorigin href="/assets/dedupe-CS18ls2z.css">
-  </head>
-  <body>
-    <div id="app"></div>
-  </body>
-</html>

app/new_web_source/delete-brand.html

@@ -1,15 +0,0 @@
-<!doctype html>
-<html lang="zh-CN">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>删除品牌 - 数富AI</title>
-    <script type="module" crossorigin src="/assets/delete-brand.js"></script>
-    <link rel="modulepreload" crossorigin href="/assets/pywebview-Dee3nQjE.js">
-    <link rel="stylesheet" crossorigin href="/assets/pywebview-MkjZQlBu.css">
-    <link rel="stylesheet" crossorigin href="/assets/delete-brand-CS44Bk-y.css">
-  </head>
-  <body>
-    <div id="app"></div>
-  </body>
-</html>

app/new_web_source/split.html

@@ -1,15 +0,0 @@
-<!doctype html>
-<html lang="zh-CN">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>数据拆分 - 数富AI</title>
-    <script type="module" crossorigin src="/assets/split.js"></script>
-    <link rel="modulepreload" crossorigin href="/assets/pywebview-Dee3nQjE.js">
-    <link rel="stylesheet" crossorigin href="/assets/pywebview-MkjZQlBu.css">
-    <link rel="stylesheet" crossorigin href="/assets/split-mwLUJT1K.css">
-  </head>
-  <body>
-    <div id="app"></div>
-  </body>
-</html>

app/tool/.device_id

@@ -1 +0,0 @@
-8cecee3bc02a178bf372ca1c3d02fc5cae3c0a51c8346f6e6a710988599c08be

app/tool/devices.py

@@ -1,249 +0,0 @@
-import hashlib
-import platform
-import subprocess
-import uuid
-import os
-from typing import Optional
-
-
-class DeviceIDGenerator:
-    """
-    Windows设备唯一ID生成器
-    通过收集多个硬件特征来生成稳定的设备唯一标识符
-    """
-
-    def __init__(self, use_cache: bool = False, cache_file: str = ".device_id"):
-        """
-        初始化设备ID生成器
-
-        Args:
-            use_cache: 是否使用本地缓存
-            cache_file: 缓存文件名
-        """
-        self.use_cache = use_cache
-        self.cache_file = cache_file
-
-    def _run_wmic_command(self, command: str) -> Optional[str]:
-        """
-        执行WMIC命令并返回结果
-
-        Args:
-            command: WMIC命令
-
-        Returns:
-            命令执行结果，失败则返回None
-        """
-        try:
-            result = subprocess.run(
-                command,
-                shell=True,
-                capture_output=True,
-                text=True,
-                timeout=10
-            )
-            if result.returncode == 0 and result.stdout.strip():
-                return result.stdout.strip()
-        except (subprocess.TimeoutExpired, Exception):
-            pass
-        return None
-
-    def _get_motherboard_serial(self) -> Optional[str]:
-        """获取主板序列号"""
-        return self._run_wmic_command("wmic baseboard get serialnumber /value")
-
-    def _get_cpu_id(self) -> Optional[str]:
-        """获取CPU ID"""
-        return self._run_wmic_command("wmic cpu get processorid /value")
-
-    def _get_bios_serial(self) -> Optional[str]:
-        """获取BIOS序列号"""
-        return self._run_wmic_command("wmic bios get serialnumber /value")
-
-    def _get_disk_serial(self) -> Optional[str]:
-        """获取系统盘序列号"""
-        return self._run_wmic_command("wmic diskdrive get serialnumber /value")
-
-    def _get_machine_guid(self) -> Optional[str]:
-        """获取Windows机器GUID"""
-        try:
-            result = subprocess.run(
-                'reg query "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography" /v MachineGuid',
-                shell=True,
-                capture_output=True,
-                text=True,
-                timeout=10
-            )
-            if result.returncode == 0:
-                for line in result.stdout.split('\n'):
-                    if 'MachineGuid' in line:
-                        return line.split()[-1]
-        except Exception:
-            pass
-        return None
-
-    def _extract_value(self, wmic_output: str) -> str:
-        """从WMIC输出中提取实际值"""
-        if not wmic_output:
-            return ""
-
-        lines = wmic_output.split('\n')
-        for line in lines:
-            if '=' in line and not line.strip().endswith('='):
-                return line.split('=', 1)[1].strip()
-        return ""
-
-    def _collect_hardware_info(self) -> dict:
-        """
-        收集硬件信息
-
-        Returns:
-            包含各种硬件信息的字典
-        """
-        hardware_info = {}
-
-        # 主板序列号
-        motherboard = self._get_motherboard_serial()
-        hardware_info['motherboard'] = self._extract_value(motherboard) if motherboard else ""
-
-        # CPU ID
-        cpu_id = self._get_cpu_id()
-        hardware_info['cpu'] = self._extract_value(cpu_id) if cpu_id else ""
-
-        # BIOS序列号
-        bios = self._get_bios_serial()
-        hardware_info['bios'] = self._extract_value(bios) if bios else ""
-
-        # 硬盘序列号
-        disk = self._get_disk_serial()
-        hardware_info['disk'] = self._extract_value(disk) if disk else ""
-
-        # Windows机器GUID
-        machine_guid = self._get_machine_guid()
-        hardware_info['machine_guid'] = machine_guid if machine_guid else ""
-
-        # 计算机名称
-        hardware_info['computer_name'] = platform.node()
-
-        # MAC地址（作为备用）
-        hardware_info['mac_address'] = ':'.join(['{:02x}'.format((uuid.getnode() >> elements) & 0xff)
-                                                 for elements in range(0, 2*6, 2)][::-1])
-
-        return hardware_info
-
-    def _generate_device_id(self, hardware_info: dict) -> str:
-        """
-        基于硬件信息生成设备ID
-
-        Args:
-            hardware_info: 硬件信息字典
-
-        Returns:
-            32位十六进制设备ID
-        """
-        # 过滤掉空值，并按键排序确保一致性
-        filtered_info = {k: v for k, v in hardware_info.items() if v and v.strip()}
-
-        # 如果没有任何硬件信息，使用MAC地址作为后备方案
-        if not filtered_info:
-            filtered_info = {'mac_address': hardware_info.get('mac_address', str(uuid.getnode()))}
-
-        # 将所有信息连接成字符串
-        info_string = '|'.join(f"{k}:{v}" for k, v in sorted(filtered_info.items()))
-
-        # 使用SHA256生成哈希值
-        hash_object = hashlib.sha256(info_string.encode('utf-8'))
-        device_id = hash_object.hexdigest()
-
-        return device_id
-
-    def _load_cached_device_id(self) -> Optional[str]:
-        """从缓存文件加载设备ID"""
-        try:
-            if os.path.exists(self.cache_file):
-                with open(self.cache_file, 'r', encoding='utf-8') as f:
-                    cached_id = f.read().strip()
-                    if len(cached_id) == 64:  # SHA256哈希长度
-                        return cached_id
-        except Exception:
-            pass
-        return None
-
-    def _save_device_id_to_cache(self, device_id: str) -> None:
-        """将设备ID保存到缓存文件"""
-        try:
-            with open(self.cache_file, 'w', encoding='utf-8') as f:
-                f.write(device_id)
-        except Exception:
-            pass
-
-    def get_device_id(self) -> str:
-        """
-        获取设备唯一ID
-
-        Returns:
-            64字符的十六进制设备ID
-        """
-        # 如果启用缓存，先尝试从缓存加载
-        if self.use_cache:
-            cached_id = self._load_cached_device_id()
-            if cached_id:
-                return cached_id
-
-        # 收集硬件信息
-        hardware_info = self._collect_hardware_info()
-
-        # 生成设备ID
-        device_id = self._generate_device_id(hardware_info)
-
-        # 保存到缓存
-        if self.use_cache:
-            self._save_device_id_to_cache(device_id)
-
-        return device_id
-
-    def get_device_id_short(self, length: int = 16) -> str:
-        """
-        获取短版本的设备ID
-
-        Args:
-            length: 返回ID的长度
-
-        Returns:
-            指定长度的设备ID
-        """
-        full_id = self.get_device_id()
-        return full_id[:length]
-
-    def get_hardware_info(self) -> dict:
-        """
-        获取硬件信息（用于调试）
-
-        Returns:
-            硬件信息字典
-        """
-        return self._collect_hardware_info()
-
-
-# 使用示例
-def main():
-    """使用示例"""
-    # 创建设备ID生成器实例
-    device_generator = DeviceIDGenerator()
-
-    # 获取完整设备ID（64字符）
-    device_id = device_generator.get_device_id()
-    print(f"完整设备ID: {device_id}")
-
-    # 获取短版本设备ID（16字符）
-    short_id = device_generator.get_device_id_short(16)
-    print(f"短设备ID: {short_id}")
-
-    # 查看硬件信息（调试用）
-    hardware_info = device_generator.get_hardware_info()
-    print("\n硬件信息:")
-    for key, value in hardware_info.items():
-        print(f"  {key}: {value}")
-
-
-if __name__ == "__main__":
-    main()

app/version.txt

@@ -1 +0,0 @@
-{"version": "1.0.22"}

app/web_source/admin.html

@@ -1,539 +0,0 @@
-<!DOCTYPE html>
-<html lang="zh-CN">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>管理后台 - 数富AI</title>
-    <style>
-        * { margin: 0; padding: 0; box-sizing: border-box; }
-        body {
-            font-family: "Microsoft YaHei", "PingFang SC", sans-serif;
-            background: #f5f5f5;
-            padding: 24px;
-        }
-        .nav { margin-bottom: 24px; }
-        .nav a { color: #667eea; text-decoration: none; }
-        .nav a:hover { text-decoration: underline; }
-        h1 { font-size: 20px; margin-bottom: 20px; }
-
-        /* Tabs */
-        .tabs {
-            display: flex;
-            gap: 4px;
-            margin-bottom: 20px;
-            border-bottom: 1px solid #e0e0e0;
-        }
-        .tab {
-            padding: 12px 24px;
-            cursor: pointer;
-            color: #666;
-            font-size: 15px;
-            border-bottom: 2px solid transparent;
-            margin-bottom: -1px;
-        }
-        .tab:hover { color: #667eea; }
-        .tab.active { color: #667eea; font-weight: 600; border-bottom-color: #667eea; }
-        .tab-panel { display: none; }
-        .tab-panel.active { display: block; }
-
-        /* Form & Table */
-        .form-box, .panel-box {
-            background: #fff;
-            border-radius: 8px;
-            padding: 24px;
-            margin-bottom: 20px;
-        }
-        .form-group { margin-bottom: 16px; }
-        .form-group label { display: block; font-size: 14px; margin-bottom: 6px; }
-        .form-group input, .form-group select {
-            width: 100%; padding: 10px; border: 1px solid #ddd; border-radius: 6px;
-        }
-        .form-group input[type="checkbox"] { width: auto; margin-right: 8px; }
-        .form-row { display: flex; gap: 16px; flex-wrap: wrap; align-items: flex-end; margin-bottom: 16px; }
-        .form-row .form-group { margin-bottom: 0; flex: 1; min-width: 120px; }
-
-        .btn { padding: 10px 20px; background: #667eea; color: #fff; border: none; border-radius: 6px; cursor: pointer; font-size: 14px; }
-        .btn:hover { opacity: 0.9; }
-        .btn-sm { padding: 6px 12px; font-size: 13px; }
-        .btn-danger { background: #e74c3c; }
-        .btn-secondary { background: #95a5a6; }
-
-        .msg { margin-top: 12px; font-size: 14px; }
-        .msg.ok { color: #27ae60; }
-        .msg.err { color: #e74c3c; }
-
-        table { width: 100%; border-collapse: collapse; }
-        th, td { padding: 12px; text-align: left; border-bottom: 1px solid #eee; font-size: 14px; }
-        th { background: #f8f9fa; font-weight: 600; }
-        .pagination {
-            display: flex;
-            align-items: center;
-            gap: 8px;
-            margin-top: 16px;
-            flex-wrap: wrap;
-        }
-        .pagination span { font-size: 14px; color: #666; }
-        .pagination button { padding: 6px 12px; border: 1px solid #ddd; background: #fff; cursor: pointer; border-radius: 4px; }
-        .pagination button:hover:not(:disabled) { background: #f0f0f0; }
-        .pagination button:disabled { opacity: 0.5; cursor: not-allowed; }
-
-        .thumb { width: 60px; height: 60px; object-fit: cover; border-radius: 4px; margin-right: 8px; vertical-align: middle; }
-        .thumb-wrap { display: flex; flex-wrap: wrap; gap: 4px; }
-        .empty-tip { color: #999; font-size: 14px; padding: 24px; text-align: center; }
-        .modal-mask {
-            display: none;
-            position: fixed; left: 0; top: 0; right: 0; bottom: 0;
-            background: rgba(0,0,0,0.4); z-index: 1000;
-            align-items: center; justify-content: center;
-        }
-        .modal-mask.show { display: flex; }
-        .modal { background: #fff; border-radius: 8px; padding: 24px; min-width: 320px; max-width: 90%; }
-        .modal h3 { margin-bottom: 16px; font-size: 16px; }
-    </style>
-</head>
-<body>
-    <div class="nav"><a href="/home">← 返回首页</a></div>
-    <h1>管理后台</h1>
-
-    <div class="tabs">
-        <div class="tab active" data-tab="users">用户管理</div>
-        <div class="tab" data-tab="history">查看生成记录</div>
-    </div>
-
-    <!-- 用户管理 -->
-    <div id="panel-users" class="tab-panel active">
-        <div class="form-box">
-            <h3 style="margin-bottom:16px;font-size:15px;">创建用户</h3>
-            <p style="margin-bottom:16px;font-size:13px;color:#666;">无注册入口，仅管理员可在此创建用户。层级：超级管理员 → 管理员 → 普通号。</p>
-            <div class="form-group">
-                <label>用户名</label>
-                <input type="text" id="username" placeholder="用户名（至少2个字符）">
-            </div>
-            <div class="form-group">
-                <label>密码</label>
-                <input type="password" id="password" placeholder="密码（至少6个字符）">
-            </div>
-            <div class="form-group" id="formGroupRole">
-                <label>角色</label>
-                <select id="createRole">
-                    <option value="normal">普通号</option>
-                    <option value="admin" id="optAdmin">管理员</option>
-                </select>
-            </div>
-            <div class="form-group" id="formGroupCreatedBy" style="display:none;">
-                <label>所属管理员</label>
-                <select id="createCreatedBy">
-                    <option value="">请选择管理员</option>
-                </select>
-            </div>
-            <button class="btn" id="btnCreate">创建用户</button>
-            <p class="msg" id="msgCreate"></p>
-        </div>
-
-        <div class="panel-box">
-            <h3 style="margin-bottom:16px;font-size:15px;">用户列表</h3>
-            <div class="form-row" style="margin-bottom:16px;">
-                <div class="form-group" style="min-width:180px;">
-                    <label>用户名（模糊搜索）</label>
-                    <input type="text" id="searchUsername" placeholder="输入用户名关键字">
-                </div>
-                <div class="form-group" id="filterCreatedByGroup" style="min-width:160px;display:none;">
-                    <label>所属管理员</label>
-                    <select id="filterCreatedBy">
-                        <option value="">全部</option>
-                    </select>
-                </div>
-                <button class="btn" id="btnSearchUsers">查询</button>
-            </div>
-            <table>
-                <thead>
-                    <tr>
-                        <th>ID</th>
-                        <th>用户名</th>
-                        <th>角色</th>
-                        <th>所属管理员</th>
-                        <th>创建时间</th>
-                        <th>操作</th>
-                    </tr>
-                </thead>
-                <tbody id="userListBody"></tbody>
-            </table>
-            <div class="pagination" id="userPagination"></div>
-        </div>
-    </div>
-
-    <!-- 查看生成记录 -->
-    <div id="panel-history" class="tab-panel">
-        <div class="form-box">
-            <h3 style="margin-bottom:16px;font-size:15px;">筛选条件</h3>
-            <div class="form-row">
-                <div class="form-group" style="min-width:140px;">
-                    <label>指定用户</label>
-                    <select id="filterUser">
-                        <option value="">全部用户</option>
-                    </select>
-                </div>
-                <div class="form-group" style="min-width:140px;">
-                    <label>开始时间</label>
-                    <input type="datetime-local" id="filterTimeStart">
-                </div>
-                <div class="form-group" style="min-width:140px;">
-                    <label>结束时间</label>
-                    <input type="datetime-local" id="filterTimeEnd">
-                </div>
-                <button class="btn" id="btnFilterHistory">查询</button>
-            </div>
-        </div>
-        <div class="panel-box">
-            <h3 style="margin-bottom:16px;font-size:15px;">生成记录</h3>
-            <table>
-                <thead>
-                    <tr>
-                        <th>ID</th>
-                        <th>用户</th>
-                        <th>类型</th>
-                        <th>创建时间</th>
-                        <th>结果预览</th>
-                    </tr>
-                </thead>
-                <tbody id="historyListBody"></tbody>
-            </table>
-            <div class="pagination" id="historyPagination"></div>
-        </div>
-    </div>
-
-    <!-- 编辑用户弹窗 -->
-    <div class="modal-mask" id="editUserModal">
-        <div class="modal">
-            <h3>编辑用户</h3>
-            <input type="hidden" id="editUserId">
-            <div class="form-group">
-                <label>用户名</label>
-                <input type="text" id="editUsername" readonly style="background:#f5f5f5;">
-            </div>
-            <div class="form-group">
-                <label>新密码（不修改留空）</label>
-                <input type="password" id="editPassword" placeholder="留空则不修改密码">
-            </div>
-            <div class="form-group" id="editFormGroupRole" style="display:none;">
-                <label>角色</label>
-                <select id="editRole">
-                    <option value="normal">普通号</option>
-                    <option value="admin">管理员</option>
-                </select>
-            </div>
-            <div class="form-group" id="editFormGroupCreator" style="display:none;">
-                <label>所属管理员</label>
-                <input type="text" id="editCreatorName" readonly style="background:#f5f5f5;">
-            </div>
-            <p class="msg" id="msgEdit"></p>
-            <div style="margin-top:16px;display:flex;gap:8px;">
-                <button class="btn" id="btnSaveUser">保存</button>
-                <button class="btn btn-secondary" id="btnCloseEdit">取消</button>
-            </div>
-        </div>
-    </div>
-
-    <script>
-        (function() {
-            // Tab 切换
-            document.querySelectorAll('.tab').forEach(function(t) {
-                t.onclick = function() {
-                    document.querySelectorAll('.tab').forEach(function(x) { x.classList.remove('active'); });
-                    document.querySelectorAll('.tab-panel').forEach(function(x) { x.classList.remove('active'); });
-                    t.classList.add('active');
-                    var id = 'panel-' + t.dataset.tab;
-                    document.getElementById(id).classList.add('active');
-                    if (t.dataset.tab === 'users') loadUsers(1);
-                    else if (t.dataset.tab === 'history') loadHistory(1);
-                };
-            });
-
-            // ========== 用户管理 ==========
-            var userPage = 1, userPageSize = 15;
-            var currentUserRole = 'admin';
-            var adminsList = [];
-            function roleLabel(role) {
-                if (role === 'super_admin') return '超级管理员';
-                if (role === 'admin') return '管理员';
-                return '普通号';
-            }
-            function buildUserListQuery(page) {
-                var q = 'page=' + (page || 1) + '&page_size=' + userPageSize;
-                var kw = (document.getElementById('searchUsername').value || '').trim();
-                if (kw) q += '&username=' + encodeURIComponent(kw);
-                var cby = document.getElementById('filterCreatedBy').value;
-                if (cby) q += '&created_by_id=' + encodeURIComponent(cby);
-                return q;
-            }
-            function loadUsers(page) {
-                userPage = page || 1;
-                fetch('/api/admin/users?' + buildUserListQuery(userPage))
-                    .then(function(r) { return r.json(); })
-                    .then(function(res) {
-                        var tbody = document.getElementById('userListBody');
-                        if (!res.success) {
-                            tbody.innerHTML = '<tr><td colspan="6" class="empty-tip">加载失败: ' + (res.error || '') + '</td></tr>';
-                            return;
-                        }
-                        currentUserRole = res.current_user_role || 'admin';
-                        adminsList = res.admins || [];
-                        var items = res.items || [];
-                        if (items.length === 0) {
-                            tbody.innerHTML = '<tr><td colspan="6" class="empty-tip">暂无用户</td></tr>';
-                        } else {
-                            tbody.innerHTML = items.map(function(u) {
-                                return '<tr><td>' + u.id + '</td><td>' + (u.username || '') + '</td><td>' +
-                                    roleLabel(u.role || 'normal') + '</td><td>' + (u.creator_username || '-') + '</td><td>' + (u.created_at || '') + '</td><td>' +
-                                    '<button class="btn btn-sm" data-edit="' + u.id + '" data-user="' + (JSON.stringify(u).replace(/"/g, '&quot;')) + '">编辑</button> ' +
-                                    '<button class="btn btn-sm btn-danger" data-delete="' + u.id + '" data-name="' + (u.username || '').replace(/"/g, '&quot;') + '">删除</button>' +
-                                    '</td></tr>';
-                            }).join('');
-                        }
-                        renderPagination('userPagination', res.total, res.page, res.page_size, loadUsers);
-                        bindUserActions();
-                        updateCreateFormByRole();
-                        updateUserFilterByRole();
-                    })
-                    .catch(function() {
-                        document.getElementById('userListBody').innerHTML = '<tr><td colspan="6" class="empty-tip">请求失败</td></tr>';
-                    });
-            }
-            function updateUserFilterByRole() {
-                var grp = document.getElementById('filterCreatedByGroup');
-                var sel = document.getElementById('filterCreatedBy');
-                if (currentUserRole === 'super_admin') {
-                    grp.style.display = 'block';
-                    var cur = sel.value;
-                    sel.innerHTML = '<option value="">全部</option>';
-                    adminsList.forEach(function(a) {
-                        var opt = document.createElement('option');
-                        opt.value = a.id;
-                        opt.textContent = a.username;
-                        sel.appendChild(opt);
-                    });
-                    sel.value = cur || '';
-                } else {
-                    grp.style.display = 'none';
-                }
-            }
-            function updateCreateFormByRole() {
-                var roleSel = document.getElementById('createRole');
-                var optAdmin = document.getElementById('optAdmin');
-                var formCreatedBy = document.getElementById('formGroupCreatedBy');
-                var selCreatedBy = document.getElementById('createCreatedBy');
-                if (currentUserRole === 'super_admin') {
-                    if (optAdmin) optAdmin.style.display = '';
-                    formCreatedBy.style.display = (roleSel.value === 'normal') ? 'block' : 'none';
-                    selCreatedBy.innerHTML = '<option value="">请选择管理员</option>';
-                    adminsList.forEach(function(a) {
-                        var opt = document.createElement('option');
-                        opt.value = a.id;
-                        opt.textContent = a.username;
-                        selCreatedBy.appendChild(opt);
-                    });
-                } else {
-                    if (optAdmin) optAdmin.style.display = 'none';
-                    roleSel.value = 'normal';
-                    formCreatedBy.style.display = 'none';
-                }
-            }
-            function bindUserActions() {
-                document.querySelectorAll('[data-edit]').forEach(function(btn) {
-                    btn.onclick = function() {
-                        var raw = (btn.getAttribute('data-user') || '{}').replace(/&quot;/g, '"');
-                        var u;
-                        try { u = JSON.parse(raw); } catch (e) { u = {}; }
-                        document.getElementById('editUserId').value = u.id || '';
-                        document.getElementById('editUsername').value = u.username || '';
-                        document.getElementById('editPassword').value = '';
-                        var editRole = document.getElementById('editRole');
-                        var editFormGroupRole = document.getElementById('editFormGroupRole');
-                        var editFormGroupCreator = document.getElementById('editFormGroupCreator');
-                        var editCreatorName = document.getElementById('editCreatorName');
-                        editFormGroupRole.style.display = (currentUserRole === 'super_admin' && u.role !== 'super_admin') ? 'block' : 'none';
-                        editFormGroupCreator.style.display = (u.role === 'normal' && u.creator_username) ? 'block' : 'none';
-                        editCreatorName.value = u.creator_username || '';
-                        if (u.role !== 'super_admin') { editRole.value = u.role || 'normal'; }
-                        document.getElementById('msgEdit').textContent = '';
-                        document.getElementById('editUserModal').classList.add('show');
-                    };
-                });
-                document.querySelectorAll('[data-delete]').forEach(function(btn) {
-                    btn.onclick = function() {
-                        if (!confirm('确定删除用户 "' + (btn.dataset.name || '') + '" 吗？')) return;
-                        fetch('/api/admin/user/' + btn.dataset.delete, { method: 'DELETE' })
-                            .then(function(r) { return r.json(); })
-                            .then(function(res) {
-                                if (res.success) { loadUsers(userPage); }
-                                else { alert(res.error || '删除失败'); }
-                            });
-                    };
-                });
-            }
-
-            document.getElementById('btnSearchUsers').onclick = function() { loadUsers(1); };
-            document.getElementById('createRole').onchange = function() { updateCreateFormByRole(); };
-            document.getElementById('btnCreate').onclick = function() {
-                var username = (document.getElementById('username').value || '').trim();
-                var password = document.getElementById('password').value || '';
-                var role = document.getElementById('createRole').value || 'normal';
-                var createdById = document.getElementById('createCreatedBy').value ? parseInt(document.getElementById('createCreatedBy').value, 10) : null;
-                var msgEl = document.getElementById('msgCreate');
-                msgEl.textContent = '';
-                msgEl.className = 'msg';
-                if (!username || username.length < 2) {
-                    msgEl.textContent = '用户名至少2个字符';
-                    msgEl.classList.add('err');
-                    return;
-                }
-                if (!password || password.length < 6) {
-                    msgEl.textContent = '密码至少6个字符';
-                    msgEl.classList.add('err');
-                    return;
-                }
-                var body = { username: username, password: password, role: role };
-                if (role === 'normal' && currentUserRole === 'super_admin' && createdById) body.created_by_id = createdById;
-                fetch('/api/admin/user', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify(body)
-                })
-                .then(function(r) { return r.json(); })
-                .then(function(res) {
-                    if (res.success) {
-                        msgEl.textContent = res.msg || '创建成功';
-                        msgEl.classList.add('ok');
-                        document.getElementById('username').value = '';
-                        document.getElementById('password').value = '';
-                        loadUsers(1);
-                    } else {
-                        msgEl.textContent = res.error || '创建失败';
-                        msgEl.classList.add('err');
-                    }
-                })
-                .catch(function() {
-                    msgEl.textContent = '请求失败';
-                    msgEl.classList.add('err');
-                });
-            };
-
-            document.getElementById('btnSaveUser').onclick = function() {
-                var uid = document.getElementById('editUserId').value;
-                var password = document.getElementById('editPassword').value;
-                var editRoleEl = document.getElementById('editRole');
-                var msgEl = document.getElementById('msgEdit');
-                msgEl.textContent = '';
-                msgEl.className = 'msg';
-                var body = {};
-                if (password) body.password = password;
-                if (currentUserRole === 'super_admin' && editRoleEl && editRoleEl.offsetParent !== null)
-                    body.role = editRoleEl.value || 'normal';
-                fetch('/api/admin/user/' + uid, {
-                    method: 'PUT',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify(body)
-                })
-                .then(function(r) { return r.json(); })
-                .then(function(res) {
-                    if (res.success) {
-                        msgEl.textContent = res.msg || '保存成功';
-                        msgEl.classList.add('ok');
-                        document.getElementById('editUserModal').classList.remove('show');
-                        loadUsers(userPage);
-                    } else {
-                        msgEl.textContent = res.error || '保存失败';
-                        msgEl.classList.add('err');
-                    }
-                });
-            };
-            document.getElementById('btnCloseEdit').onclick = function() {
-                document.getElementById('editUserModal').classList.remove('show');
-            };
-
-            // ========== 生成记录 ==========
-            var historyPage = 1, historyPageSize = 15;
-            function toSqlDatetime(val) {
-                if (!val) return '';
-                return val.replace('T', ' ');
-            }
-            function buildHistoryQuery(page) {
-                var q = 'page=' + (page || 1) + '&page_size=' + historyPageSize;
-                var uid = document.getElementById('filterUser').value;
-                var start = toSqlDatetime(document.getElementById('filterTimeStart').value);
-                var end = toSqlDatetime(document.getElementById('filterTimeEnd').value);
-                if (uid) q += '&user_id=' + uid;
-                if (start) q += '&time_start=' + encodeURIComponent(start);
-                if (end) q += '&time_end=' + encodeURIComponent(end);
-                return q;
-            }
-            function loadHistory(page) {
-                historyPage = page || 1;
-                fetch('/api/admin/history?' + buildHistoryQuery(historyPage))
-                    .then(function(r) { return r.json(); })
-                    .then(function(res) {
-                        var tbody = document.getElementById('historyListBody');
-                        if (!res.success) {
-                            tbody.innerHTML = '<tr><td colspan="5" class="empty-tip">加载失败: ' + (res.error || '') + '</td></tr>';
-                            return;
-                        }
-                        var items = res.items || [];
-                        if (items.length === 0) {
-                            tbody.innerHTML = '<tr><td colspan="5" class="empty-tip">暂无记录</td></tr>';
-                        } else {
-                            tbody.innerHTML = items.map(function(h) {
-                                var urls = (h.result_urls || []);
-                                var thumbUrls = (h.long_image_url ? [h.long_image_url] : []).concat(urls);
-                                var thumbs = thumbUrls.slice(0, 3).map(function(url) {
-                                    return '<img src="' + (url || '').replace(/"/g, '&quot;') + '" class="thumb" alt="">';
-                                }).join('');
-                                return '<tr><td>' + h.id + '</td><td>' + (h.username || '-') + '</td><td>' +
-                                    (h.panel_type || '-') + '</td><td>' + (h.created_at || '') + '</td><td>' +
-                                    '<div class="thumb-wrap">' + (thumbs || '-') + '</div></td></tr>';
-                            }).join('');
-                        }
-                        renderPagination('historyPagination', res.total, res.page, res.page_size, loadHistory);
-                    })
-                    .catch(function() {
-                        document.getElementById('historyListBody').innerHTML = '<tr><td colspan="5" class="empty-tip">请求失败</td></tr>';
-                    });
-            }
-            function loadUserOptions() {
-                fetch('/api/admin/users?page=1&page_size=999')
-                    .then(function(r) { return r.json(); })
-                    .then(function(res) {
-                        var sel = document.getElementById('filterUser');
-                        var cur = sel.value;
-                        sel.innerHTML = '<option value="">全部用户</option>';
-                        (res.items || []).forEach(function(u) {
-                            var opt = document.createElement('option');
-                            opt.value = u.id;
-                            opt.textContent = u.username + ' (' + roleLabel(u.role || 'normal') + ')';
-                            sel.appendChild(opt);
-                        });
-                        sel.value = cur || '';
-                    });
-            }
-            document.getElementById('btnFilterHistory').onclick = function() { loadHistory(1); };
-
-            // ========== 分页 ==========
-            function renderPagination(elId, total, page, pageSize, onPage) {
-                var el = document.getElementById(elId);
-                if (!el) return;
-                var totalPages = Math.max(1, Math.ceil(total / pageSize));
-                el.innerHTML = '<span>共 ' + total + ' 条</span>' +
-                    '<button ' + (page <= 1 ? 'disabled' : '') + ' data-p="' + (page - 1) + '">上一页</button>' +
-                    '<span>第 ' + page + ' / ' + totalPages + ' 页</span>' +
-                    '<button ' + (page >= totalPages ? 'disabled' : '') + ' data-p="' + (page + 1) + '">下一页</button>';
-                el.querySelectorAll('[data-p]').forEach(function(b) {
-                    if (!b.disabled) b.onclick = function() { onPage(parseInt(b.dataset.p, 10)); };
-                });
-            }
-
-            // 初始化
-            loadUsers(1);
-            loadUserOptions();
-        })();
-    </script>
-</body>
-</html>

app/web_source/home.html

@@ -1,353 +0,0 @@
-<!DOCTYPE html>
-<html lang="zh-CN">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>首页 - 数富AI</title>
-    <style>
-        * { margin: 0; padding: 0; box-sizing: border-box; }
-        body {
-            font-family: "Microsoft YaHei", "PingFang SC", "Hiragino Sans GB", sans-serif;
-            background: linear-gradient(rgba(255,255,255,0.5), rgba(255,255,255,0.5)),
-        url("/static/bg.jpg") center/cover no-repeat;;
-            /*background-image: url("/static/bg.jpg");*/
-
-            min-height: 100vh;
-            display: flex;
-            flex-direction: column;
-            align-items: center;
-            justify-content: center;
-            padding: 40px;
-        }
-        .header {
-            position: absolute;
-            top: 0;
-            left: 0;
-            right: 0;
-            height: 56px;
-            display: flex;
-            align-items: center;
-            justify-content: space-between;
-            padding: 0 24px;
-            background: rgba(255,255,255,0.5);
-        }
-        .header-title { font-size: 18px; font-weight: 600; color: #333; }
-        .header-right { display: flex; align-items: center; gap: 16px; position: relative; }
-        .header-right a, .header-right span {
-            font-size: 14px; color: #555; text-decoration: none;
-        }
-        .header-right a:hover { color: #667eea; }
-        .entrances {
-            display: flex;
-            gap: 32px;
-            flex-wrap: wrap;
-            justify-content: center;
-        }
-        .entrance-btn {
-            width: 160px;
-            height: 100px;
-            background: #c5c1c1;
-            border: 4px solid #b8d4e3;
-            border-radius: 12px;
-            display: flex;
-            align-items: center;
-            justify-content: center;
-            font-size: 18px;
-            font-weight: 600;
-            color: #333;
-            cursor: pointer;
-            transition: all 0.2s;
-            text-decoration: none;
-        }
-        .entrance-btn:hover {
-            background: #f8fbfd;
-            box-shadow: 0 4px 12px rgba(0,0,0,0.08);
-        }
-        .entrance-btn.wb { cursor: pointer; }
-        .entrance-btn.disabled {
-            cursor: not-allowed;
-            opacity: 0.9;
-        }
-        .toast {
-            position: fixed;
-            bottom: 40px;
-            left: 50%;
-            transform: translateX(-50%);
-            background: rgba(0,0,0,0.75);
-            color: #fff;
-            padding: 12px 24px;
-            border-radius: 8px;
-            font-size: 14px;
-            opacity: 0;
-            transition: opacity 0.3s;
-            pointer-events: none;
-        }
-        .toast.show { opacity: 1; }
-        .admin-link {
-            font-size: 13px;
-            color: #888;
-        }
-        .update-section {
-            margin-top: 48px;
-            padding: 20px 24px;
-            background: rgba(255,255,255,0.85);
-            border-radius: 12px;
-            border: 1px solid rgba(0,0,0,0.06);
-            max-width: 420px;
-        }
-        .update-section-title {
-            font-size: 14px;
-            color: #333;
-            margin-bottom: 12px;
-            display: flex;
-            align-items: center;
-            gap: 6px;
-        }
-        .update-block {
-            display: flex;
-            align-items: center;
-            justify-content: space-between;
-            gap: 16px;
-        }
-        .update-version-text {
-            font-size: 13px;
-            color: #555;
-        }
-        .btn-check-update {
-            padding: 8px 14px;
-            font-size: 13px;
-            background: #667eea;
-            color: #fff;
-            border: none;
-            border-radius: 8px;
-            cursor: pointer;
-        }
-        .btn-check-update:hover {
-            background: #5a6fd6;
-        }
-        .update-hint {
-            font-size: 12px;
-            color: #666;
-            margin-top: 8px;
-            min-height: 18px;
-        }
-        .btn-download-update {
-            margin-top: 8px;
-            padding: 8px 14px;
-            font-size: 13px;
-            background: #28a745;
-            color: #fff;
-            border: none;
-            border-radius: 8px;
-            cursor: pointer;
-        }
-        .btn-download-update:hover {
-            background: #218838;
-        }
-        .header-update-btn {
-            width: 28px;
-            height: 28px;
-            border-radius: 50%;
-            border: none;
-            background: rgba(102,126,234,0.12);
-            color: #4c5bd4;
-            cursor: pointer;
-            display: flex;
-            align-items: center;
-            justify-content: center;
-            font-size: 15px;
-            padding: 0;
-        }
-        .header-update-btn:hover {
-            background: rgba(102,126,234,0.2);
-        }
-        .header-update-panel {
-            position: absolute;
-            top: 44px;
-            right: 0;
-            width: 280px;
-            padding: 14px 16px;
-            background: rgba(255,255,255,0.98);
-            border-radius: 10px;
-            box-shadow: 0 4px 16px rgba(0,0,0,0.12);
-            border: 1px solid rgba(0,0,0,0.04);
-            z-index: 10;
-            display: none;
-        }
-        .header-update-title {
-            font-size: 13px;
-            color: #333;
-            margin-bottom: 8px;
-            display: flex;
-            align-items: center;
-            gap: 6px;
-        }
-    </style>
-</head>
-<body data-user-id="{{ user_id or '' }}">
-    <header class="header">
-        <span class="header-title">数富AI</span>
-        <div class="header-right">
-            {% if is_admin %}
-<!--            <a href="/admin" class="admin-link">用户管理</a>-->
-            {% endif %}
-            <span>{{ username }}</span>
-            <button type="button" class="header-update-btn" id="homeUpdateToggle" title="检测更新">↻</button>
-            <a href="/logout" onclick="handleLogout()">退出</a>
-            <div class="header-update-panel" id="homeUpdatePanel">
-                <div class="header-update-title"><span>↻</span> 软件更新</div>
-                <div class="update-block">
-                    <span class="update-version-text" id="homeVersionText">当前版本: {{ version }}</span>
-                    <button type="button" class="btn-check-update" id="homeBtnCheckUpdate"><span>↻</span> 检测</button>
-                </div>
-                <div class="update-hint" id="homeUpdateHint"></div>
-                <div style="margin-top: 4px;">
-                    <button type="button" class="btn-download-update" id="homeBtnDownloadUpdate" style="display: none;">立即更新</button>
-                </div>
-            </div>
-        </div>
-    </header>
-
-    <div class="entrances" id="entrances">
-        <a class="entrance-btn" href="/brand" data-column-key="brand">亚马逊</a>
-        <a class="entrance-btn disabled" href="javascript:;" data-msg="暂未开通，敬请期待" data-column-key="wb">wildberries</a>
-        <a class="entrance-btn image" href="/image" data-column-key="image">图片</a>
-    </div>
-
-    <div class="toast" id="toast"></div>
-
-    <script>
-        // 权限校验：根据 column-permissions 接口按 column_key 显示入口
-        (function() {
-            localStorage.setItem("uid",{{ user_id }})
-            var uid = document.body.getAttribute('data-user-id');
-            if (!uid) return;
-            var baseUrl = window.location.origin;
-            var apiUrl = baseUrl + '/api/admin/user/' + uid + '/column-permissions';
-            fetch(apiUrl, { credentials: 'same-origin' })
-                .then(function(r) { return r.json(); })
-                .then(function(res) {
-                    if (!res || !res.success || !Array.isArray(res.items)) return;
-                    var allowedKeys = res.items.map(function(item) { return (item.column_key || '').toLowerCase(); });
-                    document.querySelectorAll('.entrances .entrance-btn[data-column-key]').forEach(function(btn) {
-                        var key = (btn.getAttribute('data-column-key') || '').toLowerCase();
-                        btn.style.display = allowedKeys.indexOf(key) >= 0 ? '' : 'none';
-                    });
-                })
-                .catch(function() {});
-        })();
-
-        document.querySelectorAll('.entrance-btn.disabled').forEach(function(btn) {
-            btn.onclick = function(e) {
-                e.preventDefault();
-                var msg = btn.getAttribute('data-msg') || '暂未开通，敬请期待';
-                var t = document.getElementById('toast');
-                t.textContent = msg;
-                t.classList.add('show');
-                setTimeout(function() { t.classList.remove('show'); }, 2000);
-            };
-        });
-
-        function handleLogout() {
-            try{
-                localStorage.removeItem('maixiang_api_key');
-            }catch (e) {
-                console.log(e)
-            }
-        }
-
-        // 软件更新（与 index 设置中逻辑一致）
-        (function() {
-            const versionText = document.getElementById('homeVersionText');
-            const updateHint = document.getElementById('homeUpdateHint');
-            const btnDownload = document.getElementById('homeBtnDownloadUpdate');
-            const updatePanel = document.getElementById('homeUpdatePanel');
-            const toggleBtn = document.getElementById('homeUpdateToggle');
-            if (!versionText || !updateHint || !btnDownload || !updatePanel || !toggleBtn) return;
-
-            let currentVersion = '{{version}}';
-            versionText.textContent = '当前版本: v' + currentVersion;
-
-            // 打开/关闭浮层
-            toggleBtn.addEventListener('click', function(e) {
-                e.stopPropagation();
-                const isVisible = updatePanel.style.display === 'block';
-                updatePanel.style.display = isVisible ? 'none' : 'block';
-            });
-
-            // 点击外部关闭浮层
-            document.addEventListener('click', function() {
-                updatePanel.style.display = 'none';
-            });
-            updatePanel.addEventListener('click', function(e) {
-                e.stopPropagation();
-            });
-
-            document.getElementById('homeBtnCheckUpdate').onclick = async function() {
-                updateHint.textContent = '正在检测更新...';
-                btnDownload.style.display = 'none';
-                try {
-                    const resp = await fetch('/api/version', { credentials: 'same-origin' }).catch(function() { return null; });
-                    if (resp && resp.ok) {
-                        const data = await resp.json();
-                        currentVersion = (data.version || currentVersion).replace(/^v/i, '');
-                        versionText.textContent = '当前版本: v' + currentVersion;
-                        if (data.has_update && data.latest_version) {
-                            updateHint.textContent = '发现新版本 v' + data.latest_version + (data.desc ? '：' + data.desc : '');
-                            btnDownload.style.display = 'inline-block';
-                            btnDownload.textContent = '立即更新';
-                            btnDownload.onclick = async function() {
-                                if (!confirm('有更新，是否现在更新？\n更新将下载安装包并重启程序。')) return;
-                                if (!data.file_url) {
-                                    updateHint.textContent = '暂无下载地址，请关注官方渠道。';
-                                    return;
-                                }
-                                updateHint.textContent = '正在下载并准备更新，程序将自动退出...';
-                                btnDownload.disabled = true;
-                                try {
-                                    const updateResp = await fetch('/api/update/do', {
-                                        method: 'POST',
-                                        credentials: 'same-origin',
-                                        headers: { 'Content-Type': 'application/json' },
-                                        body: JSON.stringify({ file_url: data.file_url })
-                                    });
-                                    const result = await updateResp.json().catch(function() { return {}; });
-                                    if (result.success) {
-                                        updateHint.textContent = '更新已启动，程序即将退出...';
-                                    } else {
-                                        updateHint.textContent = result.error || '更新启动失败';
-                                        btnDownload.disabled = false;
-                                    }
-                                } catch (e) {
-                                    updateHint.textContent = '请求更新失败，请重试';
-                                    btnDownload.disabled = false;
-                                }
-                            };
-                        } else {
-                            updateHint.textContent = '已是最新版本';
-                        }
-                    } else {
-                        updateHint.textContent = '无法连接更新服务，请稍后重试。';
-                    }
-                } catch (e) {
-                    updateHint.textContent = '检测更新失败';
-                }
-            };
-            btnDownload.style.display = 'none';
-        })();
-        // (function() {
-        //     fetch('/api/auth/check', { credentials: 'same-origin' })
-        //         .then(function(r) { return r.json(); })
-        //         .then(function(res) {
-        //             if (res.logged_in && res.redirect) {
-        //                 window.location.href = res.redirect;
-        //             }else{
-        //                 window.location.href = "/login"
-        //                 // handleLogout()
-        //             }
-        //         })
-        //         .catch(function() {});
-        // })();
-    </script>
-</body>
-</html>

app/web_source/login.html

@@ -1,164 +0,0 @@
-<!DOCTYPE html>
-<html lang="zh-CN">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>登录 - 数富AI</title>
-    <style>
-        * { margin: 0; padding: 0; box-sizing: border-box; }
-        body {
-            font-family: "Microsoft YaHei", "PingFang SC", "Hiragino Sans GB", sans-serif;
-            background: #d8e4ec;
-            min-height: 100vh;
-            display: flex;
-            flex-direction: column;
-            align-items: center;
-            justify-content: center;
-            padding: 40px;
-        }
-        .header {
-            position: absolute;
-            top: 0;
-            left: 0;
-            right: 0;
-            height: 56px;
-            display: flex;
-            align-items: center;
-            justify-content: space-between;
-            padding: 0 24px;
-            background: rgba(255,255,255,0.5);
-        }
-        .header-title { font-size: 18px; font-weight: 600; color: #333; }
-        .login-box {
-            background: #fff;
-            border: 1px solid #b8d4e3;
-            border-radius: 12px;
-            box-shadow: 0 4px 12px rgba(0,0,0,0.06);
-            padding: 40px;
-            width: 100%;
-            max-width: 380px;
-        }
-        .login-title {
-            font-size: 24px;
-            font-weight: 600;
-            color: #333;
-            text-align: center;
-            margin-bottom: 30px;
-        }
-        .form-group {
-            margin-bottom: 20px;
-        }
-        .form-group label {
-            display: block;
-            font-size: 14px;
-            color: #555;
-            margin-bottom: 8px;
-        }
-        .form-group input {
-            width: 100%;
-            padding: 12px 14px;
-            font-size: 14px;
-            border: 1px solid #b8d4e3;
-            border-radius: 8px;
-            outline: none;
-            transition: border-color 0.2s;
-            background: #fff;
-        }
-        .form-group input:focus {
-            border-color: #3498db;
-        }
-        .error-msg {
-            color: #e74c3c;
-            font-size: 13px;
-            margin-bottom: 12px;
-            text-align: center;
-        }
-        .btn-login {
-            width: 100%;
-            padding: 14px;
-            font-size: 16px;
-            font-weight: 500;
-            color: #fff;
-            background: linear-gradient(135deg, #3498db 0%, #2980b9 100%);
-            border: none;
-            border-radius: 8px;
-            cursor: pointer;
-            transition: all 0.2s;
-        }
-        .btn-login:hover {
-            opacity: 0.9;
-        }
-        .btn-login:disabled {
-            opacity: 0.6;
-            cursor: not-allowed;
-        }
-    </style>
-</head>
-<body>
-    <header class="header">
-        <span class="header-title">数富AI</span>
-    </header>
-
-    <div class="login-box">
-        <h1 class="login-title">登录</h1>
-        {% if error %}
-        <p class="error-msg">{{ error }}</p>
-        {% endif %}
-        <form id="loginForm" method="POST" action="/login">
-            <div class="form-group">
-                <label>用户名</label>
-                <input type="text" name="username" placeholder="请输入用户名" required autofocus>
-            </div>
-            <div class="form-group">
-                <label>密码</label>
-                <input type="password" name="password" placeholder="请输入密码" required>
-            </div>
-            <button type="submit" class="btn-login" id="btnLogin">登录</button>
-        </form>
-    </div>
-    <script>
-        (function() {
-            fetch('/api/auth/check', { credentials: 'same-origin' })
-                .then(function(r) { return r.json(); })
-                .then(function(res) {
-                    if (res.logged_in && res.redirect) {
-                        window.location.href = res.redirect;
-                    }
-                })
-                .catch(function() {});
-        })();
-        document.getElementById('loginForm').onsubmit = function(e) {
-            e.preventDefault();
-            var btn = document.getElementById('btnLogin');
-            btn.disabled = true;
-            btn.textContent = '登录中...';
-            var form = e.target;
-            var fd = new FormData(form);
-            fetch(form.action, {
-                method: 'POST',
-                body: fd,
-                headers: { 'X-Requested-With': 'XMLHttpRequest' }
-            })
-            .then(function(r) { return r.json(); })
-            .then(function(res) {
-                if (res.success) {
-                    window.location.href = res.redirect || '/home';
-                } else {
-                    var errEl = document.querySelector('.error-msg');
-                    if (!errEl) {
-                        errEl = document.createElement('p');
-                        errEl.className = 'error-msg';
-                        form.insertBefore(errEl, form.firstChild);
-                    }
-                    errEl.textContent = res.error || '登录失败';
-                    btn.disabled = false;
-                    btn.textContent = '登录';
-                }
-            })
-            .catch(function() {
-                form.submit();
-            });
-        };
-    </script>
-</body>
-</html>

app/web_source/templates_backup/admin.html

@@ -1,539 +0,0 @@
-<!DOCTYPE html>
-<html lang="zh-CN">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>管理后台 - 南日AI</title>
-    <style>
-        * { margin: 0; padding: 0; box-sizing: border-box; }
-        body {
-            font-family: "Microsoft YaHei", "PingFang SC", sans-serif;
-            background: #f5f5f5;
-            padding: 24px;
-        }
-        .nav { margin-bottom: 24px; }
-        .nav a { color: #667eea; text-decoration: none; }
-        .nav a:hover { text-decoration: underline; }
-        h1 { font-size: 20px; margin-bottom: 20px; }
-
-        /* Tabs */
-        .tabs {
-            display: flex;
-            gap: 4px;
-            margin-bottom: 20px;
-            border-bottom: 1px solid #e0e0e0;
-        }
-        .tab {
-            padding: 12px 24px;
-            cursor: pointer;
-            color: #666;
-            font-size: 15px;
-            border-bottom: 2px solid transparent;
-            margin-bottom: -1px;
-        }
-        .tab:hover { color: #667eea; }
-        .tab.active { color: #667eea; font-weight: 600; border-bottom-color: #667eea; }
-        .tab-panel { display: none; }
-        .tab-panel.active { display: block; }
-
-        /* Form & Table */
-        .form-box, .panel-box {
-            background: #fff;
-            border-radius: 8px;
-            padding: 24px;
-            margin-bottom: 20px;
-        }
-        .form-group { margin-bottom: 16px; }
-        .form-group label { display: block; font-size: 14px; margin-bottom: 6px; }
-        .form-group input, .form-group select {
-            width: 100%; padding: 10px; border: 1px solid #ddd; border-radius: 6px;
-        }
-        .form-group input[type="checkbox"] { width: auto; margin-right: 8px; }
-        .form-row { display: flex; gap: 16px; flex-wrap: wrap; align-items: flex-end; margin-bottom: 16px; }
-        .form-row .form-group { margin-bottom: 0; flex: 1; min-width: 120px; }
-
-        .btn { padding: 10px 20px; background: #667eea; color: #fff; border: none; border-radius: 6px; cursor: pointer; font-size: 14px; }
-        .btn:hover { opacity: 0.9; }
-        .btn-sm { padding: 6px 12px; font-size: 13px; }
-        .btn-danger { background: #e74c3c; }
-        .btn-secondary { background: #95a5a6; }
-
-        .msg { margin-top: 12px; font-size: 14px; }
-        .msg.ok { color: #27ae60; }
-        .msg.err { color: #e74c3c; }
-
-        table { width: 100%; border-collapse: collapse; }
-        th, td { padding: 12px; text-align: left; border-bottom: 1px solid #eee; font-size: 14px; }
-        th { background: #f8f9fa; font-weight: 600; }
-        .pagination {
-            display: flex;
-            align-items: center;
-            gap: 8px;
-            margin-top: 16px;
-            flex-wrap: wrap;
-        }
-        .pagination span { font-size: 14px; color: #666; }
-        .pagination button { padding: 6px 12px; border: 1px solid #ddd; background: #fff; cursor: pointer; border-radius: 4px; }
-        .pagination button:hover:not(:disabled) { background: #f0f0f0; }
-        .pagination button:disabled { opacity: 0.5; cursor: not-allowed; }
-
-        .thumb { width: 60px; height: 60px; object-fit: cover; border-radius: 4px; margin-right: 8px; vertical-align: middle; }
-        .thumb-wrap { display: flex; flex-wrap: wrap; gap: 4px; }
-        .empty-tip { color: #999; font-size: 14px; padding: 24px; text-align: center; }
-        .modal-mask {
-            display: none;
-            position: fixed; left: 0; top: 0; right: 0; bottom: 0;
-            background: rgba(0,0,0,0.4); z-index: 1000;
-            align-items: center; justify-content: center;
-        }
-        .modal-mask.show { display: flex; }
-        .modal { background: #fff; border-radius: 8px; padding: 24px; min-width: 320px; max-width: 90%; }
-        .modal h3 { margin-bottom: 16px; font-size: 16px; }
-    </style>
-</head>
-<body>
-    <div class="nav"><a href="/home">← 返回首页</a></div>
-    <h1>管理后台</h1>
-
-    <div class="tabs">
-        <div class="tab active" data-tab="users">用户管理</div>
-        <div class="tab" data-tab="history">查看生成记录</div>
-    </div>
-
-    <!-- 用户管理 -->
-    <div id="panel-users" class="tab-panel active">
-        <div class="form-box">
-            <h3 style="margin-bottom:16px;font-size:15px;">创建用户</h3>
-            <p style="margin-bottom:16px;font-size:13px;color:#666;">无注册入口，仅管理员可在此创建用户。层级：超级管理员 → 管理员 → 普通号。</p>
-            <div class="form-group">
-                <label>用户名</label>
-                <input type="text" id="username" placeholder="用户名（至少2个字符）">
-            </div>
-            <div class="form-group">
-                <label>密码</label>
-                <input type="password" id="password" placeholder="密码（至少6个字符）">
-            </div>
-            <div class="form-group" id="formGroupRole">
-                <label>角色</label>
-                <select id="createRole">
-                    <option value="normal">普通号</option>
-                    <option value="admin" id="optAdmin">管理员</option>
-                </select>
-            </div>
-            <div class="form-group" id="formGroupCreatedBy" style="display:none;">
-                <label>所属管理员</label>
-                <select id="createCreatedBy">
-                    <option value="">请选择管理员</option>
-                </select>
-            </div>
-            <button class="btn" id="btnCreate">创建用户</button>
-            <p class="msg" id="msgCreate"></p>
-        </div>
-
-        <div class="panel-box">
-            <h3 style="margin-bottom:16px;font-size:15px;">用户列表</h3>
-            <div class="form-row" style="margin-bottom:16px;">
-                <div class="form-group" style="min-width:180px;">
-                    <label>用户名（模糊搜索）</label>
-                    <input type="text" id="searchUsername" placeholder="输入用户名关键字">
-                </div>
-                <div class="form-group" id="filterCreatedByGroup" style="min-width:160px;display:none;">
-                    <label>所属管理员</label>
-                    <select id="filterCreatedBy">
-                        <option value="">全部</option>
-                    </select>
-                </div>
-                <button class="btn" id="btnSearchUsers">查询</button>
-            </div>
-            <table>
-                <thead>
-                    <tr>
-                        <th>ID</th>
-                        <th>用户名</th>
-                        <th>角色</th>
-                        <th>所属管理员</th>
-                        <th>创建时间</th>
-                        <th>操作</th>
-                    </tr>
-                </thead>
-                <tbody id="userListBody"></tbody>
-            </table>
-            <div class="pagination" id="userPagination"></div>
-        </div>
-    </div>
-
-    <!-- 查看生成记录 -->
-    <div id="panel-history" class="tab-panel">
-        <div class="form-box">
-            <h3 style="margin-bottom:16px;font-size:15px;">筛选条件</h3>
-            <div class="form-row">
-                <div class="form-group" style="min-width:140px;">
-                    <label>指定用户</label>
-                    <select id="filterUser">
-                        <option value="">全部用户</option>
-                    </select>
-                </div>
-                <div class="form-group" style="min-width:140px;">
-                    <label>开始时间</label>
-                    <input type="datetime-local" id="filterTimeStart">
-                </div>
-                <div class="form-group" style="min-width:140px;">
-                    <label>结束时间</label>
-                    <input type="datetime-local" id="filterTimeEnd">
-                </div>
-                <button class="btn" id="btnFilterHistory">查询</button>
-            </div>
-        </div>
-        <div class="panel-box">
-            <h3 style="margin-bottom:16px;font-size:15px;">生成记录</h3>
-            <table>
-                <thead>
-                    <tr>
-                        <th>ID</th>
-                        <th>用户</th>
-                        <th>类型</th>
-                        <th>创建时间</th>
-                        <th>结果预览</th>
-                    </tr>
-                </thead>
-                <tbody id="historyListBody"></tbody>
-            </table>
-            <div class="pagination" id="historyPagination"></div>
-        </div>
-    </div>
-
-    <!-- 编辑用户弹窗 -->
-    <div class="modal-mask" id="editUserModal">
-        <div class="modal">
-            <h3>编辑用户</h3>
-            <input type="hidden" id="editUserId">
-            <div class="form-group">
-                <label>用户名</label>
-                <input type="text" id="editUsername" readonly style="background:#f5f5f5;">
-            </div>
-            <div class="form-group">
-                <label>新密码（不修改留空）</label>
-                <input type="password" id="editPassword" placeholder="留空则不修改密码">
-            </div>
-            <div class="form-group" id="editFormGroupRole" style="display:none;">
-                <label>角色</label>
-                <select id="editRole">
-                    <option value="normal">普通号</option>
-                    <option value="admin">管理员</option>
-                </select>
-            </div>
-            <div class="form-group" id="editFormGroupCreator" style="display:none;">
-                <label>所属管理员</label>
-                <input type="text" id="editCreatorName" readonly style="background:#f5f5f5;">
-            </div>
-            <p class="msg" id="msgEdit"></p>
-            <div style="margin-top:16px;display:flex;gap:8px;">
-                <button class="btn" id="btnSaveUser">保存</button>
-                <button class="btn btn-secondary" id="btnCloseEdit">取消</button>
-            </div>
-        </div>
-    </div>
-
-    <script>
-        (function() {
-            // Tab 切换
-            document.querySelectorAll('.tab').forEach(function(t) {
-                t.onclick = function() {
-                    document.querySelectorAll('.tab').forEach(function(x) { x.classList.remove('active'); });
-                    document.querySelectorAll('.tab-panel').forEach(function(x) { x.classList.remove('active'); });
-                    t.classList.add('active');
-                    var id = 'panel-' + t.dataset.tab;
-                    document.getElementById(id).classList.add('active');
-                    if (t.dataset.tab === 'users') loadUsers(1);
-                    else if (t.dataset.tab === 'history') loadHistory(1);
-                };
-            });
-
-            // ========== 用户管理 ==========
-            var userPage = 1, userPageSize = 15;
-            var currentUserRole = 'admin';
-            var adminsList = [];
-            function roleLabel(role) {
-                if (role === 'super_admin') return '超级管理员';
-                if (role === 'admin') return '管理员';
-                return '普通号';
-            }
-            function buildUserListQuery(page) {
-                var q = 'page=' + (page || 1) + '&page_size=' + userPageSize;
-                var kw = (document.getElementById('searchUsername').value || '').trim();
-                if (kw) q += '&username=' + encodeURIComponent(kw);
-                var cby = document.getElementById('filterCreatedBy').value;
-                if (cby) q += '&created_by_id=' + encodeURIComponent(cby);
-                return q;
-            }
-            function loadUsers(page) {
-                userPage = page || 1;
-                fetch('/api/admin/users?' + buildUserListQuery(userPage))
-                    .then(function(r) { return r.json(); })
-                    .then(function(res) {
-                        var tbody = document.getElementById('userListBody');
-                        if (!res.success) {
-                            tbody.innerHTML = '<tr><td colspan="6" class="empty-tip">加载失败: ' + (res.error || '') + '</td></tr>';
-                            return;
-                        }
-                        currentUserRole = res.current_user_role || 'admin';
-                        adminsList = res.admins || [];
-                        var items = res.items || [];
-                        if (items.length === 0) {
-                            tbody.innerHTML = '<tr><td colspan="6" class="empty-tip">暂无用户</td></tr>';
-                        } else {
-                            tbody.innerHTML = items.map(function(u) {
-                                return '<tr><td>' + u.id + '</td><td>' + (u.username || '') + '</td><td>' +
-                                    roleLabel(u.role || 'normal') + '</td><td>' + (u.creator_username || '-') + '</td><td>' + (u.created_at || '') + '</td><td>' +
-                                    '<button class="btn btn-sm" data-edit="' + u.id + '" data-user="' + (JSON.stringify(u).replace(/"/g, '&quot;')) + '">编辑</button> ' +
-                                    '<button class="btn btn-sm btn-danger" data-delete="' + u.id + '" data-name="' + (u.username || '').replace(/"/g, '&quot;') + '">删除</button>' +
-                                    '</td></tr>';
-                            }).join('');
-                        }
-                        renderPagination('userPagination', res.total, res.page, res.page_size, loadUsers);
-                        bindUserActions();
-                        updateCreateFormByRole();
-                        updateUserFilterByRole();
-                    })
-                    .catch(function() {
-                        document.getElementById('userListBody').innerHTML = '<tr><td colspan="6" class="empty-tip">请求失败</td></tr>';
-                    });
-            }
-            function updateUserFilterByRole() {
-                var grp = document.getElementById('filterCreatedByGroup');
-                var sel = document.getElementById('filterCreatedBy');
-                if (currentUserRole === 'super_admin') {
-                    grp.style.display = 'block';
-                    var cur = sel.value;
-                    sel.innerHTML = '<option value="">全部</option>';
-                    adminsList.forEach(function(a) {
-                        var opt = document.createElement('option');
-                        opt.value = a.id;
-                        opt.textContent = a.username;
-                        sel.appendChild(opt);
-                    });
-                    sel.value = cur || '';
-                } else {
-                    grp.style.display = 'none';
-                }
-            }
-            function updateCreateFormByRole() {
-                var roleSel = document.getElementById('createRole');
-                var optAdmin = document.getElementById('optAdmin');
-                var formCreatedBy = document.getElementById('formGroupCreatedBy');
-                var selCreatedBy = document.getElementById('createCreatedBy');
-                if (currentUserRole === 'super_admin') {
-                    if (optAdmin) optAdmin.style.display = '';
-                    formCreatedBy.style.display = (roleSel.value === 'normal') ? 'block' : 'none';
-                    selCreatedBy.innerHTML = '<option value="">请选择管理员</option>';
-                    adminsList.forEach(function(a) {
-                        var opt = document.createElement('option');
-                        opt.value = a.id;
-                        opt.textContent = a.username;
-                        selCreatedBy.appendChild(opt);
-                    });
-                } else {
-                    if (optAdmin) optAdmin.style.display = 'none';
-                    roleSel.value = 'normal';
-                    formCreatedBy.style.display = 'none';
-                }
-            }
-            function bindUserActions() {
-                document.querySelectorAll('[data-edit]').forEach(function(btn) {
-                    btn.onclick = function() {
-                        var raw = (btn.getAttribute('data-user') || '{}').replace(/&quot;/g, '"');
-                        var u;
-                        try { u = JSON.parse(raw); } catch (e) { u = {}; }
-                        document.getElementById('editUserId').value = u.id || '';
-                        document.getElementById('editUsername').value = u.username || '';
-                        document.getElementById('editPassword').value = '';
-                        var editRole = document.getElementById('editRole');
-                        var editFormGroupRole = document.getElementById('editFormGroupRole');
-                        var editFormGroupCreator = document.getElementById('editFormGroupCreator');
-                        var editCreatorName = document.getElementById('editCreatorName');
-                        editFormGroupRole.style.display = (currentUserRole === 'super_admin' && u.role !== 'super_admin') ? 'block' : 'none';
-                        editFormGroupCreator.style.display = (u.role === 'normal' && u.creator_username) ? 'block' : 'none';
-                        editCreatorName.value = u.creator_username || '';
-                        if (u.role !== 'super_admin') { editRole.value = u.role || 'normal'; }
-                        document.getElementById('msgEdit').textContent = '';
-                        document.getElementById('editUserModal').classList.add('show');
-                    };
-                });
-                document.querySelectorAll('[data-delete]').forEach(function(btn) {
-                    btn.onclick = function() {
-                        if (!confirm('确定删除用户 "' + (btn.dataset.name || '') + '" 吗？')) return;
-                        fetch('/api/admin/user/' + btn.dataset.delete, { method: 'DELETE' })
-                            .then(function(r) { return r.json(); })
-                            .then(function(res) {
-                                if (res.success) { loadUsers(userPage); }
-                                else { alert(res.error || '删除失败'); }
-                            });
-                    };
-                });
-            }
-
-            document.getElementById('btnSearchUsers').onclick = function() { loadUsers(1); };
-            document.getElementById('createRole').onchange = function() { updateCreateFormByRole(); };
-            document.getElementById('btnCreate').onclick = function() {
-                var username = (document.getElementById('username').value || '').trim();
-                var password = document.getElementById('password').value || '';
-                var role = document.getElementById('createRole').value || 'normal';
-                var createdById = document.getElementById('createCreatedBy').value ? parseInt(document.getElementById('createCreatedBy').value, 10) : null;
-                var msgEl = document.getElementById('msgCreate');
-                msgEl.textContent = '';
-                msgEl.className = 'msg';
-                if (!username || username.length < 2) {
-                    msgEl.textContent = '用户名至少2个字符';
-                    msgEl.classList.add('err');
-                    return;
-                }
-                if (!password || password.length < 6) {
-                    msgEl.textContent = '密码至少6个字符';
-                    msgEl.classList.add('err');
-                    return;
-                }
-                var body = { username: username, password: password, role: role };
-                if (role === 'normal' && currentUserRole === 'super_admin' && createdById) body.created_by_id = createdById;
-                fetch('/api/admin/user', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify(body)
-                })
-                .then(function(r) { return r.json(); })
-                .then(function(res) {
-                    if (res.success) {
-                        msgEl.textContent = res.msg || '创建成功';
-                        msgEl.classList.add('ok');
-                        document.getElementById('username').value = '';
-                        document.getElementById('password').value = '';
-                        loadUsers(1);
-                    } else {
-                        msgEl.textContent = res.error || '创建失败';
-                        msgEl.classList.add('err');
-                    }
-                })
-                .catch(function() {
-                    msgEl.textContent = '请求失败';
-                    msgEl.classList.add('err');
-                });
-            };
-
-            document.getElementById('btnSaveUser').onclick = function() {
-                var uid = document.getElementById('editUserId').value;
-                var password = document.getElementById('editPassword').value;
-                var editRoleEl = document.getElementById('editRole');
-                var msgEl = document.getElementById('msgEdit');
-                msgEl.textContent = '';
-                msgEl.className = 'msg';
-                var body = {};
-                if (password) body.password = password;
-                if (currentUserRole === 'super_admin' && editRoleEl && editRoleEl.offsetParent !== null)
-                    body.role = editRoleEl.value || 'normal';
-                fetch('/api/admin/user/' + uid, {
-                    method: 'PUT',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify(body)
-                })
-                .then(function(r) { return r.json(); })
-                .then(function(res) {
-                    if (res.success) {
-                        msgEl.textContent = res.msg || '保存成功';
-                        msgEl.classList.add('ok');
-                        document.getElementById('editUserModal').classList.remove('show');
-                        loadUsers(userPage);
-                    } else {
-                        msgEl.textContent = res.error || '保存失败';
-                        msgEl.classList.add('err');
-                    }
-                });
-            };
-            document.getElementById('btnCloseEdit').onclick = function() {
-                document.getElementById('editUserModal').classList.remove('show');
-            };
-
-            // ========== 生成记录 ==========
-            var historyPage = 1, historyPageSize = 15;
-            function toSqlDatetime(val) {
-                if (!val) return '';
-                return val.replace('T', ' ');
-            }
-            function buildHistoryQuery(page) {
-                var q = 'page=' + (page || 1) + '&page_size=' + historyPageSize;
-                var uid = document.getElementById('filterUser').value;
-                var start = toSqlDatetime(document.getElementById('filterTimeStart').value);
-                var end = toSqlDatetime(document.getElementById('filterTimeEnd').value);
-                if (uid) q += '&user_id=' + uid;
-                if (start) q += '&time_start=' + encodeURIComponent(start);
-                if (end) q += '&time_end=' + encodeURIComponent(end);
-                return q;
-            }
-            function loadHistory(page) {
-                historyPage = page || 1;
-                fetch('/api/admin/history?' + buildHistoryQuery(historyPage))
-                    .then(function(r) { return r.json(); })
-                    .then(function(res) {
-                        var tbody = document.getElementById('historyListBody');
-                        if (!res.success) {
-                            tbody.innerHTML = '<tr><td colspan="5" class="empty-tip">加载失败: ' + (res.error || '') + '</td></tr>';
-                            return;
-                        }
-                        var items = res.items || [];
-                        if (items.length === 0) {
-                            tbody.innerHTML = '<tr><td colspan="5" class="empty-tip">暂无记录</td></tr>';
-                        } else {
-                            tbody.innerHTML = items.map(function(h) {
-                                var urls = (h.result_urls || []);
-                                var thumbUrls = (h.long_image_url ? [h.long_image_url] : []).concat(urls);
-                                var thumbs = thumbUrls.slice(0, 3).map(function(url) {
-                                    return '<img src="' + (url || '').replace(/"/g, '&quot;') + '" class="thumb" alt="">';
-                                }).join('');
-                                return '<tr><td>' + h.id + '</td><td>' + (h.username || '-') + '</td><td>' +
-                                    (h.panel_type || '-') + '</td><td>' + (h.created_at || '') + '</td><td>' +
-                                    '<div class="thumb-wrap">' + (thumbs || '-') + '</div></td></tr>';
-                            }).join('');
-                        }
-                        renderPagination('historyPagination', res.total, res.page, res.page_size, loadHistory);
-                    })
-                    .catch(function() {
-                        document.getElementById('historyListBody').innerHTML = '<tr><td colspan="5" class="empty-tip">请求失败</td></tr>';
-                    });
-            }
-            function loadUserOptions() {
-                fetch('/api/admin/users?page=1&page_size=999')
-                    .then(function(r) { return r.json(); })
-                    .then(function(res) {
-                        var sel = document.getElementById('filterUser');
-                        var cur = sel.value;
-                        sel.innerHTML = '<option value="">全部用户</option>';
-                        (res.items || []).forEach(function(u) {
-                            var opt = document.createElement('option');
-                            opt.value = u.id;
-                            opt.textContent = u.username + ' (' + roleLabel(u.role || 'normal') + ')';
-                            sel.appendChild(opt);
-                        });
-                        sel.value = cur || '';
-                    });
-            }
-            document.getElementById('btnFilterHistory').onclick = function() { loadHistory(1); };
-
-            // ========== 分页 ==========
-            function renderPagination(elId, total, page, pageSize, onPage) {
-                var el = document.getElementById(elId);
-                if (!el) return;
-                var totalPages = Math.max(1, Math.ceil(total / pageSize));
-                el.innerHTML = '<span>共 ' + total + ' 条</span>' +
-                    '<button ' + (page <= 1 ? 'disabled' : '') + ' data-p="' + (page - 1) + '">上一页</button>' +
-                    '<span>第 ' + page + ' / ' + totalPages + ' 页</span>' +
-                    '<button ' + (page >= totalPages ? 'disabled' : '') + ' data-p="' + (page + 1) + '">下一页</button>';
-                el.querySelectorAll('[data-p]').forEach(function(b) {
-                    if (!b.disabled) b.onclick = function() { onPage(parseInt(b.dataset.p, 10)); };
-                });
-            }
-
-            // 初始化
-            loadUsers(1);
-            loadUserOptions();
-        })();
-    </script>
-</body>
-</html>

app/web_source/templates_backup/brand.html

@@ -1,918 +0,0 @@
-<!DOCTYPE html>
-<html lang="zh-CN">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>亚马逊 - 南日AI</title>
-    <style>
-        * { margin: 0; padding: 0; box-sizing: border-box; }
-        body {
-            font-family: "Microsoft YaHei", "Noto Serif SC", "SimSun", "Songti SC", "Times New Roman", serif;
-            background: rgba(13, 13, 13, 1);
-            color: #e0e0e0;
-            overflow: hidden;
-            height: 100vh;
-            font-weight: bold;
-        }
-        .top-bar {
-            height: 56px;
-            display: flex;
-            align-items: center;
-            justify-content: space-between;
-            padding: 0 16px;
-            border-bottom: 1px solid #2a2a2a;
-        }
-        .logo-area {
-            display: flex;
-            align-items: center;
-            gap: 10px;
-        }
-        .top-bar .app-name { font-size: 18px; font-weight: 600; color: #fff; }
-        .btn-home {
-            font-size: 13px;
-            color: #999;
-            text-decoration: none;
-            padding: 8px 12px;
-            border-radius: 6px;
-            transition: all 0.2s;
-        }
-        .btn-home:hover { color: #fff; background: #2a2a2a; }
-
-        /* 顶部栏目导航（容器化，便于后续增加栏目） */
-        .nav-tabs {
-            display: flex;
-            align-items: center;
-            gap: 0;
-        }
-        .nav-tab-group {
-            display: flex;
-            align-items: center;
-            gap: 6px;
-            background: rgba(77, 72, 72, 0.99);
-            border-radius: 10px;
-        }
-        .nav-tab-sep {
-            width: 1px;
-            height: 20px;
-            background: linear-gradient(to bottom, transparent, #444 15%, #444 85%, transparent);
-            margin: 0 10px;
-            flex-shrink: 0;
-            opacity: 0.9;
-        }
-        .nav-tab {
-            padding: 8px 14px;
-            font-size: 13px;
-            color: #999;
-            background: transparent;
-            border: none;
-            border-radius: 6px;
-            cursor: pointer;
-            transition: all 0.2s;
-        }
-        .nav-tab:hover {
-            color: #fff;
-            background: #2a2a2a;
-        }
-        .nav-tab.active {
-            color: #3498db;
-            background: rgba(52, 152, 219, 0.2);
-        }
-        .top-right {
-            display: flex;
-            align-items: center;
-            gap: 8px;
-        }
-
-        .main-content {
-            display: flex;
-            height: calc(100vh - 56px);
-        }
-        /* 栏目内容容器：每个栏目一个 .tab-panel，通过 data-panel 与导航对应 */
-        .tab-panel {
-            display: none;
-            flex: 1;
-            min-width: 0;
-            min-height: 0;
-        }
-        .tab-panel.active {
-            display: flex;
-        }
-        .left-panel {
-            width: 380px;
-            background: #1e1e1e;
-            padding: 20px;
-            overflow-y: auto;
-            border-right: 1px solid #2a2a2a;
-        }
-        .right-panel {
-            flex: 1;
-            display: flex;
-            flex-direction: column;
-            min-width: 0;
-            background: #1a1a1a;
-        }
-        .section-title {
-            font-size: 13px;
-            color: #bbb;
-            margin-bottom: 10px;
-        }
-        .upload-zone {
-            border: 1px dashed #3a3a3a;
-            border-radius: 10px;
-            padding: 24px;
-            text-align: center;
-            background: #252525;
-            margin-bottom: 20px;
-            transition: all 0.2s;
-        }
-        .upload-zone:hover { border-color: #3498db; background: #2a2a2a; }
-        .upload-zone .hint { color: #888; font-size: 13px; margin-bottom: 12px; }
-        .upload-zone .btns { display: flex; gap: 10px; justify-content: center; flex-wrap: wrap; }
-        .opt-btn {
-            padding: 8px 16px;
-            font-size: 13px;
-            color: #ccc;
-            background: #2a2a2a;
-            border: 1px solid #3a3a3a;
-            border-radius: 6px;
-            cursor: pointer;
-            transition: all 0.2s;
-        }
-        .opt-btn:hover { color: #fff; background: #333; border-color: #3498db; color: #3498db; }
-        .selected-files {
-            margin-top: 12px;
-            font-size: 12px;
-            color: #888;
-            max-height: 72px;
-            overflow-y: auto;
-        }
-        .selected-files span { display: block; margin: 4px 0; word-break: break-all; }
-        .option-group { margin-bottom: 20px; }
-        .radio-item {
-            display: flex;
-            align-items: flex-start;
-            gap: 10px;
-            cursor: pointer;
-            padding: 10px 12px;
-            border-radius: 8px;
-            background: #252525;
-            border: 1px solid #2a2a2a;
-            margin-bottom: 8px;
-        }
-        .radio-item:hover { background: #2a2a2a; }
-        .radio-item input { margin-top: 3px; }
-        .radio-item .label { font-weight: 500; color: #e0e0e0; font-size: 13px; }
-        .radio-item .desc { font-size: 12px; color: #888; margin-top: 2px; font-weight: normal; }
-        .run-row {
-            display: flex;
-            align-items: center;
-            gap: 12px;
-            margin-top: 16px;
-        }
-        .btn-run {
-            padding: 10px 22px;
-            background: #3498db;
-            color: #fff;
-            border: none;
-            border-radius: 8px;
-            font-size: 14px;
-            cursor: pointer;
-            transition: all 0.2s;
-        }
-        .btn-run:hover { background: #2980b9; }
-        .btn-run:disabled { background: #555; cursor: not-allowed; color: #999; }
-        .loading-msg { color: #3498db; font-size: 13px; }
-
-        .template-download-row {
-            margin-top: 16px;
-            padding: 14px 16px;
-            background: linear-gradient(135deg, #252525 0%, #1e2a1e 100%);
-            border: 1px solid #2a3a2a;
-            border-radius: 10px;
-            display: flex;
-            align-items: center;
-            gap: 14px;
-            transition: all 0.25s ease;
-            cursor: pointer;
-        }
-        .template-download-row:hover {
-            border-color: #2e7d32;
-            background: linear-gradient(135deg, #2a2a2a 0%, #243324 100%);
-            box-shadow: 0 4px 12px rgba(46, 125, 50, 0.15);
-        }
-        .template-download-row:hover .template-download-text .title { color: #2ecc71; }
-        .template-download-row:hover .template-download-icon {
-            transform: scale(1.05);
-            box-shadow: 0 6px 16px rgba(46, 125, 50, 0.45), inset 0 1px 0 rgba(255,255,255,0.15);
-        }
-        .template-download-icon {
-            width: 48px;
-            height: 48px;
-            flex-shrink: 0;
-            border-radius: 10px;
-            background: linear-gradient(145deg, #1b5e20 0%, #2e7d32 50%, #388e3c 100%);
-            display: flex;
-            align-items: center;
-            justify-content: center;
-            box-shadow: 0 4px 12px rgba(46, 125, 50, 0.35), inset 0 1px 0 rgba(255,255,255,0.1);
-            transition: transform 0.2s, box-shadow 0.2s;
-        }
-        .template-download-icon svg {
-            width: 28px;
-            height: 28px;
-        }
-        .template-download-text .title { font-size: 14px; color: #e0e0e0; font-weight: 600; display: block; }
-        .template-download-text .hint { font-size: 12px; color: #888; margin-top: 2px; font-weight: normal; }
-
-        .panel-header {
-            padding: 16px 20px;
-            border-bottom: 1px solid #2a2a2a;
-            font-size: 15px;
-            font-weight: 600;
-            color: #ddd;
-            display: flex;
-            align-items: center;
-            justify-content: space-between;
-            gap: 12px;
-        }
-        .panel-header-title {
-            flex: 1;
-        }
-        .btn-refresh-tasks {
-            padding: 6px 14px;
-            font-size: 12px;
-            border-radius: 6px;
-            border: 1px solid #3a3a3a;
-            background: #2a2a2a;
-            color: #ccc;
-            cursor: pointer;
-            transition: all 0.2s;
-            white-space: nowrap;
-        }
-        .btn-refresh-tasks:hover {
-            background: #333;
-            border-color: #3498db;
-            color: #3498db;
-        }
-        .task-list-wrap {
-            flex: 1;
-            overflow-y: auto;
-            padding: 16px;
-        }
-        .task-list { list-style: none; }
-        .task-item {
-            display: flex;
-            align-items: center;
-            justify-content: space-between;
-            padding: 14px 16px;
-            border: 1px solid #2a2a2a;
-            border-radius: 8px;
-            margin-bottom: 10px;
-            background: #1e1e1e;
-        }
-        .task-item .left { flex: 1; min-width: 0; }
-        .task-item .id { font-weight: 600; color: #e0e0e0; font-size: 13px; }
-        .task-item .files { font-size: 12px; color: #888; margin-top: 4px; }
-        .task-item .time { font-size: 12px; color: #666; margin-top: 2px; }
-        .task-item .status {
-            padding: 4px 10px;
-            border-radius: 6px;
-            font-size: 12px;
-            margin-right: 12px;
-        }
-        .task-item .status.pending { background: rgba(255,193,7,0.2); color: #d4a500; }
-        .task-item .status.running { background: rgba(52,152,219,0.2); color: #3498db; }
-        .task-item .status.success { background: rgba(46,204,113,0.2); color: #2ecc71; }
-        .task-item .status.failed { background: rgba(231,76,60,0.2); color: #e74c3c; }
-        .task-item .status.cancelled { background: rgba(149,165,166,0.2); color: #95a5a6; }
-        .task-item .progress-wrap { margin-top: 8px; margin-right: 8px; flex-shrink: 0; width: 120px; }
-        .task-item .progress-bar-bg { height: 6px; background: #2a2a2a; border-radius: 3px; overflow: hidden; }
-        .task-item .progress-bar-fill { height: 100%; background: #3498db; border-radius: 3px; transition: width 0.2s; }
-        .task-item .btn-cancel, .task-item .btn-delete {
-            padding: 6px 12px; font-size: 12px; border-radius: 6px; cursor: pointer; border: none; margin-left: 6px;
-            transition: all 0.2s;
-        }
-        .task-item .btn-cancel { background: #e67e22; color: #fff; }
-        .task-item .btn-cancel:hover { background: #d35400; }
-        .task-item .btn-delete { background: #444; color: #ccc; }
-        .task-item .btn-delete:hover { background: #e74c3c; color: #fff; }
-        .task-item .task-right { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; }
-        .run-row .progress-wrap { margin-top: 10px; width: 100%; max-width: 280px; }
-        .run-row .progress-bar-bg { height: 8px; background: #2a2a2a; border-radius: 4px; overflow: hidden; }
-        .run-row .progress-bar-fill { height: 100%; background: #3498db; border-radius: 4px; transition: width 0.2s; }
-        .run-row .btn-cancel-run { margin-left: 12px; padding: 8px 16px; background: #e67e22; color: #fff; border: none; border-radius: 6px; font-size: 13px; cursor: pointer; }
-        .run-row .btn-cancel-run:hover { background: #d35400; }
-        .task-item .download {
-            padding: 6px 14px;
-            background: #3498db;
-            color: #fff;
-            border: none;
-            border-radius: 6px;
-            font-size: 13px;
-            cursor: pointer;
-            text-decoration: none;
-            white-space: nowrap;
-            transition: all 0.2s;
-        }
-        .task-item .download:hover { background: #2980b9; color: #fff; }
-        .task-item .download.hide { display: none; }
-        .empty-tasks { text-align: center; color: #666; padding: 32px; font-size: 13px; }
-        .toast {
-            position: fixed;
-            bottom: 32px;
-            left: 50%;
-            transform: translateX(-50%);
-            background: rgba(0,0,0,0.85);
-            color: #fff;
-            padding: 12px 24px;
-            border-radius: 8px;
-            font-size: 14px;
-            z-index: 1000;
-            opacity: 0;
-            transition: opacity 0.3s;
-            border: 1px solid #333;
-        }
-        .toast.show { opacity: 1; }
-    </style>
-</head>
-<body>
-    <header class="top-bar">
-        <div class="logo-area">
-            <span class="app-name">南日AI-亚马逊</span>
-            <a href="/home" class="btn-home">返回首页</a>
-        </div>
-        <nav class="nav-tabs">
-            <span class="nav-tab-group">
-                <button type="button" class="nav-tab active" data-panel="brandCheck">品牌检测</button>
-                <!-- 后续增加栏目时在此添加，例如：<button type="button" class="nav-tab" data-panel="other">其他栏目</button> -->
-            </span>
-            <!-- 多组栏目时可用分隔符：<span class="nav-tab-sep" aria-hidden="true"></span> -->
-        </nav>
-        <div class="top-right"></div>
-    </header>
-
-    <div class="main-content">
-        <!-- 品牌检测栏目容器；后续增加栏目时复制此结构，改 data-panel 与 id，并去掉 .active -->
-        <div class="tab-panel active" data-panel="brandCheck" id="panel-brandCheck">
-        <aside class="left-panel">
-            <div class="section-title">选择文件</div>
-            <div class="upload-zone" id="uploadZone">
-                <div class="hint">选择 .xlsx 文件或文件夹（将读取该文件夹下所有 xlsx）</div>
-                <div class="btns">
-                    <button type="button" class="opt-btn" id="btnSelectFiles">选择 Excel 文件</button>
-                    <button type="button" class="opt-btn" id="btnSelectFolder">选择文件夹</button>
-                </div>
-                <div class="selected-files" id="selectedFiles"></div>
-            </div>
-
-            <div class="section-title">运行方式</div>
-            <div class="option-group">
-                <label class="radio-item">
-                    <input type="radio" name="runMode" value="immediate" checked>
-                    <div>
-                        <span class="label">立即运行</span>
-                        <div class="desc">立刻执行，执行完成后可下载结果</div>
-                    </div>
-                </label>
-                <label class="radio-item">
-                    <input type="radio" name="runMode" value="task">
-                    <div>
-                        <span class="label">添加任务</span>
-                        <div class="desc">数量较多时建议添加任务，后台执行，可在右侧任务队列查看状态与下载结果</div>
-                    </div>
-                </label>
-            </div>
-            <div class="section-title">匹配方式</div>
-            <div class="option-group">
-                <label class="radio-item">
-                    <input type="radio" name="matchStrategy" value="Terms" checked>
-                    <div>
-                        <span class="label">精确匹配表达式</span>
-                        <div class="desc">使用精确匹配，适合严格匹配品牌名称</div>
-                    </div>
-                </label>
-                <label class="radio-item">
-                    <input type="radio" name="matchStrategy" value="Simple">
-                    <div>
-                        <span class="label">嵌入（结果包含输入的词语）</span>
-                        <div class="desc">使用嵌入策略，结果中包含输入的品牌词语</div>
-                    </div>
-                </label>
-            </div>
-            <div class="run-row" id="runRow">
-                <div style="display:flex;align-items:center;flex-wrap:wrap;gap:10px;">
-                    <button type="button" class="btn-run" id="btnRun">立即运行</button>
-                    <span class="loading-msg" id="loadingMsg" style="display:none;">生成中，请稍候…</span>
-                    <div class="progress-wrap" id="runProgressWrap" style="display:none;">
-                        <div class="progress-bar-bg"><div class="progress-bar-fill" id="runProgressFill" style="width:0%;"></div></div>
-                        <span class="hint" style="font-size:12px;color:#888;" id="runProgressText">0 / 0</span>
-                    </div>
-                    <!-- 当前文件行级进度（不经数据库中转，只读内存接口） -->
-                    <div class="progress-wrap" id="runLineProgressWrap" style="display:none;">
-                        <div class="progress-bar-bg"><div class="progress-bar-fill" id="runLineProgressFill" style="width:0%;"></div></div>
-                        <span class="hint" style="font-size:12px;color:#888;" id="runLineProgressText">0 / 0</span>
-                    </div>
-                    <button type="button" class="btn-cancel-run" id="btnCancelRun" style="display:none;">取消生成</button>
-                </div>
-            </div>
-            <div class="template-download-row" id="templateDownloadRow" role="button" tabindex="0" title="下载品牌文档格式模板（选择保存位置）">
-                <span class="template-download-icon" aria-hidden="true">
-                    <svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
-                        <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8l-6-6z" stroke="rgba(255,255,255,0.9)" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"/>
-                        <path d="M14 2v6h6" stroke="rgba(255,255,255,0.9)" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"/>
-                        <path d="M8 13h8M8 17h5" stroke="rgba(255,255,255,0.85)" stroke-width="1.5" stroke-linecap="round"/>
-                    </svg>
-                </span>
-                <span class="template-download-text">
-                    <span class="title">模板下载</span>
-                    <span class="hint">品牌文档格式_模板.xlsx · 点击选择保存位置</span>
-                </span>
-            </div>
-            <div class="template-download-row" id="templateDownloadRow2" role="button" tabindex="0" title="下载模板2（以文件夹方式上传）">
-                <span class="template-download-icon" aria-hidden="true">
-                    <svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
-                        <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8l-6-6z" stroke="rgba(255,255,255,0.9)" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"/>
-                        <path d="M14 2v6h6" stroke="rgba(255,255,255,0.9)" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"/>
-                        <path d="M3 7v10h4v-4h2v4h8v-4h2v4h2V7H3z" stroke="rgba(255,255,255,0.85)" stroke-width="1.5" stroke-linecap="round"/>
-                    </svg>
-                </span>
-                <span class="template-download-text">
-                    <span class="title">模板2下载</span>
-                    <span class="hint">以文件夹方式上传.zip · 点击下载</span>
-                </span>
-            </div>
-        </aside>
-
-        <div class="right-panel">
-            <div class="panel-header">
-                <span class="panel-header-title">任务队列</span>
-                <button type="button" class="btn-refresh-tasks" id="btnRefreshTasks">刷新任务状态</button>
-            </div>
-            <div class="task-list-wrap">
-                <ul class="task-list" id="taskList"></ul>
-                <div class="empty-tasks" id="emptyTasks">暂无任务</div>
-            </div>
-        </div>
-        </div>
-    </div>
-
-    <div class="toast" id="toast"></div>
-
-    <script>
-(function() {
-    var selectedPaths = [];
-    var cachedTasks = [];
-    var api = window.pywebview && window.pywebview.api;
-
-    // 顶部栏目切换：点击 nav-tab 时显示对应 data-panel 的 tab-panel
-    document.querySelectorAll('.nav-tab').forEach(function(tab) {
-        tab.addEventListener('click', function() {
-            var panelId = this.getAttribute('data-panel');
-            if (!panelId) return;
-            document.querySelectorAll('.nav-tab').forEach(function(t) { t.classList.remove('active'); });
-            document.querySelectorAll('.tab-panel').forEach(function(p) {
-                p.classList.toggle('active', p.getAttribute('data-panel') === panelId);
-            });
-            this.classList.add('active');
-        });
-    });
-
-    function showToast(msg) {
-        var el = document.getElementById('toast');
-        el.textContent = msg;
-        el.classList.add('show');
-        setTimeout(function() { el.classList.remove('show'); }, 2500);
-    }
-
-    function renderSelected() {
-        var el = document.getElementById('selectedFiles');
-        if (selectedPaths.length === 0) {
-            el.innerHTML = '';
-            return;
-        }
-        el.innerHTML = '已选 <b>' + selectedPaths.length + '</b> 个文件：<br>' +
-            selectedPaths.slice(0, 20).map(function(p) {
-                var name = p.split(/[/\\]/).pop();
-                return '<span title="' + p + '">' + name + '</span>';
-            }).join('') +
-            (selectedPaths.length > 20 ? '<span>… 等 ' + selectedPaths.length + ' 个</span>' : '');
-    }
-
-    document.getElementById('btnSelectFiles').onclick = async function(e) {
-        e.stopPropagation();
-        if (!api || !api.select_brand_xlsx_files) {
-            showToast('当前环境不支持文件选择，请在本机客户端中打开');
-            return;
-        }
-        try {
-            var paths = await api.select_brand_xlsx_files();
-            if (paths && paths.length) {
-                selectedPaths = paths;
-                renderSelected();
-                showToast('已选择 ' + paths.length + ' 个文件');
-            }
-        } catch (err) {
-            showToast('选择失败：' + (err.message || err));
-        }
-    };
-
-    document.getElementById('templateDownloadRow').onclick = async function(e) {
-        e.preventDefault();
-        if (api && api.save_template_xlsx) {
-            try {
-                var res = await api.save_template_xlsx();
-                if (res && res.success) {
-                    showToast('模板已保存至：' + (res.path || ''));
-                } else {
-                    showToast(res && res.error ? res.error : '保存失败');
-                }
-            } catch (err) {
-                showToast('下载失败：' + (err.message || err));
-            }
-            return;
-        }
-        window.location.href = '/static/品牌文档格式_模板.xlsx';
-    };
-    document.getElementById('templateDownloadRow').onkeydown = function(e) {
-        if (e.key === 'Enter' || e.key === ' ') { e.preventDefault(); this.click(); }
-    };
-
-    document.getElementById('templateDownloadRow2').onclick = async function(e) {
-        e.preventDefault();
-        if (api && api.save_template_zip) {
-            try {
-                var res = await api.save_template_zip();
-                if (res && res.success) {
-                    showToast('模板已保存至：' + (res.path || ''));
-                } else {
-                    showToast(res && res.error ? res.error : '保存失败');
-                }
-            } catch (err) {
-                showToast('下载失败：' + (err.message || err));
-            }
-            return;
-        }
-        window.location.href = '/static/模板2-以文件夹方式上传.zip';
-    };
-    document.getElementById('templateDownloadRow2').onkeydown = function(e) {
-        if (e.key === 'Enter' || e.key === ' ') { e.preventDefault(); this.click(); }
-    };
-
-    document.getElementById('btnSelectFolder').onclick =async function(e) {
-        e.stopPropagation();
-        if (!api || !api.select_brand_folder) {
-            showToast('当前环境不支持文件夹选择，请在本机客户端中打开');
-            return;
-        }
-        try {
-            var folder = await api.select_brand_folder();
-            if (!folder) return;
-            fetch('/api/brand/expand-folder', {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json', 'X-Requested-With': 'XMLHttpRequest' },
-                credentials: 'same-origin',
-                body: JSON.stringify({ folder: folder })
-            })
-            .then(function(r) { return r.json(); })
-            .then(function(res) {
-                if (res.success && res.paths && res.paths.length) {
-                    selectedPaths = res.paths;
-                    renderSelected();
-                    showToast('已选择文件夹内 ' + res.paths.length + ' 个 xlsx 文件');
-                } else {
-                    showToast(res.error || '该文件夹下没有 xlsx 文件');
-                }
-            })
-            .catch(function() { showToast('请求失败'); });
-        } catch (err) {
-            showToast('选择失败：' + (err.message || err));
-        }
-    };
-
-    function getRunMode() {
-        var r = document.querySelector('input[name="runMode"]:checked');
-        return r ? r.value : 'immediate';
-    }
-
-    function getMatchStrategy() {
-        var r = document.querySelector('input[name="matchStrategy"]:checked');
-        return r ? r.value : 'Terms';
-    }
-
-    var pollTaskId = null;
-    var pollTimer = null;
-    var runTaskEventSource = null;
-
-    function stopPollAndResetRunUI() {
-        pollTaskId = null;
-        if (pollTimer) { clearInterval(pollTimer); pollTimer = null; }
-        if (runTaskEventSource) {
-            runTaskEventSource.close();
-            runTaskEventSource = null;
-        }
-        var btn = document.getElementById('btnRun');
-        var loadingMsg = document.getElementById('loadingMsg');
-        var runProgressWrap = document.getElementById('runProgressWrap');
-        var runLineProgressWrap = document.getElementById('runLineProgressWrap');
-        var btnCancelRun = document.getElementById('btnCancelRun');
-        btn.disabled = false;
-        loadingMsg.style.display = 'none';
-        if (runProgressWrap) runProgressWrap.style.display = 'none';
-        if (runLineProgressWrap) runLineProgressWrap.style.display = 'none';
-        if (btnCancelRun) btnCancelRun.style.display = 'none';
-    }
-
-    function onRunTaskFinished(status) {
-        stopPollAndResetRunUI();
-        loadTasks();
-        if (status === 'success') showToast('生成完成，可下载结果');
-        else if (status === 'failed') showToast('生成失败');
-        else if (status === 'cancelled') showToast('已取消');
-    }
-
-    function pollRunTask(taskId) {
-        pollTaskId = taskId;
-        var runProgressFill = document.getElementById('runProgressFill');
-        var runProgressText = document.getElementById('runProgressText');
-        var runLineProgressWrap = document.getElementById('runLineProgressWrap');
-        var runLineProgressFill = document.getElementById('runLineProgressFill');
-        var runLineProgressText = document.getElementById('runLineProgressText');
-        var btnCancelRun = document.getElementById('btnCancelRun');
-        var runProgressWrap = document.getElementById('runProgressWrap');
-        runProgressWrap.style.display = 'block';
-        btnCancelRun.style.display = 'inline-block';
-        btnCancelRun.onclick = function() {
-            fetch('/api/brand/tasks/' + taskId + '/cancel', { method: 'POST', credentials: 'same-origin', headers: { 'X-Requested-With': 'XMLHttpRequest' } })
-                .then(function(r) { return r.json(); })
-                .then(function(res) {
-                    if (res.success) onRunTaskFinished('cancelled');
-                    else showToast(res.error || '取消失败');
-                });
-        };
-
-        // 通过 SSE 订阅任务完成事件，完成后由后端主动推送，前端收到后立即隐藏进度条和取消按钮
-        var eventsUrl = '/api/brand/tasks/' + taskId + '/events';
-        runTaskEventSource = new EventSource(eventsUrl);
-        runTaskEventSource.onmessage = function(e) {
-            try {
-                var data = JSON.parse(e.data);
-                if (data && (data.status === 'success' || data.status === 'failed' || data.status === 'cancelled')) {
-                    runTaskEventSource.close();
-                    runTaskEventSource = null;
-                    // tick();
-                    onRunTaskFinished(data.status);
-                }
-            } catch (err) {}
-        };
-        runTaskEventSource.onerror = function() {
-            runTaskEventSource.close();
-            runTaskEventSource = null;
-        };
-
-        function tick() {
-            if (!pollTaskId) return;
-            fetch('/api/brand/tasks/' + taskId, { credentials: 'same-origin', headers: { 'X-Requested-With': 'XMLHttpRequest' } })
-                .then(function(r) { return r.json(); })
-                .then(function(res) {
-                    if (!res.success || !res.task) return;
-                    var t = res.task;
-                    var total = t.progress_total || 0;
-                    var cur = t.progress_current || 0;
-                    if (runProgressFill) runProgressFill.style.width = total ? (100 * cur / total) + '%' : '30%';
-                    if (runProgressText) {
-                        var st = (t.status || '').toLowerCase();
-                        if (st === 'running') {
-                            runProgressText.textContent = total ? (cur + ' / ' + total) : '生成中…';
-                        } else if (st === 'success') {
-                            runProgressText.textContent = '已完成';
-                        } else if (st === 'failed') {
-                            runProgressText.textContent = '失败';
-                        } else if (st === 'cancelled') {
-                            runProgressText.textContent = '已取消';
-                        } else {
-                            runProgressText.textContent = '执行中…';
-                        }
-                    }
-                    // 行级进度：从内存接口 /api/brand/tasks/<id>/line-progress 拉取
-                    if (runLineProgressWrap && runLineProgressFill && runLineProgressText) {
-                        var st2 = (t.status || '').toLowerCase();
-                        if (st2 === 'running') {
-                            fetch('/api/brand/tasks/' + taskId + '/line-progress', {
-                                credentials: 'same-origin',
-                                headers: { 'X-Requested-With': 'XMLHttpRequest' }
-                            })
-                                .then(function(r) { return r.json(); })
-                                .then(function(res2) {
-                                    if (!res2.success || !res2.has_progress || !res2.info) {
-                                        runLineProgressWrap.style.display = 'none';
-                                        return;
-                                    }
-                                    var info = res2.info;
-                                    var totalLines = info.total_lines || 0;
-                                    var curLine = info.current_line || 0;
-                                    runLineProgressWrap.style.display = 'block';
-                                    runLineProgressFill.style.width = totalLines ? (100 * curLine / totalLines) + '%' : '0%';
-                                    runLineProgressText.textContent = totalLines ? (curLine + ' / ' + totalLines) : '当前文件处理中…';
-                                })
-                                .catch(function() {});
-                        } else {
-                            runLineProgressWrap.style.display = 'none';
-                        }
-                    }
-                    // 终态也通过轮询兜底，确保 UI 一定被重置（SSE 可能因网络未收到）
-                    var st = (t.status || '').toLowerCase();
-                    if (st === 'success' || st === 'failed' || st === 'cancelled') {
-                        onRunTaskFinished(st);
-                    }
-                });
-        }
-        tick();
-        pollTimer = setInterval(tick, 5000);
-    }
-
-    document.getElementById('btnRun').onclick = function() {
-        if (selectedPaths.length === 0) {
-            showToast('请先选择 Excel 文件或文件夹');
-            return;
-        }
-        var mode = getRunMode();
-        var strategy = getMatchStrategy();
-        var btn = document.getElementById('btnRun');
-        var loadingMsg = document.getElementById('loadingMsg');
-
-        if (mode === 'immediate') {
-            btn.disabled = true;
-            loadingMsg.style.display = 'inline';
-            fetch('/api/brand/run', {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json', 'X-Requested-With': 'XMLHttpRequest' },
-                credentials: 'same-origin',
-                body: JSON.stringify({ paths: selectedPaths, strategy: strategy, task_type: 1 })
-            })
-            .then(function(r) { return r.json(); })
-            .then(function(res) {
-                if (res.success && res.task_id) {
-                    loadingMsg.style.display = 'none';
-                    pollRunTask(res.task_id);
-                } else {
-                    stopPollAndResetRunUI();
-                    showToast(res.error || '运行失败');
-                }
-            })
-            .catch(function() {
-                stopPollAndResetRunUI();
-                showToast('请求失败或超时');
-            });
-        } else {
-            fetch('/api/brand/tasks', {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json', 'X-Requested-With': 'XMLHttpRequest' },
-                credentials: 'same-origin',
-                body: JSON.stringify({ paths: selectedPaths, strategy: strategy, task_type: 2 })
-            })
-            .then(function(r) { return r.json(); })
-            .then(function(res) {
-                if (res.success) {
-                    showToast('任务已添加，请在任务队列查看');
-                    loadTasks();
-                } else {
-                    showToast(res.error || '添加失败');
-                }
-            })
-            .catch(function() { showToast('请求失败'); });
-        }
-    };
-
-    function loadTasks() {
-        fetch('/api/brand/tasks', { credentials: 'same-origin', headers: { 'X-Requested-With': 'XMLHttpRequest' } })
-            .then(function(r) { return r.json(); })
-            .then(function(res) {
-                var list = document.getElementById('taskList');
-                var empty = document.getElementById('emptyTasks');
-                if (!res.success || !res.items || res.items.length === 0) {
-                    list.innerHTML = '';
-                    empty.style.display = 'block';
-                    return;
-                }
-                empty.style.display = 'none';
-                cachedTasks = res.items;
-                list.innerHTML = res.items.map(function(t) {
-                    var statusClass = (t.status || 'pending').toLowerCase();
-                    var statusText = { pending: '等待中', running: '执行中', success: '已完成', failed: '失败', cancelled: '已取消' }[t.status] || t.status;
-                    var filesDesc = (t.file_paths && t.file_paths.length) ? t.file_paths.length + ' 个文件' : '';
-                    var total = t.progress_total || 0;
-                    var cur = t.progress_current || 0;
-                    var pct = total ? Math.min(100, (100 * cur / total)) : 0;
-                    var progressHtml = (statusClass === 'running' && total > 0)
-                        ? '<div class="progress-wrap"><div class="progress-bar-bg"><div class="progress-bar-fill" style="width:' + pct + '%"></div></div><span class="hint" style="font-size:11px;color:#888;">' + cur + ' / ' + total + '</span></div>'
-                        : '';
-                    var hasZipUrl = t.result_paths && t.result_paths.zip_url;
-                    var downloadHtml = hasZipUrl
-                        ? '<a class="download js-save-zip" href="#" data-task-id="' + t.id + '">下载结果</a>'
-                        : '<span class="download hide"></span>';
-                    var cancelBtn = statusClass === 'running'
-                        ? '<button type="button" class="btn-cancel js-cancel-task" data-task-id="' + t.id + '">取消</button>'
-                        : '';
-                    var deleteBtn = '<button type="button" class="btn-delete js-delete-task" data-task-id="' + t.id + '">删除</button>';
-                    var titleDesc = (t.desc && String(t.desc).trim()) ? String(t.desc).trim() : ('任务 #' + t.id);
-                    var displayDesc = titleDesc.length > 20 ? titleDesc.substring(0, 20) + '....' : titleDesc;
-                    return '<li class="task-item">' +
-                        '<div class="left">' +
-                        '<span class="id" title="' + (titleDesc.replace(/"/g, '&quot;')) + '">' + displayDesc + '</span>' +
-                        '<div class="files">' + filesDesc + '</div>' +
-                        '<div class="time">' + (t.created_at || '') + '</div>' +
-                        '</div>' +
-                        '<div class="task-right">' +
-                        progressHtml +
-                        '<span class="status ' + statusClass + '">' + statusText + '</span>' +
-                        cancelBtn +
-                        downloadHtml +
-                        deleteBtn +
-                        '</div></li>';
-                }).join('');
-            })
-            .catch(function() {});
-    }
-
-    // 手动刷新任务状态按钮
-    var btnRefreshTasks = document.getElementById('btnRefreshTasks');
-    if (btnRefreshTasks) {
-        btnRefreshTasks.onclick = function () {
-            loadTasks();
-            showToast('任务状态已刷新');
-        };
-    }
-
-    document.getElementById('taskList').addEventListener('click', function(e) {
-        var target = e.target && e.target.closest && (e.target.closest('a.js-save-zip') || e.target.closest('button.js-cancel-task') || e.target.closest('button.js-delete-task'));
-        if (!target) return;
-        e.preventDefault();
-        var taskId = target.getAttribute('data-task-id');
-        if (target.classList && (target.classList.contains('js-cancel-task') || target.closest('.js-cancel-task'))) {
-            var btn = target.classList.contains('js-cancel-task') ? target : target.closest('.js-cancel-task');
-            if (!btn) return;
-            fetch('/api/brand/tasks/' + taskId + '/cancel', { method: 'POST', credentials: 'same-origin', headers: { 'X-Requested-With': 'XMLHttpRequest' } })
-                .then(function(r) { return r.json(); })
-                .then(function(res) {
-                    if (res.success) { showToast('已取消'); loadTasks(); } else { showToast(res.error || '取消失败'); }
-                });
-            return;
-        }
-        if (target.classList && (target.classList.contains('js-delete-task') || target.closest('.js-delete-task'))) {
-            var btn = target.classList.contains('js-delete-task') ? target : target.closest('.js-delete-task');
-            if (!btn) return;
-            fetch('/api/brand/tasks/' + taskId, { method: 'DELETE', credentials: 'same-origin', headers: { 'X-Requested-With': 'XMLHttpRequest' } })
-                .then(function(r) { return r.json(); })
-                .then(function(res) {
-                    if (res.success) { showToast('已删除'); loadTasks(); } else { showToast(res.error || '删除失败'); }
-                });
-            return;
-        }
-        var a = target.closest('a.js-save-zip') || target;
-        if (!a || !a.classList || !a.classList.contains('js-save-zip')) return;
-        var task = cachedTasks.filter(function(t) { return String(t.id) === String(taskId); })[0];
-        if (!task || !task.result_paths || !task.result_paths.zip_url) {
-            showToast('无法获取下载地址');
-            return;
-        }
-        var zipUrl = task.result_paths.zip_url;
-        var filename = 'brand_task_' + taskId + '.zip';
-        if (api && api.save_file_from_url) {
-            a.style.pointerEvents = 'none';
-            var done = function(ret) {
-                if (ret && ret.success) {
-                    showToast('已保存：' + (ret.path || filename));
-                } else if (ret && ret.error && ret.error !== '用户取消') {
-                    showToast('保存失败：' + ret.error);
-                }
-                a.style.pointerEvents = '';
-            };
-            try {
-                var ret = api.save_file_from_url(zipUrl, filename);
-                if (ret && typeof ret.then === 'function') {
-                    ret.then(done).catch(function(err) { showToast('保存失败：' + (err && err.message || err)); a.style.pointerEvents = ''; });
-                } else {
-                    done(ret);
-                }
-            } catch (err) {
-                showToast('保存失败：' + (err.message || err));
-                a.style.pointerEvents = '';
-            }
-        } else {
-            window.open('/api/brand/download/' + taskId, '_blank');
-        }
-    });
-
-    loadTasks();
-    // setInterval(loadTasks, 10000);
-
-    if (window.addEventListener) {
-        window.addEventListener('pywebviewready', function() {
-            api = window.pywebview && window.pywebview.api;
-        });
-    }
-    if (window.pywebview && window.pywebview.api) api = window.pywebview.api;
-})();
-    </script>
-</body>
-</html>

app/web_source/templates_backup/home.html

@@ -1,352 +0,0 @@
-<!DOCTYPE html>
-<html lang="zh-CN">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>首页 - 南日AI</title>
-    <style>
-        * { margin: 0; padding: 0; box-sizing: border-box; }
-        body {
-            font-family: "Microsoft YaHei", "PingFang SC", "Hiragino Sans GB", sans-serif;
-            background: linear-gradient(rgba(255,255,255,0.5), rgba(255,255,255,0.5)),
-        url("/static/bg.jpg") center/cover no-repeat;;
-            /*background-image: url("/static/bg.jpg");*/
-
-            min-height: 100vh;
-            display: flex;
-            flex-direction: column;
-            align-items: center;
-            justify-content: center;
-            padding: 40px;
-        }
-        .header {
-            position: absolute;
-            top: 0;
-            left: 0;
-            right: 0;
-            height: 56px;
-            display: flex;
-            align-items: center;
-            justify-content: space-between;
-            padding: 0 24px;
-            background: rgba(255,255,255,0.5);
-        }
-        .header-title { font-size: 18px; font-weight: 600; color: #333; }
-        .header-right { display: flex; align-items: center; gap: 16px; position: relative; }
-        .header-right a, .header-right span {
-            font-size: 14px; color: #555; text-decoration: none;
-        }
-        .header-right a:hover { color: #667eea; }
-        .entrances {
-            display: flex;
-            gap: 32px;
-            flex-wrap: wrap;
-            justify-content: center;
-        }
-        .entrance-btn {
-            width: 160px;
-            height: 100px;
-            background: #c5c1c1;
-            border: 4px solid #b8d4e3;
-            border-radius: 12px;
-            display: flex;
-            align-items: center;
-            justify-content: center;
-            font-size: 18px;
-            font-weight: 600;
-            color: #333;
-            cursor: pointer;
-            transition: all 0.2s;
-            text-decoration: none;
-        }
-        .entrance-btn:hover {
-            background: #f8fbfd;
-            box-shadow: 0 4px 12px rgba(0,0,0,0.08);
-        }
-        .entrance-btn.wb { cursor: pointer; }
-        .entrance-btn.disabled {
-            cursor: not-allowed;
-            opacity: 0.9;
-        }
-        .toast {
-            position: fixed;
-            bottom: 40px;
-            left: 50%;
-            transform: translateX(-50%);
-            background: rgba(0,0,0,0.75);
-            color: #fff;
-            padding: 12px 24px;
-            border-radius: 8px;
-            font-size: 14px;
-            opacity: 0;
-            transition: opacity 0.3s;
-            pointer-events: none;
-        }
-        .toast.show { opacity: 1; }
-        .admin-link {
-            font-size: 13px;
-            color: #888;
-        }
-        .update-section {
-            margin-top: 48px;
-            padding: 20px 24px;
-            background: rgba(255,255,255,0.85);
-            border-radius: 12px;
-            border: 1px solid rgba(0,0,0,0.06);
-            max-width: 420px;
-        }
-        .update-section-title {
-            font-size: 14px;
-            color: #333;
-            margin-bottom: 12px;
-            display: flex;
-            align-items: center;
-            gap: 6px;
-        }
-        .update-block {
-            display: flex;
-            align-items: center;
-            justify-content: space-between;
-            gap: 16px;
-        }
-        .update-version-text {
-            font-size: 13px;
-            color: #555;
-        }
-        .btn-check-update {
-            padding: 8px 14px;
-            font-size: 13px;
-            background: #667eea;
-            color: #fff;
-            border: none;
-            border-radius: 8px;
-            cursor: pointer;
-        }
-        .btn-check-update:hover {
-            background: #5a6fd6;
-        }
-        .update-hint {
-            font-size: 12px;
-            color: #666;
-            margin-top: 8px;
-            min-height: 18px;
-        }
-        .btn-download-update {
-            margin-top: 8px;
-            padding: 8px 14px;
-            font-size: 13px;
-            background: #28a745;
-            color: #fff;
-            border: none;
-            border-radius: 8px;
-            cursor: pointer;
-        }
-        .btn-download-update:hover {
-            background: #218838;
-        }
-        .header-update-btn {
-            width: 28px;
-            height: 28px;
-            border-radius: 50%;
-            border: none;
-            background: rgba(102,126,234,0.12);
-            color: #4c5bd4;
-            cursor: pointer;
-            display: flex;
-            align-items: center;
-            justify-content: center;
-            font-size: 15px;
-            padding: 0;
-        }
-        .header-update-btn:hover {
-            background: rgba(102,126,234,0.2);
-        }
-        .header-update-panel {
-            position: absolute;
-            top: 44px;
-            right: 0;
-            width: 280px;
-            padding: 14px 16px;
-            background: rgba(255,255,255,0.98);
-            border-radius: 10px;
-            box-shadow: 0 4px 16px rgba(0,0,0,0.12);
-            border: 1px solid rgba(0,0,0,0.04);
-            z-index: 10;
-            display: none;
-        }
-        .header-update-title {
-            font-size: 13px;
-            color: #333;
-            margin-bottom: 8px;
-            display: flex;
-            align-items: center;
-            gap: 6px;
-        }
-    </style>
-</head>
-<body data-user-id="{{ user_id or '' }}">
-    <header class="header">
-        <span class="header-title">南日AI</span>
-        <div class="header-right">
-            {% if is_admin %}
-<!--            <a href="/admin" class="admin-link">用户管理</a>-->
-            {% endif %}
-            <span>{{ username }}</span>
-            <button type="button" class="header-update-btn" id="homeUpdateToggle" title="检测更新">↻</button>
-            <a href="/logout" onclick="handleLogout()">退出</a>
-            <div class="header-update-panel" id="homeUpdatePanel">
-                <div class="header-update-title"><span>↻</span> 软件更新</div>
-                <div class="update-block">
-                    <span class="update-version-text" id="homeVersionText">当前版本: {{ version }}</span>
-                    <button type="button" class="btn-check-update" id="homeBtnCheckUpdate"><span>↻</span> 检测</button>
-                </div>
-                <div class="update-hint" id="homeUpdateHint"></div>
-                <div style="margin-top: 4px;">
-                    <button type="button" class="btn-download-update" id="homeBtnDownloadUpdate" style="display: none;">立即更新</button>
-                </div>
-            </div>
-        </div>
-    </header>
-
-    <div class="entrances" id="entrances">
-        <a class="entrance-btn" href="/brand" data-column-key="brand">亚马逊</a>
-        <a class="entrance-btn disabled" href="javascript:;" data-msg="暂未开通，敬请期待" data-column-key="wb">wildberries</a>
-        <a class="entrance-btn image" href="/image" data-column-key="image">图片</a>
-    </div>
-
-    <div class="toast" id="toast"></div>
-
-    <script>
-        // 权限校验：根据 column-permissions 接口按 column_key 显示入口
-        (function() {
-            var uid = document.body.getAttribute('data-user-id');
-            if (!uid) return;
-            var baseUrl = window.location.origin;
-            var apiUrl = baseUrl + '/api/admin/user/' + uid + '/column-permissions';
-            fetch(apiUrl, { credentials: 'same-origin' })
-                .then(function(r) { return r.json(); })
-                .then(function(res) {
-                    if (!res || !res.success || !Array.isArray(res.items)) return;
-                    var allowedKeys = res.items.map(function(item) { return (item.column_key || '').toLowerCase(); });
-                    document.querySelectorAll('.entrances .entrance-btn[data-column-key]').forEach(function(btn) {
-                        var key = (btn.getAttribute('data-column-key') || '').toLowerCase();
-                        btn.style.display = allowedKeys.indexOf(key) >= 0 ? '' : 'none';
-                    });
-                })
-                .catch(function() {});
-        })();
-
-        document.querySelectorAll('.entrance-btn.disabled').forEach(function(btn) {
-            btn.onclick = function(e) {
-                e.preventDefault();
-                var msg = btn.getAttribute('data-msg') || '暂未开通，敬请期待';
-                var t = document.getElementById('toast');
-                t.textContent = msg;
-                t.classList.add('show');
-                setTimeout(function() { t.classList.remove('show'); }, 2000);
-            };
-        });
-
-        function handleLogout() {
-            try{
-                localStorage.removeItem('maixiang_api_key');
-            }catch (e) {
-                console.log(e)
-            }
-        }
-
-        // 软件更新（与 index 设置中逻辑一致）
-        (function() {
-            const versionText = document.getElementById('homeVersionText');
-            const updateHint = document.getElementById('homeUpdateHint');
-            const btnDownload = document.getElementById('homeBtnDownloadUpdate');
-            const updatePanel = document.getElementById('homeUpdatePanel');
-            const toggleBtn = document.getElementById('homeUpdateToggle');
-            if (!versionText || !updateHint || !btnDownload || !updatePanel || !toggleBtn) return;
-
-            let currentVersion = '{{version}}';
-            versionText.textContent = '当前版本: v' + currentVersion;
-
-            // 打开/关闭浮层
-            toggleBtn.addEventListener('click', function(e) {
-                e.stopPropagation();
-                const isVisible = updatePanel.style.display === 'block';
-                updatePanel.style.display = isVisible ? 'none' : 'block';
-            });
-
-            // 点击外部关闭浮层
-            document.addEventListener('click', function() {
-                updatePanel.style.display = 'none';
-            });
-            updatePanel.addEventListener('click', function(e) {
-                e.stopPropagation();
-            });
-
-            document.getElementById('homeBtnCheckUpdate').onclick = async function() {
-                updateHint.textContent = '正在检测更新...';
-                btnDownload.style.display = 'none';
-                try {
-                    const resp = await fetch('/api/version', { credentials: 'same-origin' }).catch(function() { return null; });
-                    if (resp && resp.ok) {
-                        const data = await resp.json();
-                        currentVersion = (data.version || currentVersion).replace(/^v/i, '');
-                        versionText.textContent = '当前版本: v' + currentVersion;
-                        if (data.has_update && data.latest_version) {
-                            updateHint.textContent = '发现新版本 v' + data.latest_version + (data.desc ? '：' + data.desc : '');
-                            btnDownload.style.display = 'inline-block';
-                            btnDownload.textContent = '立即更新';
-                            btnDownload.onclick = async function() {
-                                if (!confirm('有更新，是否现在更新？\n更新将下载安装包并重启程序。')) return;
-                                if (!data.file_url) {
-                                    updateHint.textContent = '暂无下载地址，请关注官方渠道。';
-                                    return;
-                                }
-                                updateHint.textContent = '正在下载并准备更新，程序将自动退出...';
-                                btnDownload.disabled = true;
-                                try {
-                                    const updateResp = await fetch('/api/update/do', {
-                                        method: 'POST',
-                                        credentials: 'same-origin',
-                                        headers: { 'Content-Type': 'application/json' },
-                                        body: JSON.stringify({ file_url: data.file_url })
-                                    });
-                                    const result = await updateResp.json().catch(function() { return {}; });
-                                    if (result.success) {
-                                        updateHint.textContent = '更新已启动，程序即将退出...';
-                                    } else {
-                                        updateHint.textContent = result.error || '更新启动失败';
-                                        btnDownload.disabled = false;
-                                    }
-                                } catch (e) {
-                                    updateHint.textContent = '请求更新失败，请重试';
-                                    btnDownload.disabled = false;
-                                }
-                            };
-                        } else {
-                            updateHint.textContent = '已是最新版本';
-                        }
-                    } else {
-                        updateHint.textContent = '无法连接更新服务，请稍后重试。';
-                    }
-                } catch (e) {
-                    updateHint.textContent = '检测更新失败';
-                }
-            };
-            btnDownload.style.display = 'none';
-        })();
-        // (function() {
-        //     fetch('/api/auth/check', { credentials: 'same-origin' })
-        //         .then(function(r) { return r.json(); })
-        //         .then(function(res) {
-        //             if (res.logged_in && res.redirect) {
-        //                 window.location.href = res.redirect;
-        //             }else{
-        //                 window.location.href = "/login"
-        //                 // handleLogout()
-        //             }
-        //         })
-        //         .catch(function() {});
-        // })();
-    </script>
-</body>
-</html>

app/web_source/templates_backup/login.html

@@ -1,164 +0,0 @@
-<!DOCTYPE html>
-<html lang="zh-CN">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>登录 - 南日AI</title>
-    <style>
-        * { margin: 0; padding: 0; box-sizing: border-box; }
-        body {
-            font-family: "Microsoft YaHei", "PingFang SC", "Hiragino Sans GB", sans-serif;
-            background: #d8e4ec;
-            min-height: 100vh;
-            display: flex;
-            flex-direction: column;
-            align-items: center;
-            justify-content: center;
-            padding: 40px;
-        }
-        .header {
-            position: absolute;
-            top: 0;
-            left: 0;
-            right: 0;
-            height: 56px;
-            display: flex;
-            align-items: center;
-            justify-content: space-between;
-            padding: 0 24px;
-            background: rgba(255,255,255,0.5);
-        }
-        .header-title { font-size: 18px; font-weight: 600; color: #333; }
-        .login-box {
-            background: #fff;
-            border: 1px solid #b8d4e3;
-            border-radius: 12px;
-            box-shadow: 0 4px 12px rgba(0,0,0,0.06);
-            padding: 40px;
-            width: 100%;
-            max-width: 380px;
-        }
-        .login-title {
-            font-size: 24px;
-            font-weight: 600;
-            color: #333;
-            text-align: center;
-            margin-bottom: 30px;
-        }
-        .form-group {
-            margin-bottom: 20px;
-        }
-        .form-group label {
-            display: block;
-            font-size: 14px;
-            color: #555;
-            margin-bottom: 8px;
-        }
-        .form-group input {
-            width: 100%;
-            padding: 12px 14px;
-            font-size: 14px;
-            border: 1px solid #b8d4e3;
-            border-radius: 8px;
-            outline: none;
-            transition: border-color 0.2s;
-            background: #fff;
-        }
-        .form-group input:focus {
-            border-color: #3498db;
-        }
-        .error-msg {
-            color: #e74c3c;
-            font-size: 13px;
-            margin-bottom: 12px;
-            text-align: center;
-        }
-        .btn-login {
-            width: 100%;
-            padding: 14px;
-            font-size: 16px;
-            font-weight: 500;
-            color: #fff;
-            background: linear-gradient(135deg, #3498db 0%, #2980b9 100%);
-            border: none;
-            border-radius: 8px;
-            cursor: pointer;
-            transition: all 0.2s;
-        }
-        .btn-login:hover {
-            opacity: 0.9;
-        }
-        .btn-login:disabled {
-            opacity: 0.6;
-            cursor: not-allowed;
-        }
-    </style>
-</head>
-<body>
-    <header class="header">
-        <span class="header-title">南日AI</span>
-    </header>
-
-    <div class="login-box">
-        <h1 class="login-title">登录</h1>
-        {% if error %}
-        <p class="error-msg">{{ error }}</p>
-        {% endif %}
-        <form id="loginForm" method="POST" action="/login">
-            <div class="form-group">
-                <label>用户名</label>
-                <input type="text" name="username" placeholder="请输入用户名" required autofocus>
-            </div>
-            <div class="form-group">
-                <label>密码</label>
-                <input type="password" name="password" placeholder="请输入密码" required>
-            </div>
-            <button type="submit" class="btn-login" id="btnLogin">登录</button>
-        </form>
-    </div>
-    <script>
-        (function() {
-            fetch('/api/auth/check', { credentials: 'same-origin' })
-                .then(function(r) { return r.json(); })
-                .then(function(res) {
-                    if (res.logged_in && res.redirect) {
-                        window.location.href = res.redirect;
-                    }
-                })
-                .catch(function() {});
-        })();
-        document.getElementById('loginForm').onsubmit = function(e) {
-            e.preventDefault();
-            var btn = document.getElementById('btnLogin');
-            btn.disabled = true;
-            btn.textContent = '登录中...';
-            var form = e.target;
-            var fd = new FormData(form);
-            fetch(form.action, {
-                method: 'POST',
-                body: fd,
-                headers: { 'X-Requested-With': 'XMLHttpRequest' }
-            })
-            .then(function(r) { return r.json(); })
-            .then(function(res) {
-                if (res.success) {
-                    window.location.href = res.redirect || '/home';
-                } else {
-                    var errEl = document.querySelector('.error-msg');
-                    if (!errEl) {
-                        errEl = document.createElement('p');
-                        errEl.className = 'error-msg';
-                        form.insertBefore(errEl, form.firstChild);
-                    }
-                    errEl.textContent = res.error || '登录失败';
-                    btn.disabled = false;
-                    btn.textContent = '登录';
-                }
-            })
-            .catch(function() {
-                form.submit();
-            });
-        };
-    </script>
-</body>
-</html>

backend-java/docs/baota-start-commands.md

@@ -0,0 +1,60 @@
+# Multi-Server Start Commands
+
+Use the same packaged jar on both servers. Do not switch code comments before packaging.
+
+Requirements:
+- Build once: `mvn clean package -DskipTests`
+- Use profile: `server`
+- Put JVM options before `-jar`
+- Pass `AIIMAGE_INSTANCE_ID` and Redis address from the startup command
+- Result file job MQ is expected to stay enabled in packaged `server` deployments
+
+1Panel server 121:
+
+Environment variables:
+
+```env
+SPRING_PROFILES_ACTIVE=server
+AIIMAGE_INSTANCE_ID=server-121
+AIIMAGE_REDIS_HOST=192.168.0.172
+AIIMAGE_REDIS_PORT=16379
+AIIMAGE_REDIS_PASSWORD=B6COTcY094TYe545
+AIIMAGE_REDIS_DATABASE=0
+AIIMAGE_SERVER_PORT=18080
+AIIMAGE_STORAGE_LOCAL_TEMP_DIR=/app/data/tmp
+AIIMAGE_RESULT_FILE_JOB_MQ_ENABLED=true
+AIIMAGE_ROCKETMQ_NAME_SERVER=121.196.149.225:9876
+AIIMAGE_TRANSIENT_STORAGE_ENDPOINT=http://121.196.149.225:9000
+```
+
+Recommended startup command:
+
+```bash
+java -Xmx2048M -Xms2048M -jar /app/aiimage-backend-0.0.1-SNAPSHOT.jar
+```
+
+Baota server 111:
+
+```bash
+/www/server/java/jdk-21.0.2/bin/java -Xmx1024M -Xms256M -jar /app/java/aiimage-backend-0.0.1-SNAPSHOT.jar --spring.profiles.active=server --aiimage.instance-id=server-111 --spring.data.redis.host=47.111.163.154 --spring.data.redis.port=16379 --spring.data.redis.password=B6COTcY094TYe545 --server.port=18080 --aiimage.storage.local-temp-dir=/app/data/tmp
+```
+
+Optional Baota server 121 command:
+
+```bash
+/www/server/java/jdk-21.0.2/bin/java -Xmx1024M -Xms256M -jar /app/java/aiimage-backend-0.0.1-SNAPSHOT.jar --spring.profiles.active=server --aiimage.instance-id=server-121 --spring.data.redis.host=192.168.0.172 --spring.data.redis.port=16379 --spring.data.redis.password=B6COTcY094TYe545 --server.port=18080 --aiimage.storage.local-temp-dir=/app/data/tmp
+```
+
+Successful startup should show a line similar to:
+
+```text
+[instance] resolved instanceId=server-121 source=configured
+```
+
+or:
+
+```text
+[instance] resolved instanceId=server-111 source=configured
+```
+
+If the instanceId in the log does not match the startup command, the actual process was not started with the expected command.

backend-java/docs/patrol-delete-python-api.md

@@ -0,0 +1,126 @@
+# 巡店删除 Python 提交接口
+
+本文档给 Python 端同学说明 `patrol-delete` 的结果回传方式。前端不会再提供“手动归档”按钮，任务收尾、XLSX 组装、OSS 上传与历史清理均由服务端自动完成。
+
+## 1. 提交入口
+
+- 方法：`POST`
+- 路径：`/api/patrol-delete/tasks/{taskId}/result`
+- Content-Type：`application/json`
+
+示例：
+
+```http
+POST /api/patrol-delete/tasks/123/result
+Content-Type: application/json
+```
+
+```json
+{
+  "shops": [
+    {
+      "shopName": "示例店铺",
+      "submissionId": "patrol-delete:123:示例店铺:1711111111111",
+      "chunkIndex": 1,
+      "chunkTotal": 3,
+      "shopDone": false,
+      "countrySections": [
+        {
+          "country": "德国",
+          "rows": [
+            {
+              "status": "正常",
+              "quantity": "12",
+              "deleteQuantity": "3",
+              "processStatus": "处理中"
+            }
+          ]
+        }
+      ],
+      "cartRatios": [
+        {
+          "country": "德国",
+          "ratio": "25%"
+        }
+      ]
+    }
+  ]
+}
+```
+
+## 2. 字段说明
+
+- `shops`: 本次提交的店铺结果分片列表，至少 1 条。
+- `shopName`: 店铺名。服务端会按店铺名归并分片。
+- `submissionId`: 建议每个店铺任务周期内保持同一个 submissionId，方便排查日志。
+- `chunkIndex`: 当前分片序号，建议从 1 开始。
+- `chunkTotal`: 当前店铺总分片数。
+- `shopDone`: 当前店铺是否已全部提交完成。最后一片必须传 `true`。
+- `error`: 当前店铺执行失败时传错误信息。传了 `error` 后该店铺会直接记为失败并结束。
+- `countrySections`: 店铺各国家的状态数据。
+- `cartRatios`: 店铺各国家的购物车比例数据。
+
+## 3. 分片合并规则
+
+- 服务端按 `taskId + shopName` 聚合缓存。
+- 同一国家的 `countrySections[].rows` 会按提交顺序追加合并。
+- `cartRatios` 按国家覆盖，后到数据覆盖先到数据。
+- 当 `shopDone=true` 时，该店铺会被标记为完成。
+- 如果中途提交了 `error`，该店铺会被标记为失败，不再等待后续分片。
+
+## 4. Excel 组装规则
+
+最终结果文件使用 `xlsx/日常删除格式.xlsx` 对应的数据结构：
+
+- 第 1 列：`店铺名`
+- 接着是 5 个国家块，每个国家 4 列：
+  - 国家状态
+  - 数量
+  - 删除数量
+  - 删除结果
+- 最后是 5 组购物车比例列：
+  - 国家
+  - 购物车比例
+
+每个店铺输出规则：
+
+- 一个店铺占用的行数 = 5 个国家中数据行数的最大值
+- 每个店铺处理完成后会额外空一行
+- 然后再写下一个店铺
+
+任务整体完成后：
+
+1. 服务端汇总所有已完成店铺的数据
+2. 组装成 XLSX
+3. 上传 OSS
+4. 前端历史任务中出现下载按钮，用户可直接下载
+
+## 5. 自动收尾与超时补偿
+
+前端不会手动触发归档，服务端自动处理：
+
+- Python 正常把所有店铺都提交完成后，服务端立即尝试收尾。
+- 如果最后一次提交后未来得及触发收尾，定时补偿任务会再次尝试 finalize。
+- 如果某店铺已有部分有效数据，但 Python 异常退出，补偿任务会尽量把已有数据收尾成成功店铺。
+- 如果某店铺完全没有完整结果且已超时，服务端会将该店铺标记为失败。
+
+当前超时配置来自后端配置项：
+
+- `aiimage.delete-brand-progress.patrol-delete-stale-timeout-minutes`
+- Python should call `POST /api/tasks/{taskId}/heartbeat` every minute; timeout now uses only the normal stale-timeout setting.
+
+## 6. 历史清理
+
+服务端会定时清理历史数据，但会跳过仍在执行中的任务。
+
+- `RUNNING` 任务不会被历史清理删除
+- 只有已完成或已失败的历史记录会进入清理范围
+- 临时目录缓存与结果目录也会定期清理
+
+## 7. Python 端建议
+
+- 一个店铺处理结束的最后一片一定要传 `shopDone=true`
+- 如果店铺失败，请直接回传 `error`
+- 大店铺建议按国家或按分页做分片，避免一次提交过大
+- 如果同一店铺会多次回传，`shopName` 必须保持一致
+- 如果最后一片提交成功，Python 端无需再调用额外“归档”接口

backend-java/docs/stale-task-finalize-guidelines.md

@@ -0,0 +1,79 @@
+# Stale 任务收尾约束（公共心跳模块）
+
+> 适用范围：所有使用 [TaskHeartbeatService](../src/main/java/com/nanri/aiimage/modules/task/service/TaskHeartbeatService.java) 的 file_task 模块
+> （PRODUCT_RISK_RESOLVE / PRICE_TRACK / SHOP_MATCH / PATROL_DELETE / QUERY_ASIN /
+>  APPEARANCE_PATENT / SIMILAR_ASIN / DELETE_BRAND）。
+
+## 历史故障（2026-06-08）
+
+SIMILAR_ASIN taskId=13102 的 file_job 长期持有 RUNNING 等待 Python 凑齐
+batchSize 行再发 Coze。Python 端 13:20 异常掉线，但任务到下午 16 点仍卡在 12% 不前进，
+30 分钟兜底失效。
+
+链路：
+
+1. [resetStuckJobs](../src/main/java/com/nanri/aiimage/modules/task/service/TaskResultFileJobWorker.java)
+   每 60 秒扫一次，把 RUNNING 超 30 分钟的 file_job 改回 PENDING。
+2. worker 立刻把它捞起来重跑 `processResultFileJob`。
+3. 重跑分支命中 "等 Python 上传更多 row" → 调用 `touchJavaSideTaskActivity`，
+   把 `file_task.updated_at` 刷成 now。
+4. `finalizeStaleTasks` 用 `lt(updated_at, threshold)` 预过滤，于是这个任务
+   永远进不到候选集，Redis 心跳判定那一步根本走不到。
+
+→ Python 已断线 N 小时，任务仍在循环，永不收尾。
+
+## 约束
+
+### 1. stale-finalize 必须以 Redis 心跳为主信号
+
+`TaskCacheService.touchTaskHeartbeat` 写的 Redis key 仅在 **Python 真实活动**
+（心跳接口、上传 result chunk、提交 row）时刷新。Java 内部循环不应触碰它。
+
+stale 判定时应：
+
+- 以 Redis heartbeat 为主信号；
+- 仅在 Redis 不可用 / 缺失时回落到 `file_task.updated_at`；
+- 不要再用 `lt(file_task.updated_at, threshold)` 做预过滤
+  （除非该模块 100% 不存在长期 RUNNING 等待循环）。
+
+参考实现：[SimilarAsinTaskService.finalizeStaleTasks / isHeartbeatStale](../src/main/java/com/nanri/aiimage/modules/similarasin/service/SimilarAsinTaskService.java)
+和 [AppearancePatentTaskService](../src/main/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentTaskService.java) 中 P1-7 注释段。
+
+### 2. 不要在"等 Python"分支刷 file_task.updated_at
+
+如果模块的 file_job 会持有 RUNNING 状态等待外部上传更多数据，
+**这条等待路径上不允许调 `setUpdatedAt(now)` 类方法**。
+
+否则会触发 [resetStuckJobs](../src/main/java/com/nanri/aiimage/modules/task/service/TaskResultFileJobWorker.java)
+→ 重跑 → 续命 → 再 reset 的死循环。
+
+如必须刷 `updated_at` 推动其他逻辑，应迁移到独立字段（例如
+`file_job.updated_at`、Redis pendingScope 字段），与 stale 判定信号解耦。
+
+### 3. 新增/修改 stale-finalize 流程的 PR 检查清单
+
+- [ ] stale 判定的主信号是 Redis 心跳（不是 `file_task.updated_at`）
+- [ ] 列出该模块所有刷 `file_task.updated_at` 的代码位置，
+      其中没有任何一处会被 `processResultFileJob` 在"等 Python"分支重复触发
+- [ ] 如果 file_job 会持有长 RUNNING（pull-style 工作流），明确写明 stuck-reset
+      重跑后的幂等行为（不会续命 updated_at）
+- [ ] 给 finalize 路径补一个 debug 接口（参考
+      [DebugTaskRecoveryController](../src/main/java/com/nanri/aiimage/modules/debug/controller/DebugTaskRecoveryController.java)），
+      绕过过滤直接对单 task 强制收尾，便于线上应急
+
+## 当前各模块状态（2026-06-08 复核）
+
+| 模块 | stale 入口 | 是否曾出现自我续命 | 是否需要改 |
+|---|---|---|---|
+| SIMILAR_ASIN | `SimilarAsinTaskService.finalizeStaleTasks` | 是（已修） | 已切 Redis-first |
+| APPEARANCE_PATENT | `AppearancePatentTaskService.finalizeStaleTasks` | 是（已修） | 已切 Redis-first |
+| PRODUCT_RISK_RESOLVE | `DeleteBrandStaleTaskService.failStaleProductRiskResolveTasks` | 否 | 当前不需要 |
+| PRICE_TRACK | `DeleteBrandStaleTaskService.failStalePriceTrackTasks` | 否 | 当前不需要 |
+| SHOP_MATCH | `DeleteBrandStaleTaskService.failStaleShopMatchTasks` | 否 | 当前不需要 |
+| PATROL_DELETE | `DeleteBrandStaleTaskService.failStalePatrolDeleteTasks` | 否 | 当前不需要 |
+| QUERY_ASIN | `DeleteBrandStaleTaskService.failStaleQueryAsinTasks` | 否 | 当前不需要 |
+| DELETE_BRAND | `DeleteBrandStaleTaskService.failStaleDeleteBrandTasks` | 否 | 当前不需要 |
+| BRAND | `BrandTaskService.failStaleRunningTasks`（独立心跳源） | 否 | 当前不需要 |
+
+下次新增"等 row 凑批" / "pull-style 长 RUNNING file_job"型功能时，
+请先读本约束。

backend-java/pom.xml

@@ -23,8 +23,22 @@
         <easyexcel.version>4.0.3</easyexcel.version>
         <aliyun.oss.version>3.17.4</aliyun.oss.version>
         <hutool.version>5.8.36</hutool.version>
+        <rocketmq-spring.version>2.3.5</rocketmq-spring.version>
+        <minio.version>8.5.17</minio.version>
+        <javassist.version>3.28.0-GA</javassist.version>
+        <jjwt.version>0.12.6</jjwt.version>
     </properties>
 
+    <dependencyManagement>
+        <dependencies>
+            <dependency>
+                <groupId>org.javassist</groupId>
+                <artifactId>javassist</artifactId>
+                <version>${javassist.version}</version>
+            </dependency>
+        </dependencies>
+    </dependencyManagement>
+
     <dependencies>
         <dependency>
             <groupId>org.springframework.boot</groupId>
@@ -61,6 +75,11 @@
             <artifactId>easyexcel</artifactId>
             <version>${easyexcel.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.apache.poi</groupId>
+            <artifactId>poi-ooxml</artifactId>
+            <version>5.2.5</version>
+        </dependency>
         <dependency>
             <groupId>com.aliyun.oss</groupId>
             <artifactId>aliyun-sdk-oss</artifactId>
@@ -76,6 +95,33 @@
             <artifactId>hutool-all</artifactId>
             <version>${hutool.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.apache.rocketmq</groupId>
+            <artifactId>rocketmq-spring-boot-starter</artifactId>
+            <version>${rocketmq-spring.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>io.minio</groupId>
+            <artifactId>minio</artifactId>
+            <version>${minio.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>io.jsonwebtoken</groupId>
+            <artifactId>jjwt-api</artifactId>
+            <version>${jjwt.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>io.jsonwebtoken</groupId>
+            <artifactId>jjwt-impl</artifactId>
+            <version>${jjwt.version}</version>
+            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.jsonwebtoken</groupId>
+            <artifactId>jjwt-jackson</artifactId>
+            <version>${jjwt.version}</version>
+            <scope>runtime</scope>
+        </dependency>
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>
@@ -110,6 +156,7 @@
                 <configuration>
                     <source>${java.version}</source>
                     <target>${java.version}</target>
+                    <parameters>true</parameters>
                     <annotationProcessorPaths>
                         <path>
                             <groupId>org.projectlombok</groupId>
@@ -124,6 +171,13 @@
                     </annotationProcessorPaths>
                 </configuration>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <configuration>
+                    <argLine>-XX:+EnableDynamicAgentLoading -Xshare:off</argLine>
+                </configuration>
+            </plugin>
         </plugins>
     </build>
 </project>

backend-java/src/main/java/com/nanri/aiimage/AiImageApplication.java

@@ -4,11 +4,17 @@ import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.scheduling.annotation.EnableScheduling;
 
+import java.time.ZoneId;
+import java.util.TimeZone;
+
 @SpringBootApplication
 @EnableScheduling
 public class AiImageApplication {
 
+    private static final ZoneId BUSINESS_ZONE = ZoneId.of("Asia/Shanghai");
+
     public static void main(String[] args) {
+        TimeZone.setDefault(TimeZone.getTimeZone(BUSINESS_ZONE));
         SpringApplication.run(AiImageApplication.class, args);
     }
 }

backend-java/src/main/java/com/nanri/aiimage/common/api/ApiResponse.java

@@ -1,13 +1,11 @@
 package com.nanri.aiimage.common.api;
 
 import io.swagger.v3.oas.annotations.media.Schema;
-import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 
 @Data
 @NoArgsConstructor
-@AllArgsConstructor
 @Schema(description = "统一响应体")
 public class ApiResponse<T> {
 
@@ -20,6 +18,20 @@ public class ApiResponse<T> {
     @Schema(description = "响应数据")
     private T data;
 
+    @Schema(description = "业务错误码，成功时可为空")
+    private Integer code;
+
+    public ApiResponse(boolean success, String message, T data) {
+        this(success, message, data, null);
+    }
+
+    public ApiResponse(boolean success, String message, T data, Integer code) {
+        this.success = success;
+        this.message = message;
+        this.data = data;
+        this.code = code;
+    }
+
     public static <T> ApiResponse<T> success(T data) {
         return new ApiResponse<>(true, "操作成功", data);
     }
@@ -31,4 +43,8 @@ public class ApiResponse<T> {
     public static <T> ApiResponse<T> fail(String message) {
         return new ApiResponse<>(false, message, null);
     }
+
+    public static <T> ApiResponse<T> fail(Integer code, String message) {
+        return new ApiResponse<>(false, message, null, code);
+    }
 }

backend-java/src/main/java/com/nanri/aiimage/common/exception/BusinessException.java

@@ -2,7 +2,28 @@ package com.nanri.aiimage.common.exception;
 
 public class BusinessException extends RuntimeException {
 
+    private final Integer code;
+
     public BusinessException(String message) {
+        this(null, message);
+    }
+
+    public BusinessException(String message, Throwable cause) {
+        super(message, cause);
+        this.code = null;
+    }
+
+    public BusinessException(Integer code, String message) {
         super(message);
+        this.code = code;
+    }
+
+    public BusinessException(Integer code, String message, Throwable cause) {
+        super(message, cause);
+        this.code = code;
+    }
+
+    public Integer getCode() {
+        return code;
     }
 }