From ce121cf0d0c85b1b4a0be55544d59228764db5dd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=93=AD=E5=9D=A4?= <10372463+ming-kun@user.noreply.gitee.com> Date: Fri, 20 Mar 2026 11:23:57 +0800 Subject: [PATCH] new file: ali_oss.py new file: app.py new file: app/ali_oss.py new file: app/app.py new file: app/app_common.py new file: app/config.py new file: app/coze.py new file: app/generate_api.py new file: app/html_crypto.py new file: app/main.py new file: app/web_source/admin.html new file: app/web_source/brand.html new file: app/web_source/home.html new file: app/web_source/index.html new file: app/web_source/login.html new file: app_common.py new file: blueprints/__init__.py new file: blueprints/__pycache__/__init__.cpython-311.pyc new file: blueprints/__pycache__/__init__.cpython-39.pyc new file: blueprints/__pycache__/admin.cpython-311.pyc new file: blueprints/__pycache__/admin.cpython-39.pyc new file: blueprints/__pycache__/auth.cpython-311.pyc new file: blueprints/__pycache__/auth.cpython-39.pyc new file: blueprints/__pycache__/brand.cpython-311.pyc new file: blueprints/__pycache__/brand.cpython-39.pyc new file: blueprints/__pycache__/image.cpython-311.pyc new file: blueprints/__pycache__/image.cpython-39.pyc new file: blueprints/__pycache__/main.cpython-311.pyc new file: blueprints/__pycache__/main.cpython-39.pyc new file: blueprints/admin.py new file: blueprints/auth.py new file: blueprints/brand.py new file: blueprints/image.py new file: blueprints/main.py new file: brand_spider/__pycache__/main.cpython-39.pyc new file: brand_spider/__pycache__/web_dec.cpython-39.pyc new file: brand_spider/main.py new file: brand_spider/web_dec.py new file: config.py new file: coze.py new file: generate_api.py new file: html_crypto.py new file: main.py new file: static/bg.jpg new file: "static/\345\223\201\347\211\214\346\226\207\346\241\243\346\240\274\345\274\217_\346\250\241\346\235\277.xlsx" new file: "static/\346\250\241\346\235\2772-\344\273\245\346\226\207\344\273\266\345\244\271\346\226\271\345\274\217\344\270\212\344\274\240.zip" new file: tool/.device_id new file: tool/__pycache__/devices.cpython-311.pyc new file: tool/__pycache__/devices.cpython-39.pyc new file: tool/devices.py --- ali_oss.py | 73 ++ app.py | 45 + app/ali_oss.py | 73 ++ app/app.py | 45 + app/app_common.py | 261 ++++++ app/config.py | 46 + app/coze.py | 92 ++ app/generate_api.py | 261 ++++++ app/html_crypto.py | 68 ++ app/main.py | 344 +++++++ app/web_source/admin.html | 1 + app/web_source/brand.html | 1 + app/web_source/home.html | 1 + app/web_source/index.html | 1 + app/web_source/login.html | 1 + app_common.py | 261 ++++++ blueprints/__init__.py | 1 + .../__pycache__/__init__.cpython-311.pyc | Bin 0 -> 162 bytes .../__pycache__/__init__.cpython-39.pyc | Bin 0 -> 144 bytes blueprints/__pycache__/admin.cpython-311.pyc | Bin 0 -> 21814 bytes blueprints/__pycache__/admin.cpython-39.pyc | Bin 0 -> 11271 bytes blueprints/__pycache__/auth.cpython-311.pyc | Bin 0 -> 7498 bytes blueprints/__pycache__/auth.cpython-39.pyc | Bin 0 -> 3320 bytes blueprints/__pycache__/brand.cpython-311.pyc | Bin 0 -> 24298 bytes blueprints/__pycache__/brand.cpython-39.pyc | Bin 0 -> 25387 bytes blueprints/__pycache__/image.cpython-311.pyc | Bin 0 -> 20393 bytes blueprints/__pycache__/image.cpython-39.pyc | Bin 0 -> 12197 bytes blueprints/__pycache__/main.cpython-311.pyc | Bin 0 -> 4528 bytes blueprints/__pycache__/main.cpython-39.pyc | Bin 0 -> 2360 bytes blueprints/admin.py | 362 ++++++++ blueprints/auth.py | 107 +++ blueprints/brand.py | 855 ++++++++++++++++++ blueprints/image.py | 411 +++++++++ blueprints/main.py | 69 ++ brand_spider/__pycache__/main.cpython-39.pyc | Bin 0 -> 15429 bytes .../__pycache__/web_dec.cpython-39.pyc | Bin 0 -> 4726 bytes brand_spider/main.py | 692 ++++++++++++++ brand_spider/web_dec.py | 126 +++ config.py | 46 + coze.py | 92 ++ generate_api.py | 261 ++++++ html_crypto.py | 68 ++ main.py | 344 +++++++ static/bg.jpg | Bin 0 -> 164259 bytes static/品牌文档格式_模板.xlsx | Bin 0 -> 10103 bytes static/模板2-以文件夹方式上传.zip | Bin 0 -> 26336 bytes tool/.device_id | 1 + tool/__pycache__/devices.cpython-311.pyc | Bin 0 -> 12348 bytes tool/__pycache__/devices.cpython-39.pyc | Bin 0 -> 7288 bytes tool/devices.py | 249 +++++ 50 files changed, 5258 insertions(+) create mode 100644 ali_oss.py create mode 100644 app.py create mode 100644 app/ali_oss.py create mode 100644 app/app.py create mode 100644 app/app_common.py create mode 100644 app/config.py create mode 100644 app/coze.py create mode 100644 app/generate_api.py create mode 100644 app/html_crypto.py create mode 100644 app/main.py create mode 100644 app/web_source/admin.html create mode 100644 app/web_source/brand.html create mode 100644 app/web_source/home.html create mode 100644 app/web_source/index.html create mode 100644 app/web_source/login.html create mode 100644 app_common.py create mode 100644 blueprints/__init__.py create mode 100644 blueprints/__pycache__/__init__.cpython-311.pyc create mode 100644 blueprints/__pycache__/__init__.cpython-39.pyc create mode 100644 blueprints/__pycache__/admin.cpython-311.pyc create mode 100644 blueprints/__pycache__/admin.cpython-39.pyc create mode 100644 blueprints/__pycache__/auth.cpython-311.pyc create mode 100644 blueprints/__pycache__/auth.cpython-39.pyc create mode 100644 blueprints/__pycache__/brand.cpython-311.pyc create mode 100644 blueprints/__pycache__/brand.cpython-39.pyc create mode 100644 blueprints/__pycache__/image.cpython-311.pyc create mode 100644 blueprints/__pycache__/image.cpython-39.pyc create mode 100644 blueprints/__pycache__/main.cpython-311.pyc create mode 100644 blueprints/__pycache__/main.cpython-39.pyc create mode 100644 blueprints/admin.py create mode 100644 blueprints/auth.py create mode 100644 blueprints/brand.py create mode 100644 blueprints/image.py create mode 100644 blueprints/main.py create mode 100644 brand_spider/__pycache__/main.cpython-39.pyc create mode 100644 brand_spider/__pycache__/web_dec.cpython-39.pyc create mode 100644 brand_spider/main.py create mode 100644 brand_spider/web_dec.py create mode 100644 config.py create mode 100644 coze.py create mode 100644 generate_api.py create mode 100644 html_crypto.py create mode 100644 main.py create mode 100644 static/bg.jpg create mode 100644 static/品牌文档格式_模板.xlsx create mode 100644 static/模板2-以文件夹方式上传.zip create mode 100644 tool/.device_id create mode 100644 tool/__pycache__/devices.cpython-311.pyc create mode 100644 tool/__pycache__/devices.cpython-39.pyc create mode 100644 tool/devices.py diff --git a/ali_oss.py b/ali_oss.py new file mode 100644 index 0000000..179fadd --- /dev/null +++ b/ali_oss.py @@ -0,0 +1,73 @@ +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") \ No newline at end of file diff --git a/app.py b/app.py new file mode 100644 index 0000000..c1f0140 --- /dev/null +++ b/app.py @@ -0,0 +1,45 @@ +""" +卖相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 + + +def create_app(): + app = Flask(__name__, template_folder=BASE_DIR, static_folder=BASE_DIR) + CORS(app) + app.secret_key = os.environ.get('SECRET_KEY', secrets.token_hex(32)) + app.config['PERMANENT_SESSION_LIFETIME'] = timedelta(days=7) + + # 注册蓝图(不设 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) + + 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() diff --git a/app/ali_oss.py b/app/ali_oss.py new file mode 100644 index 0000000..179fadd --- /dev/null +++ b/app/ali_oss.py @@ -0,0 +1,73 @@ +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") \ No newline at end of file diff --git a/app/app.py b/app/app.py new file mode 100644 index 0000000..c1f0140 --- /dev/null +++ b/app/app.py @@ -0,0 +1,45 @@ +""" +卖相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 + + +def create_app(): + app = Flask(__name__, template_folder=BASE_DIR, static_folder=BASE_DIR) + CORS(app) + app.secret_key = os.environ.get('SECRET_KEY', secrets.token_hex(32)) + app.config['PERMANENT_SESSION_LIFETIME'] = timedelta(days=7) + + # 注册蓝图(不设 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) + + 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() diff --git a/app/app_common.py b/app/app_common.py new file mode 100644 index 0000000..67169e0 --- /dev/null +++ b/app/app_common.py @@ -0,0 +1,261 @@ +""" +公共模块:数据库连接、初始化、会话校验、装饰器、模板渲染 +供各蓝图复用 +""" +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') + + +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 _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 diff --git a/app/config.py b/app/config.py new file mode 100644 index 0000000..56b7ef8 --- /dev/null +++ b/app/config.py @@ -0,0 +1,46 @@ +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 +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" + +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.3" +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 + + + diff --git a/app/coze.py b/app/coze.py new file mode 100644 index 0000000..ea8e95a --- /dev/null +++ b/app/coze.py @@ -0,0 +1,92 @@ +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) \ No newline at end of file diff --git a/app/generate_api.py b/app/generate_api.py new file mode 100644 index 0000000..ce92eff --- /dev/null +++ b/app/generate_api.py @@ -0,0 +1,261 @@ +""" +生成图片 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":""} + + diff --git a/app/html_crypto.py b/app/html_crypto.py new file mode 100644 index 0000000..cb089d9 --- /dev/null +++ b/app/html_crypto.py @@ -0,0 +1,68 @@ +""" +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 diff --git a/app/main.py b/app/main.py new file mode 100644 index 0000000..eb64fdf --- /dev/null +++ b/app/main.py @@ -0,0 +1,344 @@ +""" +基于 pywebview 实现的跨平台 UI,需先登录方可使用 +""" +from config import cache_path,debug,version +import datetime +import json +import sys +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 + + +with open("version.txt","w",encoding="utf-8") as file: + file.write(json.dumps({"version":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 保存到用户选择的位置。""" + import shutil + 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 _select_folder_win32(): + """Windows: 用 ctypes 调用系统文件夹选择对话框,打包成 exe 后也能正常弹窗(不依赖 tkinter)""" + try: + import ctypes + from ctypes import wintypes + BIF_RETURNONLYFSDIRS = 0x00000001 + BIF_NEWDIALOGSTYLE = 0x00000040 + MAX_PATH = 260 + shell32 = ctypes.windll.shell32 # type: ignore[attr-defined] + # BROWSEINFOW + class BROWSEINFOW(ctypes.Structure): + _fields_ = [ + ("hwndOwner", wintypes.HWND), + ("pidlRoot", ctypes.c_void_p), + ("pszDisplayName", ctypes.c_wchar_p), + ("lpszTitle", ctypes.c_wchar_p), + ("ulFlags", wintypes.UINT), + ("lpfn", ctypes.c_void_p), + ("lParam", wintypes.LPARAM), + ("iImage", ctypes.c_int), + ] + display_name_buf = ctypes.create_unicode_buffer(MAX_PATH) + bi = BROWSEINFOW() + bi.hwndOwner = 0 + bi.pidlRoot = 0 + bi.pszDisplayName = ctypes.cast(display_name_buf, ctypes.c_wchar_p) + bi.lpszTitle = "选择保存图片的文件夹" + bi.ulFlags = BIF_RETURNONLYFSDIRS | BIF_NEWDIALOGSTYLE + bi.lpfn = 0 + bi.lParam = 0 + bi.iImage = 0 + pidl = shell32.SHBrowseForFolderW(ctypes.byref(bi)) + if not pidl: + return '' + path_buf = ctypes.create_unicode_buffer(MAX_PATH) + if not shell32.SHGetPathFromIDListW(pidl, path_buf): + return '' + ole32 = ctypes.windll.ole32 # type: ignore[attr-defined] + ole32.CoTaskMemFree(pidl) + return path_buf.value or '' + except Exception as e: + print("Windows 文件夹选择失败:", e) + return '' + + +# def _select_folder_tk(): +# """使用 tkinter 选择文件夹(在非 Windows 或作为后备)""" +# try: +# +# root = tkinter.Tk() +# root.withdraw() +# root.attributes('-topmost', True) +# path = filedialog.askdirectory(title='选择保存图片的文件夹') +# try: +# root.destroy() +# except Exception: +# pass +# return path if path else '' +# except Exception as e: +# print("tkinter 选择文件夹失败:", e) +# return '' + + +def _select_folder_tk(): + import tkinter as tk + from tkinter import filedialog + + root = tk.Tk() + root.withdraw() + root.attributes('-topmost', True) + + # 使用 after 确保 askdirectory 在主循环启动后执行 + def ask(): + nonlocal path + path = filedialog.askdirectory(title='选择保存图片的文件夹') + root.quit() # 关闭主循环 + + path = '' + root.after(100, ask) + root.mainloop() # 启动主循环,直到 root.quit() 被调用 + try: + root.destroy() + except: + pass + return path + + +def select_folder(): + """弹窗选择文件夹,返回路径(空字符串表示取消)。Windows 打包 exe 时优先用系统 API 避免 tkinter 不弹窗。""" + # if sys.platform == 'win32': + # path = _select_folder_win32() + # if path: + # return path + return _select_folder_tk() + + +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) + webview.start( + debug=True, + storage_path=cache_path, + private_mode=False + ) + + +if __name__ == "__main__": + main() diff --git a/app/web_source/admin.html b/app/web_source/admin.html new file mode 100644 index 0000000..a3fc796 --- /dev/null +++ b/app/web_source/admin.html @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/app/web_source/brand.html b/app/web_source/brand.html new file mode 100644 index 0000000..85a0834 --- /dev/null +++ b/app/web_source/brand.html @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/app/web_source/home.html b/app/web_source/home.html new file mode 100644 index 0000000..042fc48 --- /dev/null +++ b/app/web_source/home.html @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/app/web_source/index.html b/app/web_source/index.html new file mode 100644 index 0000000..239a586 --- /dev/null +++ b/app/web_source/index.html @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/app/web_source/login.html b/app/web_source/login.html new file mode 100644 index 0000000..a9290d2 --- /dev/null +++ b/app/web_source/login.html @@ -0,0 +1 @@ +gAAAAABptQU3wdLKj6wXeh85m66DaSbcQitb7FOrLuKKjNF-Cm_tlx_Ee50c6R-q6RfZMCPDVsDQsrdDSNPjFRwCupu-WgK437L8un-9W_9O11KWEfNEZUKy9SuCFQ1jpv5dji1Fb94OQ1o1dV0i22d9MkLF7hv00ipeLe43DbxOJkk79-QgrR7sE0Bn1FfgpZvXg_7U3HynI7AEo4PFifn5XeFyf4k0w2-mb6uyrpwAK3fi895kMRjppkqwLIm8lADo_SRZrE79EZd_HBaA1PdH96BwIJG4-7qPJOJQKp3MbOKZRuztvxttwAu3TZeeXcAzzf07GxD22UXblxg5purCKbQIMtUT2ezUyQOnZEojoj2A2NSv7ptKREZQ8_-KNQS0E3P9hBRK_y4eCsOZ0A6CRGpW2Fi09ODBROqnabZFfvx0YFpN57pgGXj76o97cEr9pcmJUCaMcleGfj5vc6R_5xyt76M0A-gej0htvFuzmgFnCSvcRR0rbAtynfLAVaNYioa6UHn7Ujx4em5ewpJWx-YTjzuoVqJdiFBuDmkiIQ0lsVb7iesAPXfkIeS8PqoLGyK3G7jUTT_9UNVZMcQiS8hE2RVsTslAU1x1KncWgsSEqTlJS27-lSAWs-wR88MilsKxFZnG2tN3c8gUKdLgxI0K0sdueT3kPA0W0PpuGeyEmU40s11AFrGt5IfeaII_4rbI6FUqmoiPaOhgGYNQzUHMMPuwEW1NCvXKfGnyR-BQgG4xZ_i46Q8Gptab2qVNUaugpYu5Xs_gOeI2Jg0tdXSNxh_USt8RS2RjWsMIfq_OjNYUxVWOi-4jZXv3ogizEPz1pk5lWBQXw1DessdZUbDpYIrYcPrIdl5gmZVYdKuUCbAezmUYgZXdraCSUhDd7QUupNNa2OnDTz5TtWlkio-MSqFReZUpaYdvByq8h6X7SxGmK-uLAhHKs6292UTJVsDcZjYC2BgHFtPsWJhFu4cM25wPGYE5psXX4PJ3GG5X5TZW4aGvUlsDGMN54Az5V2skwN6HrkPSYstb7XG-hhk1iKiGLonS-I0ojVtgL2O09gamfi-DoExylTG6B0lARBTKKyIH_l0W1v8miiL3nFgtMjIeaZXTZqI9n-UGuP0XimK6y6RglzYvjbKodKK-RIMsIXFKIDhiHXt5AYpSEsaWiJHHWT8JNHUy3Cv-dtiT1crd-Q4KtpWl1Gr0DHmvKvfrWmvqPc1W3AqVMXBZcbeo1XCmNM5T69Lqi-kaiNF70TZ0tvE420buYT34-4_2mbVnv51DQQ1fWtMk96o63Y-ZiM0QLeeKYqSTMhy2soAa7w8FOHLBofDs0paf1a31l4tsrm3IJ1pEQAF7YhHKR7TjIljElQ76Q6BubPlHUxzhzcuaxV4qBA2OL-3tQkNXhrn2XieRMoqqFgIiIny-SCdOnCjtugxTKZndf0YNgIQZwI0qLnsQRGNev8s0kLRZHoGI4pvHQp29B3gTt212hIh7YaGrQgWETYkfB_W-0CMRzIXBje_ZSHNHtWBsrNxiQb0P-eA6se4NFa82xj7nP9ZizcM0Dn72J6hUQ5u3gcdxVMtEYvX7s8N06UOQFuSOhqlso3qiF_22sWVt-kznfa5H26TqzNu3X3KG1sx8zQY0UKPrusykv11OnSJInoyth4tP2Dxx-XH7jitw1O2Ltk8XgRv5lETnmdPkFvya9chBzgwVVbNRHVjspfycvIedZBT3fon5kWSxRCJENy5xtfz0aR3WhpLJYZ4IsOj6Hdju1zzJmgO_kzra7gbTkdAbkHdaskw2MFRX3r2HB2MusuE2dSbBNCwbdBw59c8F8Jfmkm5h2BeswdO0p0V1xqbdY90XIzDQ4k_Sx_Nz9xcfQ5hPTJKlAlUndORA_zGjYgWowQpAsZtLh1SxVYJtJhhVLkLEh0ALdrcpUWFub6ahDfDDKH-icdm5G6boSkO8zu8zo-oHuwMJGctd7ME64mVhhxcFUneRcSVBApBQYepTDI1tajxIS3kwBgW1PVV5MZ157ajyaHoWAYBY7PvsUxAFXNeD5XjYhNL4gTEae1qu7CPlmekiGR_k1hphyW4XaCW7jLXzFXOPokJSzRBXzUF8Dm7waDeeT9Gv9_zerOxymqFuEDqK2L7_q-3pfXLtCyv4TWKAUr---TOhZg2WfBUTNA1c-iHQIYEeu7CXrBJ3IlNNMEqQd2t0fLmhc1sJPCOrvT9kQ838ogMZOChES680RnUGm65fx80kpNcViuvfMHqz7uQmT1woP0ZaB2Roe3T9U25gbM3jSP8mTdDQ-FufqpAYc0JIRK_L7IWoZ7zEqg885ENmpGvxqS2n3SxLK11wmbdwgbtSFtD_xaIW69lYW2nZuBnIBHfgyeIGAFPvJ4JVed2RI8uUQ7my38o0JgaMjcgetslFYbJGT0ZFROcK-p3uQOSjWC3z82z3pCEWuBKNbzDln2yC9IeE1TSQOpTs-j7KHUr66RqXmT2MQp6wY54IVqn0olAJMz-OBtmZAisrj570k5PBt82qS4kOlbvxfzoMPgeiFT3eTKzjH7VeaWhW-TnjN4XCTDOagR2QqKUpWRpKZO80Xp---GRpH15hJ-0TrJDxjUy7C_DKKt43MZKNou2vkVSPThABd-F1oEIMoDvtGggk5zFEh8MLze0hui9zS2-ddauY3SzLhY7F5-dqx2hb6sf-S6ZrcTdK2N9sQdvQ3S2PhZ_EBAGCUBqr9jKX4OGIe7aF18-kM7U7FLgKYZnZ9Z0d8v2cYYmlCqEy0dzh1s80Ydd5jG_64ZwnnkkvRYiFk4pFKjVDEhK1B77mimbDT5Mx-9Qr2-RuF7prdv3iSqdhT5nIGGT6D4FRZ3SFdh_objZ5g0493raPpqYGvgx3K9k2SDBI9oCUOsOOpUISrHiuzl6wB0nJ2t0ZLtan4VgRVBe-SRISNnPWD3aKmugWOyVjxSGNk8ozRm10z2TumJMoqjkEIV10yXtxY4Y4pR4e7dCpBq5eKvIk6jglCBrwV4URC7DqJA2YjguNrC2Lfcyq_Sh79I2gq2SQNgGSyaUp4cEZYRxtJAyBJTO2-gIRDhNxg96uyVB0TF46h2rNEdlT7R4zvuq3g2l6eSztrDITlOE7PokM8-HCOawsqghpYoCVTQdG1hWlfXkJYQPewhJOUJ0krrSc3wLJLsf-wr4Awb0EKw4S9R8uTYWzKkxFf1P3MPiNLbHuvP8oeSwSVmo40EqRGfkkAX1YPTuWeMgI17Xvt4Ses7Upa-N-g1aeHNYbmXcvqL2j9TY6hPz6igF6i9pwyFV_hDI_3qX94KS1VpCY-bpXPA6DeDnM-8jkmL0-b4hy-0OaGOaK-wG1gfQUIxXg3RTv9J9rDsQRD5nZ6AavroEhjd7EGOTmglAtg_RAhqQMOXbewi2u7rYIxXZAqYmRHRvofCszWED8M7XS0ADN1yu8LlJuR-ug_rJB2NM018YIFwRzEbLDbhLaTG0eJ3fn-yeitnCNMwFbGEmn8yXCrT1t1pRm4GA--ZFKM29gzMiMwH8Zxa4ROHwD-ht6i7o2lotWp6VPjhtxxjVtGNeyVyi22srzRvIESNMgWI6jh0alwBNfPhgTCblxNvwaF-NkQFrrwSivjiXPFclqFjcxgs-xpMeZSz7-KG2xeXZvX1KMG9DwlIWzGNrlx9G5kPV3b_LDBzlV-ZldUTVHq0MjT7famjLRnI0yic3y1nmIqlbNUx6U2D-UN4o2_lovYahorxLbUgkLX-ovtUbrORfoOSX6j88XDeIWWh0QNwSULVDMJztebb2rAqVxCc6D7bDQNj0rZCB0dAUgaoHFCKtbE5Da6f7-P5l-qzjMvtflyRaqYyW78BL-BGaoNH1yv2_Hu2Cpx3TpQYGfNOd8S75T4JbGxIXdMgiJKVpZSqhVEdejpnZnmSD7G1W7OMct212l-bkPmjJbprZOCPGWmx_PVrGYUWn7ibZgrbegzx-bQ-zt5FXz5AmfSGQLhYWVc1SihHnIb0cnus_wIuWkMDdCFiU2Hrc6s3qwOlFplPOaiZQZ9PgmoeUUDHJkacOR_eODwBdVjTkZWc8-jRn6XmQaz_BrUBvkV_Lu3Fy9wbUASX50n1yXihvuuSBzD-NV-2c9CI_o-LjiALNGE1_12noazR3yevRMJmzIaUCLK-Wba_7_61VBSTUdIh89W1FSMjJerslzZj1bpyWCf7DZ0qboKcgAqrj8yqyTSsUOgV2_hEhhSosaCAPlWopOswchyJ5ACvjvIp2wr5LylfmkApd0hF8QmOOVXF87a9OY-_QmqMOAK-E3nP80eQQ-XWdDiRAo5kRDayqD4zUD3wVcFta36ggRnwkSppRNfQe8Aa3JvZdd0HxrZCh4F34ux7wAGARyDKuYNtnT-KCZKwJLhXNt_FQoFjjjBMrINDg0-hwUElfb604t_kWNTa2lHAFbMZvuBB7s3kjY2GV36HufQayYibhS_Bo463Nl3sEBSjH6_QZRrmZQKj894JqjM9MU1cA5DeHL3ohJu6b9pxTGZQNsK0jTHgX8YFBKt2XmdaWTiQxJZ7IIKwVX3aS_HHoa-UXXRaWW4lCwQux5MD6OJ0g0ip4ns5ZfiXIuGFYwXmjoVRbVddtI4Gx7G4XHtPRFIFc456mbumja_YTsyg6E5phpuNvO8xDUGjYUxsdu1nSRK24YacjKJkOvH0y5APe9l9STGPTtmdgdBfhfz79TtdCyg1fgxyG_OxWcpdCDhGlYQnDA_YGLSfhhlxeZnDobarbnlM42fnfqz5ulcA82xR--qF-pjyWWmu7UomnUwEpMfi1KCC1kDGjTeorMauMCnQw52FMBKC_nTheV5V0sDD6bO6GOLZ03eAG5Cjf8vmfmxtEb8uWtK8ed1pDne76dV_c71JQgYCKueYWThMGZjlOHQCivsjQLM0YWkdZBYnZuxdCdiqtJDiJbSKaMiLCqGeTpWIvd0vBdlzTFg5r8GAZZ8wn0gelIp8t5g5K1mpVocaYwkKK8CgzBauiyNCv5ClQp3AahkfdJLAQp35BRLIIrJA3suVrNzK19b_TvYp25fyafYheW8bQEzBw_B19xS1ftHbwDjlJFo83mXt_n5G0I7N9ZJqIRyJUhemvPq3VttIGGcGGiqA-hIm1lz497sTGuaeWEc3zFPZmHnKk1hjDyOmpSSylU6yV2Nm5od7EeWL5qHR6R9l6YBZFMgB7ofueI5TrT4Bh2IS3ZK3IRw1b3NgJpKyV0pqPA1Hw7JSRrb4Kg-948SSPDQrMU1_q3qUiUdjEFnOFjYcKFoJYb3Ycy-mIv-oBhQ_LFisz3oWSldwgM0iMoKSCJEE2ug327lEqLKPrp4X9hsJoqbNzFxaKG3JSOKmxIYygE5wXjgU_6FJXt3mcdDsuQwICJJGqK7CvlXsQyMrZuUNhvWoCPyXdJidTtHvf6Qlx6h7RN6R5fr6ameYC4rZwJlBznKlLFbAyeRIfuuHJvEkPl98o39aCv0J1guSLSQEj0YfGuwN9AiA1WxvVYxRc0-DDcl-xbixiqh0lCboHqCSgZ0doYC-360c956p-i_RK8wMp055waR_vnJV7EVrRsmS9rqLeC4DS5ipvxfZWVbgyrnEfBiTeT8yGbz3KFEfNrq7ZWejGs2Nus-nG-G2bJ_NoVZc2OgiWcXNE6rivy4gpsa_T6y5Q342lZqVF9-kL6h3WsFIGnuHNDU71QVbJhwOrZIezpZvQvFG5IN_GfZByXIn6kdnpzTxhoefK-YZVkD-eCCZYDWcrGJu6Hw9D-FA4tCMT4V2LLv_BXeZSkcc05AkA2J1i8plnUejtvLDvN9AperQW7_o0FrWmtvOSS5xohjo1T7J3iXP1Lx5dH_mM7SMK4Nw71y7BuOTh7R48Se0reb58BctGMSzsGvUQOmmG3hiIHOq1ZhjVxoZLi088DD3V-eRFnjW4AdsKhx9_eEwCD0mESIv-F2Xhkh0qqlyXucHIfTkxZQW0CtBkFzhrB5fTY85g2weHoz2NQG0ankzIbfHJn2xiIg8OHm3Xv6aok94aNWWdTbObvXf8Rtg3-TCws-dHyityJs0keJj2jX4Ta468cn6yBso57X8nwDI0blHbQ8qU6EMdI88rfeREq41PYwpnol-dkkIhi5dKpNLtxR7-qQlL3f4apXIsQIII8P3ImWUcs1MXMy0ekJl6ubJpp2rxPvpI5QPL6Ak3r-Vs5ohgmqe6QmThINP7nBV0xeIfNf_8gpeqWi4BDwN33tlu_V4l3ztxr1LdhO5ioVSxINxlGvdrVXzYT_yjvhMALc3tbbNR5hmak2ctennb_ql0krFk8QcqW92DKgaBVmQnPM-sWAFsSyTXqE_yHB-UqmGhBCIyiH6wMCZIzEFN7ly_71okmk7R7D8XxhVVBMJHfQKAjCGrIyGfgk9ray6v70JJfKzNyhITlAQOpi3iZZzvM50ONCO4rGW8dEDJbuWhiS1HFE57MbiK0sd2U5ussngAamapSPClWqLb7WIvpOUdNst92tl5QdfEAYGRNu9MvPALt_JC9i8CLGcp1ZsiiPEjsD6i44zB9NYHOM1q5gGEmyBUY_s3QstMurbSN-bJSCjE7v624ZG-m8Dl1uzE3AId3nSSVK2CTYOALnV368IRGVilwzviKuCXoLo3hI3GWJ2U0-XpSyDgWlkYBVogDsccIWiTnVD4qVk6wiNezkQTx4CyRqALpJWFR0hXTiUDCuZei_yBiMn3vJ6NsJrMTDKfgA_5HJ0JplyrEQiyFmdZrs80acYgPoRuKDMLfHNeehyfEzvFYfKWGRVMvNxqm8WulGvwgW4vB8CUH2HuUc6uYN73wIle30VzN9iBpwTyD003OiRK5azjPwsVLrsK1D0FGXpQnf-gs0kUNC9uh0g3u-DE6-D6s5-q--VDYFeG7tYnDrb3tkdanBCHen0f2GL_r2d9Fj6N09OXOJrFYBphK55uYdqirVa2_mwTWeY07kVSSKeKpeNV7Jbj-GdhSMnlp5T5IzuGPdjMZSb9FoBMnVLBgMIaQI8A0QNbnnW60Q9SV75dlQvjoX3dBGSSaOHtefbC1E-BxxfMYGM6zruZGULfNm1_smnre6PHds5QLnWq34n2lP84AUGeGoiSoPg== \ No newline at end of file diff --git a/app_common.py b/app_common.py new file mode 100644 index 0000000..67169e0 --- /dev/null +++ b/app_common.py @@ -0,0 +1,261 @@ +""" +公共模块:数据库连接、初始化、会话校验、装饰器、模板渲染 +供各蓝图复用 +""" +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') + + +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 _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 diff --git a/blueprints/__init__.py b/blueprints/__init__.py new file mode 100644 index 0000000..283385b --- /dev/null +++ b/blueprints/__init__.py @@ -0,0 +1 @@ +# 蓝图包 diff --git a/blueprints/__pycache__/__init__.cpython-311.pyc b/blueprints/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..42f3b4ca982f394fc9225a5f0fad7f755e9bfcb7 GIT binary patch literal 162 zcmZ3^%ge<81g{&{X7U2*#~=<2FhUuh*?^4c3@Hr344RC7D;bKIfc(!O$*)F0!o@1) z`SQl6y;Gm;TJmJ~jF{ZS%!Y%)FA~nE3e2yv&mLc)fzkUmP~M h`6;D2sdh!IKm$Pb6!Qa#56p~=j2{?aL=iJk3;>aYDa8N) literal 0 HcmV?d00001 diff --git a/blueprints/__pycache__/__init__.cpython-39.pyc b/blueprints/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..237128e589c5f15033fb10b1dd7c421702764914 GIT binary patch literal 144 zcmYe~<>g`kg8yrGWby*(#~=+t!6j?} literal 0 HcmV?d00001 diff --git a/blueprints/__pycache__/admin.cpython-311.pyc b/blueprints/__pycache__/admin.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..23ca2bf98f11a575bbc76570887052a7909c3bb6 GIT binary patch literal 21814 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 BJ&ynY literal 0 HcmV?d00001 diff --git a/blueprints/__pycache__/admin.cpython-39.pyc b/blueprints/__pycache__/admin.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2d77d4f19971838c9e30d34851d5be0489c1df08 GIT binary patch literal 11271 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 literal 0 HcmV?d00001 diff --git a/blueprints/__pycache__/brand.cpython-311.pyc b/blueprints/__pycache__/brand.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8731fea1cc2b1607ae4bcabf76ac35ed485ae17f GIT binary patch literal 24298 zcmeHvX>b(hnQ-^?jONzNXmrd-LK+E#5E9}Lrx1rg2SVb$i~uV_J%EHR_lyFTN3861 zz6c^4ft8?OSdYEfmSY^0-8d$(oq!LFuib7{rJNAl-ZUZP>uwcAouOE& zo?>ZM)k@dXl)t9zQNce3fM{%N{Coi)H&2Amn;ER!|C*)(^GKTA#}jI(Ao@gRNC zqNM0fVy#b8uRx;L!wF-~>a(Y$Xq$p!(tRkprle?RlYyoxPAOCFLo;VenyIhQ@OJQ* zHhAN-`_Rgrl9ponA__;_Y9JU-lq*#o@WPFTHZ> zAAf*XFaPNFyYGJa_H(!X>73y!e7B7SbWqpDwRSdg9(O@PP`{?N%iYN}w|j$H&iz=I z+XG08r=z|3z~e!!$L;YnceDrf9(Oz2aG<%>9n^7dwwZG`c?+0e!a=vUf!!ZWZ0$JM z+}?os;T9XzttsDD*-%llHK^IoHMX-s6FD?=ba^|wyiJj6hVtm)&%pm{4z8Y|d=!`M zh12lX5=rZi42$qRJo+eQWqVWyscqCjs)zPQa#BOHd>VolKEd8!xSo@~M==R#_tD8BO)~_-N>KOjjvT zyZyVt@#p_3(!HSD+&bQS>)dfy@zGY#QI~Y%%d<~^`S$toOTWJT)}`^^J}vdNZVgES zheztRJyM_xsyaMDb!VgZP*BtCfu0i7wl;gbi0GgXd5$#0orK2DPB;nb+B>*5l2+Z) z(cBI_%6Ooom34Cs5&?ujt-Z0$?ZGB=xmRU|qVamLQv-u<`I&_$YrXAESJy9(DYh@TudyKg=8&9|g0* z-JS$r0?bA6OChVFa2cSkV&20;_s^IjzpMtM`KL&0j;4rWvCmT0AWJ(VNqe-cHh!(4 znBdb^#ISNDr5@cBrHb1QKDAHB>aqP|+CZ-d5yz+UCHVBpJJ91a{=`UOWeB8%89d68 zVaED&I^~s#Ei))?T93h}QS?`XGS>lBlWI4`8hQ-J3{5a9wuSH`^bzVPvzt0X`!uZK z0J2|W*H(BuOmE{C&VF(EXD(^xJN_zgS(m4|{a~w`Fu;aGFp;#n|M*V7G-z}C{M}{{G_b~tQA}ywSYQp>q(^%?n}K%} z12<^rvLPjB1rXG=H6BKh#S^ry*;>A_qG8jH?VEROC*ld?@d96Bp~}6@ZSEk`-f<+T zgKG!yl(QiXl)8fn%^pek@pQH}d)-I9LEZjFkcogXaVeNUUwO32-RT8cslXUCU|Oj^ z1hw8q&*6q2)CVGy_)54al$s>8H|AJT3QPCUQ` z!y9Rdpf$Goxs{L%Yryl*FouA)sTcCfeN3J3bnWl0u3@+_Pf*Vj)$;%eOq;=*Tc6oB zkam1;|K7g6!)5Qz5=(1ulx`X=-6WK55lgq+D6JnYt>^c&2&IR`(!)aG;ohpTL~H-S zldUIOf1gn}yi-VAC?+oKttO8c(E4Za>U=?+FRJqa3D{G5>jH_63Cf_EML?elm@D$d z6y%35WSz|#Rte5R(OF0?229Cg7F++38mtdbG-tNLdF&mVDc6*c}t&u%$_p1NTBH%{Z#(>yq>eQ3$4oUi(DzM;yY z`Ea?l%C5O)qyfKX*8o(^0LVuP-~UhGzh^**mP@hYm#H!kO%RJ#w@3hh?l$q^F;MFCG{uqE5oVg8D3^qtpDLcIR@_g*vJsE|g1 zcVlVbfIm>?!H$ADHUj zSFE4^A2KOKLNtPJN0MotV0Urm#c{`R;`6{o`+#;a<$l%QLI_66uW-o_I6_K5T8n&yg(^H@$RTNY= zb+oq!8F*BX;X00x#^#nH83xonZUtZ-6v>ogc`C^7O@|M19bI5~lKK_)C~ga+#G3cq z1mi+4HKATjYiwhdl;cPHkAe(qww>H_V$bn?{re^;jXr0nDPXdktUXa1u(k$ljse3R z4P#EcO97Z5Ku6hA&lH_5I#oPa+_!eZ2zf|G0`4G*y9lD!;$bM3#!F?Q^yZU>6Ncla zep8<*U`axO*B&q>^;HE@9A|c&-ZivWNSQ6B%OhL~%%0PGPVF0n zcURj|{Y`=7v@^A*YXgp!fU{&|7w=dBub+|%ub%?uIs^=)BZ&#PgW2vPh+d0_k@t<0 z%0Sst&KOS{PnieJ1LlA=`HbPT;go66GyuPE#_XB!Ugnf2fD{925a`V*D9~fIOsKSa z+nC*XYU$w8zKQ^l%Q&5JYTDp5%+yT#rw6Qdd;*`jhkw+~?>i`14~f=8y!8;0X$EUz z6y72DUD*}+-N`t4t7vw4f}18QcB11O`Zx4#2*Anu6YG!H_1E>mFRaZFHB17KqOSrK z6&uhT&nz0Qzmmph)(Dw3B0!z9&ot09p|Vc(rUr8=yr>--L2pZqv|&%cnR%W)*D{bi>7);HtE#LgrA zpnLUIgn#hBZzj^<<>Bbr3A*P~x$9R_7mCU=nX6V4pjR{1I#eY0}F$A5{2Xr2k-*q0+>Bs8<30p^--1 zgrq-A%B?n0A1-uMIhboE6X4ez>Z(lbwM+)_Y#MP_A>bbwk7~^z6a1EJ1Rgl+uVV z$D(|)(y(Cx^Qk^}gH82m;mo>en$K(|z(1R&uFKJXmct-EgGM~B5b)2f^oBXi=QhKJ zEY0T`D#WMJh-Wc~&(Q!ig(m>5{lp@00TA?~^(Oe}Cy9j*Jz{eEfRFOZbO5=1H&(j@ z3nAnMc~)lIZvmzyZLz*IA}`CdOV9=NsLzK>ftJ{)}5Kn9Iq6$2+`19Eci5lD@OXAk-9(|4rr$jAa-w`fdj8<>7xeV!fg3ECN=b_UFk8awc`KEs5H(JUUb*!#POrXT-@ z{(sKG|Fs3z&qacPJkc1s3NzG#H=qQs9+smkTtmPKwY9b9#VY9({BQ10nkTdsa zkr-=4vX6?dvnh3Uu!ev?@4?c>x7&b?2F7aC;@&y)FQOJ>e*p`-dSg|$_K?@xSvq%a zw+;~xU!KcRWqWqg%~a2n?HTKt?gYr=71SSn;jkome`MkoZ& zp5o~WT{foA#3`3P;?ZG_F~pk#N129b>_TZgCR`%otQr5ouj2c*NoK zLI=R@OK;seIq=1ApLa>OTvGbiR1hK|X)Hkvar}HW08PBTK*eDP;LyPH)m^x<5i|*$ zp@TY%m>?5YH72M>kbnTa(USgw>Pdkbro%=U1C4kY$w*2D&LOB|NOu1;=#3%8LgC-$ znjzVb;P3el0H9&$beeK{%#tcvvIR?yXvyI%`Tnh-Yb2$fnRR;B&{833hL|*iPntcf zx?!6?YMU?EN<>>pUqZlw!mj=idd!~g@8XwimTc>SeXD5S%5UGr+jsG%U1Qei{wl#* zC|V2qH1Hh%!jU{aZ7J-6WtnJM#_N`ar_*v2aG^93#I%dvEE#$17mI(nm`^K(U9c<{ zEz2)&<1MRsUF=RI3z%@rX`FFqz}r1lZZBU#T}^c%Tw+*L#Joql*5otq<D{1H&1dvvjO;HZ*)??&o_B--r

