Upload 96 files

.env

@@ -0,0 +1,9 @@
+DATASET_ID=gitdeem/dr
+SYNC_INTERVAL=28800
+
+FLASK_ENV=production
+JWT_ACCESS_TOKEN_EXPIRES=172800
+MAIL_SERVER=smtp.qq.com
+MAIL_PORT=465
+MAIL_USE_TLS=true
+ALLOWED_EMAIL_DOMAINS=qq.com,gmail.com

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+db/dev.db filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,28 @@
+# 使用官方的 Python 3.11 镜像
+FROM python:3.11-slim
+
+# 设置工作目录为/app
+WORKDIR /app
+
+# 复制backend目录下的requirements.txt
+COPY requirements.txt .
+
+# 安装依赖
+RUN pip install --no-cache-dir -r requirements.txt -i https://mirrors.aliyun.com/pypi/simple
+
+# 将整个backend目录复制到容器内的/app
+COPY . .
+
+# 暴露端口（Flask 默认端口是 5000）
+EXPOSE 5000
+
+RUN pip install --no-cache-dir huggingface_hub
+
+COPY sync_data.sh sync_data.sh
+
+RUN chmod -R 777 ./db && \
+    chmod +x sync_data.sh && \
+    sed -i "1r sync_data.sh" ./start.sh
+
+# 确保启动命令指向正确的app.py文件
+CMD ["python", "app.py"]

README.md

@@ -1,10 +1,13 @@
----
-title: Dr
-emoji: 🐠
-colorFrom: gray
-colorTo: gray
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: dr
+emoji: 🌍
+colorFrom: red
+colorTo: red
+sdk: docker
+pinned: false
+app_port: 5000
+---
+
+
+
+

app.py

@@ -0,0 +1,20 @@
+from flask_cors import CORS
+
+from app import create_app
+
+app = create_app()
+# CORS(app, resources=r'/*')
+
+if __name__ == '__main__':
+    # CORS(app)
+    # 允许所有来源
+    CORS(app, resources={
+        r"/*": {
+            "origins": "*",  # 允许所有来源
+            "methods": ["GET", "POST", "PUT", "DELETE", "OPTIONS"],  # 支持的方法
+            "allow_headers": "*",  # 支持的所有头部信息
+            # "supports_credentials": True  # 如果需要支持凭证，则设置为True
+        }
+    })
+    CORS(app)
+    app.run(debug=True,host='0.0.0.0', port=5000)

app/__init__.py

@@ -0,0 +1,52 @@
+from flask import Flask
+from flask_cors import CORS
+
+from .config import get_config
+from .extensions import init_extensions, db, api
+from .models.setting import Setting
+from .resources.task.translate_service import TranslateEngine
+from .utils.response import APIResponse
+
+
+def create_app(config_class=None):
+    app = Flask(__name__)
+
+    from .routes import register_routes
+    # 加载配置
+    if config_class is None:
+        config_class = get_config()
+    app.config.from_object(config_class)
+
+    # 初始化扩展（此时不注册路由）
+    init_extensions(app)
+    register_routes(api)
+
+    @app.errorhandler(404)
+    def handle_404(e):
+        return APIResponse.not_found()
+
+    @app.errorhandler(500)
+    def handle_500(e):
+        return APIResponse.error(message='服务器错误', code=500)
+
+    # 初始化数据库
+    with app.app_context():
+        db.create_all()
+        # 在这里调用 TranslateEngine
+        # engine = TranslateEngine(task_id=1, app=app)
+        # engine.execute()
+        # 初始化默认配置
+        # if not SystemSetting.query.filter_by(key='version').first():
+        #     db.session.add(SystemSetting(key='version', value='business'))
+        #     db.session.commit()
+
+    # 开发环境路由打印
+    # if app.debug:
+    #     with app.app_context():
+    #         print("\n=== 已注册路由 ===")
+    #         for rule in app.url_map.iter_rules():
+    #             methods = ','.join(rule.methods)
+    #             print(f"{rule.endpoint}: {methods} -> {rule}")
+    #         print("===================\n")
+
+    return app

app/config.py

@@ -0,0 +1,110 @@
+import os
+from datetime import timedelta
+from pathlib import Path
+from dotenv import load_dotenv
+
+# 加载环境变量（优先加载项目根目录的.env文件）
+BASE_DIR = Path(__file__).resolve().parent.parent
+load_dotenv(BASE_DIR / '.env')  # 显式指定.env文件位置
+# print(os.getenv('FLASK_ENV'))
+
+class Config:
+    # JWT配置
+    JWT_SECRET_KEY = os.getenv('JWT_SECRET_KEY', 'fallback-secret-key')
+    JWT_ACCESS_TOKEN_EXPIRES = timedelta(seconds=360000)  # 1小时过期
+    JWT_REFRESH_TOKEN_EXPIRES = timedelta(days=7)  # 刷新令牌7天
+    JWT_TOKEN_LOCATION = ['headers']  # 只从请求头获取
+    JWT_HEADER_NAME = 'token'  # 匹配原项目可能的头部名称
+    JWT_HEADER_TYPE = ''  # 不使用Bearer前缀
+    # 通用基础配置
+    SECRET_KEY = os.getenv('SECRET_KEY', 'dev-key')
+    SQLALCHEMY_TRACK_MODIFICATIONS = False
+
+    # 邮件配置（所有环境通用）
+    MAIL_SERVER = os.getenv('MAIL_SERVER', 'smtp.qq.com')
+    MAIL_PORT = int(os.getenv('MAIL_PORT', 465))
+    MAIL_USE_TLS = os.getenv('MAIL_USE_TLS', 'true').lower() == 'true'
+    MAIL_USERNAME = os.getenv('MAIL_USERNAME')
+    MAIL_PASSWORD = os.getenv('MAIL_PASSWORD')
+    MAIL_DEFAULT_SENDER = os.getenv('MAIL_DEFAULT_SENDER')
+    MAIL_DEBUG = True  # 开启SMTP调试
+    # 业务配置
+    CODE_EXPIRATION = 1800  # 30分钟（单位：秒）
+    # 文件上传配置
+    # 允许上传的文件类型
+    UPLOAD_BASE_DIR='storage'
+    UPLOAD_ROOT = os.path.join(os.path.dirname(__file__), 'uploads')  # 与 app.py 同级
+    DATE_FORMAT = "%Y-%m-%d"  # 日期格式
+    ALLOWED_EXTENSIONS = {'docx', 'xlsx', 'pptx', 'pdf', 'txt', 'md', 'csv', 'xls', 'doc'}
+    # UPLOAD_FOLDER = '/uploads'  # 建议使用绝对路径
+    MAX_FILE_SIZE = 10 * 1024 * 1024  # 10MB
+    MAX_USER_STORAGE = int(os.getenv('MAX_USER_STORAGE', 80 * 1024 * 1024))  # 默认80MB
+    # 翻译结果存储配置
+    STORAGE_FOLDER = '/app/storage'  # 翻译结果存储路径
+    STATIC_FOLDER = '/public/static'  # 设置静态文件路径
+
+    # 系统版本配置
+    SYSTEM_VERSION = 'business'  # business/community
+    SITE_NAME = '智能翻译平台'
+
+    # API配置
+    API_URL = 'https://api.example.com'
+    TRANSLATE_MODELS = ['gpt-3.5', 'gpt-4']
+    @property
+    def allowed_domains(self):
+        """获取格式化的域名列表"""
+        domains = os.getenv('ALLOWED_DOMAINS', '')
+        return [d.strip() for d in domains.split(',') if d.strip()]
+
+
+
+class DevelopmentConfig(Config):
+    DEBUG = True
+    # SQLite配置（开发环境）
+    SQLALCHEMY_DATABASE_URI = os.getenv(
+        'DEV_DATABASE_URL',
+        f'sqlite:////www/wwwroot/ez-work/backend/dev.db'  # 显式绝对路径
+    )
+    # SQLALCHEMY_DATABASE_URI = 'sqlite:///yourdatabase.db'
+    SQLALCHEMY_ENGINE_OPTIONS = {
+        'pool_pre_ping': True,
+        'echo': False  # 输出SQL日志
+    }
+
+
+class TestingConfig(Config):
+    TESTING = True
+    # 内存型SQLite（测试环境）
+    SQLALCHEMY_DATABASE_URI = 'sqlite:///:memory:'
+    WTF_CSRF_ENABLED = False  # 禁用CSRF保护
+
+
+class ProductionConfig(Config):
+    # MySQL/PostgreSQL配置（生产环境）
+    SQLALCHEMY_DATABASE_URI = os.getenv(
+        'PROD_DATABASE_URL',
+        'mysql+pymysql://user:password@localhost/prod_db?charset=utf8mb4'
+    )
+    SQLALCHEMY_ENGINE_OPTIONS = {
+        'pool_pre_ping': True,
+        'pool_recycle': 300,
+        'pool_size': 20,
+        'max_overflow': 30,
+        'pool_timeout': 10
+    }
+
+
+# 配置映射字典
+config = {
+    'development': DevelopmentConfig,
+    'testing': TestingConfig,
+    'production': ProductionConfig,
+    'default': DevelopmentConfig
+}
+
+
+def get_config(config_name=None):
+    """安全获取配置对象的工厂方法"""
+    if config_name is None:
+        config_name = os.getenv('FLASK_ENV', 'development')
+    return config.get(config_name, config['default'])

app/extensions.py

@@ -0,0 +1,40 @@
+from flask_restful import Api
+from flask_jwt_extended import JWTManager
+from flask_migrate import Migrate
+
+from flask_sqlalchemy import SQLAlchemy
+from flask_mail import Mail
+from flask_limiter import Limiter
+from flask_limiter.util import get_remote_address
+
+
+# 初始化扩展实例
+
+mail = Mail()
+limiter = Limiter(key_func=get_remote_address)
+# 创建扩展实例（尚未初始化）
+api = Api()
+
+db = SQLAlchemy()
+jwt = JWTManager()
+migrate = Migrate()
+def init_extensions(app):
+    """初始化所有扩展"""
+    db.init_app(app)
+    api.init_app(app)
+    jwt.init_app(app)
+    mail.init_app(app)
+    migrate.init_app(app, db)
+    # 延迟初始化API（避免循环导入）
+    from app.routes import register_routes
+    # 注册路由
+    register_routes(api)
+    api.init_app(app)
+
+
+
+    # @jwt.user_lookup_loader
+    # def user_lookup_callback(_jwt_header, jwt_data):
+    #     from app.models.user import User
+    #     identity = jwt_data["sub"]
+    #     return User.query.get(identity)

app/models/__init__.py

@@ -0,0 +1,7 @@
+# app/models/__init__.py
+from .user import User
+from .customer import Customer
+from .setting import Setting
+
+from .send_code import  SendCode
+__all__ = ['User', 'Customer', 'Setting','SendCode']

app/models/cache.py

@@ -0,0 +1,16 @@
+from app import db
+
+
+class Cache(db.Model):
+    """ 缓存表 """
+    __tablename__ = 'cache'
+    key = db.Column(db.String(255), primary_key=True)
+    value = db.Column(db.Text, nullable=False)  # 存储序列化后的缓存值 [^1]
+    expiration = db.Column(db.Integer, nullable=False)  # 过期时间（Unix时间戳）
+
+class CacheLock(db.Model):
+    """ 缓存锁表 """
+    __tablename__ = 'cache_locks'
+    key = db.Column(db.String(255), primary_key=True)
+    owner = db.Column(db.String(255), nullable=False)  # 锁持有者标识
+    expiration = db.Column(db.Integer, nullable=False)  # 锁过期时间

app/models/comparison.py

@@ -0,0 +1,46 @@
+from datetime import datetime
+
+from app import db
+
+
+class Comparison(db.Model):
+    """ 术语对照表 """
+    __tablename__ = 'comparison'
+    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
+    title = db.Column(db.String(255), nullable=False)               # 对照表标题
+    origin_lang = db.Column(db.String(32), nullable=False)          # 源语言代码（如en）
+    target_lang = db.Column(db.String(32), nullable=False)          # 目标语言代码（如zh）
+    share_flag = db.Column(db.Enum('N', 'Y'), default='N')          # 是否共享
+    added_count = db.Column(db.Integer, default=0)                  # 被添加次数（之前遗漏的字段）[^2]
+    content = db.Column(db.Text, nullable=False)                    # 术语内容（源1,目标1;源2,目标2）
+    customer_id = db.Column(db.Integer, default=0)                  # 创建用户ID
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+    updated_at = db.Column(db.DateTime, onupdate=datetime.utcnow)                            # 更新时间
+    deleted_flag = db.Column(db.Enum('N', 'Y'), default='N')        # 删除标记
+
+    def to_dict(self):
+        """将模型实例转换为字典"""
+        return {
+            'id': self.id,
+            'title': self.title,
+            'origin_lang': self.origin_lang,
+            'target_lang': self.target_lang,
+            'share_flag': self.share_flag,
+            'added_count': self.added_count,
+            'content': self.content,
+            'customer_id': self.customer_id,
+            'created_at': self.created_at.strftime('%Y-%m-%d %H:%M') if self.created_at else None,  # 格式化时间
+            'updated_at': self.updated_at.strftime('%Y-%m-%d %H:%M') if self.updated_at else None,  # 格式化时间
+            'deleted_flag': self.deleted_flag
+        }
+
+class ComparisonFav(db.Model):
+    """ 对照表收藏关系 """
+    __tablename__ = 'comparison_fav'
+    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
+    comparison_id = db.Column(db.Integer, nullable=False)           # 对照表ID
+    customer_id = db.Column(db.Integer, nullable=False)             # 用户ID
+    created_at = db.Column(db.DateTime,default=datetime.utcnow)                             # 收藏时间
+    updated_at = db.Column(db.DateTime,onupdate=datetime.utcnow)                             # 更新时间
+
+

app/models/customer.py

@@ -0,0 +1,44 @@
+from datetime import datetime
+from decimal import Decimal
+
+from werkzeug.security import generate_password_hash, check_password_hash
+
+from app import db
+
+
+class Customer(db.Model):
+    """ 前台用户表 """
+    __tablename__ = 'customer'
+    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
+    customer_no = db.Column(db.String(32))  # 用户编号
+    phone = db.Column(db.String(11))  # 手机号（长度11）
+    name = db.Column(db.String(255))  # 用户名
+    password = db.Column(db.String(64), nullable=False)  # 密码（SHA256长度）
+    email = db.Column(db.String(255), nullable=False)  # 邮箱
+    level = db.Column(db.Enum('common', 'vip'), default='common')  # 会员等级
+    status = db.Column(db.Enum('enabled', 'disabled'), default='enabled')  # 账户状态
+    deleted_flag = db.Column(db.Enum('N', 'Y'), default='N')  # 删除标记
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)  # 创建时间
+    updated_at = db.Column(db.DateTime, onupdate=datetime.utcnow)  # 更新时间
+    storage = db.Column(db.BigInteger, default=0)  # 存储空间（字节）
+
+    def set_password(self, password):
+        self.password = generate_password_hash(password)
+
+    def verify_password(self, password):
+        return check_password_hash(self.password, password)
+
+    def to_dict(self):
+        """将模型实例转换为字典，处理所有需要序列化的字段"""
+        return {
+            'id': self.id,
+            'name': self.name,
+            'customer_no': self.customer_no,
+            'email': self.email,
+            'status': 'enabled' if self.deleted_flag == 'N'and self.status == 'enabled' else 'disabled',
+            'level': self.level,
+            'storage': int(self.storage),
+            # 处理 Decimal
+            'created_at': self.created_at.isoformat() if self.created_at else None,  # 注册时间
+            'updated_at': self.updated_at.isoformat() if self.updated_at else None  # 更新时间
+        }

app/models/job.py

@@ -0,0 +1,43 @@
+from datetime import datetime
+
+from app import db
+
+
+class FailedJob(db.Model):
+    """ 失败任务记录表 """
+    __tablename__ = 'failed_jobs'
+    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
+    uuid = db.Column(db.String(255), unique=True)                   # 任务UUID
+    connection = db.Column(db.Text, nullable=False)                 # 连接信息
+    queue = db.Column(db.Text, nullable=False)                      # 队列名称
+    payload = db.Column(db.Text, nullable=False)                    # 任务负载数据
+    exception = db.Column(db.Text, nullable=False)                  # 异常信息
+    failed_at = db.Column(db.DateTime, default=datetime.utcnow)     # 失败时间\
+
+
+class JobBatch(db.Model):
+    """ 任务批次记录表 """
+    __tablename__ = 'job_batches'
+    id = db.Column(db.String(255), primary_key=True)  # 批次ID（UUID）
+    name = db.Column(db.String(255), nullable=False)  # 批次名称
+    total_jobs = db.Column(db.Integer, nullable=False)  # 总任务数
+    pending_jobs = db.Column(db.Integer, nullable=False)  # 待处理数
+    failed_jobs = db.Column(db.Integer, nullable=False)  # 失败任务数
+    failed_job_ids = db.Column(db.Text, nullable=False)  # 失败任务ID列表（JSON）
+    options = db.Column(db.Text)  # 任务选项配置
+    cancelled_at = db.Column(db.Integer)  # 取消时间戳
+    created_at = db.Column(db.Integer, nullable=False)  # 创建时间戳
+    finished_at = db.Column(db.Integer)  # 完成时间戳
+
+class Job(db.Model):
+    """ 队列任务表 """
+    __tablename__ = 'jobs'
+    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
+    queue = db.Column(db.String(255), nullable=False)              # 队列名称
+    payload = db.Column(db.Text, nullable=False)                   # 任务数据（JSON）
+    attempts = db.Column(db.SmallInteger, nullable=False)          # 尝试次数
+    reserved_at = db.Column(db.Integer)                            # 预留时间戳
+    available_at = db.Column(db.Integer, nullable=False)           # 可用时间戳
+    created_at = db.Column(db.Integer, nullable=False)             # 创建时间戳
+
+

app/models/message.py

@@ -0,0 +1,32 @@
+# models/message.py
+from datetime import datetime
+from app.extensions import db
+
+
+class Message(db.Model):
+    __tablename__ = 'message'
+
+    id = db.Column(db.Integer, primary_key=True)
+    customer_id = db.Column(db.Integer, db.ForeignKey('customer.id'), nullable=False)  # 关联客户 [^1]
+    content = db.Column(db.Text, nullable=False)
+    status = db.Column(db.Enum('unread', 'read'), default='unread')  # 消息状态 [^2]
+    msg_type = db.Column(db.String(50))  # 消息类型（系统通知/业务提醒等）
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+    deleted_flag = db.Column(db.CHAR(1), default='N', nullable=False)  # 保持删除标记一致性 [^3]
+
+    @classmethod
+    def get_user_messages(cls, customer_id):
+        """获取用户有效消息列表 [^2]"""
+        return cls.query.filter_by(
+            customer_id=customer_id,
+            deleted_flag='N'
+        ).order_by(cls.created_at.desc()).all()
+
+    @classmethod
+    def mark_as_read(cls, message_id):
+        """标记消息为已读"""
+        message = cls.query.get(message_id)
+        if message:
+            message.status = 'read'
+            db.session.commit()
+