=GUKf5 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 Bf-nF8 literal 0 HcmV?d00001 diff --git a/blueprints/__pycache__/brand.cpython-39.pyc b/blueprints/__pycache__/brand.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..22d046a921bc1f844932e1689031a04575453313 GIT binary patch literal 25387 zcmc(H3v?UTdFH(EBnW~OMNzUO!?Gj`3iWW}IPu5kKV=%sRI0*p}1eII{fe$!2@ntWP(a?RLAfuWl<)WVXA>rtR)I zYMSo%|91ckNXm9|dUnZ!J2Q9g+`0G8fB(n#|M&K{wni2FeaE?wi=I@JzoZNQpMi@l z_*pk=iXxP>B2=Lbt7(;wT3X|yp4Rzjqzyg>(g8jO(?LFl(jh*E(_ubF(h)vJ(@`At z;g*qDIyTapZdIv%V>mw2mTntKq!WA{7;YcwNO$mgaCpH;XS#D_VS3?6SGsFtQF_rx zce;CIaeDE{lJpWT6B@p1WNCWo$g=dZk>%;-oEILxdL)@n@_A(VnvoUh6(iTCuT_<7 zr-)`(9@EmRvg*+4%5~Z0qGeJ`uMx3yDyO8^X7$R)CY5v#&ewV8>qV=GKcJ*Hh&GYH zaieG#9XMVuZWf(l;R9;=sT% zn}1zw^6qWn+J1v;+blli<=!H+JxXdzF%3$JRv)|n(utFo#$TC!`dibFJy(79-Jibw zO!eDetG<17>WSkQ-+H6^{F{Gy^#1AhCZ;D(UVQ7V>Q^RlDNm~7Pfkys-7tObg{fl? zQttV$PQUZcrMDiN`udsZ3~E<;Q<@w2tzx#AbpzW*3icSTJNovU*?zHWbaZ&zk?cUx z9yQ%qzm*vn9VrZF?W{8{VC@3Zr>cqr1U4y7A%BeYt#wYC<95 zhHt%P&$i6g9lP<`mc7M+11MJLxA#*^tz3TJaF%P$?C;MDRNm3oZymU;KR=Ki9?ptw zra5Y+1A9%}Ovm_;87dmt}6M&^@_E6qoVTv-AEm6t8(w^vR;ZidPR5CNmW(uR1V%?D7G6r(nP8^*&b0WEC&$i_BdtaY=_?uG?pPj+yzwlMi%TM1vS$*@3OE11P^Yrunhi0Do zUC@gpnZG>xV%_WDjNYc4l~V;DFoV&jIy- zeq6mUT5zNIN}2rV;r^WMMz$Rp$QEoOq;6S$IG4|63g+lOd_YUqv|ye)DZ>r%8*{=9 z@LSVC?qzZbvp{zMt1tJ6YH}RP^shTSswG!YbgPevOP~Rl( z5X~LLT~Lc&+=N$5zxR0c*{|1`2AF|IC+m+4TSt=e20rekx1Ot>dvp4G=c?~MAj#o! zfQys@>+jmR=dM)P)kZDXph@Tkau(*Y8ye18Hl2hq%dNvX+zIv<3b=5?`B8I(%Nj$Y zxqM1bw+xOBi>%4B*bUGv)Rylb$@15b$<=7EyC9Q2Qozj3cn?rJe*-tHI1)ums0RMy zYNxtfHEH;pCNW8B`tc-&Xq+>|G?7XPp+TbRBSx7gUcM7kG%$8kZHfwGkFpWdA0H-2 zpP{UaKqVxCBJ_ab=vyIqkY_kXB`m`DEW?f=!i$u$VMm@-M8uBTEtQr@MMOJM5;-jn zr7_2NR(UQ|4wSarF--c_W7_HNa?lA@S|^oq2-82_#9H3=Pk%>qLQdeARt`I15g!C2 z+59TP`MlRl_U2>_ISsQ=#hwnEZT~F7@z9v4^5qU zrF!P|q>l_Pp8v|lw=320*OPbb*@GD_X(zb`Y`-VjJDSg?l2hYPB-hYsPclnfHZy{W z*uO8E!c0$Ty~Q@vEolnu0i2_H=B!Cm;3cr}Vqti+UrK|QP;>#Z@t)+=*~#j2PfneA zdFH`Wm)?2JZJsm4p=sV&^jnR@QSMz{Rzd&Dq+)eBs!$Fo<`PHEL(Td;xbQ)Z1nEn9 zNne*)@2Z(zygHP#`iJwyk(V@ATffm&2WHb;Wb?jk9%N_UdtolTpmnpLv9-FzN~IAKaN|jX724xCCn8#H?O6P zV9sK>80sI+QKja3%5B*(QW!ODmSAppZ$IQGO_3BmM!h%NsgzD)*RXRVS=SiFd~*$w z-DWr6vura3rBSw;r(mdPVd8-ow&6XsUh&HfdIO|%|6n%5r}}~Hn5z!Dp@Gr74Q}n~ z`1r0mXOb?iRWoOBwxbc&N+fcsYHEV`A%2}|6vx%zkTIlD{3leimzo^t%bFwB014pQ zUnfpt`0=ODBc<7B;}Z+*6z1%>VJ@-tapRbp?-06e3>lTcq*4hAV^Zars0@WFVOw(y zh;3$+4r|-=>^|j0z)`?jhiUeiyX}Y*wDn^e&giMA6U3Z056Y_+&Wlmrq$&c7F;hhl z^FAcP-~}O%7lgS~*a={EMi!B(5E&0tTAiR183a=XQSKfOSnuxxPZ$Jog2hMec%=>V zzC{G~spZ&l<+y&_7}Q0Jh&>QKq1g%1YPXLEpyO)gR=dN2HhoH+&`$3>p&nO{YsUj9 zOPY1qUO=U&9c6HX(vR&b>7Dw~gay+T+SGK00yqI$lmViORxBOqB`s;O$OS zv=3?;uI|LYh8EVi5cuT#PFtl5t&BJ=r(cGG6GfjQ)E_4%0s&>QB04^aPqZ1|V?r~R zm+rC`9aGBfPJ5+$QaQb{+~IUo7K;T`dNImiETp1Se@DLKdbGm&^Cn)`URgq|LoHX) z@lGY51g~2Jp^&*im^q&zj(saa67WNA{(P{-@2BZ)d5khycl zLOa+e$AWn0{Nv%Z;%DHv3&3&v{Oz!pISZ&g^VIu_6SZ}^Tj$Kt@`C#o%>NF-_lR5L z>uf~3ck)~Hv8~=)Kkk3){58-1j*U9!jFWEN;~yuC08?nHvq+i?G=l2$&s;qJvL_`@ zya?qkIamMw>D%L%F1&Z?>{qA0UBLtL{HJf9@W~LVakKQd=8+w&cn<8(4jjk~)YSM* z$?EBI)2|=9^!Qm)O};(ZsIJc}W|L4-p>a;V`VDBdHBr_4n(OLyT}J|nU*hS7NhzGD z4p>%a&Q6^>U48xm(s*BkW_uKU_H?F+ho_$X?$i^nC+lkGK+!b88fz7T-}c+tePd`Y zTW!^oZ$gqyJ@IDs?bB%S%v(=QzxI5RSsX6WrJ1A9(sN{1p^83;r*QTN6sgSU0XLc( z8G)IE`ZAYWSKYm8WR=LQx_#AWSM6abYHkEeY*HzIMe&%@OWL{&OQv4)6R6buHA+Y? zZfIiWO}HGUtY1e`x;A4L^BHMBk?@#L43=Ur;mEXN)v>pUr3X++2tShh)>wY9UEyLOT;E>$d7>wgz6mnN2k2&9-s68?Vvrz_`AdI0-Z>pNaPc|NNkL zr1W0?7^#38rE$pQ@*;c0JGV#e{$V%5`7C>59<^l1ba7kwKA&5upt%K2$2Z4>vTUMy z*AO`v$iZSkfCS9NxNR;$k}}LY>HID#AIKg7#kocIF~5L3SyDIq`F?GValcZ!uNXaV zavxiKtvZZcD~LqVI@>zb(yEWtml>id0vtyAk7N#yng_C`)im3P?#Q}ex}&+6BXxAm zJz81CPb=%=N(B@MZ5`&nP!<6^7}sDe1RVV_?I5g*lsZG&a7s%Dt>WGh*tq&|Hjl4( zBXXhEi6cB9=3XkK6JwB2j49}TfOwbX`>fH;L@xx<+zl*>lAlVhvXXb+zHRrmWKQr^>KayX z-S9~N0YZB$H*xFkTY9%$_om-$A-$)mUn~ccYxS znG0Km;harW|7ps*j`AWl!&N|nTw^Bz3i?PcZ|acLm-005owaZp=XxOt%ge z?V_1wL!<~!Aur9(P$dR*_Pnc8`Oi|#H2uM3xG6)FK}5ujl5IRdmppY6v&n_P3F`6r+Wdo!Q!Qq6I^yNTzM;nRZOZTML?Lhd=L8Fn-)=CkOP5!mXi z?U6;Vjcu%HfYPFe-fh@AZ1I4j!4}uc0SB7$z315uxE)qR0QNp<|6e#LuR?TH4%y*n z6(_*Yh47qF4wpVdR)Yw#4IgnLl_<32C}c;dNp`&8mmS~yh& zl7OucwcCc;C-u{hmg5fe$in)4WbfQW{e(TRvC&hya^jT^SU}YK1)_zI+;6~1(AG%{ z(MD_5C(PF4S79Gb(x>S1B{iJ zH{;BW0z%5{+P!W2j=LJ*3d;>CEr@NHw^BlkgN29W>soHq4c$6sXRRG~aQ&o0xuJBf zu$@j~=^eW=TeofB34yrP4IDNhfmkrPhLz18aKmt19O?%|oN7@bi%&$=LWlC6c`52w;pyV@@{4+{+QbHWu)%O+$U9B{j=KcekF~3UpXq zG~)Q`O4WQ4wKZu(BtBa4BkkNOK!2JDm44p_-oOx@3KU>91K65S$CW{LbO6NG!K-xe z1+9r&-rU3$)QT|)j_2rBno91$StTHJLSF5lW7r{R@kbrQbnI{?0-Of`An|uDg{#6z z5g@Kycw7Jhast-7dspb#)oVe>QSo!|mB)#4M zr$K*ect)cilD~y#^(4kU@p=S4M$)Mj*litgCJe)lj{_AJG2&InBu;`}gOexhcEWlX z_X0mQhwTs$9YVg^?T(?2$^sx?ouY%0uMo;FtaRD!P6#Men4ShEoVH2Qs1xOO*&ip29If0TI?D?` z==>zGnhEXTUi<2y0C1?q7>gyR^m3=uSxM4Yv9EDD#8r^vHH->SY8Av|05@g zcdRXUmw?(=Ryp1DM4dA9vE4Pzg(zb}KiE_HLK7XXt<&LhJLD`PKf`m{6)94;o@r{M zTA80B^|2rN-|JDN?+p#wgnvORFS-wXk+V}?kzSJT=5MmviQx-@s-PXMq;u9Ka5Z6A zFI;g}U46wq7*>-d4hO*eeK5uzo~I92H(E}-WI``>mVPqth$ijp$cs{IhocRxDKD7w z)eY;fK4?TidDk4!CIaT8P4B4j!WF39&kH-})E}^R&Z^%aYIQnM=QwCLAg;ye!Zr~B zv6A03&R+|W5jkMS^i}Ae`dX)|z}Q*;$Q(x-#454+fpB@TopK`MinAE}@48b4X5NzW zRnAotLG$_2p{5?(3c9<>d*jc+7dLQ&Q-WW^r({#Ij46) zYwfJw&Hk1*@_Y%7Io^C(YOk#z#su@Vhp3(EtWjV-+Mqoe17ABHmF;MJdpRQZIw#^R z0T0#D(`Du5&hm+nx%o;o=`63&!aV)>`G@pFa{AEN3jfHA1l7fU= z?<||F)8w3Xgsjp>YzI($`j@D=M=@(_6eE%J{8=9R@Ys+y_74Ns_shVQHQpmR&lN`} zY$ZNYtHNVj=CrC+*4-GP`Mx$$cj{wB!cM9a4_8mWKE(hvx%1Dz><^*w0%M@VGn88o zSSSte*|u}rZGFHmdXk=#tS4Cq?*LTSfTy117e&?@_+oPV?mIp^4?xlcgCqfY;K_cw zXaN?vjvV3uDz57_??+3e0Z!l%&^}aI3jekQgYR{N^28(`JxJio zB#&o?Q6%<+HtC44)qfQiu6aGx{|QR21Wv;r@!D;2po|36@g_9bh6>8 zC3ox$VH@aQh(IR*Gt^PIP)A(t@ZOxFBnSnJ4(u=H4`i%dDO)6Wq>Q8TtVPf2DH0gv zA4iJAVZS;YW9*xo z_=MtV{@UnXNR|L$1BEXLT^I*yaSy?5B1~3*=OB+6n4rc-4cqK#i{Zu)PZs{{0jY?L{_M*)*%Re&Tu!;kO=Y!(>R_i=9 zBC<~wO>LMpsOF2*0~$~BEF}!zZpE2vP*k8Bpx6(~4Pc(-5ak8xGi?qTG94;T{K!mF zvVxL4C8LxSC^<-pNy)X8a5Mx#{B9_dLqLN$Yz8U+)0Bl59R{~rO&Jzt1lhZ0Q2-)` zDFT!>`*Rio2ob&_X8{8QZj4NP1Uz!!gZU^`K+_xUm^_>}2PCMlpK`*WjRCM4n_)`x zOOzL3oR~pjnhR_yy8%%gDOjni> zDM*0fS}}S!Ps5p&!8B~}4-9Af^Th&OG8y9DCb*d5ss%U50h=OCv6~r+B}vO@4?b<7 zm=8qTq1Et2P(mWfcGbMAni5nFFc)MvBCXkj5=}lvmFpN~SF`LoTumrdI_d?@;HHEq zUZ$?n+;O|+pBq)&vkI6~3h?9_N^JbnFlbWAoT%ENb>X}N|1z(ECkN|zau66rP>Tb( zAT*ky#Hc)B)Py_}nn5Kx@e3o0ERMXmx>SwfoRDWctFHHu5E;f7$5rD!3Ez8`Aoh%K zZa=O)s~zl9tMw-8^@ds^8O9pCb1Bz>TC`XTwN1W@TCAyE-rJ~cVYLhIBh02&hDtQQ zk6K)NTg=ze1n?ZfdTRF?=sN-we}FM>ik>4$O&t9;{H!k^L7bXW#Ox$*R#7!O$r(#Q zisWIn5sx!SzSOl2a!N5Wg_2h(A*KKbP{+h@Ln1ra56ALs@T&!=8zPc3#ALohj5&da6do=5!h~|gRP&FJ z*QApWx#{?EPe~(?Jwk6fAiXpSEhE2zJg?|1gErQ$fI>m@G`gvsl;@h-KQxR=7TYEoWPOR1IhmJ&B~6f1^EB1Dta zz5`nQd1@QCas?0`_Ip!Ill5`B;(LUgA(YhYMNc)`z`b5UIq+82YoaKq{rKiwckLZ1 zqxdjhTSLs7Ma1-r4@{ptRz3Lyq0g4@XPrf)+c^h#N zNh(Fbgb1wga>$eE!?&-1Y}erPUJ0ZU9115g4>%JK%bq_#F8dkbLWKwUaHH(3FW@c$ z^MfyM7&@L8xFA8?AJA7Jz*`AO{z1IJVD2EV!>ai{?v}bY^cQj)SmE3t!&cYHuvORC zb;q7QeD=^t*4{rVtO2U6_GjQEiXW37jcy5_g_Nd3ET@#2>?q>5utZ3(6pEB}lZ}W7 zVTb_WK~)6F;Q<1G3kzTzKBx#enh4W9ZvqC##$mwe0Gn3OlQ5`sJSU$2R0uk%L5|AnleS!R)gZ9Kfp}y%yC65qL9S9I-!q7*+%a{Bq37_TnPcH+}AVQ>P~` zzWZ!a-b%{yFm=9#y9jKch|-w}jD259=9z18W9Dy=)0+yL#F`j*=h-gx44z>T+~8PX zsYj67fe>(m1d{o$=^jvn*t0yh0)@B7A^zVA|+o~15?ht;OMo+LDrQHu^5hk1(i+*W8g$lc33Qg(@+}>OagXt zVnYkdtuQtg8nu8P3C};;WNx%jh$Bk3R2I?E?jBlf1J(vOhUG}7bQy$*9wSdI_02DY zJdVL(TaNP#!&ur&DfF^20^ST;SdQO^z-z%ro?#0y!#NmM-;v9BXob)C zv(>jQ)X@q*sDa5>D@+0XNmdPWf;@dEPF?!eIT)MM@4PmB?i+G_#>Ml%L!Ov=W1LAJ z;S#j|!X7JR*+$2V+lRN$ki3_8#2s|@43Z|-%?WLm$jP?+SW4=X6vygP7n@Lu1jLT(AN*RlG zO=H?(^7*X%dfDy8Yf#xN)7&5IE_sjnBYNeJDcOePZ>6D6zTaj;|FWK3mo)z^id@!u zl5+-$_&FIHEHf}f9VCK>Xk7=mxEGact@kpUy{!KBW$oVNfWXKrM;AL`}k;hd1>Cflht z-3iKdZ>$TGbqcdost#@DzoR->a{PNbBNop@BGn0|Rd&^WpX!OQ2{$lmX3eLl;6s!g zr-bc$a_7$a#BOWTN4-Q6rx(Q(1koTo1|fM}I8w|!88VcT3PMV4CzN_pL+HE*WmcnP zO~LQ3n;Kn^RteSo32H1QeA0?o0Tx^R=C-~jp+&+jfgh_Rf3C}jd!Yi)SIsZ8-%kSr zCe;Mq+tbVguq;Wl;gell^JZYZ41^GbmoVxqmzK%(HZfeK5+X(m5d&5YFWCF+wGAVd z15x6Lt1(1yG438i^nN8u{@KFAB1|i43Qq`HbrThcK`(qmL^C@(-htiF@C;v zF@zlF#*zEJ_w=6#11oRnd3YBKe<2cx50%&Lxc)g^^Ih^Rs%9MR=vb^&TEznLEh8p} zp6uj%YjLmBe@`qt!|^-^_uFyN1tGl1Cn(zB={*WTfnZjsVsX)JC$N@B6^mK$E~%?x zMmcaF&@9165)>0!X$jN@2t0_kN1-^-YN4pOirP^42F5Q`>P8PJZz<=!A(lb7hoL-l zLwTV0{)wkPEGvgS^&u>lAEN$U6v*ReF`B6F=W;v|>mLzUql9J#p%g~2_8??0fKOPn zy6BCx4!5@Qp&W8T$iJETBvyF+xwfX55?z#|c&3HcN!)v;9K+fK@*|Ut(NaN-6DbAx zqxQm~uF4|z7Ha1A$=B>eS=nfn{$%qFu74$$gYTKuja5#Z)s6ZX%4mA18&q>E*Swma zgC7z~^L3h?M<6S^4}Ybr~yT6it`*CPGYcyfuSn1su1;$sf2@alnL z(l((NR`RN^1mcMs^Wr9sdoaX0MCM;rSxQk}P6B0jfpQ~G*i%f@p=IUvrddLYiEbU5 zHBXkaV&csg^rp*c7welSOUG)RUxBhH9xk<^NL&egU{iAX;qO6RsJ`RxW`w7hPIad7slq(AvKk_)sfziXZ zXL8=Z+wQn!=e9k!ZCld_KbG;5J;{x!oH2`M<)=X#m zVG7G&ZaTlx10RUNd$L-Bv3Km=x@~vz*1IX-b}PD_+_~ekJNlB>Z`{a|sn^vY;qJ#b zkV0r9ow3|v{q8wjx*^XUWgerOU#G0Z?6G4{fg7)9%eeArqgR*XtL|R6YGmCikz95A zrd6MH0sFz);vT=$V*V9X-Dn24fL`8sr};nW@~4#ijFO)tsTqA(UTSAYtnE@aBc019 zh5rLx{uw3nYO56N%i1cbSgfrsnXRpoPhwK>Yp42b#AZH)>_4Ky&(syNYa6ng<>`DX zXpwY>y3IR%{5#dxAGvtGv9v^Lpa4N;9(xzdwWSvNpYV+NpOLV|JoRJ+&be6yHzj9w zQK|oeWR50E1HhW-N}NCwU0TybVPgU*7*Y!W^XBTL#%!gE)P5M@9G9*ZXQ?i%o!(s^ zj1^ZNjGBIG{#Vpz{y8Q8jgl%7z~XGt2PHx>+o3@Ep69B;ng!`vU{#O6JfHEug)U7> zSWRU8kq`i>ST>Z%*C~(4LTcWd>5TL(87G*cGlm{XVKk>GA-Q=02H#gBG(IjCax8Y|w5Dri$Z)yrD=LXdSJ0 zheAoAf_jrexwT19vf&8}Ubpf#mVhE8CdjH42L%Ho3qpC*MFh$vFfbAIluI4UI7w-o z5V1-G%H>l6=n3+mJQSW6an5^1&|VG*phMnyk>KasS-GTKD2jzY_MZMzAZ$@C3w5z@ zQFKDNl-CGwEBp;z^IZgzLHSCc9bHf$Tf`z(E@ONTL14JogL~cndr(Ec>%J=x$ zix(c2Xu_qhyfJn3en|HI-@RnP{|H}c=5dUA-)wnG-*1*!H~$Ca)kV4#uXxrkWB(UjlAtyJ8VQ&?p{{9z zrYs{HsrY;>*yq?~{`yB$0h{Zu(b*PCnETclF93OFZVeOoB`P$Z3B0hG;blbDhVycW z*xpTehD_la(~H)bUMIXd8aCLNkL?-1j3&UMet~C8Js-@XHqeT^bu}Gl4#Ohx!wd^Z zqCzpvr?GRA?QPXj2FNZxXe$`i+DeR!0Q=g+m2FbScN89&j3!o6Dkqx!7x^t z{G!e_bTBN~+IWKEjaAWBXB&vHX12jcW*g+~N)$;tvI;AChoo2734d|)jI>#gSGeHa=Abe=ut-&3i3DWT~qr%|-Aa8phco;MB6gE7A?RD8~q z;hKJlTePEtRhW0qES)uHng-<&nmVLaC?RtCu7PY%Xe(K6(@qQtEbpXHeiQhMQd;#P z6NGopnY#j#lr|kd>kN|P8h~qJjM6ahU}PQZ(N8qtyDJsyXDcoGpm<4{mJYP4DC=lw#T77h<;Q zSx45VPM(-~^tA!Jp#DcNFpbUv{H*7Z$atvIE}&)<5!J)!fJSQ}n$#SX)f~djFi(AJ zk8kz&_)fy!fUpBIiPp|GVqC2uihhEs6r|M=;2Q?vYwQXNU~7~LIYe-eRz5t6dtsf)_3+>1G(H~EgA&}Ygi@JJ-C#$>>*!IBeV=VW9=Wce?T3?53vNLH6PZA z+C!ywT3Wk-JGo9qL6)$4)4G9vgsQn(el(?(T5qF^b+;ij${ZaowcoYw76gn9ue-H4 zIGDvAaQhIY5gtJ(B{>P)(0*)2LrbTrCAB|lRvbSblwHJqepb3~Tp7aPU`rRZ45neL zL-1&l{?3CGl!HWJ?6!XTX0Ql@7FY95Y?wff3gSjk3D^akPSE~U>x(E697m`MdH?22 zCfh%mXy_plLt{^Q0BMLm$lcgI2n#DQ5wG~h?>D{i#~=8{DgPVuY1Db^e7%6q51YKv z4=le~d&PRC2Xl+RW-t6P+&j~W0mjn$Z{T2J2$b!nj?@J3tdv?eB@bk?1;jcW%7U!I zQZzMai=H(XBB3?XBcq41W*6n?NI-)`##pOv**ITD`3>`xr&|b-bQD1QZ-@kMKmi3R z8hOsURl^`vO$K4D{Xb-RCRllsIX!0h62zgHAxhw?l{^C6C`jjxu5d4AtD|z}e~bD=a0;yO1wr&AhMp1c2>*RB6a+8X zsKwiBIc5U&eyC)XtI@BlbCNPqnrJeSYb$={n8-uMJO*+Tfe>*qlFa@YGL$Kn);wf~ z$W$gt0R1oQ;r3xn!H9^;H329A35)ZZ4jG{pLZ0D?r(xof1}SUc5CYzLY<|NtUfh9h zNw@UWtN)xfUEz3rAYhkXJyCu4K`3-}*coc02UKqG;-Qn(=Z?e6EuV+-SSo(BNLk+| zF!O{-`$d*NZhA*=a*fZad0j0iJ0(pvMo72wiq~0o8wE81wfoN3JpViEg+E5e8&T9O z3Hzk7*fOu|`yQ2dC@E9I3S^Sb>KfxqbBwI_=>A7BvLx}5^WUO6DZ-`ZJtS$k5)@AV zos0(|-lYQ+?FP4Er9|JhE0gT^QB|6fQp!FB|pFONzFh#YL{ za7;ynRDd^=I8ScbW2$)`$Xt-9^AvOniiNU%$j`>{><=9{df9+MK1XGRX!$RkkMatO zcd=ar%yV|Z$KYzkW)G+jXe2gXtJjHAp?aw;P8g-Oz`-2iQdl}n3xwqr;;h`B$_ExRJ~Kz6__Qzg)Dk+-Y;-Lsv^3kC##>5s9^2>T%M^jn;hy`d`C*B&|ua zHu<$CEK9wHa9wC*3G{mr+T86ZU5Z$I%Ahgg@4uv3I6`Bjcl{o?3&cE}`6L1(4gv?f za(?VJabJS5R~&uV>o84b-jP{OX}R|S*{5$mRef;$;ydpFex?04Yaz7Bnd7IbuRViZ zf8m3zPP|YZe_F0E+JJR#(sQ%{d#=ed*re5me|H8D%e#+Mc{{Vx4$rjn`&WN8X5}%Z zW9Y&5Vh2+29NGN(N+-#A{towY>oL(`t6)s zJIoU(HN!UWB+g19_PnpMN-gzbxM=GyU_YgSe%e=g1LCwx?Tz(vnN=3=yP=yAywU8U z1WUXXUgzfDrlSs1*WH(tbNU>JSL!t@=9M-tqFKI0Laf)YhmIX~e?)iRr-a8RMrVIO z$$m;&C|NiY=5Ia9p6g2t~WgEuX%IYx4<8-lAkD5(J)S51PMEmmi~KKEW`Ti#O|%J9Nb` zoWr@j>v=hc_rV4cws*h`(Ypv%lX@^|0+JY*Kw5F>MnTiGRXsusCEby`(M-@S?CF&s z%1MtwOD>?C{|lxe#^?Y5 literal 0 HcmV?d00001 diff --git a/blueprints/__pycache__/image.cpython-311.pyc b/blueprints/__pycache__/image.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..510cc6b6c8c316f4dee8a679e4adf03de300bdb4 GIT binary patch literal 20393 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 e1LN?B3JXzK3jiECB_wt$lAR*|~k!_8w>g z+1=5BOtTg4iMj~Jt=$iI^{iNFBkgX|GwQJqr?(WtsT>5*)ekd0b^)c8xWS7ML5Gwl zm0tWgnHP6~p9<)pfIEp^$-h{UxF@7~ZGoQ%|jDqWJCoW^8JK^{KyPD zK_b2^!U@Eg(FBMU&;f3wS)9bsG4b#7Wj3a4UEomQ(3LvI^Z;`4v|f^5qJm!5Sj8EU zMaxhCmbHKu9Vuy=1G#r1WIg`u^s|g5TIE3_i_y&rS*espMsCcZpVx+o)A}h8vRP3Uk1pvt=`+XEcJgrS7W}~m8590b* z0;tEPkhtJM1oZ(5uA<;Q2s$KT;vtbZ4Gg#)9{M-} zIf3$O4-GkJIQIq44}xAY@ArwH;P(|q54ojw{2qa$W(hbgvFAwdhuHJ@m7v&;ObB`w zfHKeo$OINo)WqnG{-;h_PYzBG-^f`$o3lK05YA2I)N(nsthtUe*Ri^_oNn!8+nmV~ zXgNm&TP_iowqESKQC>e=UO)3Vn6b*+x$<`DfDoIvmCM`8nznJKZIj#Q%=yz*H_T70XB0Bm$_wf2cKaMJal9zXk!i5$&N*tO#yDk*+&jf z9R_~hka_I!qmLt14m#Xb73}BpEB!m>3az2-Twx7Uu-f0r8}k=2nPCka(qfA1SyMfn zjWHG8Fj;3!*3b^tw3;)mW=yMjz46%2qdURQm$`8=nQ;acTyUn~HmMa;$EGt`DJP!RvNR1Dd$t4F_Sf<6V5D&v?G;p*I0{C4Eede*wqn&(CZcsiw$an6#KK!R{rno<759!a2 z-Y8x_TfCmxu$3*|#uaa4;I{Yk#U&_>DPB8c=1Z$W1>uLn&vMmU-Z!(QZCq&^zpNs- zDr66}aC@6X4M1>aK+C z7zjR&FUn-N92O@8N(|RdYS15#=_bWL9uwcumsrFwDgN=8aZ>zCh^%0+CGMNpPUf53 zJeJKQ-#4*pW~rOUDwyQ^rY_6BDex#9^wU*xy2?rQqB0wYUss6*Yu4d#dMy@=;aND$ z<5*CG$+SNxe!e(h3@;DoO%}6w9f#NP03++cabz|ZADo|O!nAa%gMPWkT^^m$K7n91P6-E#fGp)v9DMFBtMMO~^O%PMXiS&N~`cm38 literal 0 HcmV?d00001 diff --git a/blueprints/__pycache__/image.cpython-39.pyc b/blueprints/__pycache__/image.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1f9361d30a14c45601025db40b4311b3546b7ff2 GIT binary patch literal 12197 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 literal 0 HcmV?d00001 diff --git a/blueprints/__pycache__/main.cpython-311.pyc b/blueprints/__pycache__/main.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ebd595bafd78f545a4016997241e3fb0ec3fab90 GIT binary patch literal 4528 zcmcIneQXrR6`$GN`#yUywy_BiuBOI5bKEtiDGg1KjAOpBD{KV57?$(xVxMz+cimmb zj$@RAB4Ma2Qv$IIMRFrP67iuZ3IUZS1x1zmPo-P55!OnUDq%zXS1+QGQ2y$hJ>U8E zYzw7Q=WgG!&( zp>=_;vPFHl=J|5Jz*qUAzKZ7gDt>{lWsCY^&A#|0g`R>Hi`tg(OS|xmQgbf&vUwgV zd8!q8%X|01qC2PV-kbUJ?U_p-efz5E_e`>z*fu6_uT$H`;eaZ!LDkUl+ia{A7d zsW1ODJ@P4$d~odPso{*$%%wj*NgjLh;mN6cU%=4rcvsvxL$cZIrF6%ZXs?ivA~8jG z$U= z+-pUP+RQ%b^#zJ~6QZWRg(~ty-geSQPDFX5d zdIl7I?+5bcrjDoAj!pmm{M27APu&~q0AKx)P^^n<*wN9MO{+}AF@NG+-4cOB_DdCD zSq_if3?zxBZN(?vJM)@qTcz1nr4hFHzp47ATD3{5+GO-5*@{cHahF=@(<*%`yIy10 zr|jz|U8U!@jqO&;yjq!8b=7IEx)f6<5x)bL0GW>|ZDd)Ev{44mIZTN&C*&v^MB}+s zf?cke^Z)pXPtzM@@@}OJ8y^>7OMd%m8y^4_8U-lz{67G)21lU{}H;`=Nr9C~dV{ zI6TRgpXwj(A7UnoN=Du~{nn|2!w1uda{Od0JmF?XcAegps@(n0zSRE1T1zO^99G@D z=H^pweqw3)sPC-r5B_uhp~kcYEDSS)d`BGohmbkhLfrG`&leJ>t;kU{;ymp<G^~Wq*X}^$X8P+lFwg;OAR>mk z%!oshL!M_IAm)Rj@OS`7rkV$w209vb^$E@tLK&DEkd{d?)z>N2f~XFjXQUL9=zA-2 zSB|+=SGDGvR85_Gd|?lfH(Vi(aR-sUyMJ|`M1 zfKW3i9mR|IT@Xz3{TBG4evF^Ng8RZzdXOF`YcsD67TgJ>)r-6*2afqJ1`BQmGR0%K zN902}%~LmMGt`qCL+`J^&y$feQ(s;5Wb*2Hdhyoum*=NPPEX%Fli{cC{_g386ZyBj zZ*To=X7twM zz9Vp%X-Tia*e~Fb&jK+v*pj8geUI4H582gMsLQr%?vLCzgLf-c&lb(IMP(Z`wlTSV zvZVA}#pvp@tFOGImiV+1UvlRpTQb}?^8V@f$NE*aR%2_E+b3M5k6bT5biF(_kh!uD zz^b@i^?A)5|7ZUDm1_M?t$wE=oM4v?^#QP*Iq>nmlxu_P+Mu~Mq?iqv&E*KdH7)M% zNp$J-wx%{%P@5VdhKF-Xa~xAf%r@fU6%z%J09`yaP(xik;hvjGCG z5o`?fB!n)A(=J9J(svUATro)+Byx|G0))Imh>MUiLI{dvaIcvB6(IgN!tdYmjS8EkCNLvtDNg}~a|+`$MPUYx zQy^A^ok<7zOrW)?g}!OVj;S>Ie~_gJuTLT0V&8u`ONYE?wvKIAozDlXMr-)shASp8o2DF?9PNY>uVHO6u)<7c6N5Mc^LCBDrKQ6T`P$Sg<`GvidC>FBoT2ChS|N7&7?as+dFqP zE}LQ+L2Mf$SZ%8fWJ@3Tp;8L1Qmcjj8TYG+F`wEm{nAf8=dRJUk6HHYxo6J%{?19f z_I8`VGy2=zV3$S6BRsS|1{@B;H~9kyBMxDdX=UnA_|?l=s5^RSI0i+zQBH-XV}@xb z9a@eRW}HlDJ9gOSw1rtGt8`Le)9$o~9ZpBs>2xZYS?&rqI2*!lr<)RAXK8=qoaXfS zJxjgJYEYJ8_9Ze$ojxULYfwMKvaB6tAnjMu4khhmT~DQ(lyrlVcC(F7r2|UZ13r6M zpYplc@0sdl{cKZ-vVnPxZDw1Pd<)aYNPcVe6qIc*-@Cuo_;GFV%O}?sS8hH0{g<0- z-`oJnql>eXap=PjNLR01Ub*}A@`Eo{7QRQxwb|7xA2*fO7C(P{arW_z%ggtFf>$Tw zQf#k*V=|K0WaeQ{IW37JX!h`AF%+0Un?S@MO;3Nq_*kow%66k%ERxk2J4ev$-n z_9pYzHAlO5%_6hxr!$y0kzU42nXg ztGw(^#9XGIx`*7Xf|vL%ypZX0KF65S2)!Wsiw+er|JFx`!x8uDHP|mk(#aWqndG>HdB3u$7TvDx^}*>3oH}#Lv+3!D8wpo zFJeU$wLbqJOX;gvd>dG_l&E5=NVZaPD^SH=&{>bT1Nd71P$E1L6o>X#JTbWsw+vqV zfg){*k5_}EpvoNwMvy7Mw4yM=biuImk& z9A`N6Rvo5->GQZ&jp`fV`ticm<%hR&&8%{(x9+SwxW2OR;mUVcoBZ;77RxKger*6L<(df!vSfsciQEyh3=z$)U0)ffJ{X4&{V}QfnO^O!1INQ55tMoaa_?nkK|P(_%A?970>b1fq#S0 zsjK{{6cmaz{u;z)y7VXluWqPzO%?92!EvnIMR#9V}+I9#18wP1=!T', 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/', 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//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)}) diff --git a/blueprints/auth.py b/blueprints/auth.py new file mode 100644 index 0000000..7b003e0 --- /dev/null +++ b/blueprints/auth.py @@ -0,0 +1,107 @@ +""" +认证蓝图:登录、登出、登录状态校验 +""" +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')) diff --git a/blueprints/brand.py b/blueprints/brand.py new file mode 100644 index 0000000..01924dc --- /dev/null +++ b/blueprints/brand.py @@ -0,0 +1,855 @@ +""" +品牌爬虫蓝图:展开文件夹、运行任务、任务列表/详情、下载结果 +""" +import os +import json +import threading +import datetime +import traceback +import zipfile +import io +import time +import tempfile +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 +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() + + +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) + + +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/{int(time.time() * 1000)}/{user_id}_{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_files(file_paths, task_id=None, check_cancelled=None, strategy="Terms"): + """对多个 xlsx 执行 single_file_handle(线程池多线程),返回 (result_paths, error_message)。 + check_cancelled: 可调用对象,返回 True 时中止并返回 (result_paths, 'cancelled')。 + task_id 存在时会在每处理完一个文件后更新 progress_current。 + strategy: 品牌匹配方式,默认 Terms,可选 Simple。""" + os.makedirs(BRAND_OUTPUT_DIR, exist_ok=True) + subdir = str(task_id) if task_id else ('immediate_' + datetime.datetime.now().strftime('%Y%m%d_%H%M%S')) + out_dir = os.path.join(BRAND_OUTPUT_DIR, subdir) + os.makedirs(out_dir, exist_ok=True) + + # 先筛出有效路径并生成 (fp, out_path) 列表 + tasks = [] + for fp in file_paths: + if not fp or not isinstance(fp, str) or not os.path.isfile(fp): + continue + base = os.path.splitext(os.path.basename(fp))[0] + safe_base = "".join(c if c.isalnum() or c in '-_' else '_' for c in base) + out_path = os.path.join(out_dir, safe_base + '_result.xlsx') + tasks.append((fp, out_path)) + + if not tasks: + return [], None + + result_paths = [] + result_lock = threading.Lock() + current = [0] # 用列表以便在闭包中修改 + + def process_one(fp, out_path, file_index, files_total): + # 行级进度回调:由 single_file_handle 在循环中调用,直接写入内存字典,不落库 + def progress_callback(current_line, total_lines, extra=None): + if not task_id: + return + info = { + 'file_index': file_index, + 'file_total': files_total, + 'file_path': fp, + 'current_line': int(current_line or 0), + 'total_lines': int(total_lines or 0), + } + if isinstance(extra, dict): + info.update(extra) + with _task_line_progress_lock: + _task_line_progress[task_id] = info + + single_file_handle(fp, out_path, strategy, check_cancelled=check_cancelled, progress_callback=progress_callback) + return out_path + + max_workers = min(8, len(tasks)) + with ThreadPoolExecutor(max_workers=max_workers) as executor: + future_to_out = { + executor.submit(process_one, fp, out_path, idx + 1, len(tasks)): out_path + for idx, (fp, out_path) in enumerate(tasks) + } + try: + for future in as_completed(future_to_out): + if check_cancelled and check_cancelled(): + for f in future_to_out: + f.cancel() + return result_paths, 'cancelled' + try: + out_path = future.result() + with result_lock: + result_paths.append(out_path) + current[0] += 1 + if task_id: + try: + conn = get_db() + with conn.cursor() as cur: + cur.execute( + "UPDATE brand_crawl_tasks SET progress_current = %s WHERE id = %s", + (current[0], task_id) + ) + conn.commit() + conn.close() + except Exception: + print(traceback.format_exc()) + except TaskCancelledError: + for f in future_to_out: + f.cancel() + return result_paths, 'cancelled' + except Exception as e: + print(traceback.format_exc()) + print(e) + for f in future_to_out: + f.cancel() + return result_paths, str(e) + except Exception as e: + print(traceback.format_exc()) + return result_paths, str(e) + return result_paths, None + + +def _upload_results_to_oss(source_paths, local_result_paths, task_id): + """ + 将源文件和结果文件上传到 OSS,并打包成 zip(分两个文件夹:源文件、结果文件)上传。 + 返回 (result_data, error_message),result_data 为 {"urls": [url1, ...], "zip_url": "..."},出错时为 (None, err)。 + """ + if not local_result_paths or not task_id: + return None, "无结果文件" + try: + from ali_oss import upload_file as oss_upload_file + except ImportError: + return None, "OSS 模块未配置" + urls = [] + subdir = f"{OSS_PREFIX}/{task_id}" + for fp in local_result_paths: + if not fp or not os.path.isfile(fp): + continue + name = os.path.basename(fp) + key = f"{bucket_path}{subdir}/{name}" + try: + with open(fp, "rb") as f: + content = f.read() + url = oss_upload_file(content, key) + urls.append(url) + except Exception as e: + return None, f"上传结果文件失败: {e}" + if not urls: + return None, "没有可上传的结果文件" + # 打包成 zip:源文件 -> 源文件/,结果文件 -> 结果文件/ + buf = io.BytesIO() + with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf: + for fp in (source_paths or []): + if fp and os.path.isfile(fp): + zf.write(fp, os.path.join("源文件", os.path.basename(fp))) + for fp in local_result_paths: + if fp and os.path.isfile(fp): + zf.write(fp, os.path.join("结果文件", os.path.basename(fp))) + buf.seek(0) + zip_key = f"{bucket_path}{subdir}/result.zip" + try: + zip_url = oss_upload_file(buf.getvalue(), zip_key) + except Exception as e: + return {"urls": urls, "zip_url": None}, None # 单文件链接已保存,zip 失败不报错 + return {"urls": urls, "zip_url": zip_url}, None + + +def _background_brand_task(task_id): + """后台执行单个品牌爬虫任务并更新数据库""" + try: + conn = get_db() + with conn.cursor() as cur: + cur.execute( + "SELECT id, user_id, file_paths, strategy, `desc` FROM brand_crawl_tasks WHERE id = %s AND status = 'pending'", + (task_id,) + ) + row = cur.fetchone() + conn.close() + if not row: + return + file_paths = row.get('file_paths') + if isinstance(file_paths, str): + file_paths = json.loads(file_paths) if file_paths else [] + # 优先使用表里存的 strategy 字段,兼容旧数据则从 desc 解析 + strategy = (row.get('strategy') or '').strip() or None + if not strategy: + desc_val = (row.get('desc') or '').strip() + strategy = "Simple" if desc_val.startswith('[Simple]') else "Terms" + if strategy not in ('Terms', 'Simple'): + strategy = 'Terms' + if not file_paths: + try: + conn = get_db() + with conn.cursor() as cur: + cur.execute( + "UPDATE brand_crawl_tasks SET status = 'failed', error_message = %s WHERE id = %s", + ('没有有效文件路径', task_id) + ) + conn.commit() + conn.close() + except Exception: + pass + _push_task_event(task_id, {'status': 'failed', 'error_message': '没有有效文件路径'}) + return + # 将 file_paths 解析为本地路径:URL 下载到 BRAND_OUTPUT_DIR 对应任务文件夹下(兼容旧数据中的本地路径) + os.makedirs(BRAND_OUTPUT_DIR, exist_ok=True) + task_subdir = str(task_id) if task_id else ('immediate_' + datetime.datetime.now().strftime('%Y%m%d_%H%M%S')) + task_dir = os.path.join(BRAND_OUTPUT_DIR, task_subdir) + os.makedirs(task_dir, exist_ok=True) + + local_paths = [] + downloaded_files_to_cleanup_on_fail = [] + for idx, p in enumerate(file_paths): + if not p or not isinstance(p, str): + continue + p = p.strip() + if _is_url(p): + try: + parsed = urlparse(p) + url_name = os.path.basename(parsed.path or '') + if not url_name: + url_name = f"input_{idx + 1}.xlsx" + safe_name = "".join(c if c.isalnum() or c in '-_.' else '_' for c in url_name) + if not safe_name.lower().endswith('.xlsx'): + safe_name = safe_name + '.xlsx' + + base_no_ext, ext = os.path.splitext(safe_name) + dest = os.path.join(task_dir, safe_name) + n = 1 + while os.path.exists(dest): + dest = os.path.join(task_dir, f"{base_no_ext}_{n}{ext}") + n += 1 + + r = requests.get(p, timeout=120, stream=True) + r.raise_for_status() + with open(dest, "wb") as f: + for chunk in r.iter_content(chunk_size=1024 * 1024): + if chunk: + f.write(chunk) + local_paths.append(dest) + downloaded_files_to_cleanup_on_fail.append(dest) + except Exception as e: + for tf in downloaded_files_to_cleanup_on_fail: + try: + os.unlink(tf) + except Exception: + pass + try: + conn = get_db() + with conn.cursor() as cur: + cur.execute( + "UPDATE brand_crawl_tasks SET status = 'failed', error_message = %s WHERE id = %s", + (f'下载文件失败: {str(e)}', task_id) + ) + conn.commit() + conn.close() + except Exception: + pass + _push_task_event(task_id, {'status': 'failed', 'error_message': f'下载文件失败: {str(e)}'}) + return + elif os.path.isfile(p): + local_paths.append(p) + if not local_paths: + try: + conn = get_db() + with conn.cursor() as cur: + cur.execute( + "UPDATE brand_crawl_tasks SET status = 'failed', error_message = %s WHERE id = %s", + ('没有有效的本地或可下载文件', task_id) + ) + conn.commit() + conn.close() + except Exception: + pass + _push_task_event(task_id, {'status': 'failed', 'error_message': '没有有效的本地或可下载文件'}) + return + try: + # 原子地将 pending 改为 running,避免用户先点取消时仍被覆盖为 running + try: + conn = get_db() + with conn.cursor() as cur: + cur.execute( + "UPDATE brand_crawl_tasks SET status = 'running', progress_total = %s, progress_current = 0 WHERE id = %s AND status = 'pending'", + (len(local_paths), task_id) + ) + n = cur.rowcount + conn.commit() + conn.close() + if n == 0: + conn = get_db() + with conn.cursor() as cur: + cur.execute("SELECT status FROM brand_crawl_tasks WHERE id = %s", (task_id,)) + r = cur.fetchone() + conn.close() + if r and (r.get('status') or '') == 'cancelled': + _push_task_event(task_id, {'status': 'cancelled'}) + return + except Exception: + pass + + def check_cancelled(): + try: + conn = get_db() + with conn.cursor() as cur: + cur.execute("SELECT status FROM brand_crawl_tasks WHERE id = %s", (task_id,)) + row = cur.fetchone() + conn.close() + return row and (row.get('status') or '') == 'cancelled' + except Exception: + return False + + result_paths, err = _run_brand_files(local_paths, task_id=task_id, check_cancelled=check_cancelled, strategy=strategy) + if err: + try: + conn = get_db() + with conn.cursor() as cur: + st = 'cancelled' if err == 'cancelled' else 'failed' + cur.execute( + "UPDATE brand_crawl_tasks SET status = %s, error_message = %s WHERE id = %s", + (st, err if st == 'failed' else None, task_id) + ) + conn.commit() + conn.close() + except Exception as e: + traceback.print_exc() + print(e) + pass + _push_task_event(task_id, {'status': st, 'error_message': err if st == 'failed' else None}) + return + result_data, upload_err = _upload_results_to_oss(local_paths, result_paths, task_id) + if upload_err: + try: + conn = get_db() + with conn.cursor() as cur: + cur.execute( + "UPDATE brand_crawl_tasks SET status = 'failed', error_message = %s WHERE id = %s", + (upload_err, task_id) + ) + conn.commit() + conn.close() + except Exception: + pass + _push_task_event(task_id, {'status': 'failed', 'error_message': upload_err}) + return + try: + conn = get_db() + with conn.cursor() as cur: + cur.execute( + "UPDATE brand_crawl_tasks SET status = 'success', result_paths = %s WHERE id = %s", + (json.dumps(result_data), task_id) + ) + conn.commit() + conn.close() + except Exception: + pass + _push_task_event(task_id, {'status': 'success'}) + finally: + pass + except Exception as e: + try: + conn = get_db() + with conn.cursor() as cur: + cur.execute( + "UPDATE brand_crawl_tasks SET status = 'failed', error_message = %s WHERE id = %s", + (str(e), task_id) + ) + conn.commit() + conn.close() + except Exception: + pass + _push_task_event(task_id, {'status': 'failed', 'error_message': str(e)}) + + +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: + 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 + + +@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 = session['user_id'] + 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 + urls.append(url) + desc_core = ', '.join(os.path.basename(p) for p in paths)[:500] if paths else '' + desc = f'[{strategy}] ' + (desc_core or '') + conn = get_db() + with conn.cursor() as cur: + cur.execute( + "INSERT INTO brand_crawl_tasks (user_id, file_paths, `desc`, strategy, status, task_type) VALUES (%s, %s, %s, %s, 'pending', %s)", + (user_id, json.dumps(urls), desc or None, strategy, task_type) + ) + task_id = cur.lastrowid + conn.commit() + conn.close() + threading.Thread(target=_background_brand_task, args=(task_id,), daemon=True).start() + return jsonify({'success': True, 'task_id': task_id}) + except Exception as e: + 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: + conn = get_db() + with conn.cursor() as cur: + cur.execute( + """SELECT id, file_paths, `desc`, strategy, status, result_paths, error_message, + COALESCE(progress_current, 0) AS progress_current, + COALESCE(progress_total, 0) AS progress_total, + created_at, updated_at + FROM brand_crawl_tasks WHERE user_id = %s ORDER BY id DESC LIMIT 100""", + (session['user_id'],) + ) + rows = cur.fetchall() + conn.close() + items = [] + for r in rows: + items.append({ + 'id': r['id'], + 'file_paths': _parse_json(r['file_paths'], []), + 'desc': (r.get('desc') or '').strip() or None, + 'strategy': (r.get('strategy') or 'Terms').strip() or 'Terms', + 'status': r.get('status') or 'pending', + 'result_paths': _parse_json(r['result_paths']), + 'error_message': (r.get('error_message') or '').strip() or None, + 'progress_current': int(r.get('progress_current') or 0), + 'progress_total': int(r.get('progress_total') or 0), + 'created_at': r['created_at'].strftime('%Y-%m-%d %H:%M') if r.get('created_at') else '', + 'updated_at': r['updated_at'].strftime('%Y-%m-%d %H:%M') if r.get('updated_at') else '', + }) + return jsonify({'success': True, 'items': items}) + except Exception as 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 = session['user_id'] + urls = [] + for p in paths: + if _is_url(p): + urls.append(p) + elif os.path.isfile(p): + url, err = _upload_local_xlsx_to_oss(p, user_id) + if err: + return jsonify({'success': False, 'error': f'上传文件失败: {os.path.basename(p)} - {err}'}), 500 + urls.append(url) + else: + return jsonify({'success': False, 'error': f'无效路径或链接: {p[:80]}'}), 400 + desc_core = ', '.join(os.path.basename(urlparse(u).path or u) for u in urls)[:500] if urls else '' + desc = f'[{strategy}] ' + (desc_core or '') + conn = get_db() + with conn.cursor() as cur: + cur.execute( + "INSERT INTO brand_crawl_tasks (user_id, file_paths, `desc`, strategy, status, task_type) VALUES (%s, %s, %s, %s, 'pending', %s)", + (user_id, json.dumps(urls), desc or None, strategy, task_type) + ) + task_id = cur.lastrowid + conn.commit() + conn.close() + # threading.Thread(target=_background_brand_task, args=(task_id,), daemon=True).start() + return jsonify({'success': True, 'task_id': task_id}) + except Exception as e: + return jsonify({'success': False, 'error': str(e)}), 500 + + +@brand_bp.route('/api/brand/tasks/') +@login_required +def api_brand_task_detail(task_id): + """获取单个任务详情(用于轮询状态)""" + try: + conn = get_db() + with conn.cursor() as cur: + cur.execute( + """SELECT id, file_paths, `desc`, strategy, status, result_paths, error_message, + COALESCE(progress_current, 0) AS progress_current, + COALESCE(progress_total, 0) AS progress_total, + created_at, updated_at + FROM brand_crawl_tasks WHERE id = %s AND user_id = %s""", + (task_id, session['user_id']) + ) + row = cur.fetchone() + conn.close() + if not row: + return jsonify({'success': False, 'error': '任务不存在'}), 404 + return jsonify({ + 'success': True, + 'task': { + 'id': row['id'], + 'file_paths': _parse_json(row['file_paths'], []), + 'desc': (row.get('desc') or '').strip() or None, + 'strategy': (row.get('strategy') or 'Terms').strip() or 'Terms', + 'status': row.get('status') or 'pending', + 'result_paths': _parse_json(row['result_paths']), + 'error_message': (row.get('error_message') or '').strip() or None, + 'progress_current': int(row.get('progress_current') or 0), + 'progress_total': int(row.get('progress_total') or 0), + 'created_at': row['created_at'].strftime('%Y-%m-%d %H:%M') if row.get('created_at') else '', + 'updated_at': row['updated_at'].strftime('%Y-%m-%d %H:%M') if row.get('updated_at') else '', + } + }) + except Exception as e: + return jsonify({'success': False, 'error': str(e)}), 500 + + +@brand_bp.route('/api/brand/tasks//line-progress') +@login_required +def api_brand_task_line_progress(task_id): + """ + 获取任务的“当前文件行级进度”(当前行数/总行数)。 + 该信息仅存放在内存字典 _task_line_progress 中,不写入数据库。 + """ + try: + with _task_line_progress_lock: + info = _task_line_progress.get(task_id) + if not info: + return jsonify({'success': True, 'has_progress': False}) + # 为了避免暴露完整路径,只返回文件名 + file_name = os.path.basename(info.get('file_path') or '') if info.get('file_path') else '' + resp = { + 'file_index': int(info.get('file_index') or 0), + 'file_total': int(info.get('file_total') or 0), + 'file_name': 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}) + except Exception as e: + return jsonify({'success': False, 'error': str(e)}), 500 + + +@brand_bp.route('/api/brand/tasks//events') +@login_required +def api_brand_task_events(task_id): + """SSE:任务完成时后端主动推送事件,前端监听后隐藏进度条与取消按钮""" + 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, session['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//cancel', methods=['POST']) +@login_required +def api_brand_task_cancel(task_id): + """取消正在执行或等待中的任务(pending/running 均可取消)""" + try: + conn = get_db() + with conn.cursor() as cur: + cur.execute( + "UPDATE brand_crawl_tasks SET status = 'cancelled' WHERE id = %s AND user_id = %s AND status IN ('pending', 'running')", + (task_id, session['user_id']) + ) + n = cur.rowcount + conn.commit() + conn.close() + if n == 0: + return jsonify({'success': False, 'error': '任务不存在或无法取消'}), 400 + _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/', methods=['DELETE']) +@login_required +def api_brand_task_delete(task_id): + """删除任务(仅限非 running 状态)""" + try: + conn = get_db() + with conn.cursor() as cur: + cur.execute( + "DELETE FROM brand_crawl_tasks WHERE id = %s AND user_id = %s AND status != 'running'", + (task_id, session['user_id']) + ) + n = cur.rowcount + conn.commit() + conn.close() + if n == 0: + 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/') +@login_required +def api_brand_download(task_id): + """下载任务结果:优先使用 OSS zip_url 重定向;否则本地/单链接/多链接按原逻辑处理""" + try: + 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, session['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 + + diff --git a/blueprints/image.py b/blueprints/image.py new file mode 100644 index 0000000..c454d54 --- /dev/null +++ b/blueprints/image.py @@ -0,0 +1,411 @@ +""" +图片生成蓝图:生成、历史、下载、拼接、版本 +""" +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)}) + + + + + diff --git a/blueprints/main.py b/blueprints/main.py new file mode 100644 index 0000000..c6ec5a2 --- /dev/null +++ b/blueprints/main.py @@ -0,0 +1,69 @@ +""" +主页面蓝图:首页、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, +) +from flask import redirect, url_for, session + +from config import base_url,version + +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/') +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('/logo.jpg', methods=['GET']) +def get_logo_image(): + return send_file(os.path.join(BASE_DIR, "logo.jpg"), mimetype='image/jpeg') diff --git a/brand_spider/__pycache__/main.cpython-39.pyc b/brand_spider/__pycache__/main.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f8e611a0a90d26f1bdf3839130f42ba21227a85e GIT binary patch literal 15429 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 literal 0 HcmV?d00001 diff --git a/brand_spider/__pycache__/web_dec.cpython-39.pyc b/brand_spider/__pycache__/web_dec.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..db0f7cdcdbe74591102c267d59ab5ce6efe3d8d6 GIT binary patch literal 4726 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 AWdHyG literal 0 HcmV?d00001 diff --git a/brand_spider/main.py b/brand_spider/main.py new file mode 100644 index 0000000..d6a7305 --- /dev/null +++ b/brand_spider/main.py @@ -0,0 +1,692 @@ +import json +import re +import random +import requests +import time +import datetime +import openpyxl +import unicodedata +from openpyxl import Workbook + +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"}' 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(file_path, output_path, strategy="Terms", check_cancelled=None, progress_callback=None): + 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 = ["已过期的","已结束"] + # 1. 读取 Excel 活动工作表 + wb = openpyxl.load_workbook(file_path, data_only=True) + active_sheet = wb.active + active_sheet_name = active_sheet.title + print(active_sheet_name) + + # 2. 将数据转换为列表嵌套字典 + rows = list(active_sheet.iter_rows(values_only=True)) + if rows: + columns = list(rows[0]) + data_rows = [] + for row in rows[1:]: + row_dict = {} + for idx, col in enumerate(columns): + row_dict[col] = row[idx] if idx < len(row) else None + data_rows.append(row_dict) + else: + columns = [] + data_rows = [] + + # 3. 确保必要列存在 + # required_cols = ["状态", "国家", "时间"] + # for col in required_cols: + # if col not in columns: + # columns.append(col) + # for row_dict in data_rows: + # row_dict[col] = "" + + # 4. 提取唯一品牌列表 + brand_ls = set() + for row in data_rows: + brand = row.get("品牌") + if brand: + brand_ls.add(brand) + + # 5. 初始化不符合品牌的数据列表 + faild_data = [] + # 初始化查询失败的品牌的数据列表 + query_faild_data = [] + + # 6. 对每个品牌进行处理 + brands = list(brand_ls) + total_brands = len(brands) + for idx, brand in enumerate(brands, start=1): + if check_cancelled and check_cancelled(): + raise TaskCancelledError() + + # 行级进度回调:当前第 idx 条 / total_brands + if progress_callback and total_brands > 0: + try: + progress_callback(idx, total_brands, extra={'current_brand': str(brand)}) + except Exception: + # 回调失败不影响主流程 + pass + + # 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, "时间": datetime.datetime.now().strftime("%y-%m-%d %H:%M:%S")}) + 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, "国家": office_name, "状态": status_name, "原因":"|".join(d.get("brandName","")),"时间": datetime.datetime.now().strftime("%y-%m-%d %H:%M:%S")}) + matched = True + else: + # print("添加",brand,office_name) + faild_data.append({"品牌": brand, "国家": office_name, "状态": status_name, "时间": datetime.datetime.now().strftime("%y-%m-%d %H:%M:%S")}) + # break + if matched: + break + + # 如果 Simple 策略下本页未命中,则翻下一页;其他策略不翻页 + if not matched: + page += 1 + # else: + # # 更新主表数据 + # for row in data_rows: + # if row.get("品牌") == brand: + # row["状态"] = status_name + # row["国家"] = office_name + # row["时间"] = datetime.datetime.now().strftime("%y-%m-%d %H:%M:%S") # 品牌匹配行 + # else: + # # 非匹配行:时间 = 当前国家值(模拟原 mask 逻辑) + # row["时间"] = "" + + # 7. 创建输出工作簿 + out_wb = Workbook() + out_wb.remove(out_wb.active) # 删除默认 sheet + + # 主工作表 + main_ws = out_wb.create_sheet(title=active_sheet_name) + main_ws.append(columns) + for row_dict in data_rows: + main_ws.append([row_dict.get(col, "") for col in columns]) + + # 不符合品牌工作表 + faild_ws = out_wb.create_sheet(title="不符合品牌") + if strategy == "Simple": + faild_columns = ["品牌", "国家", "状态","原因"] + else: + faild_columns = ["品牌", "国家", "状态"] + faild_ws.append(faild_columns) + for row_dict in faild_data: + # print("写入",row_dict) + faild_ws.append([row_dict.get(col, "") for col in faild_columns]) + + # 查询失败品牌工作表 + query_faild_ws = out_wb.create_sheet(title="查询失败品牌") + query_faild_columns = ["品牌", "时间"] + query_faild_ws.append(query_faild_columns) + for row_dict in query_faild_data: + query_faild_ws.append([row_dict.get(col, "") for col in query_faild_columns]) + + out_wb.save(output_path) + print("生成完成--->", output_path) + return output_path + + +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) + + + + + + + + + + + diff --git a/brand_spider/web_dec.py b/brand_spider/web_dec.py new file mode 100644 index 0000000..7610c86 --- /dev/null +++ b/brand_spider/web_dec.py @@ -0,0 +1,126 @@ +""" +通过 pywebview 加载本地 HTML,执行 JS 实现解密与 GUID 生成。 +""" +import json +import threading +import traceback + +import webview + +# 内嵌 HTML:加载 CryptoJS 并定义 decryptWithHashSearches、guid +_DECRYPT_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) diff --git a/config.py b/config.py new file mode 100644 index 0000000..56b7ef8 --- /dev/null +++ b/config.py @@ -0,0 +1,46 @@ +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 +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" + +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.3" +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 + + + diff --git a/coze.py b/coze.py new file mode 100644 index 0000000..ea8e95a --- /dev/null +++ b/coze.py @@ -0,0 +1,92 @@ +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) \ No newline at end of file diff --git a/generate_api.py b/generate_api.py new file mode 100644 index 0000000..ce92eff --- /dev/null +++ b/generate_api.py @@ -0,0 +1,261 @@ +""" +生成图片 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":""} + + diff --git a/html_crypto.py b/html_crypto.py new file mode 100644 index 0000000..cb089d9 --- /dev/null +++ b/html_crypto.py @@ -0,0 +1,68 @@ +""" +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 diff --git a/main.py b/main.py new file mode 100644 index 0000000..eb64fdf --- /dev/null +++ b/main.py @@ -0,0 +1,344 @@ +""" +基于 pywebview 实现的跨平台 UI,需先登录方可使用 +""" +from config import cache_path,debug,version +import datetime +import json +import sys +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 + + +with open("version.txt","w",encoding="utf-8") as file: + file.write(json.dumps({"version":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 保存到用户选择的位置。""" + import shutil + 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 _select_folder_win32(): + """Windows: 用 ctypes 调用系统文件夹选择对话框,打包成 exe 后也能正常弹窗(不依赖 tkinter)""" + try: + import ctypes + from ctypes import wintypes + BIF_RETURNONLYFSDIRS = 0x00000001 + BIF_NEWDIALOGSTYLE = 0x00000040 + MAX_PATH = 260 + shell32 = ctypes.windll.shell32 # type: ignore[attr-defined] + # BROWSEINFOW + class BROWSEINFOW(ctypes.Structure): + _fields_ = [ + ("hwndOwner", wintypes.HWND), + ("pidlRoot", ctypes.c_void_p), + ("pszDisplayName", ctypes.c_wchar_p), + ("lpszTitle", ctypes.c_wchar_p), + ("ulFlags", wintypes.UINT), + ("lpfn", ctypes.c_void_p), + ("lParam", wintypes.LPARAM), + ("iImage", ctypes.c_int), + ] + display_name_buf = ctypes.create_unicode_buffer(MAX_PATH) + bi = BROWSEINFOW() + bi.hwndOwner = 0 + bi.pidlRoot = 0 + bi.pszDisplayName = ctypes.cast(display_name_buf, ctypes.c_wchar_p) + bi.lpszTitle = "选择保存图片的文件夹" + bi.ulFlags = BIF_RETURNONLYFSDIRS | BIF_NEWDIALOGSTYLE + bi.lpfn = 0 + bi.lParam = 0 + bi.iImage = 0 + pidl = shell32.SHBrowseForFolderW(ctypes.byref(bi)) + if not pidl: + return '' + path_buf = ctypes.create_unicode_buffer(MAX_PATH) + if not shell32.SHGetPathFromIDListW(pidl, path_buf): + return '' + ole32 = ctypes.windll.ole32 # type: ignore[attr-defined] + ole32.CoTaskMemFree(pidl) + return path_buf.value or '' + except Exception as e: + print("Windows 文件夹选择失败:", e) + return '' + + +# def _select_folder_tk(): +# """使用 tkinter 选择文件夹(在非 Windows 或作为后备)""" +# try: +# +# root = tkinter.Tk() +# root.withdraw() +# root.attributes('-topmost', True) +# path = filedialog.askdirectory(title='选择保存图片的文件夹') +# try: +# root.destroy() +# except Exception: +# pass +# return path if path else '' +# except Exception as e: +# print("tkinter 选择文件夹失败:", e) +# return '' + + +def _select_folder_tk(): + import tkinter as tk + from tkinter import filedialog + + root = tk.Tk() + root.withdraw() + root.attributes('-topmost', True) + + # 使用 after 确保 askdirectory 在主循环启动后执行 + def ask(): + nonlocal path + path = filedialog.askdirectory(title='选择保存图片的文件夹') + root.quit() # 关闭主循环 + + path = '' + root.after(100, ask) + root.mainloop() # 启动主循环,直到 root.quit() 被调用 + try: + root.destroy() + except: + pass + return path + + +def select_folder(): + """弹窗选择文件夹,返回路径(空字符串表示取消)。Windows 打包 exe 时优先用系统 API 避免 tkinter 不弹窗。""" + # if sys.platform == 'win32': + # path = _select_folder_win32() + # if path: + # return path + return _select_folder_tk() + + +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) + webview.start( + debug=True, + storage_path=cache_path, + private_mode=False + ) + + +if __name__ == "__main__": + main() diff --git a/static/bg.jpg b/static/bg.jpg new file mode 100644 index 0000000000000000000000000000000000000000..de6e38d8f381a8c2e06f259aab20665bda03e0ed GIT binary patch literal 164259 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

|2!~hYkh>j5F9L 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®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 literal 0 HcmV?d00001 diff --git a/static/模板2-以文件夹方式上传.zip b/static/模板2-以文件夹方式上传.zip new file mode 100644 index 0000000000000000000000000000000000000000..5ccf9336b23fa33b7434b2efc05465d21afaed2b GIT binary patch literal 26336 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 qnBdC}9joZecT%pw$-9wmUn>WeIn$o~Zt&hhgA literal 0 HcmV?d00001 diff --git a/tool/devices.py b/tool/devices.py new file mode 100644 index 0000000..efdf582 --- /dev/null +++ b/tool/devices.py @@ -0,0 +1,249 @@ +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() \ No newline at end of file