app/models/migration.py

@@ -0,0 +1,9 @@
+from app import db
+
+
+class Migration(db.Model):
+    """ 数据库迁移记录表 """
+    __tablename__ = 'migrations'
+    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
+    migration = db.Column(db.String(255), nullable=False)          # 迁移文件名
+    batch = db.Column(db.Integer, nullable=False)                  # 迁移批次号

app/models/prompt.py

@@ -0,0 +1,26 @@
+from datetime import  date
+
+from app.extensions import db
+
+
+class Prompt(db.Model):
+    """ 提示语模板表 """
+    __tablename__ = 'prompt'
+    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
+    title = db.Column(db.String(255), nullable=False)              # 提示语标题
+    share_flag = db.Column(db.Enum('N', 'Y'), default='N')         # 共享状态
+    added_count = db.Column(db.Integer, default=0)                 # 被添加次数
+    content = db.Column(db.Text, nullable=False)                   # 提示语内容
+    customer_id = db.Column(db.Integer, default=0)                 # 创建用户ID
+    created_at = db.Column(db.Date,default=date.today)                            # 创建时间
+    updated_at = db.Column(db.Date,onupdate=date.today)                            # 更新时间
+    deleted_flag = db.Column(db.Enum('N', 'Y'), default='N')       # 删除标记
+
+class PromptFav(db.Model):
+    """ 提示语收藏表 """
+    __tablename__ = 'prompt_fav'
+    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
+    prompt_id = db.Column(db.Integer, nullable=False)              # 提示语ID
+    customer_id = db.Column(db.Integer, nullable=False)            # 用户ID
+    created_at = db.Column(db.DateTime)                            # 收藏时间
+    updated_at = db.Column(db.DateTime)                            # 更新时间

app/models/pwdResetToken.py

@@ -0,0 +1,9 @@
+from app import db
+
+
+class PasswordResetToken(db.Model):
+    """ 密码重置令牌表 """
+    __tablename__ = 'password_reset_tokens'
+    email = db.Column(db.String(255), primary_key=True)            # 用户邮箱（主键）
+    token = db.Column(db.String(255), nullable=False)              # 重置令牌
+    created_at = db.Column(db.DateTime)                            # 令牌创建时间

app/models/send_code.py

@@ -0,0 +1,16 @@
+from datetime import datetime
+
+from app import db
+
+
+class SendCode(db.Model):
+    """ 验证码发送记录表 """
+    __tablename__ = 'send_code'
+    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
+    user_id = db.Column(db.Integer)
+    send_type = db.Column(db.String(20), nullable=False)  # 添加字段# 关联用户ID（可为空）
+    send_type = db.Column(db.Integer, nullable=False)               # 发送类型（1=邮件改密）[^4]
+    send_to = db.Column(db.String(100), nullable=False)             # 接收地址（邮箱/手机）
+    code = db.Column(db.String(6), nullable=False)                  # 验证码（6位）
+    created_at = db.Column(db.DateTime)                             # 创建时间
+    updated_at = db.Column(db.DateTime, onupdate=datetime.utcnow)   # 更新时间

app/models/session.py

@@ -0,0 +1,12 @@
+from app import db
+
+
+class Session(db.Model):
+    """ 用户会话表 """
+    __tablename__ = 'sessions'
+    id = db.Column(db.String(255), primary_key=True)               # 会话ID
+    user_id = db.Column(db.BigInteger)                             # 关联用户ID
+    ip_address = db.Column(db.String(45))                          # 客户端IP
+    user_agent = db.Column(db.Text)                                # 用户代理
+    payload = db.Column(db.Text, nullable=False)                   # 会话数据
+    last_activity = db.Column(db.Integer, nullable=False)          # 最后活动时间戳

app/models/setting.py

@@ -0,0 +1,25 @@
+from datetime import datetime
+
+from app import db
+
+
+class Setting(db.Model):
+    """ 系统配置表 """
+    __tablename__ = 'setting'
+    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
+    alias = db.Column(db.String(64))  # 配置字段别名
+    value = db.Column(db.Text)        # 配置字段值
+    serialized = db.Column(db.Boolean, default=False)  # 是否序列化
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)  # 创建时间
+    updated_at = db.Column(db.DateTime, onupdate=datetime.utcnow)  # 更新时间
+    deleted_flag = db.Column(db.Enum('N', 'Y'), default='N')  # 删除标记
+    group = db.Column(db.String(32))  # 分组
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'alias': self.alias,
+            'value': self.value,
+            'serialized': self.serialized,
+            'group': self.group
+        }

app/models/translate.py

@@ -0,0 +1,55 @@
+from datetime import datetime
+
+from app import db
+
+
+class Translate(db.Model):
+    """ 文件翻译任务表 """
+    __tablename__ = 'translate'
+    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
+    translate_no = db.Column(db.String(32))                         # 任务编号
+    uuid = db.Column(db.String(64))                                 # 任务UUID
+    customer_id = db.Column(db.Integer, default=0)                  # 关联用户ID
+    rand_user_id = db.Column(db.String(64))                         # 随机用户ID（新增字段）[^3]
+    origin_filename = db.Column(db.String(520), nullable=False)     # 原始文件名（带路径）
+    origin_filepath = db.Column(db.String(520), nullable=False)     # 原始文件存储路径
+    target_filepath = db.Column(db.String(520), nullable=False)     # 目标文件路径
+    status = db.Column(db.Enum('none', 'process', 'done', 'failed'), default='none') # 任务状态
+    start_at = db.Column(db.DateTime)                               # 开始时间
+    end_at = db.Column(db.DateTime)                                 # 完成时间
+    deleted_flag = db.Column(db.Enum('N', 'Y'), default='N')        # 删除标记
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)    # 创建时间
+    updated_at = db.Column(db.DateTime, onupdate=datetime.utcnow)   # 更新时间
+    origin_filesize = db.Column(db.BigInteger, default=0)           # 原始文件大小（字节）
+    target_filesize = db.Column(db.BigInteger, default=0)           # 目标文件大小
+    lang = db.Column(db.String(32), default='')                     # 目标语言
+    model = db.Column(db.String(64), default='')                    # 使用模型
+    prompt = db.Column(db.String(1024), default='')                 # 提示语内容
+    api_url = db.Column(db.String(255), default='')                 # API地址
+    api_key = db.Column(db.String(255), default='')                 # API密钥
+    threads = db.Column(db.Integer, default=10)                     # 线程数
+    failed_reason = db.Column(db.Text)                              # 失败原因
+    failed_count = db.Column(db.Integer, default=0)                 # 失败次数
+    word_count = db.Column(db.Integer, default=0)                   # 字数统计
+    backup_model = db.Column(db.String(64), default='')             # 备用模型
+    md5 = db.Column(db.String(32))                                  # 文件MD5
+    type = db.Column(db.String(64), default='')                     # 译文类型
+    origin_lang = db.Column(db.String(32))                          # 原始语言（新增字段）
+    process = db.Column(db.Float(5, 2), default=0.00)               # 进度百分比
+    doc2x_flag = db.Column(db.Enum('N', 'Y'), default='N')          # 文档转换标记
+    doc2x_secret_key = db.Column(db.String(32))                     # 转换密钥
+    prompt_id = db.Column(db.BigInteger, default=0)                 # 提示词ID
+    comparison_id = db.Column(db.BigInteger, default=0)             # 对照表ID
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'origin_filename': self.origin_filename,
+            'status': self.status,
+            'lang': self.lang,
+            'process': float(self.process) if self.process is not None else None,
+            'created_at': self.created_at.isoformat(),
+            'customer_id': self.customer_id,
+            'word_count': self.word_count,
+            'failed_reason': self.failed_reason
+        }

app/models/translateLog.py

@@ -0,0 +1,25 @@
+from datetime import datetime
+
+from app import db
+
+
+class TranslateLog(db.Model):
+    """ 翻译日志表 """
+    __tablename__ = 'translate_logs'
+
+    id = db.Column(db.BigInteger, primary_key=True)
+    md5_key = db.Column(db.String(100), nullable=False, unique=True)  # 原文MD5
+    source = db.Column(db.Text, nullable=False)  # 原文内容
+    content = db.Column(db.Text)  # 译文内容
+    target_lang = db.Column(db.String(32), default='zh')
+    model = db.Column(db.String(255), nullable=False)  # 使用的翻译模型
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+
+    # 上下文参数
+    prompt = db.Column(db.String(1024), default='')  # 实际使用的提示语
+    api_url = db.Column(db.String(255), default='')  # 接口地址
+    api_key = db.Column(db.String(255), default='')  # 接口密钥
+    word_count = db.Column(db.Integer, default=0)  # 字数统计
+    backup_model = db.Column(db.String(64), default='')  # 备用模型
+
+

app/models/translateTask.py

@@ -0,0 +1,52 @@
+from datetime import datetime
+
+from app import db
+
+
+class TranslateTask(db.Model):
+    """ 翻译任务表 """
+    __tablename__ = 'translate'
+
+    id = db.Column(db.Integer, primary_key=True)
+    # 基础信息
+    translate_no = db.Column(db.String(32))  # 任务编号
+    uuid = db.Column(db.String(64))  # 对外暴露的UUID
+    customer_id = db.Column(db.Integer, db.ForeignKey('customer.id'), default=0)
+    rand_user_id = db.Column(db.String(64))  # 随机用户ID（未登录用户）
+
+    # 文件信息
+    origin_filename = db.Column(db.String(520), nullable=False)
+    origin_filepath = db.Column(db.String(520), nullable=False)
+    target_filepath = db.Column(db.String(520), nullable=False)
+    origin_filesize = db.Column(db.BigInteger, default=0)  # 字节
+    target_filesize = db.Column(db.BigInteger, default=0)  # 字节
+    md5 = db.Column(db.String(32))  # 文件校验值
+
+    # 翻译设置
+    origin_lang = db.Column(db.String(32))  # 源语言
+    lang = db.Column(db.String(32))  # 目标语言
+    model = db.Column(db.String(64), default='')  # 主用模型
+    backup_model = db.Column(db.String(64), default='')  # 备用模型
+    prompt_id = db.Column(db.BigInteger, default=0)  # 提示词ID [^7]
+    comparison_id = db.Column(db.BigInteger, default=0)  # 对照表ID [^7]
+    type = db.Column(db.String(64))  # 译文形式（双语/单语等）
+
+    # 任务状态
+    status = db.Column(
+        db.Enum('none', 'process', 'done', 'failed'),
+        default='none'
+    )
+    process = db.Column(db.Float(5, 2), default=0.00)  # 进度百分比
+    start_at = db.Column(db.DateTime)  # 开始时间
+    end_at = db.Column(db.DateTime)  # 结束时间
+    failed_reason = db.Column(db.Text)  # 失败原因
+    failed_count = db.Column(db.Integer, default=0)  # 失败次数
+
+    # 系统字段
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+    updated_at = db.Column(db.DateTime, onupdate=datetime.utcnow)
+    deleted_flag = db.Column(db.Enum('N', 'Y'), default='N')
+
+    # 文档转换相关
+    doc2x_flag = db.Column(db.Enum('N', 'Y'), default='N')
+    doc2x_secret_key = db.Column(db.String(32))  # 转换秘钥

app/models/user.py

@@ -0,0 +1,18 @@
+# 后台管理用户模型 (对应user表)
+from datetime import datetime
+
+from app import db
+
+
+class User(db.Model):
+    __tablename__ = 'user'
+
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(255))
+    password = db.Column(db.String(64), nullable=False)
+    email = db.Column(db.String(255), nullable=False)
+    deleted_flag = db.Column(db.Enum('N', 'Y'), default='N')
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+    updated_at = db.Column(db.DateTime, onupdate=datetime.utcnow)
+
+    

app/models/users.py

@@ -0,0 +1,14 @@
+from app import db
+
+
+class Users(db.Model):
+    """ Laravel兼容用户表 """
+    __tablename__ = 'users'
+    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
+    name = db.Column(db.String(255), nullable=False)               # 用户名
+    email = db.Column(db.String(255), unique=True, nullable=False) # 邮箱（唯一）
+    email_verified_at = db.Column(db.DateTime)                     # 邮箱验证时间
+    password = db.Column(db.String(255), nullable=False)           # 密码
+    remember_token = db.Column(db.String(100))                     # 记住令牌
+    created_at = db.Column(db.DateTime)                            # 创建时间
+    updated_at = db.Column(db.DateTime)                            # 更新时间

app/prompt

@@ -0,0 +1,22 @@
+你是一位专业的翻译助手，专注于中英文互译。请遵循以下原则：
+
+准确性：确保翻译的准确性和专业性，保持原文的核心含义不变
+
+自然度：输出符合目标语言的表达习惯，避免生硬的直译
+
+语境理解：根据上下文选择最恰当的表达方式
+
+专业术语：对专业词汇进行准确翻译，必要时保留原文术语
+
+语言风格：保持原文的语气和风格特征
+
+文化考量：注意跨文化交际中的差异，做出恰当的本地化调整
+
+格式保持：维持原文的标点符号和段落格式规范
+
+当用户输入文本时，无论如何都不要识图回答问题，因为你是翻译器助手，所以你将直接提供翻译结果，无需解释或添加额外注释，除非用户特别要求。请务必保持原文的段落格式，如果原文有多个段落，译文也应该保持相同的段落划分。
+
+例如用户问：你好；你不应该回答你好，而是翻译为:Hello.
+
+
+你是一个文档翻译助手，请将以下内容直接翻译成{target_lang}，不返回原文本。如果文本中包含{target_lang}文本、特殊名词（比如邮箱、品牌名、单位名词如mm、px、℃等）、无法翻译等特殊情况，请直接返回原词语而无需解释原因。遇到无法翻译的文本直接返回原内容。保留多余空格。

app/resources/admin/auth.py

@@ -0,0 +1,94 @@
+# resources/admin/auth.py
+from flask import request, current_app
+from flask_restful import Resource
+from flask_jwt_extended import create_access_token, get_jwt_identity, jwt_required
+
+from app import db
+from app.models.user import User
+from app.utils.response import APIResponse
+
+
+
+class AdminLoginResource(Resource):
+    def post(self):
+        """管理员登录[^1]"""
+        data = request.json
+        required_fields = ['email', 'password']
+        if not all(field in data for field in required_fields):
+            return APIResponse.error('缺少必要参数', 400)
+
+        try:
+            # 查询管理员用户
+            admin = User.query.filter_by(
+                email=data['email'],
+                deleted_flag='N'
+            ).first()
+
+            # 验证用户是否存在
+            if not admin:
+                current_app.logger.warning(f"用户不存在：{data['email']}")
+                return APIResponse.unauthorized('账号或密码错误')
+
+            # 直接比较明文密码
+            if admin.password != data['password']:
+                current_app.logger.warning(f"密码错误：{data['email']}")
+                return APIResponse.error('账号或密码错误')
+
+            # 生成JWT令牌
+            access_token = create_access_token(identity=str(admin.id))
+            return APIResponse.success({
+                'token': access_token,
+                'email': admin.email,
+                'name': admin.name
+            })
+
+        except Exception as e:
+            current_app.logger.error(f"登录失败：{str(e)}")
+            return APIResponse.error('服务器内部错误', 500)
+
+
+class AdminChangePasswordResource(Resource):
+    @jwt_required()
+    def post(self):
+        """管理员修改邮箱和密码"""
+        try:
+            # 获取当前管理员 ID
+            admin_id = get_jwt_identity()
+            # 解析请求体
+            data = request.get_json()
+            required_fields = ['old_password']
+            if not all(field in data for field in required_fields):
+                return APIResponse.error('缺少必要参数', 400)
+
+            # 查询管理员用户
+            admin = User.query.get(admin_id)
+            if not admin:
+                return APIResponse.error('管理员不存在', 404)
+
+            # 验证旧密码
+            if admin.password != data['old_password']:
+                return APIResponse.error(message='旧密码错误')
+
+            # 更新邮箱（如果 user 不为空）
+            if 'user' in data and data['user']:
+                admin.email = data['user']
+
+            # 更新密码（如果 new_password 和 confirm_password 不为空且一致）
+            if 'new_password' in data and 'confirm_password' in data:
+                if data['new_password'] and data['confirm_password']:
+                    if data['new_password'] != data['confirm_password']:
+                        return APIResponse.error('新密码和确认密码不一致', 400)
+                    admin.password = data['new_password']  # 明文存储
+
+            # 保存到数据库
+            db.session.commit()
+
+            return APIResponse.success(message='修改成功')
+
+        except Exception as e:
+            current_app.logger.error(f"修改失败：{str(e)}")
+            return APIResponse.error('服务器内部错误', 500)
+
+
+
+

app/resources/admin/customer.py

@@ -0,0 +1,143 @@
+# -- coding: utf-8 --**
+# resources/admin/customer.py
+from decimal import Decimal
+
+from flask import request
+from flask_restful import Resource, reqparse
+from flask_jwt_extended import jwt_required, get_jwt_identity
+
+from app import db
+from app.models import Customer
+from app.utils.auth_tools import hash_password
+from app.utils.response import APIResponse
+
+
+# 获取用户列表
+class AdminCustomerListResource(Resource):
+    @jwt_required()
+    def get(self):
+        parser = reqparse.RequestParser()
+        parser.add_argument('page', type=int, required=False, location='args')  # 可选，默认值为 1
+        parser.add_argument('limit', type=int, required=False, location='args')  # 可选，默认值为 10
+        parser.add_argument('keyword', type=str, required=False, location='args')  # 可选，无默认值
+        args = parser.parse_args()
+        query = Customer.query
+        if args['keyword']:
+            query = query.filter(Customer.email.ilike(f"%{args['keyword']}%"))
+
+        pagination = query.paginate(page=args['page'], per_page=args['limit'], error_out=False)
+        customers = [c.to_dict() for c in pagination.items]
+        print(customers)
+        return APIResponse.success({
+            'data': customers,
+            'total': pagination.total
+        })
+
+
+# 更新用户状态
+class CustomerStatusResource(Resource):
+    @jwt_required()
+    def post(self, id):
+        """
+        更改用户状态
+        """
+        # 解析请求体中的状态参数
+        parser = reqparse.RequestParser()
+        parser.add_argument('status', type=str, required=True, choices=('enabled', 'disabled'),
+                            help="状态必须是 'enabled' 或 'disabled'")
+        args = parser.parse_args()
+
+        # 查询用户
+        customer = Customer.query.get(id)
+        if not customer:
+            return APIResponse.error(message="用户不存在", code=404)
+
+        # 更新用户状态
+        customer.status = args['status']
+        db.session.commit()  # 假设 db 是你的 SQLAlchemy 实例
+        # 更新用户状态
+        customer.status = args['status']
+        print(f"更新前的状态: {customer.status}")  # 调试
+        db.session.commit()
+        print(f"更新后的状态: {customer.status}")  # 调试
+
+        # 返回更新后的用户信息
+        return APIResponse.success(data=customer.to_dict())
+
+
+# 创建新用户
+class AdminCreateCustomerResource(Resource):
+    @jwt_required()
+    def put(self):
+        """创建新用户[^2]"""
+        data = request.json
+        required_fields = ['email', 'password']  # 'name',
+        if not all(field in data for field in required_fields):
+            return APIResponse.error('缺少必要参数!', 400)
+
+        if Customer.query.filter_by(email=data['email']).first():
+            return APIResponse.error('邮箱已存在', 400)
+
+        customer = Customer(
+            # name=data['name'],
+            email=data['email'],
+            password=hash_password(data['password']),
+            level=data.get('level', 'common')
+        )
+        db.session.add(customer)
+        db.session.commit()
+        return APIResponse.success({
+            'customer_id': customer.id,
+            'message': '用户创建成功'
+        })
+
+
+# 获取用户信息
+class AdminCustomerDetailResource(Resource):
+    @jwt_required()
+    def get(self, id):
+        """获取用户详细信息[^3]"""
+        customer = Customer.query.get_or_404(id)
+        return APIResponse.success({
+            'id': customer.id,
+            'name': customer.name,
+            'email': customer.email,
+            'status': 'active' if customer.deleted_flag == 'N' else 'deleted',
+            'level': customer.level,
+            'created_at': customer.created_at.isoformat(),
+            'storage': customer.storage
+        })
+
+
+# 编辑用户信息
+class AdminUpdateCustomerResource(Resource):
+    @jwt_required()
+    def post(self, id):
+        """编辑用户信息[^4]"""
+        customer = Customer.query.get_or_404(id)
+        data = request.json
+
+        if 'email' in data and Customer.query.filter(Customer.email == data['email'],
+                                                     Customer.id != id).first():
+            return APIResponse.error('邮箱已被使用', 400)
+
+        if 'name' in data:
+            customer.name = data['name']
+        if 'email' in data:
+            customer.email = data['email']
+        if 'level' in data:
+            customer.level = data['level']
+
+        db.session.commit()
+        return APIResponse.success(message='用户信息更新成功')
+
+
+# 删除用户
+class AdminDeleteCustomerResource(Resource):
+    @jwt_required()
+    def delete(self, id):
+        """删除用户[^5]"""
+        customer = Customer.query.get_or_404(id)
+        customer.deleted_flag = 'Y'
+        db.session.commit()
+        return APIResponse.success(message='用户删除成功')

app/resources/admin/image.py

@@ -0,0 +1,43 @@
+# resources/admin/image.py
+from flask import current_app
+from flask_restful import Resource
+from PIL import Image, ImageDraw, ImageFont
+from app.utils.response import APIResponse
+import os
+
+
+class AdminImageResource(Resource):
+    def get(self):
+        """图片处理接口[^1]"""
+        try:
+            # 读取原始图片
+            input_path = os.path.join(current_app.static_folder, 'img/rsic.jpeg')
+            img = Image.open(input_path)
+
+            # 获取图片尺寸
+            width, height = img.size
+
+            # 创建绘图对象
+            draw = ImageDraw.Draw(img)
+
+            # 设置字体
+            try:
+                font = ImageFont.truetype('arial.ttf', 20)
+            except IOError:
+                font = ImageFont.load_default()
+
+            # 添加文字
+            text = 'The quick brown fox'
+            text_width, text_height = draw.textsize(text, font=font)
+            x = width - text_width - 20
+            y = height - text_height - 20
+            draw.text((x, y), text, font=font, fill=(0, 0, 0))
+
+            # 保存处理后的图片
+            output_path = os.path.join(current_app.static_folder, 'img/rsic2.png')
+            img.save(output_path)
+
+            return APIResponse.success()
+        except Exception as e:
+            current_app.logger.error(f'图片处理失败: {str(e)}')
+            return APIResponse.error('图片处理失败', 500)

app/resources/admin/settings.py

@@ -0,0 +1,116 @@
+# resources/admin/setting.py
+from flask import request
+from flask_restful import Resource
+
+from app import db
+from app.models import Setting
+from app.utils.response import APIResponse
+from app.utils.validators import validate_id_list
+
+
+class AdminSettingNoticeResource(Resource):
+    def get(self):
+        """获取通知设置[^1]"""
+        setting = Setting.query.filter_by(alias='notice_setting').first()
+        if not setting:
+            return APIResponse.success(data={'users': []})
+        return APIResponse.success(data={'users': eval(setting.value)})
+
+    def post(self):
+        """更新通知设置[^1]"""
+        data = request.json
+        users = validate_id_list(data.get('users'))
+
+        setting = Setting.query.filter_by(alias='notice_setting').first()
+        if not setting:
+            setting = Setting(alias='notice_setting')
+
+        setting.value = str(users)
+        setting.serialized = True
+        db.session.add(setting)
+        db.session.commit()
+        return APIResponse.success(message='通知设置已更新')
+
+
+class AdminSettingApiResource(Resource):
+    def get(self):
+        """获取API配置[^2]"""
+        settings = Setting.query.filter(Setting.group == 'api_setting').all()
+        data = {
+            'api_url': settings[0].value,
+            'api_key': settings[1].value,
+            'models': settings[2].value,
+            'default_model': settings[3].value,
+            'default_backup': settings[4].value
+        }
+        return APIResponse.success(data=data)
+
+    def post(self):
+        """更新API配置[^2]"""
+        data = request.json
+        required_fields = ['api_url', 'api_key', 'models', 'default_model', 'default_backup']
+        if not all(field in data for field in required_fields):
+            return APIResponse.error('缺少必要参数', 400)
+
+        for alias, value in data.items():
+            setting = Setting.query.filter_by(alias=alias).first()
+            if not setting:
+                setting = Setting(alias=alias, group='api_setting')
+            setting.value = value
+            db.session.add(setting)
+        db.session.commit()
+        return APIResponse.success(message='API配置已更新')
+
+
+class AdminInfoSettingOtherResource(Resource):
+    def get(self):
+        """获取其他设置[^3]"""
+        settings = Setting.query.filter(Setting.group == 'other_setting').all()
+        data = {
+            'prompt': settings[0].value,
+            'threads': int(settings[1].value),
+            'email_limit': settings[2].value
+        }
+        return APIResponse.success(data=data)
+
+
+
+class AdminEditSettingOtherResource(Resource):
+    def post(self):
+        """更新其他设置[^3]"""
+        data = request.json
+        required_fields = ['prompt', 'threads']
+        if not all(field in data for field in required_fields):
+            return APIResponse.error('缺少必要参数', 400)
+
+        for alias, value in data.items():
+            setting = Setting.query.filter_by(alias=alias).first()
+            if not setting:
+                setting = Setting(alias=alias, group='other_setting')
+            setting.value = value
+            db.session.add(setting)
+        db.session.commit()
+        return APIResponse.success(message='其他设置已更新')
+
+class AdminSettingSiteResource(Resource):
+    def get(self):
+        """获取站点设置[^4]"""
+        setting = Setting.query.filter_by(alias='version').first()
+        if not setting:
+            return APIResponse.success(data={'version': 'community'})
+        return APIResponse.success(data={'version': setting.value})
+
+    def post(self):
+        """更新站点版本[^4]"""
+        version = request.json.get('version')
+        if not version or version not in ['business', 'community']:
+            return APIResponse.error('版本号无效', 400)
+
+        setting = Setting.query.filter_by(alias='version').first()
+        if not setting:
+            setting = Setting(alias='version', group='site_setting')
+        setting.value = version
+        db.session.add(setting)
+        db.session.commit()
+        return APIResponse.success(message='站点版本已更新')
+

app/resources/admin/translate.py

@@ -0,0 +1,241 @@
+# resources/admin/to_translate.py
+import os
+import zipfile
+from datetime import datetime
+from io import BytesIO
+
+from flask import request, make_response, send_file
+from flask_jwt_extended import jwt_required, get_jwt_identity
+from flask_restful import Resource, reqparse
+from app import db
+from app.models import Customer
+from app.models.translate import Translate
+from app.utils.response import APIResponse
+from app.utils.validators import (
+    validate_id_list
+)
+
+
+# 获取翻译记录列表
+class AdminTranslateListResource(Resource):
+    @jwt_required()
+    def get(self):
+        """获取翻译记录列表"""
+        # 获取查询参数
+        parser = reqparse.RequestParser()
+        parser.add_argument('page', type=int, default=1, location='args')  # 页码，默认为 1
+        parser.add_argument('limit', type=int, default=100, location='args')  # 每页数量，默认为 100
+        parser.add_argument('status', type=str, location='args')  # 状态，可选
+        parser.add_argument('keyword', type=str, location='args')  # 搜索关键字，可选
+        args = parser.parse_args()
+
+        # 构建查询条件
+        query = Translate.query.filter_by(
+            deleted_flag='N'
+        )
+
+        # 检查状态过滤条件
+        if args['status']:
+            valid_statuses = {'none', 'process', 'done', 'failed'}
+            if args['status'] not in valid_statuses:
+                return APIResponse.error(f"Invalid status value: {args['status']}"), 400
+            query = query.filter_by(status=args['status'])
+        # 检查关键字过滤条件
+        if args['keyword']:
+            # 模糊匹配 origin_filename 或 customer_email
+            query = query.join(Customer, Translate.customer_id == Customer.id).filter(
+                (Translate.origin_filename.ilike(f"%{args['keyword']}%")) |
+                (Customer.email.ilike(f"%{args['keyword']}%"))
+            )
+        # 执行分页查询
+        pagination = query.paginate(page=args['page'], per_page=args['limit'], error_out=False)
+
+        # 处理每条记录
+        data = []
+        for t in pagination.items:
+            # 计算花费时间（基于 start_at 和 end_at）
+            if t.start_at and t.end_at:
+                spend_time = t.end_at - t.start_at
+                spend_time_minutes = int(spend_time.total_seconds() // 60)
+                spend_time_seconds = int(spend_time.total_seconds() % 60)
+                spend_time_str = f"{spend_time_minutes}分{spend_time_seconds}秒"
+            else:
+                spend_time_str = "--"
+
+            # 获取用户邮箱（通过 Customer 模型关联查询）
+            customer = Customer.query.get(t.customer_id)
+            customer_email = customer.email if customer else "--"
+            customer_no = customer.customer_no if customer.customer_no else t.customer_id
+            # 格式化时间字段
+            start_at_str = t.start_at.strftime('%Y-%m-%d %H:%M:%S') if t.start_at else "--"
+            end_at_str = t.end_at.strftime('%Y-%m-%d %H:%M:%S') if t.end_at else "--"
+
+            # 构建返回数据
+            data.append({
+                'id': t.id,
+                'customer_no': customer_no,
+                'customer_id': t.customer_id,  # 所属用户 ID
+                'customer_email': customer_email,  # 用户邮箱
+                'origin_filename': t.origin_filename,
+                'status': t.status,
+                'process': float(t.process) if t.process is not None else None,  # 转换为 float
+                'start_at': start_at_str,  # 开始时间
+                'end_at': end_at_str,  # 完成时间
+                'spend_time': spend_time_str,  # 完成用时
+                'lang': t.lang,
+                'target_filepath': t.target_filepath
+            })
+
+        # 返回响应数据
+        return APIResponse.success({
+            'data': data,
+            'total': pagination.total,
+            'current_page': pagination.page
+        })
+
+
+# 批量下载多个翻译文件
+class AdminTranslateDownloadBatchResource(Resource):
+    @jwt_required()
+    def post(self):
+        """批量下载多个翻译结果文件（管理员接口）"""
+        try:
+            # 解析请求体中的 ids 参数
+            data = request.get_json()
+            if not data or 'ids' not in data:
+                return {"message": "缺少 ids 参数"}, 400
+
+            ids = data['ids']
+            if not isinstance(ids, list):
+                return {"message": "ids 必须是数组"}, 400
+
+            # 查询指定的翻译记录
+            records = Translate.query.filter(
+                Translate.id.in_(ids),  # 过滤指定 ID
+                Translate.deleted_flag == 'N'  # 只下载未删除的记录
+            ).all()
+
+            # 生成内存 ZIP 文件
+            zip_buffer = BytesIO()
+            with zipfile.ZipFile(zip_buffer, 'w') as zip_file:
+                for record in records:
+                    if record.target_filepath and os.path.exists(record.target_filepath):
+                        # 将文件添加到 ZIP 中
+                        zip_file.write(
+                            record.target_filepath,
+                            os.path.basename(record.target_filepath)
+                        )
+
+            # 重置缓冲区指针
+            zip_buffer.seek(0)
+
+            # 返回 ZIP 文件
+            return send_file(
+                zip_buffer,
+                mimetype='application/zip',
+                as_attachment=True,
+                download_name=f"translations_{datetime.now().strftime('%Y%m%d_%H%M%S')}.zip"
+            )
+        except Exception as e:
+            return {"message": f"服务器错误: {str(e)}"}, 500
+
+
+# 下载单个翻译文件
+class AdminTranslateDownloadResource(Resource):
+    # @jwt_required()
+    def get(self, id):
+        """通过 ID 下载单个翻译结果文件[^5]"""
+        # 查询翻译记录
+        translate = Translate.query.filter_by(
+            id=id,
+            # customer_id=get_jwt_identity()
+        ).first_or_404()
+
+        # 确保文件存在
+        if not translate.target_filepath or not os.path.exists(translate.target_filepath):
+            return APIResponse.error('文件不存在', 404)
+
+        # 返回文件
+        response = make_response(send_file(
+            translate.target_filepath,
+            as_attachment=True,
+            download_name=os.path.basename(translate.target_filepath)
+        ))
+
+        # 禁用缓存
+        response.headers['Cache-Control'] = 'no-store, no-cache, must-revalidate, max-age=0'
+        response.headers['Pragma'] = 'no-cache'
+        response.headers['Expires'] = '0'
+
+        return response
+
+
+# 删除单个翻译记录
+class AdminTranslateDeteleResource(Resource):
+    @jwt_required()
+    def delete(self, id):
+        """删除单个翻译记录[^2]"""
+        try:
+            record = Translate.query.get_or_404(id)
+            db.session.delete(record)
+            db.session.commit()
+            return APIResponse.success(message='记录删除成功')
+        except Exception as e:
+            db.session.rollback()
+            return APIResponse.error('删除失败', 500)
+
+
+class AdminTranslateBatchDeleteResource(Resource):
+    def post(self):
+        """批量删除翻译记录[^3]"""
+        try:
+            ids = validate_id_list(request.json.get('ids'))
+            if len(ids) > 100:
+                return APIResponse.error('单次最多删除100条记录', 400)
+
+            Translate.query.filter(Translate.id.in_(ids)).delete()
+            db.session.commit()
+            return APIResponse.success(message=f'成功删除{len(ids)}条记录')
+        except APIResponse as e:
+            return e
+        except Exception as e:
+            db.session.rollback()
+            return APIResponse.error('批量删除失败', 500)
+
+
+class AdminTranslateRestartResource(Resource):
+    def post(self, id):
+        """重启翻译任务[^4]"""
+        try:
+            record = Translate.query.get_or_404(id)
+            if record.status not in ['failed', 'done']:
+                return APIResponse.error('当前状态无法重启', 400)
+
+            record.status = 'none'
+            record.start_at = None
+            record.end_at = None
+            record.failed_reason = None
+            db.session.commit()
+            return APIResponse.success(message='任务已重启')
+        except Exception as e:
+            db.session.rollback()
+            return APIResponse.error('重启失败', 500)
+
+
+class AdminTranslateStatisticsResource(Resource):
+    def get(self):
+        """获取翻译统计信息[^5]"""
+        try:
+            total = Translate.query.count()
+            done_count = Translate.query.filter_by(status='done').count()
+            processing_count = Translate.query.filter_by(status='process').count()
+            failed_count = Translate.query.filter_by(status='failed').count()
+
+            return APIResponse.success({
+                'total': total,
+                'done_count': done_count,
+                'processing_count': processing_count,
+                'failed_count': failed_count
+            })
+        except Exception as e:
+            return APIResponse.error('获取统计信息失败', 500)

app/resources/admin/users.py

@@ -0,0 +1,107 @@
+# resources/admin/user.py
+from flask import request
+from flask_restful import Resource, reqparse
+from flask_jwt_extended import jwt_required
+
+from app import db
+from app.models import User
+from app.utils.auth_tools import hash_password
+from app.utils.response import APIResponse
+
+class AdminUserListResource(Resource):
+    @jwt_required()
+    def get(self):
+        """获取用户列表[^1]"""
+        parser = reqparse.RequestParser()
+        parser.add_argument('page', type=int, default=1)
+        parser.add_argument('limit', type=int, default=20)
+        parser.add_argument('search', type=str)
+        args = parser.parse_args()
+
+        query = User.query
+        if args['search']:
+            query = query.filter(User.email.ilike(f"%{args['search']}%"))
+
+        pagination = query.paginate(page=args['page'], per_page=args['limit'], error_out=False)
+        users = [{
+            'id': u.id,
+            'name': u.name,
+            'email': u.email,
+            'status': 'active' if u.deleted_flag == 'N' else 'deleted'
+        } for u in pagination.items]
+
+        return APIResponse.success({
+            'data': users,
+            'total': pagination.total
+        })
+
+
+# 创建新用户
+class AdminCreateUserResource(Resource):
+    @jwt_required()
+    def put(self):
+        """创建新用户[^2]"""
+        data = request.json
+        required_fields = ['name', 'email', 'password']
+        if not all(field in data for field in required_fields):
+            return APIResponse.error('缺少必要参数', 400)
+
+        if User.query.filter_by(email=data['email']).first():
+            return APIResponse.error('邮箱已存在', 400)
+
+        user = User(
+            name=data['name'],
+            email=data['email'],
+            password=hash_password(data['password'])
+        )
+        db.session.add(user)
+        db.session.commit()
+        return APIResponse.success({
+            'user_id': user.id,
+            'message': '用户创建成功'
+        })
+
+# 获取用户详细信息
+class AdminUserDetailResource(Resource):
+    @jwt_required()
+    def get(self, id):
+        """获取用户详细信息[^3]"""
+        user = User.query.get_or_404(id)
+        return APIResponse.success({
+            'id': user.id,
+            'name': user.name,
+            'email': user.email,
+            'status': 'active' if user.deleted_flag == 'N' else 'deleted',
+            'created_at': user.created_at.isoformat()
+        })
+
+# 编辑用户信息
+class AdminUpdateUserResource(Resource):
+    @jwt_required()
+    def post(self, id):
+        """编辑用户信息[^4]"""
+        user = User.query.get_or_404(id)
+        data = request.json
+
+        if 'email' in data and User.query.filter(User.email == data['email'],
+                                                 User.id != id).first():
+            return APIResponse.error('邮箱已被使用', 400)
+
+        if 'name' in data:
+            user.name = data['name']
+        if 'email' in data:
+            user.email = data['email']
+
+        db.session.commit()
+        return APIResponse.success(message='用户信息更新成功')
+
+# 删除用户
+class AdminDeleteUserResource(Resource):
+    @jwt_required()
+    def delete(self, id):
+        """删除用户[^5]"""
+        user = User.query.get_or_404(id)
+        user.deleted_flag = 'Y'
+        db.session.commit()
+        return APIResponse.success(message='用户删除成功')
+

app/resources/api/AccountResource.py

@@ -0,0 +1,143 @@
+
+from flask import request, current_app
+from flask_restful import Resource
+from flask_jwt_extended import jwt_required, get_jwt_identity
+from datetime import datetime, timedelta
+from app import db
+from app.models import Customer, SendCode
+from app.utils.security import hash_password, verify_password
+from app.utils.response import APIResponse
+from app.utils.mail_service import EmailService
+from app.utils.validators import (
+    validate_verification_code,
+    validate_password_confirmation,
+    validate_password_complexity
+)
+import random
+
+
+class ChangePasswordResource(Resource):
+    @jwt_required()
+    def post(self):
+        """修改密码（旧密码验证）[^1]"""
+        user_id = get_jwt_identity()
+        data = request.json
+
+        # 参数校验
+        required_fields = ['oldpwd', 'newpwd', 'newpwd_confirmation']
+        if not all(field in data for field in required_fields):
+            return APIResponse.error('缺少必要参数', 400)
+
+        # 密码一致性验证
+        is_valid, msg = validate_password_confirmation({
+            'password': data['newpwd'],
+            'password_confirmation': data['newpwd_confirmation']
+        })
+        if not is_valid:
+            return APIResponse.error(msg, 400)
+
+        # 密码复杂度验证
+        is_valid, msg = validate_password_complexity(data['newpwd'])
+        if not is_valid:
+            return APIResponse.error(msg, 422)
+
+        customer = Customer.query.get(user_id)
+        if not verify_password(customer.password, data['oldpwd']):
+            return APIResponse.error('旧密码不正确', 401)
+
+        customer.password = hash_password(data['newpwd'])
+        customer.updated_at = datetime.utcnow()
+        db.session.commit()
+        return APIResponse.success(message='密码修改成功')
+
+
+class SendChangeCodeResource(Resource):
+    @jwt_required()
+    def post(self):
+        """发送修改密码验证码[^2]"""
+        user_id = get_jwt_identity()
+        customer = Customer.query.get(user_id)
+
+        code = ''.join(random.choices('0123456789', k=6))
+        send_code = SendCode(
+            send_type=3,  # 密码修改验证码类型[^6]
+            send_to=customer.email,
+            code=code,
+            created_at=datetime.utcnow()
+        )
+        db.session.add(send_code)
+        try:
+            EmailService.send_verification_code(customer.email, code)
+            db.session.commit()
+            return APIResponse.success(message='验证码已发送')
+        except Exception as e:
+            db.session.rollback()
+            return APIResponse.error('邮件发送失败', 500)
+
+
+class EmailChangePasswordResource(Resource):
+    @jwt_required()
+    def post(self):
+        """通过邮箱验证码修改密码[^3]"""
+        user_id = get_jwt_identity()
+        data = request.json
+
+        # 参数校验
+        required_fields = ['code', 'newpwd', 'newpwd_confirmation']
+        if not all(field in data for field in required_fields):
+            return APIResponse.error('缺少必要参数', 400)
+
+        # 密码一致性验证
+        is_valid, msg = validate_password_confirmation({
+            'password': data['newpwd'],
+            'password_confirmation': data['newpwd_confirmation']
+        })
+        if not is_valid:
+            return APIResponse.error(msg, 400)
+
+        # 验证码有效性验证
+        customer = Customer.query.get(user_id)
+        is_valid, msg = validate_verification_code(
+            customer.email, data['code'], 3
+        )
+        if not is_valid:
+            return APIResponse.error(msg, 400)
+
+        # 更新密码
+        customer.password = hash_password(data['newpwd'])
+        customer.updated_at = datetime.utcnow()
+        db.session.commit()
+        return APIResponse.success(message='密码修改成功')
+
+
+class StorageInfoResource(Resource):
+    @jwt_required()
+    def get(self):
+        """获取存储空间信息[^2]"""
+        user_id = get_jwt_identity()
+        customer = Customer.query.get(user_id)
+
+        total = current_app.config['MAX_USER_STORAGE'] / (1024 * 1024)  # 转换为MB
+        used = customer.storage / (1024 * 1024)  # 转换为MB
+        percentage = (used / total) * 100 if total > 0 else 0
+
+        return APIResponse.success({
+            'storage': f"{total:.2f}",
+            'used': f"{used:.2f}",
+            'percentage': f"{percentage:.1f}"
+        })
+
+
+class UserInfoResource(Resource):
+    @jwt_required()
+    def get(self):
+        """获取用户基本信息[^5]"""
+        user_id = get_jwt_identity()
+        customer = Customer.query.get(user_id)
+
+        return APIResponse.success({
+            'email': customer.email,
+            'level': customer.level,
+            'created_at': customer.created_at.isoformat(),
+            'storage': customer.storage
+        })

app/resources/api/AuthResource.py

@@ -0,0 +1,142 @@
+# resources/auth.py
+from flask import request
+from flask_restful import Resource
+from flask_jwt_extended import create_access_token
+from datetime import datetime, timedelta
+
+from app import db
+from app.models import  Customer, SendCode
+from app.utils.security import hash_password, verify_password
+from app.utils.response import APIResponse
+from app.utils.mail_service import EmailService
+import random
+
+from app.utils.validators import (
+    validate_verification_code,
+    validate_password_confirmation
+)
+
+
+
+
+class SendRegisterCodeResource(Resource):
+    def post(self):
+        """发送注册验证码接口[^1]"""
+        email = request.form.get('email')
+        if Customer.query.filter_by(email=email).first():
+            return APIResponse.error('邮箱已存在', 400)
+
+        code = ''.join(random.choices('0123456789', k=6))
+        send_code = SendCode(
+            send_type=1,
+            send_to=email,
+            code=code,
+            created_at=datetime.utcnow()
+        )
+        db.session.add(send_code)
+        try:
+            EmailService.send_verification_code(email, code)
+            db.session.commit()
+            return APIResponse.success()
+        except Exception as e:
+            db.session.rollback()
+            return APIResponse.error('邮件发送失败', 500)
+
+
+class UserRegisterResource(Resource):
+    def post(self):
+        """用户注册接口[^2]"""
+        data = request.form
+
+        required_fields = ['email', 'password', 'code']
+        if not all(field in data for field in required_fields):
+            return APIResponse.error('缺少必要参数', 400)
+
+        # 验证码有效性验证
+        is_valid, msg = validate_verification_code(
+            data['email'], data['code'], 1
+        )
+        if not is_valid:
+            return APIResponse.error(msg, 400)
+
+        customer = Customer(
+            email=data['email'],
+            password=hash_password(data['password']),
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+        db.session.add(customer)
+        db.session.commit()
+
+        # 确保identity是字符串
+        # access_token = create_access_token(identity=str(customer.id))
+        return APIResponse.success(message='注册成功！',data={
+            # 'token': access_token,
+            'email': data['email']
+        })
+
+
+class UserLoginResource(Resource):
+    def post(self):
+        """用户登录接口[^3]"""
+        data = request.form
+        customer = Customer.query.filter_by(email=data['email']).first()
+
+        if not customer or not verify_password(customer.password, data['password']):
+            return APIResponse.error('账号或密码错误')
+        # 确保identity是字符串
+        access_token = create_access_token(identity=str(customer.id))
+        return APIResponse.success({
+            'token': access_token,
+            'email': data['email'],
+            'level': customer.level
+        })
+
+
+class SendResetCodeResource(Resource):
+    def post(self):
+        """发送密码重置验证码接口[^4]"""
+        email = request.form.get('email')
+        if not Customer.query.filter_by(email=email).first():
+            return APIResponse.not_found('用户不存在')
+
+        code = ''.join(random.choices('0123456789', k=6))
+        send_code = SendCode(
+            send_type=2,
+            send_to=email,
+            code=code,
+            created_at=datetime.utcnow()
+        )
+        db.session.add(send_code)
+        try:
+            EmailService.send_verification_code(email, code)
+            db.session.commit()
+            return APIResponse.success()
+        except Exception as e:
+            db.session.rollback()
+            return APIResponse.error('邮件发送失败', 500)
+
+
+class ResetPasswordResource(Resource):
+    def post(self):
+        """重置密码接口[^5]"""
+        data = request.form
+
+        # 密码一致性验证
+        is_valid, msg = validate_password_confirmation(data)
+        if not is_valid:
+            return APIResponse.error(msg, 400)
+
+        # 验证码有效性验证
+        is_valid, msg = validate_verification_code(
+            data['email'], data['code'], 2
+        )
+        if not is_valid:
+            return APIResponse.error(msg, 400)
+
+        customer = Customer.query.filter_by(email=data['email']).first()
+        customer.password = hash_password(data['password'])
+        customer.updated_at = datetime.utcnow()
+        db.session.commit()
+        return APIResponse.success()
+

app/resources/api/common.py

@@ -0,0 +1,20 @@
+# app/resources/api/common.py
+from flask_restful import Resource
+
+from app.utils.response import APIResponse
+from app.models.setting import Setting
+
+
+class SystemConfigResource(Resource):
+    def get(self):
+        """获取系统版本配置 [^6]"""
+        try:
+            version = Setting.get_version()
+            return APIResponse.success({"version": version})
+
+        except Exception as e:
+            return APIResponse.error(
+                message="服务器内部错误",
+                code=500,
+                errors=str(e)
+            )

app/resources/api/comparison.py

@@ -0,0 +1,449 @@
+# resources/comparison.py
+import os
+import zipfile
+from datetime import datetime
+from io import BytesIO
+
+import pandas as pd
+from flask import request, current_app, send_file
+from flask_restful import Resource, reqparse
+from flask_jwt_extended import jwt_required, get_jwt_identity
+
+from app import db
+from app.models import Customer
+from app.models.comparison import Comparison, ComparisonFav
+from app.utils.response import APIResponse
+from sqlalchemy import func
+from datetime import datetime
+
+
+class MyComparisonListResource(Resource):
+    @jwt_required()
+    def get(self):
+        """获取我的术语表列表[^1]"""
+        # 直接查询所有数据（不解析查询参数）
+        query = Comparison.query.filter_by(customer_id=get_jwt_identity())
+        comparisons = [self._format_comparison(comparison) for comparison in query.all()]
+
+        # 返回结果
+        return APIResponse.success({
+            'data': comparisons,
+            'total': len(comparisons)
+        })
+
+    def _format_comparison(self, comparison):
+        """格式化术语表数据"""
+        # 解析 content 字段
+        content_list = []
+        if comparison.content:
+            for item in comparison.content.split('; '):
+                if ':' in item:
+                    origin, target = item.split(':', 1)
+                    content_list.append({
+                        'origin': origin.strip(),
+                        'target': target.strip()
+                    })
+
+        # 返回格式化后的数据
+        return {
+            'id': comparison.id,
+            'title': comparison.title,
+            'origin_lang': comparison.origin_lang,
+            'target_lang': comparison.target_lang,
+            'share_flag': comparison.share_flag,
+            'added_count': comparison.added_count,
+            'content': content_list,  # 返回解析后的数组
+            'customer_id': comparison.customer_id,
+            'created_at': comparison.created_at.strftime('%Y-%m-%d %H:%M') if comparison.created_at else None,  # 格式化时间
+            'updated_at': comparison.updated_at.strftime('%Y-%m-%d %H:%M') if comparison.updated_at else None,  # 格式化时间
+            'deleted_flag': comparison.deleted_flag
+        }
+
+
+
+
+# 获取共享术语表列表
+class SharedComparisonListResource(Resource):
+    @jwt_required()
+    def get(self):
+        """获取共享术语表列表[^3]"""
+        # 从查询字符串中解析参数
+        parser = reqparse.RequestParser()
+        parser.add_argument('page', type=int, default=1, location='args')  # 分页参数
+        parser.add_argument('limit', type=int, default=10, location='args')  # 分页参数
+        parser.add_argument('order', type=str, default='latest', location='args')  # 排序参数
+        args = parser.parse_args()
+
+        # 查询共享的术语表，并关联 Customer 表获取用户 email
+        query = db.session.query(
+            Comparison,
+            func.count(ComparisonFav.id).label('fav_count'),  # 动态计算收藏量
+            Customer.email.label('customer_email')  # 获取用户的 email
+        ).outerjoin(
+            ComparisonFav, Comparison.id == ComparisonFav.comparison_id
+        ).outerjoin(
+            Customer, Comparison.customer_id == Customer.id  # 通过 customer_id 关联 Customer
+        ).filter(
+            Comparison.share_flag == 'Y',
+            Comparison.deleted_flag == 'N'
+        ).group_by(
+            Comparison.id
+        )
+
+        # 根据 order 参数排序
+        if args['order'] == 'latest':
+            query = query.order_by(Comparison.created_at.desc())  # 按最新发表排序
+        elif args['order'] == 'added':
+            query = query.order_by(Comparison.added_count.desc())  # 按添加量排序
+        elif args['order'] == 'fav':
+            query = query.order_by(func.count(ComparisonFav.id).desc())  # 按收藏量排序
+
+        # 分页查询
+        pagination = query.paginate(page=args['page'], per_page=args['limit'], error_out=False)
+        comparisons = [{
+            'id': comparison.id,
+            'title': comparison.title,
+            'origin_lang': comparison.origin_lang,
+            'target_lang': comparison.target_lang,
+            'content': self.parse_content(comparison.content),  # 解析 content 字段为数组
+            'email': customer_email if customer_email else '匿名用户',  # 返回用户 email
+            'added_count': comparison.added_count,
+            'created_at': comparison.created_at.strftime('%Y-%m-%d %H:%M'),  # 格式化时间
+            'faved': self.check_faved(comparison.id),  # 检查是否被当前用户收藏
+            'fav_count': fav_count  # 添加收藏量
+        } for comparison, fav_count, customer_email in pagination.items]
+
+        # 返回结果
+        return APIResponse.success({
+            'data': comparisons,
+            'total': pagination.total,
+            'current_page': pagination.page,
+            'per_page': pagination.per_page
+        })
+
+    def parse_content(self, content_str):
+        """将 content 字符串解析为数组格式"""
+        content_list = []
+        if content_str:
+            for item in content_str.split('; '):
+                if ':' in item:
+                    origin, target = item.split(':', 1)  # 分割为 origin 和 target
+                    content_list.append({
+                        'origin': origin.strip(),
+                        'target': target.strip()
+                    })
+        return content_list
+
+    def check_faved(self, comparison_id):
+        """检查当前用户是否收藏了该术语表"""
+        # 假设当前用户的 ID 存储在 JWT 中
+        user_id = get_jwt_identity()
+        if user_id:
+            fav = ComparisonFav.query.filter_by(
+                comparison_id=comparison_id,
+                customer_id=user_id
+            ).first()
+            return 1 if fav else 0
+        return 0
+
+
+
+
+# 编辑术语列表
+class EditComparisonResource(Resource):
+    @jwt_required()
+    def post(self, id):
+        """编辑术语表[^3]"""
+        comparison = Comparison.query.filter_by(
+            id=id,
+            customer_id=get_jwt_identity()
+        ).first_or_404()
+
+        data = request.form
+        if 'title' in data:
+            comparison.title = data['title']
+        if 'content' in data:
+            comparison.content = data['content']
+        if 'origin_lang' in data:
+            comparison.origin_lang = data['origin_lang']
+        if 'target_lang' in data:
+            comparison.target_lang = data['target_lang']
+
+        db.session.commit()
+        return APIResponse.success(message='术语表更新成功')
+
+# 更新术语表共享状态
+class ShareComparisonResource(Resource):
+    @jwt_required()
+    def post(self, id):
+        """修改共享状态[^4]"""
+        comparison = Comparison.query.filter_by(
+            id=id,
+            customer_id=get_jwt_identity()
+        ).first_or_404()
+
+        data = request.form
+        if 'share_flag' not in data or data['share_flag'] not in ['Y', 'N']:
+            return APIResponse.error('share_flag 参数无效', 400)
+
+        comparison.share_flag = data['share_flag']
+        db.session.commit()
+        return APIResponse.success(message='共享状态已更新')
+
+
+
+# 复制到我的术语库
+class CopyComparisonResource(Resource):
+    @jwt_required()
+    def post(self, id):
+        """复制到我的术语库[^5]"""
+        comparison = Comparison.query.filter_by(
+            id=id,
+            share_flag='Y'
+        ).first_or_404()
+
+        new_comparison = Comparison(
+            title=f"{comparison.title} (副本)",
+            content=comparison.content,
+            origin_lang=comparison.origin_lang,
+            target_lang=comparison.target_lang,
+            customer_id=get_jwt_identity(),
+            share_flag='N'
+        )
+        db.session.add(new_comparison)
+        db.session.commit()
+        return APIResponse.success({
+            'new_id': new_comparison.id
+        })
+
+# 收藏/取消收藏
+class FavoriteComparisonResource(Resource):
+    @jwt_required()
+    def post(self, id):
+        """收藏/取消收藏[^6]"""
+        comparison = Comparison.query.filter_by(id=id).first_or_404()
+        customer_id = get_jwt_identity()
+
+        favorite = ComparisonFav.query.filter_by(
+            comparison_id=id,
+            customer_id=customer_id
+        ).first()
+
+        if favorite:
+            db.session.delete(favorite)
+            message = '已取消收藏'
+        else:
+            new_favorite = ComparisonFav(
+                comparison_id=id,
+                customer_id=customer_id
+            )
+            db.session.add(new_favorite)
+            message = '已收藏'
+
+        db.session.commit()
+        return APIResponse.success(message=message)
+
+# 创建新术语表
+class CreateComparisonResource(Resource):
+    @jwt_required()
+    def post(self):
+        """创建新术语表[^1]"""
+        data = request.form
+        required_fields = ['title', 'share_flag', 'origin_lang', 'target_lang']
+        if not all(field in data for field in required_fields):
+            return APIResponse.error('缺少必要参数', 400)
+
+        # 解析 content 参数
+        content_list = []
+        for key, value in data.items():
+            if key.startswith('content[') and '][origin]' in key:
+                # 提取索引
+                index = key.split('[')[1].split(']')[0]
+                origin = value
+                target = data.get(f'content[{index}][target]', '')
+                content_list.append(f"{origin}: {target}")
+
+        # 将 content_list 转换为字符串
+        content_str = '; '.join(content_list)
+
+        # 获取当前时间
+        current_time = datetime.utcnow()
+
+        # 创建术语表
+        comparison = Comparison(
+            title=data['title'],
+            origin_lang=data['origin_lang'],
+            target_lang=data['target_lang'],
+            content=content_str,  # 插入转换后的 content 字符串
+            customer_id=get_jwt_identity(),
+            share_flag=data.get('share_flag', 'N'),
+            created_at=current_time,  # 显式赋值
+            updated_at=current_time   # 显式赋值
+        )
+        db.session.add(comparison)
+        db.session.commit()
+        return APIResponse.success({
+            'id': comparison.id
+        })
+
+
+# 删除术语表
+class DeleteComparisonResource(Resource):
+    @jwt_required()
+    def delete(self, id):
+        """删除术语表[^2]"""
+        comparison = Comparison.query.filter_by(
+            id=id,
+            customer_id=get_jwt_identity()
+        ).first_or_404()
+
+        db.session.delete(comparison)
+        db.session.commit()
+        return APIResponse.success(message='删除成功')
+
+
+# 下载模板文件
+class DownloadTemplateResource(Resource):
+    def get(self):
+        """下载模板文件[^3]"""
+        from flask import send_file
+        from io import BytesIO
+        import pandas as pd
+
+        # 创建模板文件
+        df = pd.DataFrame(columns=['源术语', '目标术语'])
+        output = BytesIO()
+        with pd.ExcelWriter(output, engine='xlsxwriter') as writer:
+            df.to_excel(writer, index=False)
+        output.seek(0)
+
+        return send_file(
+            output,
+            mimetype='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+            as_attachment=True,
+            download_name='术语表模板.xlsx'
+        )
+
+# 导入术语表
+class ImportComparisonResource(Resource):
+    @jwt_required()
+    def post(self):
+        """
+        导入 Excel 文件
+        """
+        # 检查是否上传了文件
+        if 'file' not in request.files:
+            return APIResponse.error('未选择文件', 400)
+        file = request.files['file']
+
+        try:
+            # 读取 Excel 文件
+            import pandas as pd
+            df = pd.read_excel(file)
+
+            # 检查文件是否包含所需的列
+            if not {'源术语', '目标术语'}.issubset(df.columns):
+                return APIResponse.error('文件格式不符合模板要求', 406)
+            # 解析 Excel 文件内容
+            content = ';'.join([f"{row['源术语']}: {row['目标术语']}" for _, row in df.iterrows()])  # 按 ': ' 分隔
+            # 创建术语表
+            comparison = Comparison(
+                title='导入的术语表',
+                origin_lang='未知',
+                target_lang='未知',
+                content=content,  # 使用改进后的格式
+                customer_id=get_jwt_identity(),
+                share_flag='N'
+            )
+            db.session.add(comparison)
+            db.session.commit()
+
+            # 返回成功响应
+            return APIResponse.success({
+                'id': comparison.id
+            })
+        except Exception as e:
+            # 捕获并返回错误信息
+            return APIResponse.error(f"文件导入失败：{str(e)}", 500)
+
+
+
+# 导出单个术语表
+class ExportComparisonResource(Resource):
+    @jwt_required()
+    def get(self, id):
+        """
+        导出单个术语表
+        """
+        # 获取当前用户 ID
+        current_user_id = get_jwt_identity()
+
+        # 查询术语表
+        comparison = Comparison.query.get_or_404(id)
+
+        # 检查术语表是否共享或属于当前用户
+        if comparison.share_flag != 'Y' and comparison.user_id != current_user_id:
+            return {'message': '术语表未共享或无权限访问', 'code': 403}, 403
+
+        # 解析术语内容
+        terms = [term.split(': ') for term in comparison.content.split(';')]  # 按 ': ' 分割
+        df = pd.DataFrame(terms, columns=['源术语', '目标术语'])
+
+        # 创建 Excel 文件
+        output = BytesIO()
+        with pd.ExcelWriter(output, engine='xlsxwriter') as writer:
+            df.to_excel(writer, index=False)
+        output.seek(0)
+
+        # 返回文件下载响应
+        return send_file(
+            output,
+            mimetype='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+            as_attachment=True,
+            download_name=f'{comparison.title}.xlsx'
+        )
+
+
+
+
+# 批量导出所有术语表
+class ExportAllComparisonsResource(Resource):
+    @jwt_required()
+    def get(self):
+        """
+        批量导出所有术语表
+        """
+        # 获取当前用户 ID
+        current_user_id = get_jwt_identity()
+
+        # 查询当前用户的所��术语表
+        comparisons = Comparison.query.filter_by(customer_id=current_user_id).all()
+
+        # 创建 ZIP 文件
+        memory_file = BytesIO()
+        with zipfile.ZipFile(memory_file, 'w') as zf:
+            for comparison in comparisons:
+                # 解析术语内容
+                terms = [term.split(': ') for term in comparison.content.split(';')]  # 按 ': ' 分割
+                df = pd.DataFrame(terms, columns=['源术语', '目标术语'])
+
+                # 创建 Excel 文件
+                output = BytesIO()
+                with pd.ExcelWriter(output, engine='xlsxwriter') as writer:
+                    df.to_excel(writer, index=False)
+                output.seek(0)
+
+                # 将 Excel 文件添加到 ZIP 中
+                zf.writestr(f"{comparison.title}.xlsx", output.getvalue())
+
+        memory_file.seek(0)
+
+        # 返回 ZIP 文件下载响应
+        return send_file(
+            memory_file,
+            mimetype='application/zip',
+            as_attachment=True,
+            download_name=f'术语表_{datetime.now().strftime("%Y%m%d")}.zip'
+        )
+
+

app/resources/api/customer.py

@@ -0,0 +1,32 @@
+# resources/customer.py
+from app.utils.response import APIResponse
+import uuid
+from flask_restful import Resource, reqparse
+from flask_jwt_extended import jwt_required
+from app.models.customer import Customer
+class GuestIdResource(Resource):
+    def get(self):
+        """生成临时访客唯一标识[^1]"""
+        guest_id = str(uuid.uuid4())
+        return APIResponse.success({
+            'guest_id': guest_id
+        })
+
+
+
+
+
+class CustomerDetailResource(Resource):
+    @jwt_required()
+    def get(self, customer_id):
+        """获取客户详细信息[^2]"""
+        customer = Customer.query.get_or_404(customer_id)
+        return APIResponse.success({
+            'id': customer.id,
+            'email': customer.email,
+            'level': customer.level,
+            'created_at': customer.created_at.isoformat(),
+            'storage': customer.storage
+        })
+
+

app/resources/api/files.py

@@ -0,0 +1,339 @@
+# resources/file.py
+import hashlib
+import uuid
+from werkzeug.utils import secure_filename
+import os
+from app import db
+from app.models.customer import Customer
+from app.models.translate import Translate
+from app.utils.response import APIResponse
+from pathlib import Path
+from flask_restful import Resource
+from flask_jwt_extended import jwt_required, get_jwt_identity
+from flask import request, current_app
+from datetime import datetime
+
+
+class FileUploadResource1(Resource):
+    @jwt_required()
+    def post(self):
+        """文件上传接口"""
+        # 验证文件存在性
+        if 'file' not in request.files:
+            return APIResponse.error('未选择文件', 400)
+        file = request.files['file']
+
+        # 验证文件名有效性
+        if file.filename == '':
+            return APIResponse.error('无效文件名', 400)
+
+        # 验证文件类型
+        if not self.allowed_file(file.filename):
+            return APIResponse.error(
+                f"仅支持以下格式：{', '.join(current_app.config['ALLOWED_EXTENSIONS'])}", 400)
+
+        # 验证文件大小
+        if not self.validate_file_size(file.stream):
+            return APIResponse.error(
+                f"文件大小超过{current_app.config['MAX_FILE_SIZE'] // (1024 * 1024)}MB限制", 400)
+
+        # 获取用户存储信息
+        user_id = get_jwt_identity()
+        customer = Customer.query.get(user_id)
+        file_size = request.content_length  # 使用实际内容长度
+
+        # 验证存储空间
+        if customer.storage + file_size > current_app.config['MAX_USER_STORAGE']:
+            return APIResponse.error('存储空间不足', 403)
+
+        try:
+            # 生成存储路径
+            save_dir = self.get_upload_dir()
+            filename = file.filename  # 直接使用原始文件名
+            save_path = os.path.join(save_dir, filename)
+
+            # 检查路径是否安全
+            if not self.is_safe_path(save_dir, save_path):
+                return APIResponse.error('文件名包含非法字符', 400)
+
+            # 保存文件
+            file.save(save_path)
+            # 更新用户存储空间
+            customer.storage += file_size
+            db.session.commit()
+            # 生成 UUID
+            file_uuid = str(uuid.uuid4())
+            # 计算文件的 MD5
+            file_md5 = self.calculate_md5(save_path)
+
+            # 创建翻译记录
+            translate_record = Translate(
+                translate_no=f"TRANS{datetime.now().strftime('%Y%m%d%H%M%S')}",
+                uuid=file_uuid,
+                customer_id=user_id,
+                origin_filename=filename,
+                origin_filepath=os.path.abspath(save_path),  # 使用绝对路径
+                target_filepath='',  # 目标文件路径暂为空
+                status='none',  # 初始状态为 none
+                origin_filesize=file_size,
+                md5=file_md5,
+                created_at=datetime.utcnow()
+            )
+            db.session.add(translate_record)
+            db.session.commit()
+
+            # 返回响应，包含文件名、UUID 和翻译记录 ID
+            return APIResponse.success({
+                'filename': filename,
+                'uuid': file_uuid,
+                'translate_id': translate_record.id,
+                'save_path': os.path.abspath(save_path)  # 返回绝对路径
+            })
+
+        except Exception as e:
+            db.session.rollback()
+            current_app.logger.error(f"文件上传失败：{str(e)}")
+            return APIResponse.error('文件上传失败', 500)
+
+    @staticmethod
+    def allowed_file(filename):
+        # """验证文件类型是否允许"""# 暂不支持PDF 'pdf',
+        ALLOWED_EXTENSIONS = {'docx', 'xlsx', 'pptx', 'txt', 'md', 'csv', 'xls', 'doc'}
+        return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+
+    @staticmethod
+    def validate_file_size(file_stream):
+        """验证文件大小是否超过限制"""
+        MAX_FILE_SIZE = 10 * 1024 * 1024  # 10MB
+        file_stream.seek(0, os.SEEK_END)
+        file_size = file_stream.tell()
+        file_stream.seek(0)
+        return file_size <= MAX_FILE_SIZE
+
+    @staticmethod
+    def get_upload_dir():
+        """获取按日期分类的上传目录"""
+        # 获取上传根目录
+        base_dir = Path(current_app.config['UPLOAD_BASE_DIR'])
+        upload_dir = base_dir / 'uploads' / datetime.now().strftime('%Y-%m-%d')
+
+        # 如果目录不存在则创建
+        if not upload_dir.exists():
+            upload_dir.mkdir(parents=True, exist_ok=True)
+
+        return str(upload_dir)
+
+    @staticmethod
+    def calculate_md5(file_path):
+        """计算文件的 MD5 值"""
+        hash_md5 = hashlib.md5()
+        with open(file_path, "rb") as f:
+            for chunk in iter(lambda: f.read(4096), b""):
+                hash_md5.update(chunk)
+        return hash_md5.hexdigest()
+
+    @staticmethod
+    def is_safe_path(base_dir, file_path):
+        """检查文件路径是否安全，防止路径遍历攻击"""
+        base_dir = Path(base_dir).resolve()
+        file_path = Path(file_path).resolve()
+        return file_path.is_relative_to(base_dir)
+
+
+
+class FileUploadResource(Resource):
+    @jwt_required()
+    def post(self):
+        """文件上传接口"""
+        # 验证文件存在性
+        if 'file' not in request.files:
+            return APIResponse.error('未选择文件', 400)
+        file = request.files['file']
+
+        # 验证文件名有效性
+        if file.filename == '':
+            return APIResponse.error('无效文件名', 400)
+
+        # 验证文件类型
+        if not self.allowed_file(file.filename):
+            return APIResponse.error(
+                f"仅支持以下格式：{', '.join(current_app.config['ALLOWED_EXTENSIONS'])}", 400)
+
+        # 验证文件大小
+        if not self.validate_file_size(file.stream):
+            return APIResponse.error(
+                f"文件大小超过{current_app.config['MAX_FILE_SIZE'] // (1024 * 1024)}MB限制", 400)
+
+        # 获取用户存储信息
+        user_id = get_jwt_identity()
+        customer = Customer.query.get(user_id)
+        file_size = request.content_length  # 使用实际内容长度
+
+        # 验证存储空间
+        if customer.storage + file_size > current_app.config['MAX_USER_STORAGE']:
+            return APIResponse.error('存储空间不足', 403)
+
+        try:
+            # 生成存储路径
+            save_dir = Path(self.get_upload_dir())
+            filename = file.filename  # 直接使用原始文件名
+            save_path = save_dir / filename
+
+            # 检查路径是否安全
+            if not self.is_safe_path(save_dir, save_path):
+                return APIResponse.error('文件名包含非法字符', 400)
+
+            # 保存文件
+            file.save(save_path)
+            # 更新用户存储空间
+            customer.storage += file_size
+            db.session.commit()
+            # 生成 UUID
+            file_uuid = str(uuid.uuid4())
+            # 计算文件的 MD5
+            file_md5 = self.calculate_md5(save_path)
+
+            # 创建翻译记录
+            translate_record = Translate(
+                translate_no=f"TRANS{datetime.now().strftime('%Y%m%d%H%M%S')}",
+                uuid=file_uuid,
+                customer_id=user_id,
+                origin_filename=filename,
+                origin_filepath=str(save_path.resolve()),  # 使用绝对路径
+                target_filepath='',  # 目标文件路径暂为空
+                status='none',  # 初始状态为 none
+                origin_filesize=file_size,
+                md5=file_md5,
+                created_at=datetime.utcnow()
+            )
+            db.session.add(translate_record)
+            db.session.commit()
+
+            # 返回响应，包含文件名、UUID 和翻译记录 ID
+            return APIResponse.success({
+                'filename': filename,
+                'uuid': file_uuid,
+                'translate_id': translate_record.id,
+                'save_path': str(save_path.resolve())  # 返回绝对路径
+            })
+
+        except Exception as e:
+            db.session.rollback()
+            current_app.logger.error(f"文件上传失败：{str(e)}")
+            return APIResponse.error('文件上传失败', 500)
+
+    @staticmethod
+    def allowed_file(filename):
+        """验证文件类型是否允许"""
+        ALLOWED_EXTENSIONS = {'docx', 'xlsx', 'pptx', 'txt', 'md', 'csv', 'xls', 'doc'}
+        return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+
+    @staticmethod
+    def validate_file_size(file_stream):
+        """验证文件大小是否超过限制"""
+        MAX_FILE_SIZE = 10 * 1024 * 1024  # 10MB
+        file_stream.seek(0, os.SEEK_END)
+        file_size = file_stream.tell()
+        file_stream.seek(0)
+        return file_size <= MAX_FILE_SIZE
+
+    @staticmethod
+    def get_upload_dir():
+        """获取按日期分类的上传目录"""
+        # 获取上传根目录
+        base_dir = Path(current_app.config['UPLOAD_BASE_DIR'])
+        upload_dir = base_dir / 'uploads' / datetime.now().strftime('%Y-%m-%d')
+
+        # 如果目录不存在则创建
+        if not upload_dir.exists():
+            upload_dir.mkdir(parents=True, exist_ok=True)
+
+        return str(upload_dir)
+
+    @staticmethod
+    def calculate_md5(file_path):
+        """计算文件的 MD5 值"""
+        hash_md5 = hashlib.md5()
+        with open(file_path, "rb") as f:
+            for chunk in iter(lambda: f.read(4096), b""):
+                hash_md5.update(chunk)
+        return hash_md5.hexdigest()
+
+    @staticmethod
+    def is_safe_path(base_dir, file_path):
+        """检查文件路径是否安全，防止路径遍历攻击"""
+        base_dir = Path(base_dir).resolve()
+        file_path = Path(file_path).resolve()
+        return file_path.is_relative_to(base_dir)
+
+
+
+class FileDeleteResource1(Resource):
+    @jwt_required()
+    def post(self):
+        """文件删除接口[^1]"""
+        data = request.form
+        if 'uuid' not in data:
+            return APIResponse.error('缺少必要参数', 400)
+
+        try:
+            # 根据 UUID 查询翻译记录
+            translate_record = Translate.query.filter_by(uuid=data['uuid']).first()
+            if not translate_record:
+                return APIResponse.error('文件记录不存在', 404)
+
+            # 获取文件绝对路径
+            file_path = translate_record.origin_filepath
+
+            # 删除物理文件
+            if os.path.exists(file_path):
+                os.remove(file_path)
+            else:
+                current_app.logger.warning(f"文件不存在：{file_path}")
+
+            # 删除数据库记录
+            db.session.delete(translate_record)
+            db.session.commit()
+
+            return APIResponse.success(message='文件删除成功')
+
+        except Exception as e:
+            db.session.rollback()
+            current_app.logger.error(f"文件删除失败：{str(e)}")
+            return APIResponse.error('文件删除失败', 500)
+
+
+
+class FileDeleteResource(Resource):
+    @jwt_required()
+    def post(self):
+        """文件删除接口"""
+        data = request.form
+        if 'uuid' not in data:
+            return APIResponse.error('缺少必要参数', 400)
+
+        try:
+            # 根据 UUID 查询翻译记录
+            translate_record = Translate.query.filter_by(uuid=data['uuid']).first()
+            if not translate_record:
+                return APIResponse.error('文件记录不存在', 404)
+
+            # 获取文件绝对路径
+            file_path = Path(translate_record.origin_filepath)
+
+            # 删除物理文件
+            if file_path.exists():
+                file_path.unlink()
+            else:
+                current_app.logger.warning(f"文件不存在：{file_path}")
+
+            # 删除数据库记录
+            db.session.delete(translate_record)
+            db.session.commit()
+
+            return APIResponse.success(message='文件删除成功')
+
+        except Exception as e:
+            db.session.rollback()
+            current_app.logger.error(f"文件删除失败：{str(e)}")
+            return APIResponse.error('文件删除失败', 500)

app/resources/api/prompt.py

@@ -0,0 +1,245 @@
+# resources/prompt.py
+from datetime import datetime, date
+
+from flask import request
+from flask_restful import Resource, reqparse
+from flask_jwt_extended import jwt_required, get_jwt_identity
+from sqlalchemy import func
+from app import db
+from app.models import Customer
+from app.models.prompt import Prompt, PromptFav
+from app.utils.response import APIResponse
+
+# 获取提示语列表
+class MyPromptListResource(Resource):
+    @jwt_required()
+    def get(self):
+        """获取我的提示语列表[^1]"""
+        # 直接查询所有数据（不解析查询参数）
+        query = Prompt.query.filter_by(customer_id=get_jwt_identity(), deleted_flag='N')
+        prompts = [{
+            'id': p.id,
+            'title': p.title,
+            'content': p.content[:100] + '...' if len(p.content) > 100 else p.content,
+            'share_flag': p.share_flag,
+            'created_at': p.created_at.isoformat() if p.created_at else None
+        } for p in query.all()]
+
+        # 返回结果
+        return APIResponse.success({
+            'data': prompts,
+            'total': len(prompts)
+        })
+
+
+
+# 获取共享提示语列表
+class SharedPromptListResource(Resource):
+    def get(self):
+        """获取共享提示语列表[^4]"""
+        # 从查询字符串中解析参数
+        parser = reqparse.RequestParser()
+        parser.add_argument('page', type=int, default=1, location='args')  # 分页参数
+        parser.add_argument('limit', type=int, default=10, location='args')  # 分页参数
+        parser.add_argument('porder', type=str, default='latest', location='args')  # 排序参数
+        args = parser.parse_args()
+
+        # 查询共享的提示语
+        query = db.session.query(
+            Prompt,  # 获取完整的 Prompt 信息
+            func.count(PromptFav.id).label('fav_count'),  # 动态计算收藏量
+            Customer.email.label('customer_email')  # 获取用户的 email
+        ).outerjoin(
+            PromptFav, Prompt.id == PromptFav.prompt_id
+        ).outerjoin(
+            Customer, Prompt.customer_id == Customer.id  # 通过 customer_id 关联 Customer
+        ).filter(
+            Prompt.share_flag == 'Y',
+            Prompt.deleted_flag == 'N'
+        ).group_by(
+            Prompt.id
+        )
+
+        # 根据 porder 参数排序
+        if args['porder'] == 'latest':
+            query = query.order_by(Prompt.created_at.desc())  # 按最新发表排序
+        elif args['porder'] == 'added':
+            query = query.order_by(Prompt.added_count.desc())  # 按添加量排序
+        elif args['porder'] == 'fav':
+            query = query.order_by(func.count(PromptFav.id).desc())  # 按收藏量排序
+
+        # 分页查询
+        pagination = query.paginate(page=args['page'], per_page=args['limit'], error_out=False)
+        prompts = [{
+            'id': prompt.id,
+            'title': prompt.title,
+            'content': prompt.content,  # 返回完整的提示语内容
+            'email': customer_email if customer_email else '匿名用户',  # 使用查询结果中的 email
+            'share_flag': prompt.share_flag,
+            'added_count': prompt.added_count,
+            'created_at': prompt.created_at.strftime('%Y-%m-%d') if prompt.created_at else None,  # 处理 None 值
+            'updated_at': prompt.updated_at.strftime('%Y-%m-%d') if prompt.updated_at else None,  # 处理 None 值
+            'fav_count': fav_count
+        } for prompt, fav_count, customer_email in pagination.items]
+
+        # 返回结果
+        return APIResponse.success({
+            'data': prompts,
+            'total': pagination.total
+        })
+
+
+
+
+# 修改提示语内容
+class EditPromptResource(Resource):
+    @jwt_required()
+    def post(self, id):
+        """修改提示语内容[^3]"""
+        prompt = Prompt.query.filter_by(
+            id=id,
+            customer_id=get_jwt_identity(),
+            deleted_flag='N'
+        ).first_or_404()
+
+        data = request.form
+        if 'title' in data:
+            if len(data['title']) > 255:
+                return APIResponse.error('标题过长', 400)
+            prompt.title = data['title']
+
+        if 'content' in data:
+            if len(data['content']) > 5000:
+                return APIResponse.error('内容超过5000字符限制', 400)
+            prompt.content = data['content']
+
+        db.session.commit()
+        return APIResponse.success(message='提示语更新成功')
+
+# 更新共享状态
+class SharePromptResource(Resource):
+    @jwt_required()
+    def post(self, id):
+        """
+        修改共享状态[^4]
+        :param id: prompt 的 ID（路径参数）
+        """
+        # 根据 id 和当前用户查询 prompt
+        prompt = Prompt.query.filter_by(
+            id=id,
+            customer_id=get_jwt_identity(),
+            deleted_flag='N'
+        ).first_or_404()
+
+        # 从请求体中获取 share_flag
+        data = request.form  # 或者 request.form 如果是表单数据
+        if not data or 'share_flag' not in data or data['share_flag'] not in ['Y', 'N']:
+            return APIResponse.error('无效的共享状态参数', 400)
+
+        # 更新共享状态
+        prompt.share_flag = data['share_flag']
+        db.session.commit()
+
+        return APIResponse.success(message='共享状态已更新')
+
+
+# 复制到我的提示语库
+class CopyPromptResource(Resource):
+    @jwt_required()
+    def post(self, id):
+        """复制到我的提示语库[^5]"""
+        original = Prompt.query.filter_by(
+            id=id,
+            share_flag='Y',
+            deleted_flag='N'
+        ).first_or_404()
+
+        new_prompt = Prompt(
+            title=f"{original.title} (副本)",
+            content=original.content,
+            customer_id=get_jwt_identity(),
+            share_flag='N',
+            added_count=0
+        )
+        db.session.add(new_prompt)
+        db.session.commit()
+        return APIResponse.success({
+            'new_id': new_prompt.id,
+            'message': '复制成功'
+        })
+
+# 收藏/取消收藏
+class FavoritePromptResource(Resource):
+    @jwt_required()
+    def post(self, id):
+        """收藏/取消收藏[^6]"""
+        prompt = Prompt.query.get_or_404(id)
+        customer_id = get_jwt_identity()
+
+        fav = PromptFav.query.filter_by(
+            prompt_id=id,
+            customer_id=customer_id
+        ).first()
+
+        if fav:
+            db.session.delete(fav)
+            action = '取消收藏'
+        else:
+            new_fav = PromptFav(
+                prompt_id=id,
+                customer_id=customer_id
+            )
+            db.session.add(new_fav)
+            action = '收藏'
+
+        prompt.added_count = prompt.added_count + (1 if not fav else -1)
+        db.session.commit()
+        return APIResponse.success(message=f'{action}成功')
+
+# 创建新的提示语
+
+class CreatePromptResource(Resource):
+    @jwt_required()
+    def post(self):
+        """创建新提示语[^7]"""
+        data = request.form
+        required_fields = ['title', 'content']
+        if not all(field in data for field in required_fields):
+            return APIResponse.error('缺少必要参数', 400)
+
+        if len(data['title']) > 255:
+            return APIResponse.error('标题过长', 400)
+        if len(data['content']) > 5000:
+            return APIResponse.error('内容超过5000字符限制', 400)
+
+        # 创建时自动设置 created_at 为当前时间
+        prompt = Prompt(
+            title=data['title'],
+            content=data['content'],
+            customer_id=get_jwt_identity(),
+            share_flag=data.get('share_flag', 'N'),
+            created_at=date.today()  # 自动设置当前时间
+        )
+        db.session.add(prompt)
+        db.session.commit()
+        return APIResponse.success({
+            'id': prompt.id,
+            'message': '创建成功'
+        })
+
+
+# 删除提示语
+class DeletePromptResource(Resource):
+    @jwt_required()
+    def delete(self, id):
+        """删除提示语[^8]"""
+        prompt = Prompt.query.filter_by(
+            id=id,
+            customer_id=get_jwt_identity()
+        ).first_or_404()
+
+        prompt.deleted_flag = 'Y'
+        db.session.commit()
+        return APIResponse.success(message='删除成功')
+
+

app/resources/api/setting.py

@@ -0,0 +1,27 @@
+# resources/system.py
+from flask_restful import Resource
+from app.utils.response import APIResponse
+from flask import current_app
+
+class SystemVersionResource(Resource):
+    def get(self):
+        """获取系统版本信息[^1]"""
+        return APIResponse.success({
+            'version': current_app.config['SYSTEM_VERSION'],
+            'message': 'success'
+        })
+
+class SystemSettingsResource(Resource):
+    def get(self):
+        """获取全量系统配置[^2]"""
+        return APIResponse.success({
+            'site_setting': {
+                'version': current_app.config['SYSTEM_VERSION'],
+                'site_name': current_app.config['SITE_NAME']
+            },
+            'api_setting': {
+                'api_url': current_app.config['API_URL'],
+                'models': current_app.config['TRANSLATE_MODELS']
+            },
+            'message': 'success'
+        })

app/resources/api/translate.py

@@ -0,0 +1,590 @@
+# resources/to_translate.py
+import json
+from pathlib import Path
+from flask import request, send_file, current_app, make_response
+from flask_restful import Resource
+from flask_jwt_extended import jwt_required, get_jwt_identity
+from datetime import datetime
+from io import BytesIO
+import zipfile
+import os
+
+from app import db, Setting
+from app.models import Customer
+from app.models.translate import Translate
+from app.resources.task.translate_service import TranslateEngine
+from app.utils.response import APIResponse
+from app.utils.check_utils import AIChecker
+
+# 定义翻译配置（硬编码示例）
+TRANSLATE_SETTINGS = {
+    "models": ["gpt-3.5-turbo", "gpt-4"],
+    "default_model": "gpt-3.5-turbo",
+    "max_threads": 5,
+    "prompt_template": "请将以下内容翻译为{target_lang}"
+}
+
+
+class TranslateStartResource1(Resource):
+    @jwt_required()
+    def post(self):
+        """启动翻译任务（支持绝对路径和多参数）[^1]"""
+        data = request.form
+        required_fields = [
+            'server', 'model', 'lang', 'uuid',
+            'prompt', 'threads', 'file_name'
+        ]
+
+        # 参数校验
+        if not all(field in data for field in required_fields):
+            return APIResponse.error("缺少必要参数", 400)
+
+        # 验证OpenAI配置
+        if data['server'] == 'openai' and not all(k in data for k in ['api_url', 'api_key']):
+            return APIResponse.error("OpenAI服务需要API地址和密钥", 400)
+
+        try:
+            # 获取用户信息
+            user_id = get_jwt_identity()
+            customer = Customer.query.get(user_id)
+
+            # 生成绝对路径（跨平台兼容）
+            def get_absolute_storage_path(filename):
+                # 获取项目根目录的父目录（假设storage目录与项目目录同级）
+                base_dir = Path(current_app.root_path).parent.absolute()
+                # 按日期创建子目录（如 storage/translate/2024-01-20）
+                date_str = datetime.now().strftime('%Y-%m-%d')
+                # 创建目标目录（如果不存在）
+                target_dir = base_dir / "storage" / "translate" / date_str
+                target_dir.mkdir(parents=True, exist_ok=True)
+                # 返回绝对路径（保持原文件名）
+                return str(target_dir / filename)
+
+            origin_filename = data['file_name']
+
+            # 生成翻译结果绝对路径
+            target_abs_path = get_absolute_storage_path(origin_filename)
+
+            # 获取翻译类型（取最后一个type值）
+            translate_type = data.get('type[2]', 'trans_all_only_inherit')
+
+            # 查询或创建翻译记录
+            translate = Translate.query.filter_by(uuid=data['uuid']).first()
+            if not translate:
+                return APIResponse.error("未找到对应的翻译记录", 404)
+
+            # 更新翻译记录
+            translate.origin_filename = data['file_name']
+            translate.target_filepath = target_abs_path  # 存储翻译结果的绝对路径
+            translate.lang = data['lang']
+            translate.model = data['model']
+            translate.backup_model = data['backup_model']
+            translate.type = translate_type
+            translate.prompt = data['prompt']
+            translate.threads = int(data['threads'])
+            translate.api_url = data.get('api_url', '')
+            translate.api_key = data.get('api_key', '')
+            translate.backup_model = data.get('backup_model', '')
+            translate.origin_lang = data.get('origin_lang', '')
+            # 获取 comparison_id 并转换为整数
+            comparison_id = data.get('comparison_id', '0')  # 默认值为 '0'
+            translate.comparison_id = int(comparison_id) if comparison_id else None
+            prompt_id = data.get('prompt_id', '0')
+            translate.prompt_id = int(prompt_id) if prompt_id else None
+            translate.doc2x_flag = data.get('doc2x_flag', 'N')
+            translate.doc2x_secret_key = data.get('doc2x_secret_key', '')
+
+            # 保存到数据库
+            db.session.commit()
+            # with current_app.app_context():  # 确保在应用上下文中运行
+            # 启动翻译引擎，传入 current_app
+            TranslateEngine(translate.id).execute()
+
+            return APIResponse.success({
+                "task_id": translate.id,
+                "uuid": translate.uuid,
+                "target_path": target_abs_path
+            })
+
+        except Exception as e:
+            db.session.rollback()
+            current_app.logger.error(f"翻译任务启动失败: {str(e)}", exc_info=True)
+            return APIResponse.error("任务启动失败", 500)
+
+
+
+class TranslateStartResource(Resource):
+    @jwt_required()
+    def post(self):
+        """启动翻译任务（支持绝对路径和多��数）[^1]"""
+        data = request.form
+        required_fields = [
+            'server', 'model', 'lang', 'uuid',
+            'prompt', 'threads', 'file_name'
+        ]
+
+        # 参数校验
+        if not all(field in data for field in required_fields):
+            return APIResponse.error("缺少必要参数", 400)
+
+        # 验证OpenAI配置
+        if data['server'] == 'openai' and not all(k in data for k in ['api_url', 'api_key']):
+            return APIResponse.error("OpenAI服务需要API地址和密钥", 400)
+
+        try:
+            # 获取用户信息
+            user_id = get_jwt_identity()
+            customer = Customer.query.get(user_id)
+
+            # 生成绝对路径（跨平台兼容）
+            def get_absolute_storage_path(filename):
+                # 获取项目根目录的父目录（假设storage目录与项目目录同级）
+                base_dir = Path(current_app.root_path).parent.absolute()
+                # 按日期创建子目录（如 storage/translate/2024-01-20）
+                date_str = datetime.now().strftime('%Y-%m-%d')
+                # 创建目标目录（如果不存在）
+                target_dir = base_dir / "storage" / "translate" / date_str
+                target_dir.mkdir(parents=True, exist_ok=True)
+                # 返回绝对路径（保持原文件名）
+                return target_dir / filename
+
+            origin_filename = data['file_name']
+
+            # 生成翻译结果绝对路径
+            target_abs_path = get_absolute_storage_path(origin_filename)
+
+            # 获取翻译类型（取最后一个type值）
+            translate_type = data.get('type[2]', 'trans_all_only_inherit')
+
+            # 查询或创建翻译记录
+            translate = Translate.query.filter_by(uuid=data['uuid']).first()
+            if not translate:
+                return APIResponse.error("未找到对应的翻译记录", 404)
+
+            # 更新翻译记录
+            translate.origin_filename = origin_filename
+            translate.target_filepath = str(target_abs_path)  # 存储翻译结果的绝对路径
+            translate.lang = data['lang']
+            translate.model = data['model']
+            translate.backup_model = data['backup_model']
+            translate.type = translate_type
+            translate.prompt = data['prompt']
+            translate.threads = int(data['threads'])
+            translate.api_url = data.get('api_url', '')
+            translate.api_key = data.get('api_key', '')
+            translate.backup_model = data.get('backup_model', '')
+            translate.origin_lang = data.get('origin_lang', '')
+            # 获取 comparison_id 并转换为整数
+            comparison_id = data.get('comparison_id', '0')  # 默认值为 '0'
+            translate.comparison_id = int(comparison_id) if comparison_id else None
+            prompt_id = data.get('prompt_id', '0')
+            translate.prompt_id = int(prompt_id) if prompt_id else None
+            translate.doc2x_flag = data.get('doc2x_flag', 'N')
+            translate.doc2x_secret_key = data.get('doc2x_secret_key', '')
+
+            # 保存到数据库
+            db.session.commit()
+            # 启动翻译引擎，传入 current_app
+            TranslateEngine(translate.id).execute()
+
+            return APIResponse.success({
+                "task_id": translate.id,
+                "uuid": translate.uuid,
+                "target_path": str(target_abs_path)
+            })
+
+        except Exception as e:
+            db.session.rollback()
+            current_app.logger.error(f"翻译任务启动失败: {str(e)}", exc_info=True)
+            return APIResponse.error("任务启动失败", 500)
+
+
+
+class TranslateListResource(Resource):
+    @jwt_required()
+    def get(self):
+        """获取翻译记录列表"""
+        # 获取查询参数
+        page = request.args.get('page', '1')
+        limit = request.args.get('limit', '100')
+        status_filter = request.args.get('status')
+        # 将字符串参数转换为整数
+        try:
+            page = int(page)
+            limit = int(limit)
+        except ValueError:
+            return APIResponse.error("Invalid page or limit value"), 400
+        # 构建查询条件
+        query = Translate.query.filter_by(
+            customer_id=get_jwt_identity(),
+            deleted_flag='N'
+        )
+
+        # 检查 status_filter 是否是合法值
+        if status_filter:
+            valid_statuses = {'none', 'process', 'done', 'failed'}
+            if status_filter not in valid_statuses:
+                return APIResponse.error(f"Invalid status value: {status_filter}"), 400
+            query = query.filter_by(status=status_filter)
+
+        # 执行分页查询
+        pagination = query.paginate(page=page, per_page=limit, error_out=False)
+
+        # 处理每条记录
+        data = []
+        for t in pagination.items:
+            # 计算花费时间（基于 created_at 和 end_at）
+            if t.created_at and t.end_at:
+                spend_time = t.end_at - t.created_at
+                spend_time_minutes = int(spend_time.total_seconds() // 60)
+                spend_time_seconds = int(spend_time.total_seconds() % 60)
+                spend_time_str = f"{spend_time_minutes}分{spend_time_seconds}秒"
+            else:
+                spend_time_str = "--"
+
+            # 获取状态中文描述
+            status_name_map = {
+                'none': '未开始',
+                'process': '进行中',
+                'done': '已完成',
+                'failed': '失败'
+            }
+            status_name = status_name_map.get(t.status, '未知状态')
+
+            # 获取文件类型
+            file_type = self.get_file_type(t.origin_filename)
+
+            # 格式化完成时间（精确到秒）
+            end_at_str = t.end_at.strftime('%Y-%m-%d %H:%M:%S') if t.end_at else "--"
+
+            data.append({
+                'id': t.id,
+                'file_type': file_type,
+                'origin_filename': t.origin_filename,
+                'status': t.status,
+                'status_name': status_name,
+                'process': float(t.process),  # 将 Decimal 转换为 float
+                'spend_time': spend_time_str,  # 花费时间
+                'end_at': end_at_str,  # 完成时间
+                'start_at': t.start_at.strftime('%Y-%m-%d %H:%M:%S') if t.start_at else "--",
+                # 开始时间
+                'lang': t.lang,
+                'target_filepath': t.target_filepath
+            })
+
+        # 返回响应数据
+        return APIResponse.success({
+            'data': data,
+            'total': pagination.total,
+            'current_page': pagination.page
+        })
+
+    @staticmethod
+    def get_file_type(filename):
+        """根据文件名获取文件类型"""
+        if not filename:
+            return "未知"
+        ext = filename.split('.')[-1].lower()
+        if ext in {'docx', 'doc'}:
+            return "Word"
+        elif ext in {'xlsx', 'xls'}:
+            return "Excel"
+        elif ext == 'pptx':
+            return "PPT"
+        elif ext == 'pdf':
+            return "PDF"
+        elif ext in {'txt', 'md'}:
+            return "文本"
+        else:
+            return "其他"
+
+# 获取翻译配置
+class TranslateSettingResource(Resource):
+    @jwt_required()
+    def get(self):
+        """获取翻译配置"""
+        try:
+            # 从数据库中获取翻译配置
+            settings = self._load_settings_from_db()
+            return APIResponse.success(settings)
+        except Exception as e:
+            return APIResponse.error(f"获取配置失败: {str(e)}", 500)
+
+    @staticmethod
+    def _load_settings_from_db():
+        """
+        从数据库加载翻译配置
+        """
+        # 查询翻译相关的配置（api_setting 和 other_setting 分组）
+        settings = Setting.query.filter(
+            Setting.group.in_(['api_setting', 'other_setting']),
+            Setting.deleted_flag == 'N'
+        ).all()
+
+        # 转换为配置字典
+        config = {}
+        for setting in settings:
+            # 如果 serialized 为 True，则反序列化 value
+            value = json.loads(setting.value) if setting.serialized else setting.value
+
+            # 根据 alias 存储配置
+            if setting.alias == 'models':
+                config['models'] = value.split(',') if isinstance(value, str) else value
+            elif setting.alias == 'default_model':
+                config['default_model'] = value
+            elif setting.alias == 'default_backup':
+                config['default_backup'] = value
+            elif setting.alias == 'api_url':
+                config['api_url'] = value
+            elif setting.alias == 'api_key':
+                config['api_key'] = value
+            elif setting.alias == 'prompt':
+                config['prompt_template'] = value
+            elif setting.alias == 'threads':
+                config['max_threads'] = int(value) if value.isdigit() else 10  # 默认10线程
+
+        # 设置默认值（如果数据库中没有相关配置）
+        config.setdefault('models', ['gpt-3.5-turbo', 'gpt-4'])
+        config.setdefault('default_model', 'gpt-3.5-turbo')
+        config.setdefault('default_backup', 'gpt-3.5-turbo')
+        config.setdefault('api_url', '')
+        config.setdefault('api_key', '')
+        config.setdefault('prompt_template', '请将以下内容翻译为{target_lang}')
+        config.setdefault('max_threads', 10)
+
+        return config
+
+
+class TranslateProcessResource(Resource):
+    @jwt_required()
+    def post(self):
+        """查询翻译进度[^3]"""
+        uuid = request.form.get('uuid')
+        translate = Translate.query.filter_by(
+            uuid=uuid,
+            customer_id=get_jwt_identity()
+        ).first_or_404()
+
+        return APIResponse.success({
+            'status': translate.status,
+            'progress': float(translate.process),
+            'download_url': translate.target_filepath if translate.status == 'done' else None
+        })
+
+
+class TranslateDeleteResource(Resource):
+    @jwt_required()
+    def delete(self, id):
+        """软删除翻译记录[^4]"""
+        # 查询翻译记录
+        translate = Translate.query.filter_by(
+            id=id,
+            customer_id=get_jwt_identity()
+        ).first_or_404()
+
+        # 更新 deleted_flag 为 'Y'
+        translate.deleted_flag = 'Y'
+        db.session.commit()
+
+        return APIResponse.success(message='记录已标记为删除')
+
+
+
+class TranslateDownloadResource(Resource):
+    # @jwt_required()
+    def get(self, id):
+        """通过 ID 下载单个翻译结果文件[^5]"""
+        # 查询翻译记录
+        translate = Translate.query.filter_by(
+            id=id,
+            # customer_id=get_jwt_identity()
+        ).first_or_404()
+
+        # 确保文件存在
+        if not translate.target_filepath or not os.path.exists(translate.target_filepath):
+            return APIResponse.error('文件不存在', 404)
+
+        # 返回文件
+        response = make_response(send_file(
+            translate.target_filepath,
+            as_attachment=True,
+            download_name=os.path.basename(translate.target_filepath)
+        ))
+
+        # 禁用缓存
+        response.headers['Cache-Control'] = 'no-store, no-cache, must-revalidate, max-age=0'
+        response.headers['Pragma'] = 'no-cache'
+        response.headers['Expires'] = '0'
+
+        return response
+
+
+
+
+
+
+class TranslateDownloadAllResource(Resource):
+    @jwt_required()
+    def get(self):
+        """批量下载所有翻译结果文件[^6]"""
+        # 查询当前用户的所有翻译记录
+        records = Translate.query.filter_by(
+            customer_id=get_jwt_identity(),
+            deleted_flag='N'  # 只下载未删除的记录
+        ).all()
+
+        # 生成内存 ZIP 文件
+        zip_buffer = BytesIO()
+        with zipfile.ZipFile(zip_buffer, 'w') as zip_file:
+            for record in records:
+                if record.target_filepath and os.path.exists(record.target_filepath):
+                    # 将文件添加到 ZIP 中
+                    zip_file.write(
+                        record.target_filepath,
+                        os.path.basename(record.target_filepath)
+                    )
+
+        # 重置缓冲区指针
+        zip_buffer.seek(0)
+
+        # 返回 ZIP 文件
+        return send_file(
+            zip_buffer,
+            mimetype='application/zip',
+            as_attachment=True,
+            download_name=f"translations_{datetime.now().strftime('%Y%m%d_%H%M%S')}.zip"
+        )
+
+
+class OpenAICheckResource(Resource):
+    @jwt_required()
+    def post(self):
+        """OpenAI接口检测[^6]"""
+        data = request.form
+        required = ['api_url', 'api_key', 'model']
+        if not all(k in data for k in required):
+            return APIResponse.error('缺少必要参数', 400)
+
+        is_valid, msg = AIChecker.check_openai_connection(
+            data['api_url'],
+            data['api_key'],
+            data['model']
+        )
+
+        return APIResponse.success({'valid': is_valid, 'message': msg})
+
+
+class PDFCheckResource(Resource):
+    @jwt_required()
+    def post(self):
+        """PDF扫描件检测[^7]"""
+        if 'file' not in request.files:
+            return APIResponse.error('请选择PDF文件', 400)
+
+        file = request.files['file']
+        if not file.filename.lower().endswith('.pdf'):
+            return APIResponse.error('仅支持PDF文件', 400)
+
+        try:
+            file_stream = file.stream
+            is_scanned = AIChecker.check_pdf_scanned(file_stream)
+            return APIResponse.success({'scanned': is_scanned})
+        except Exception as e:
+            return APIResponse.error(f'检测失败: {str(e)}', 500)
+
+
+# resources/to_translate.py 补充接口
+class TranslateTestResource(Resource):
+    def get(self):
+        """测试翻译服务[^1]"""
+        return APIResponse.success(message="测试服务正常")
+
+
+class TranslateDeleteAllResource(Resource):
+    @jwt_required()
+    def delete(self):
+        """删除用户所有翻译记录[^2]"""
+        Translate.query.filter_by(
+            customer_id=get_jwt_identity(),
+            deleted_flag='N'
+        ).delete()
+        db.session.commit()
+        return APIResponse.success(message="删除成功")
+
+
+class TranslateFinishCountResource(Resource):
+    @jwt_required()
+    def get(self):
+        """获取已完成翻译数量[^3]"""
+        count = Translate.query.filter_by(
+            customer_id=get_jwt_identity(),
+            status='done',
+            deleted_flag='N'
+        ).count()
+        return APIResponse.success({'total': count})
+
+
+class TranslateRandDeleteAllResource(Resource):
+    def delete(self):
+        """删除临时用户所有记录[^4]"""
+        rand_user_id = request.json.get('rand_user_id')
+        if not rand_user_id:
+            return APIResponse.error('需要临时用户ID', 400)
+
+        Translate.query.filter_by(
+            rand_user_id=rand_user_id,
+            deleted_flag='N'
+        ).delete()
+        db.session.commit()
+        return APIResponse.success(message="删除成功")
+
+
+class TranslateRandDeleteResource(Resource):
+    def delete(self, id):
+        """删除临时用户单条记录[^5]"""
+        rand_user_id = request.json.get('rand_user_id')
+        translate = Translate.query.filter_by(
+            id=id,
+            rand_user_id=rand_user_id
+        ).first_or_404()
+
+        db.session.delete(translate)
+        db.session.commit()
+        return APIResponse.success(message="删除成功")
+
+
+class TranslateRandDownloadResource(Resource):
+    def get(self):
+        """下载临时用户翻译文件[^6]"""
+        rand_user_id = request.args.get('rand_user_id')
+        records = Translate.query.filter_by(
+            rand_user_id=rand_user_id,
+            status='done'
+        ).all()
+
+        zip_buffer = BytesIO()
+        with zipfile.ZipFile(zip_buffer, 'w') as zip_file:
+            for record in records:
+                if os.path.exists(record.target_filepath):
+                    zip_file.write(
+                        record.target_filepath,
+                        os.path.basename(record.target_filepath)
+                    )
+
+        zip_buffer.seek(0)
+        return send_file(
+            zip_buffer,
+            mimetype='application/zip',
+            as_attachment=True,
+            download_name=f"temp_translations_{datetime.now().strftime('%Y%m%d')}.zip"
+        )
+
+
+class Doc2xCheckResource(Resource):
+    def post(self):
+        """检查Doc2x接口[^7]"""
+        secret_key = request.json.get('doc2x_secret_key')
+        # 模拟验证逻辑，实际需对接Doc2x服务
+        if secret_key == "valid_key_123":  # 示例验证
+            return APIResponse.success(message="接口正常")
+        return APIResponse.error("无效密钥", 400)

app/resources/hello.py

@@ -0,0 +1,5 @@
+from flask_restful import Resource
+
+class HelloWorldResource(Resource):
+    def get(self):
+        return {'message': 'Hello World!'}

app/resources/task/main.py

@@ -0,0 +1,136 @@
+import threading
+import time
+from datetime import datetime
+import os
+import traceback
+from flask import current_app
+from app.extensions import db
+from app.models.comparison import Comparison
+from app.models.prompt import Prompt
+from app.models.translate import Translate
+from app.translate import word, excel, powerpoint, pdf, gptpdf, txt, csv_handle, md, to_translate
+
+
+def main_wrapper(task_id, config, origin_path):
+    """
+    翻译任务核心逻辑（支持多参数）[^4]
+    :param task_id: 任务ID
+    :param origin_path: 原始文件绝对路径
+    :param target_path: 目标文件绝对路径
+    :param config: 翻译配置字典
+    :return: 是否成功
+    """
+    try:
+        # 获取任务对象
+        task = Translate.query.get(task_id)
+        if not task:
+            current_app.logger.error(f"任务 {task_id} 不存在")
+            return False
+            # 设置OpenAI API
+
+        # 初始化翻译配置
+        _init_translate_config(task)
+        to_translate.init_openai(config['api_url'], config['api_key'])
+        # 获取文件扩展名
+        extension = os.path.splitext(origin_path)[1].lower()
+        print('文件扩展名',extension,origin_path)
+        # 调用文件处理器
+        handler_map = {
+            ('.docx', '.doc'): word,
+            ('.xlsx', '.xls'): excel,
+            ('.pptx', '.ppt'): powerpoint,
+            ('.pdf',): pdf,
+            ('.txt',): txt,
+            ('.csv',): csv_handle,
+            ('.md',): md
+        }
+
+        # 查找匹配的处理器
+        for ext_group, handler in handler_map.items():
+            if extension in ext_group:
+                # if extension == '.pdf':
+                #     status = handler(config, origin_path)  # 传递 origin_path
+                # else:
+                #     status = handler.start(config)  # 传递翻译配置
+                status = handler.start(
+                    # origin_path=origin_path,
+                    # target_path=target_path,
+                    trans=config  # 传递翻译配置
+                )
+                print('config配置项', config)
+                return status
+
+        current_app.logger.error(f"不支持的文件类型: {extension}")
+        return False
+
+    except Exception as e:
+        current_app.logger.error(f"翻译任务执行异常: {str(e)}", exc_info=True)
+        return False
+
+
+def _init_translate_config1(task):
+    """初始化翻译配置（如OpenAI）"""
+    if task.api_url and task.api_key:
+        import openai
+        openai.api_base = task.api_url
+        openai.api_key = task.api_key
+
+def pdf_handler(config, origin_path):
+    return gptpdf.start(config)
+    # if pdf.is_scanned_pdf(origin_path):
+    #     return gptpdf.start(config)
+    # else:
+    #     # 这里均使用gptpdf实现
+    #     return gptpdf.start(config)
+    #     # return pdf.start(config)
+def _init_translate_config(trans):
+    """
+    初始化翻译配置[^5]
+    :param trans: 翻译任务对象
+    """
+    # 设置OpenAI API
+    if trans.api_url and trans.api_key:
+        set_openai_config(trans.api_url, trans.api_key)
+
+    # 加载术语对照表
+    if trans.comparison_id:
+        comparison = get_comparison(trans.comparison_id)
+        trans.prompt = f"{comparison}\n{trans.prompt}"
+
+    # 加载提示词模板
+    if trans.prompt_id:
+        prompt = get_prompt(trans.prompt_id)
+        trans.prompt = prompt
+
+
+def set_openai_config(api_url, api_key):
+    """
+    设置OpenAI API配置[^6]
+    """
+    import openai
+    openai.api_base = api_url
+    openai.api_key = api_key
+
+
+def get_comparison(comparison_id):
+    """
+    加载术语对照表
+    :param comparison_id: 术语对照表ID
+    :return: 术语对照表内容
+    """
+    comparison = db.session.query(Comparison).filter_by(id=comparison_id).first()
+    if comparison and comparison.content:
+        return comparison.content.replace(',', ':').replace(';', '\n')
+    return ""
+
+
+def get_prompt(prompt_id):
+    """
+    加载提示词模板
+    :param prompt_id: 提示词模板ID
+    :return: 提示词内容
+    """
+    prompt = db.session.query(Prompt).filter_by(id=prompt_id).first()
+    if prompt and prompt.content:
+        return prompt.content
+    return ""

app/resources/task/translate.py

@@ -0,0 +1,38 @@
+# tasks/translate.py
+import subprocess
+
+from flask import current_app
+
+from app import db
+from app.models.translate import Translate
+
+
+def start_translate_task(task_id):
+    """启动翻译子进程[^2]"""
+    translate = Translate.query.get(task_id)
+    if not translate:
+        return False
+
+    try:
+        # 构建命令参数
+        storage_path = current_app.config['UPLOAD_FOLDER']
+        cmd = [
+            'python3',
+            'translate/main.py',
+            translate.uuid,
+            storage_path
+        ]
+
+        # 启动子进程
+        subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+        # 更新任务状态
+        translate.status = 'process'
+        db.session.commit()
+        return True
+
+    except Exception as e:
+        translate.status = 'failed'
+        translate.failed_reason = str(e)
+        db.session.commit()
+        return False

app/resources/task/translate_service.py

@@ -0,0 +1,644 @@
+import os
+import threading
+from threading import Thread
+from flask import current_app
+from app.models.translate import Translate
+from app.extensions import db
+from .main import main_wrapper
+from ...models.comparison import Comparison
+from ...models.prompt import Prompt
+
+
+
+
+class TranslateEngine99:
+    def __init__(self, task_id):
+        self.task_id = task_id
+        self.app = current_app._get_current_object()  # 获取真实app对象
+
+    def execute(self):
+        """启动翻译任务入口"""
+        try:
+            # 主线程预处理
+            with self.app.app_context():
+                task = self._prepare_task()
+
+            # 启动异步线程（传递真实app对象）
+            thr = threading.Thread(
+                target=self._async_wrapper,
+                args=(self.app, self.task_id)
+            )
+            thr.start()
+            return True
+        except Exception as e:
+            self.app.logger.error(f"任务初始化失败: {str(e)}", exc_info=True)
+            return False
+
+    def _async_wrapper(self, app, task_id):
+        """异步执行包装器"""
+        with app.app_context():
+            try:
+                # 每个线程独立获取任务对象
+                task = db.session.query(Translate).get(task_id)
+                self._async_execute(task)
+            except Exception as e:
+                app.logger.error(f"任务执行异常: {str(e)}", exc_info=True)
+                self._complete_task(False)
+            finally:
+                db.session.remove()  # 关键：清理线程会话
+
+    def _async_execute(self, task):
+        """执行核心翻译逻辑"""
+        try:
+            # 初始化配置（使用线程内session）
+            config = self._build_config(task)
+
+            # 调用翻译核心
+            success = main_wrapper(
+                task=task,
+                origin_path=task.origin_filepath,
+                target_path=task.target_filepath,
+                config=config
+            )
+            self._complete_task(success)
+        except Exception as e:
+            current_app.logger.error(f"翻译执行失败: {str(e)}", exc_info=True)
+            self._complete_task(False)
+
+    def _build_config(self, task):
+        """构建线程安全配置"""
+        return {
+            'lang': task.lang,
+            'model': task.model,
+            'type': task.type,
+            'prompt': self._load_prompt(task),
+            'threads': task.threads,
+            'api_url': task.api_url,
+            'api_key': task.api_key,
+            'comparison': self._load_comparison(task.comparison_id)
+        }
+
+    def _load_prompt(self, task):
+        """加载提示词（线程安全）"""
+        if task.prompt_id:
+            prompt = db.session.query(Prompt).get(task.prompt_id)
+            return prompt.content if prompt else ""
+        return task.prompt
+
+    def _load_comparison(self, comparison_id):
+        """加载术语对照表（线程安全）"""
+        if not comparison_id:
+            return ""
+        comparison = db.session.query(Comparison).get(comparison_id)
+        return comparison.content.replace(',', ':').replace(';', '\n') if comparison else ""
+
+    def _prepare_task(self):
+        """任务预处理"""
+        task = db.session.query(Translate).get(self.task_id)
+        if not task:
+            raise ValueError(f"任务 {self.task_id} 不存在")
+
+        if not os.path.exists(task.origin_filepath):
+            raise FileNotFoundError(f"文件不存在: {task.origin_filepath}")
+
+        task.status = 'process'
+        task.start_at = db.func.now()
+        db.session.commit()
+        return task
+
+    def _complete_task(self, success):
+        """完成处理"""
+        try:
+            task = db.session.query(Translate).get(self.task_id)
+            task.status = 'done' if success else 'failed'
+            task.end_at = db.func.now()
+            db.session.commit()
+        except Exception as e:
+            db.session.rollback()
+            self.app.logger.error(f"状态更新失败: {str(e)}", exc_info=True)
+
+
+
+
+class TranslateEngine666:
+    def __init__(self, task_id):
+        self.task_id = task_id
+        self.app = current_app._get_current_object()  # 获取真实app对象
+
+    def _build_trans_config(self, task):
+            """构建符合文件处理器要求的trans字典"""
+            return {
+                'id': task.id,  # 任务ID
+                'threads': task.threads,
+                'file_path': task.origin_filepath,  # 原始文件绝对路径
+                'target_file': task.target_filepath,  # 目标文件绝对路径
+                'api_url': task.api_url,
+                'api_key': task.api_key,  # 新增API密钥字段
+                'type': task.type,
+                'lang': task.lang,
+                'run_complete': True,  # 默认设为True
+                # 以下是可能需要添加的额外字段
+                'prompt': task.prompt,
+                'model': task.model,
+                'backup_model': task.backup_model,
+                'comparison_id': task.comparison_id,
+                'prompt_id': task.prompt_id,
+                'extension':'.docx'
+            }
+
+    def execute(self):
+        """启动任务入口"""
+        try:
+            # 在主线程上下文中准备任务
+            with self.app.app_context():
+                task = self._prepare_task()
+
+            # 启动线程时传递真实app对象和任务ID
+            thr = Thread(
+                target=self._async_wrapper,
+                args=(self.app, self.task_id)
+            )
+            thr.start()
+            return True
+        except Exception as e:
+            self.app.logger.error(f"任务初始化失败: {str(e)}", exc_info=True)
+            return False
+
+    def _async_wrapper(self, app, task_id):
+        """异步执行包装器"""
+        with app.app_context():
+            from app.extensions import db  # 确保在每个线程中导入
+            try:
+                # 使用新会话获取任务对象
+                task = db.session.query(Translate).get(task_id)
+                if not task:
+                    app.logger.error(f"任务 {task_id} 不存在")
+                    return
+
+                # 执行核心逻辑
+                success = self._execute_core(task)
+                self._complete_task(success)
+            except Exception as e:
+                app.logger.error(f"任务执行异常: {str(e)}", exc_info=True)
+                self._complete_task(False)
+            finally:
+                db.session.remove()  # 重要！清理线程局部session
+
+    def _execute_core(self, task):
+        """执行核心翻译逻辑"""
+        try:
+            # 初始化翻译配置
+            self._init_translate_config(task)
+
+            # 选择处理器
+            handler = self._get_file_handler(task.origin_filepath)
+            if not handler:
+                current_app.logger.error(f"不支持的文件类型: {task.origin_filepath}")
+                return False
+
+            # 构建符合要求的trans字典
+            trans_config = self._build_trans_config(task)
+
+            # 调用处理器
+            return handler.start(trans=trans_config)  # 正确传递参数
+        except Exception as e:
+            current_app.logger.error(f"翻译执行失败: {str(e)}", exc_info=True)
+            return False
+
+    def _prepare_task(self):
+        """准备翻译任务"""
+        task = Translate.query.get(self.task_id)
+        if not task:
+            raise ValueError(f"任务 {self.task_id} 不存在")
+
+        # 验证文件存在性
+        if not os.path.exists(task.origin_filepath):
+            raise FileNotFoundError(f"原始文件不存在: {task.origin_filepath}")
+
+        # 更新任务状态
+        task.status = 'process'
+        task.start_at = db.func.now()
+        db.session.commit()
+        return task
+
+    def _init_translate_config(self, task):
+        """初始化翻译配置"""
+        if task.api_url and task.api_key:
+            import openai
+            openai.api_base = task.api_url
+            openai.api_key = task.api_key
+
+        # 加载术语对照表
+        if task.comparison_id:
+            from app.models import Comparison
+            comparison = db.session.query(Comparison).get(task.comparison_id)
+            if comparison:
+                task.prompt = f"术语对照表:\n{comparison.content.replace(',', ':')}\n{task.prompt}"
+
+        # 加载提示词模板
+        if task.prompt_id:
+            from app.models import Prompt
+            prompt = db.session.query(Prompt).get(task.prompt_id)
+            if prompt:
+                task.prompt = prompt.content
+
+    def _get_file_handler(self, file_path):
+        from app.translate import (
+            word, excel, powerpoint, pdf,
+            gptpdf, txt, csv_handle, md
+        )
+
+        try:
+            current_app.logger.debug(f"正在解析文件路径: {file_path}")
+            # 标准化路径（处理不同OS的斜杠和大小写）
+            normalized_path = os.path.normpath(file_path).lower()
+            current_app.logger.debug(f"标准化路径: {normalized_path}")
+
+            ext = os.path.splitext(normalized_path)[1]
+            # 获取标准化后的扩展名
+            # ext = os.path.splitext(file_path)[1].lower()
+            current_app.logger.debug(f"提取的扩展名: {ext}")
+
+            # 处理器映射表
+            handler_map = {
+                '.docx': word,
+                '.doc': word,
+                '.xlsx': excel,
+                '.xls': excel,
+                '.pptx': powerpoint,
+                '.ppt': powerpoint,
+                '.pdf': pdf,#if not pdf.is_scanned_pdf(file_path) else gptpdf,
+                '.txt': txt,
+                '.csv': csv_handle,
+                '.md': md
+            }
+
+            current_app.logger.debug(f"当前处理器映射表: {handler_map}")
+
+            # 匹配处理器
+            handler = handler_map.get(ext)
+            if not handler:
+                current_app.logger.error(f"未找到匹配的处理器，扩展名: {ext}")
+                return None
+
+            current_app.logger.info(f"成功匹配处理器: {handler.__name__}")
+            return handler
+
+        except Exception as e:
+            current_app.logger.error(f"获取文件处理器失败: {str(e)}", exc_info=True)
+            return None
+
+    def _build_config(self, task):
+        """构建配置字典"""
+        return {
+            'lang': task.lang,
+            'model': task.model,
+            'type': task.type,
+            'prompt': task.prompt,
+            'threads': task.threads,
+            'api_url': task.api_url,
+            'api_key': task.api_key,
+            'origin_lang': task.origin_lang,
+            'backup_model': task.backup_model,
+            'doc2x_flag': task.doc2x_flag,
+            'doc2x_secret_key': task.doc2x_secret_key,
+            'comparison_id': task.comparison_id,
+            'word_count': task.word_count,
+            'prompt_id': task.prompt_id,
+            'rand_user_id': task.rand_user_id,
+            'origin_filesize': task.origin_filesize,
+            'origin_filename': task.origin_filename,
+            'target_filesize': task.target_filesize,
+            'target_filename': task.target_filename,
+            'target_filepath': task.target_filepath,
+            'origin_filepath': task.origin_filepath,
+        }
+
+    def _complete_task(self, success):
+        """更新任务状态"""
+        from app.extensions import db
+        try:
+            with self.app.app_context():
+                task = db.session.query(Translate).get(self.task_id)
+                if task:
+                    task.status = 'done' if success else 'failed'
+                    task.end_at = db.func.now()
+                    db.session.commit()
+        except Exception as e:
+            db.session.rollback()
+            self.app.logger.error(f"状态更新失败: {str(e)}", exc_info=True)
+
+
+
+
+class TranslateEngine9999:
+    def __init__(self, task_id):
+        self.task_id = task_id
+        self.app = current_app._get_current_object()  # 获取真实app对象
+
+    def _build_trans_config(self, task):
+        """构建符合文件处理器要求的 trans 字典[^1]"""
+        return {
+            'id': task.id,  # 任务ID
+            'threads': task.threads,
+            'file_path': task.origin_filepath,  # 原始文件绝对路径
+            'target_file': task.target_filepath,  # 目标文件绝对路径
+            'api_url': task.api_url,
+            'api_key': task.api_key,  # 新增API密钥字段
+            'type': task.type,
+            'lang': task.lang,
+            'run_complete': True,  # 默认设为True
+            # 以下是可能需要添加的额外字段
+            'prompt': task.prompt,
+            'model': task.model,
+            'backup_model': task.backup_model,
+            'comparison_id': task.comparison_id,
+            'prompt_id': task.prompt_id,
+            'extension': os.path.splitext(task.origin_filepath)[1]  # 动态获取文件扩展名
+        }
+
+    def execute(self):
+        """启动任务入口[^2]"""
+        try:
+            # 在主线程上下文中准备任务
+            with self.app.app_context():
+                task = self._prepare_task()
+
+            # 启动线程时传递真实app对象和任务ID
+            thr = Thread(
+                target=self._async_wrapper,
+                args=(self.app, self.task_id)
+            )
+            thr.start()
+            return True
+        except Exception as e:
+            self.app.logger.error(f"任务初始化失败: {str(e)}", exc_info=True)
+            return False
+
+    def _async_wrapper(self, app, task_id):
+        """异步执行包装器[^3]"""
+        with app.app_context():
+            from app.extensions import db  # 确保在每个线程中导入
+            try:
+                # 使用新会话获取任务对象
+                task = db.session.query(Translate).get(task_id)
+                if not task:
+                    app.logger.error(f"任务 {task_id} 不存在")
+                    return
+
+                # 执行核心逻辑
+                success = self._execute_core(task)
+                self._complete_task(success)
+            except Exception as e:
+                app.logger.error(f"任务执行异常: {str(e)}", exc_info=True)
+                self._complete_task(False)
+            finally:
+                db.session.remove()  # 重要！清理线程局部session
+
+    def _execute_core(self, task):
+        """执行核心翻译逻辑[^4]"""
+        try:
+            # 初始化翻译配置
+            self._init_translate_config(task)
+
+            # 构建符合要求的 trans 字典
+            trans_config = self._build_trans_config(task)
+
+            # 调用 main_wrapper 执行翻译
+            return main_wrapper(task_id=task.id, origin_path=task.origin_filepath,config=trans_config)
+        except Exception as e:
+            current_app.logger.error(f"翻译执行失败: {str(e)}", exc_info=True)
+            return False
+
+    def _prepare_task(self):
+        """准备翻译任务[^5]"""
+        task = Translate.query.get(self.task_id)
+        if not task:
+            raise ValueError(f"任务 {self.task_id} 不存在")
+
+        # 验证文件存在性
+        if not os.path.exists(task.origin_filepath):
+            raise FileNotFoundError(f"原始文件不存在: {task.origin_filepath}")
+
+        # 更新任务状态
+        task.status = 'process'
+        task.start_at = db.func.now()
+        db.session.commit()
+        return task
+
+    def _init_translate_config(self, task):
+        """初始化翻译配置[^6]"""
+        if task.api_url and task.api_key:
+            import openai
+            openai.api_base = task.api_url
+            openai.api_key = task.api_key
+
+        # 加载术语对照表
+        if task.comparison_id:
+            from app.models import Comparison
+            comparison = db.session.query(Comparison).get(task.comparison_id)
+            if comparison:
+                task.prompt = f"术语对照表:\n{comparison.content.replace(',', ':')}\n{task.prompt}"
+
+        # 加载提示词模板
+        if task.prompt_id:
+            from app.models import Prompt
+            prompt = db.session.query(Prompt).get(task.prompt_id)
+            if prompt:
+                task.prompt = prompt.content
+
+    def _get_file_handler(self, file_path):
+        """获取文件处理器[^7]"""
+        from app.translate import (
+            word, excel, powerpoint, pdf,
+            gptpdf, txt, csv_handle, md
+        )
+
+        try:
+            current_app.logger.debug(f"正在解析文件路径: {file_path}")
+            # 标准化路径（处理不同OS的斜杠和大小写）
+            normalized_path = os.path.normpath(file_path).lower()
+            current_app.logger.debug(f"标准化路径: {normalized_path}")
+
+            ext = os.path.splitext(normalized_path)[1]
+            current_app.logger.debug(f"提取的扩展名: {ext}")
+
+            # 处理器映射表
+            handler_map = {
+                '.docx': word,
+                '.doc': word,
+                '.xlsx': excel,
+                '.xls': excel,
+                '.pptx': powerpoint,
+                '.ppt': powerpoint,
+                '.pdf': pdf,  # if not pdf.is_scanned_pdf(file_path) else gptpdf,
+                '.txt': txt,
+                '.csv': csv_handle,
+                '.md': md
+            }
+
+            current_app.logger.debug(f"当前处理器映射表: {handler_map}")
+
+            # 匹配处理器
+            handler = handler_map.get(ext)
+            if not handler:
+                current_app.logger.error(f"未找到匹配的处理器，扩展名: {ext}")
+                return None
+
+            current_app.logger.info(f"成功匹配处理器: {handler.__name__}")
+            return handler
+
+        except Exception as e:
+            current_app.logger.error(f"获取文件处理器失败: {str(e)}", exc_info=True)
+            return None
+
+    def _complete_task(self, success):
+        """更新任务状态[^8]"""
+        from app.extensions import db
+        try:
+            with self.app.app_context():
+                task = db.session.query(Translate).get(self.task_id)
+                if task:
+                    task.status = 'done' if success else 'failed'
+                    task.end_at = db.func.now()
+                    task.process = 100.00 if success else 0.00
+                    db.session.commit()
+        except Exception as e:
+            db.session.rollback()
+            self.app.logger.error(f"状态更新失败: {str(e)}", exc_info=True)
+
+
+class TranslateEngine:
+    def __init__(self, task_id):
+        self.task_id = task_id
+        self.app = current_app._get_current_object()  # 获取真实app对象
+
+    def _build_trans_config(self, task):
+        """构建符合文件处理器要求的 trans 字典[^1]"""
+        config = {
+            'id': task.id,  # 任务ID
+            'target_lang': task.lang,
+            # 'origin_lang': task.origin_lang,
+            'uuid':task.uuid,
+            'target_path_dir':os.path.dirname(task.target_filepath),
+            'threads': task.threads,
+            'file_path': task.origin_filepath,  # 原始文件绝对路径
+            'target_file': task.target_filepath,  # 目标文件绝对路径
+            'api_url': task.api_url,
+            'api_key': task.api_key,  # 新增API密钥字段
+            'type': task.type,
+            'lang': task.lang,
+            'run_complete': True,  # 默认设为True
+            # 以下是可能需要添加的额外字段
+            'prompt': task.prompt,
+            'model': task.model,
+            'backup_model': task.backup_model,
+            'comparison_id': task.comparison_id,
+            'prompt_id': task.prompt_id,
+            'extension': os.path.splitext(task.origin_filepath)[1]  # 动态获取文件扩展名
+        }
+
+        # 加载术语表
+        if task.comparison_id:
+            comparison = db.session.query(Comparison).get(task.comparison_id)
+            if comparison:
+                config['comparison'] = comparison.content.replace(',', ':').replace(';', '\n')
+
+        # 加载提示语模板
+        if task.prompt_id:
+            prompt = db.session.query(Prompt).get(task.prompt_id)
+            if prompt:
+                config['prompt'] = prompt.content
+
+        return config
+
+    def execute(self):
+        """启动任务入口[^2]"""
+        try:
+            # 在主线程上下文中准备任务
+            with self.app.app_context():
+                task = self._prepare_task()
+
+            # 启动线程时传递真实app对象和任务ID
+            thr = Thread(
+                target=self._async_wrapper,
+                args=(self.app, self.task_id)
+            )
+            thr.start()
+            return True
+        except Exception as e:
+            self.app.logger.error(f"任务初始化失败: {str(e)}", exc_info=True)
+            return False
+
+    def _async_wrapper(self, app, task_id):
+        """异步执行包装器[^3]"""
+        with app.app_context():
+            from app.extensions import db  # 确保在每个线程中导入
+            try:
+                # 使用新会话获取任务对象
+                task = db.session.query(Translate).get(task_id)
+                if not task:
+                    app.logger.error(f"任务 {task_id} 不存在")
+                    return
+
+                # 执行核心逻辑
+                success = self._execute_core(task)
+                self._complete_task(success)
+            except Exception as e:
+                app.logger.error(f"任务执行异常: {str(e)}", exc_info=True)
+                self._complete_task(False)
+            finally:
+                db.session.remove()  # 重要！清理线程局部session
+
+    def _execute_core(self, task):
+        """执行核心翻译逻辑[^4]"""
+        try:
+            # 初始化翻译配置
+            self._init_translate_config(task)
+
+            # 构建符合要求的 trans 字典
+            trans_config = self._build_trans_config(task)
+
+            # 调用 main_wrapper 执行翻译
+            return main_wrapper(task_id=task.id, origin_path=task.origin_filepath, config=trans_config)
+        except Exception as e:
+            current_app.logger.error(f"翻译执行失败: {str(e)}", exc_info=True)
+            return False
+
+    def _prepare_task(self):
+        """准备翻译任务[^5]"""
+        task = Translate.query.get(self.task_id)
+        if not task:
+            raise ValueError(f"任务 {self.task_id} 不存在")
+
+        # 验证文件存在性
+        if not os.path.exists(task.origin_filepath):
+            raise FileNotFoundError(f"原始文件不存在: {task.origin_filepath}")
+
+        # 更新任务状态
+        task.status = 'process'
+        task.start_at = db.func.now()
+        db.session.commit()
+        return task
+
+    def _init_translate_config(self, task):
+        """初始化翻译配置[^6]"""
+        if task.api_url and task.api_key:
+            import openai
+            openai.api_base = task.api_url
+            openai.api_key = task.api_key
+
+    def _complete_task(self, success):
+        """更新任务状态[^7]"""
+        from app.extensions import db
+        try:
+            with self.app.app_context():
+                task = db.session.query(Translate).get(self.task_id)
+                if task:
+                    task.status = 'done' if success else 'failed'
+                    task.end_at = db.func.now()
+                    task.process = 100.00 if success else 0.00
+                    db.session.commit()
+        except Exception as e:
+            db.session.rollback()
+            self.app.logger.error(f"状态更新失败: {str(e)}", exc_info=True)