Upload 5 files

app.py

@@ -31,6 +31,8 @@ from router_users_social import router as users_social_router
 # 其他业务模块
 # ==========================================
 from router_items import router as items_router       # 📦 内容管理(工具/应用/推荐)
+from router_posts import router as posts_router       # 💬 讨论区
+from router_tasks import router as tasks_router       # 📝 任务榜
 from router_comments import router as comments_router # 💬 评论系统
 from router_messages import router as messages_router # ✉️ 私信系统
 from router_wallet import router as wallet_router     # 💰 钱包/提现
@@ -76,6 +78,8 @@ app.include_router(users_social_router)   # 🤝 关注/隐私
 
 # 其他业务模块
 app.include_router(items_router)          # 📦 内容管理
+app.include_router(posts_router)          # 💬 讨论区
+app.include_router(tasks_router)          # 📝 任务榜
 app.include_router(comments_router)       # 💬 评论系统
 app.include_router(messages_router)       # ✉️ 私信系统
 app.include_router(wallet_router)         # 💰 钱包/提现

models.py

@@ -117,4 +117,107 @@ class WithdrawRequest(BaseModel):
     amount: int
     alipayAccount: str
     real_name: str
-    code: str
+    code: str
+
+
+# ==========================================
+# 💬 讨论区数据模型
+# ==========================================
+class PostCreate(BaseModel):
+    """ 发布讨论区内容 """
+    title: str                              # 标题
+    content: str                            # 文案内容
+    coverImage: str                         # 封面图
+    images: Optional[List[str]] = []        # 详情图（最多9张）
+    author: str                             # 作者账号
+
+class PostUpdate(BaseModel):
+    """ 更新讨论区内容 """
+    title: Optional[str] = None
+    content: Optional[str] = None
+    coverImage: Optional[str] = None
+    images: Optional[List[str]] = None
+
+class PostInteraction(BaseModel):
+    """ 讨论区互动（点赞/收藏） """
+    post_id: str
+    user_id: str
+    action_type: str                        # like / favorite
+    is_active: bool                         # True=添加, False=取消
+
+
+# ==========================================
+# 📝 任务榜数据模型
+# ==========================================
+class TaskCreate(BaseModel):
+    """ 发布新任务 """
+    title: str                              # 任务标题
+    description: str                        # 任务详情
+    referenceImages: Optional[List[str]] = []  # 参考图（最多6张）
+    referenceLink: Optional[str] = None     # 参考链接
+    totalPrice: int                         # 总价格（积分）
+    depositRatio: int                       # 订金比例（10/20/30/50）
+    deadline: str                           # 截止时间 (ISO格式)
+    publisher: str                          # 发布者账号
+
+class TaskUpdate(BaseModel):
+    """ 更新任务 """
+    title: Optional[str] = None
+    description: Optional[str] = None
+    referenceImages: Optional[List[str]] = None
+    referenceLink: Optional[str] = None
+    totalPrice: Optional[int] = None
+    depositRatio: Optional[int] = None
+    deadline: Optional[str] = None
+
+class TaskApply(BaseModel):
+    """ 申请接单 """
+    task_id: str
+    applicant: str                          # 申请者账号
+    message: Optional[str] = None           # 申请留言
+
+class TaskAssign(BaseModel):
+    """ 指派接单者 """
+    task_id: str
+    publisher: str                          # 发布者（校验权限）
+    assignee: str                           # 被指派的接单者
+
+class TaskSubmit(BaseModel):
+    """ 接单者提交成果 """
+    task_id: str
+    assignee: str                           # 接单者（校验权限）
+    deliverables: List[str]                 # 交付物图片URL列表
+    note: Optional[str] = None              # 备注说明
+
+class TaskAccept(BaseModel):
+    """ 发布者验收 """
+    task_id: str
+    publisher: str                          # 发布者（校验权限）
+    is_accepted: bool                       # True=验收通过, False=验收不通过
+    feedback: Optional[str] = None          # 反馈意见
+
+
+# ==========================================
+# ⚖️ P3增强：任务申诉数据模型
+# ==========================================
+class TaskDispute(BaseModel):
+    """ 发起申诉 """
+    task_id: str                            # 任务ID
+    initiator: str                          # 申诉发起人（可以是发布者或接单者）
+    reason: str                             # 申诉理由
+    evidence: Optional[List[str]] = []      # 证据图片URL列表
+
+class TaskDisputeResponse(BaseModel):
+    """ 被申诉方回应 """
+    dispute_id: str                         # 申诉ID
+    respondent: str                         # 回应人
+    response: str                           # 回应内容
+    evidence: Optional[List[str]] = []      # 证据图片URL列表
+
+class TaskDisputeResolve(BaseModel):
+    """ 管理员仲裁 """
+    dispute_id: str                         # 申诉ID
+    admin_account: str                      # 管理员账号
+    result: str                             # 仲裁结果: support_initiator / support_respondent / split
+    split_ratio: Optional[int] = 50         # 分成比例（申诉方获得的百分比，仅当result=split时有效）
+    admin_note: Optional[str] = None        # 管理员备注

router_posts.py

@@ -0,0 +1,278 @@
+# router_posts.py
+# ==========================================
+# 💬 讨论区路由模块
+# ==========================================
+# 作用：处理讨论区内容的增删改查和互动功能
+# 关联文件：
+#   - 数据库连接.py (JSON数据库读写 posts.json)
+#   - models.py (PostCreate, PostUpdate, PostInteraction)
+# 前端调用：
+#   - 讨论区列表组件.js (获取帖子列表)
+#   - 讨论区发布组件.js (发布新帖子)
+#   - 讨论区详情组件.js (帖子详情、互动操作)
+# ==========================================
+
+from fastapi import APIRouter, HTTPException
+import 数据库连接 as db
+from models import PostCreate, PostUpdate, PostInteraction
+import time
+import uuid
+
+# 创建子路由实例
+router = APIRouter()
+
+
+# ==========================================
+# 📖 获取讨论区列表
+# ==========================================
+@router.get("/api/posts")
+async def get_posts(sort: str = "time", page: int = 1, page_size: int = 20):
+    """
+    获取讨论区帖子列表
+    
+    查询参数：
+        - sort: 排序方式 (time=最新, hot=最热)
+        - page: 页码
+        - page_size: 每页数量
+    """
+    posts_db = db.load_data("posts.json", default_data=[])
+    
+    # 排序
+    if sort == "hot":
+        # 最热：按点赞+收藏加权排序
+        posts_db.sort(key=lambda x: x.get("likes", 0) * 2 + x.get("favorites", 0), reverse=True)
+    else:
+        # 最新：按创建时间倒序
+        posts_db.sort(key=lambda x: x.get("createdAt", 0), reverse=True)
+    
+    # 分页
+    start = (page - 1) * page_size
+    end = start + page_size
+    paginated = posts_db[start:end]
+    
+    return {
+        "status": "success",
+        "data": paginated,
+        "total": len(posts_db),
+        "page": page,
+        "page_size": page_size
+    }
+
+
+# ==========================================
+# 📖 获取单个帖子详情
+# ==========================================
+@router.get("/api/posts/{post_id}")
+async def get_post_detail(post_id: str):
+    """
+    获取帖子详情
+    """
+    posts_db = db.load_data("posts.json", default_data=[])
+    
+    post = next((p for p in posts_db if p.get("id") == post_id), None)
+    if not post:
+        raise HTTPException(status_code=404, detail="帖子不存在")
+    
+    # 增加浏览量
+    post["views"] = post.get("views", 0) + 1
+    db.save_data("posts.json", posts_db)
+    
+    return {"status": "success", "data": post}
+
+
+# ==========================================
+# ✏️ 发布新帖子
+# ==========================================
+@router.post("/api/posts")
+async def create_post(post_data: PostCreate):
+    """
+    发布新帖子
+    """
+    posts_db = db.load_data("posts.json", default_data=[])
+    users_db = db.load_data("users.json", default_data={})
+    
+    # 获取作者信息
+    author_info = users_db.get(post_data.author, {})
+    
+    # 构建新帖子对象
+    new_post = {
+        "id": f"post_{uuid.uuid4().hex[:12]}",
+        "type": "discussion",
+        "title": post_data.title,
+        "content": post_data.content,
+        "coverImage": post_data.coverImage,
+        "images": post_data.images or [],
+        
+        # 作者信息快照
+        "author": post_data.author,
+        "authorName": author_info.get("name", post_data.author),
+        "authorAvatar": author_info.get("avatarDataUrl", ""),
+        
+        # 互动数据初始化
+        "likes": 0,
+        "favorites": 0,
+        "comments": 0,
+        "views": 0,
+        
+        # 点赞/收藏用户列表（用于判断当前用户是否已操作）
+        "likedBy": [],
+        "favoritedBy": [],
+        
+        # 打赏数据
+        "tip_board": [],
+        "totalTips": 0,
+        
+        # 时间戳
+        "createdAt": int(time.time()),
+        "updatedAt": int(time.time())
+    }
+    
+    posts_db.insert(0, new_post)  # 插入到列表头部
+    db.save_data("posts.json", posts_db)
+    
+    return {"status": "success", "data": new_post}
+
+
+# ==========================================
+# ✏️ 更新帖子
+# ==========================================
+@router.put("/api/posts/{post_id}")
+async def update_post(post_id: str, update_data: PostUpdate, author: str = None):
+    """
+    更新帖子内容
+    """
+    posts_db = db.load_data("posts.json", default_data=[])
+    
+    post_idx = next((i for i, p in enumerate(posts_db) if p.get("id") == post_id), None)
+    if post_idx is None:
+        raise HTTPException(status_code=404, detail="帖子不存在")
+    
+    post = posts_db[post_idx]
+    
+    # 权限校验：只有作者可以修改
+    if author and post.get("author") != author:
+        raise HTTPException(status_code=403, detail="无权修改此帖子")
+    
+    # 更新字段
+    for k, v in update_data.dict(exclude_unset=True).items():
+        if v is not None:
+            post[k] = v
+    
+    post["updatedAt"] = int(time.time())
+    db.save_data("posts.json", posts_db)
+    
+    return {"status": "success", "data": post}
+
+
+# ==========================================
+# 🗑️ 删除帖子
+# ==========================================
+@router.delete("/api/posts/{post_id}")
+async def delete_post(post_id: str, author: str = None):
+    """
+    删除帖子
+    """
+    posts_db = db.load_data("posts.json", default_data=[])
+    
+    post_idx = next((i for i, p in enumerate(posts_db) if p.get("id") == post_id), None)
+    if post_idx is None:
+        raise HTTPException(status_code=404, detail="帖子不存在")
+    
+    post = posts_db[post_idx]
+    
+    # 权限校验
+    if author and post.get("author") != author:
+        raise HTTPException(status_code=403, detail="无权删除此帖子")
+    
+    posts_db.pop(post_idx)
+    db.save_data("posts.json", posts_db)
+    
+    return {"status": "success", "message": "帖子已删除"}
+
+
+# ==========================================
+# ❤️ 点赞/收藏操作
+# ==========================================
+@router.post("/api/posts/interaction")
+async def toggle_interaction(req: PostInteraction):
+    """
+    点赞或收藏帖子
+    
+    请求参数：
+        - post_id: 帖子ID
+        - user_id: 用户账号
+        - action_type: like / favorite
+        - is_active: True=添加, False=取消
+    """
+    posts_db = db.load_data("posts.json", default_data=[])
+    users_db = db.load_data("users.json", default_data={})
+    
+    post_idx = next((i for i, p in enumerate(posts_db) if p.get("id") == req.post_id), None)
+    if post_idx is None:
+        raise HTTPException(status_code=404, detail="帖子不存在")
+    
+    post = posts_db[post_idx]
+    
+    if req.action_type == "like":
+        liked_by = post.get("likedBy", [])
+        if req.is_active and req.user_id not in liked_by:
+            liked_by.append(req.user_id)
+            post["likes"] = post.get("likes", 0) + 1
+        elif not req.is_active and req.user_id in liked_by:
+            liked_by.remove(req.user_id)
+            post["likes"] = max(0, post.get("likes", 0) - 1)
+        post["likedBy"] = liked_by
+        
+    elif req.action_type == "favorite":
+        favorited_by = post.get("favoritedBy", [])
+        if req.is_active and req.user_id not in favorited_by:
+            favorited_by.append(req.user_id)
+            post["favorites"] = post.get("favorites", 0) + 1
+            # 同步到用户收藏列表
+            user = users_db.get(req.user_id, {})
+            user_favs = user.get("favorited_posts", [])
+            if req.post_id not in user_favs:
+                user_favs.append(req.post_id)
+                user["favorited_posts"] = user_favs
+                users_db[req.user_id] = user
+                db.save_data("users.json", users_db)
+        elif not req.is_active and req.user_id in favorited_by:
+            favorited_by.remove(req.user_id)
+            post["favorites"] = max(0, post.get("favorites", 0) - 1)
+            # 从用户收藏列表移除
+            user = users_db.get(req.user_id, {})
+            user_favs = user.get("favorited_posts", [])
+            if req.post_id in user_favs:
+                user_favs.remove(req.post_id)
+                user["favorited_posts"] = user_favs
+                users_db[req.user_id] = user
+                db.save_data("users.json", users_db)
+        post["favoritedBy"] = favorited_by
+    
+    db.save_data("posts.json", posts_db)
+    
+    return {
+        "status": "success",
+        "data": {
+            "likes": post.get("likes", 0),
+            "favorites": post.get("favorites", 0),
+            "isLiked": req.user_id in post.get("likedBy", []),
+            "isFavorited": req.user_id in post.get("favoritedBy", [])
+        }
+    }
+
+
+# ==========================================
+# 📊 获取用户的帖子列表
+# ==========================================
+@router.get("/api/posts/user/{account}")
+async def get_user_posts(account: str):
+    """
+    获取指定用户发布的帖子
+    """
+    posts_db = db.load_data("posts.json", default_data=[])
+    
+    user_posts = [p for p in posts_db if p.get("author") == account]
+    user_posts.sort(key=lambda x: x.get("createdAt", 0), reverse=True)
+    
+    return {"status": "success", "data": user_posts}

router_tasks.py

@@ -0,0 +1,1411 @@
+# router_tasks.py
+# ==========================================
+# 📝 任务榜路由模块
+# ==========================================
+# 作用：处理任务榜的发布、申请、指派、提交、验收等功能
+# 关联文件：
+#   - 数据库连接.py (JSON数据库读写 tasks.json)
+#   - models.py (TaskCreate, TaskApply, TaskAssign 等)
+#   - router_wallet.py (订金/尾款支付)
+# 前端调用：
+#   - 任务榜列表组件.js (获取任务列表)
+#   - 任务榜发布组件.js (发布新任务)
+#   - 任务榜详情组件.js (任务详情、申请/指派/提交/验收)
+# ==========================================
+# P2 增强功能：
+#   - 余额预检与冻结
+#   - 交易明细记录
+#   - 过期自动退款
+#   - 支付通知推送
+# P3 增强功能：
+#   - 验收申诉机制
+#   - 管理员仲裁
+#   - 争议资金分配
+# ==========================================
+
+from fastapi import APIRouter, HTTPException
+import 数据库连接 as db
+from models import TaskCreate, TaskUpdate, TaskApply, TaskAssign, TaskSubmit, TaskAccept, TaskDispute, TaskDisputeResponse, TaskDisputeResolve
+import time
+import uuid
+from datetime import datetime
+
+# 创建子路由实例
+router = APIRouter()
+
+
+# ==========================================
+# 💰 P2增强：交易明细记录辅助函数
+# ==========================================
+def _record_transaction(account: str, tx_type: str, amount: int, related_task_id: str = None, 
+                        target_account: str = None, note: str = ""):
+    """
+    记录交易明细
+    
+    tx_type 类型:
+        - task_freeze: 发布任务冻结
+        - task_unfreeze: 取消任务解冻
+        - deposit_pay: 支付订金
+        - deposit_receive: 收到订金
+        - final_pay: 支付尾款
+        - final_receive: 收到尾款
+        - task_refund: 任务退款
+        - expired_refund: 过期退款
+    """
+    transactions_db = db.load_data("transactions.json", default_data=[])
+    
+    transaction = {
+        "id": f"tx_{uuid.uuid4().hex[:12]}",
+        "account": account,
+        "type": tx_type,
+        "amount": amount,
+        "related_task_id": related_task_id,
+        "target_account": target_account,
+        "note": note,
+        "createdAt": int(time.time())
+    }
+    
+    transactions_db.insert(0, transaction)
+    db.save_data("transactions.json", transactions_db)
+    
+    return transaction
+
+
+def _send_task_notification(account: str, title: str, content: str, task_id: str = None):
+    """
+    发送任务相关的系统通知
+    """
+    messages_db = db.load_data("messages.json", default_data={})
+    
+    if account not in messages_db:
+        messages_db[account] = []
+    
+    notification = {
+        "id": f"msg_{uuid.uuid4().hex[:8]}",
+        "type": "task_notification",
+        "title": title,
+        "content": content,
+        "related_task_id": task_id,
+        "timestamp": int(time.time()),
+        "read": False
+    }
+    
+    messages_db[account].insert(0, notification)
+    db.save_data("messages.json", messages_db)
+    
+    return notification
+
+
+# ==========================================
+# 📖 获取任务榜列表（仅显示未过期+招募中的任务）
+# ==========================================
+@router.get("/api/tasks")
+async def get_tasks(sort: str = "time", page: int = 1, page_size: int = 20):
+    """
+    获取任务列表
+    P2增强：过期自动退款
+    
+    查询参数：
+        - sort: 排序方式 (time=最新, price=价格最高)
+        - page: 页码
+        - page_size: 每页数量
+    """
+    tasks_db = db.load_data("tasks.json", default_data=[])
+    users_db = db.load_data("users.json", default_data={})
+    current_time = int(time.time())
+    
+    # 过滤：只显示 open 状态且未过期的任务
+    visible_tasks = []
+    users_updated = False
+    
+    for task in tasks_db:
+        # 检查是否过期
+        deadline_ts = _parse_deadline(task.get("deadline", ""))
+        if deadline_ts and deadline_ts < current_time:
+            # P2增强：过期自动退款
+            if task.get("status") in ["open", "assigned"]:
+                _handle_task_expiry(task, users_db)
+                users_updated = True
+            continue
+        
+        # 只显示招募中的任务
+        if task.get("status") == "open":
+            visible_tasks.append(task)
+    
+    # 保存状态更新
+    db.save_data("tasks.json", tasks_db)
+    if users_updated:
+        db.save_data("users.json", users_db)
+    
+    # 排序
+    if sort == "price":
+        visible_tasks.sort(key=lambda x: x.get("totalPrice", 0), reverse=True)
+    else:
+        visible_tasks.sort(key=lambda x: x.get("createdAt", 0), reverse=True)
+    
+    # 分页
+    start = (page - 1) * page_size
+    end = start + page_size
+    paginated = visible_tasks[start:end]
+    
+    return {
+        "status": "success",
+        "data": paginated,
+        "total": len(visible_tasks),
+        "page": page,
+        "page_size": page_size
+    }
+
+
+def _handle_task_expiry(task: dict, users_db: dict):
+    """
+    P2增强：处理任务过期退款
+    """
+    publisher = task.get("publisher")
+    assignee = task.get("assignee")
+    status = task.get("status")
+    
+    publisher_info = users_db.get(publisher, {})
+    
+    if status == "open":
+        # 招募中过期：解冻全部金额
+        frozen_amount = task.get("frozenAmount", task.get("totalPrice", 0))
+        publisher_info["frozen_balance"] = max(0, publisher_info.get("frozen_balance", 0) - frozen_amount)
+        users_db[publisher] = publisher_info
+        
+        _record_transaction(
+            account=publisher,
+            tx_type="expired_refund",
+            amount=frozen_amount,
+            related_task_id=task.get("id"),
+            note=f"任务过期解冻: {task['title'][:20]}"
+        )
+        
+        _send_task_notification(
+            account=publisher,
+            title="⏰ 任务已过期",
+            content=f"任务『{task['title']}』已过期，冻结的 {frozen_amount} 积分已解冻。",
+            task_id=task.get("id")
+        )
+        
+    elif status == "assigned":
+        # 已指派但未完成过期
+        if task.get("depositPaid"):
+            # 已支付订金：从接单者扣回订金，解冻尾款
+            deposit_amount = task.get("depositAmount", 0)
+            final_payment = task.get("finalPayment", 0)
+            
+            if assignee in users_db:
+                users_db[assignee]["balance"] = max(0, users_db[assignee].get("balance", 0) - deposit_amount)
+            
+            publisher_info["balance"] = publisher_info.get("balance", 0) + deposit_amount
+            publisher_info["frozen_balance"] = max(0, publisher_info.get("frozen_balance", 0) - final_payment)
+            users_db[publisher] = publisher_info
+            
+            _record_transaction(
+                account=publisher,
+                tx_type="expired_refund",
+                amount=deposit_amount,
+                related_task_id=task.get("id"),
+                target_account=assignee,
+                note=f"任务过期收回订金: {task['title'][:20]}"
+            )
+            
+            _send_task_notification(
+                account=publisher,
+                title="⏰ 任务已过期",
+                content=f"任务『{task['title']}』已过期，订金 {deposit_amount} 积分已退回。",
+                task_id=task.get("id")
+            )
+            _send_task_notification(
+                account=assignee,
+                title="⏰ 任务已过期",
+                content=f"任务『{task['title']}』已过期，订金 {deposit_amount} 积分已退回发布者。",
+                task_id=task.get("id")
+            )
+        else:
+            # 未支付订金：解冻全部金额
+            frozen_amount = task.get("frozenAmount", task.get("totalPrice", 0))
+            publisher_info["frozen_balance"] = max(0, publisher_info.get("frozen_balance", 0) - frozen_amount)
+            users_db[publisher] = publisher_info
+            
+            _record_transaction(
+                account=publisher,
+                tx_type="expired_refund",
+                amount=frozen_amount,
+                related_task_id=task.get("id"),
+                note=f"任务过期解冻: {task['title'][:20]}"
+            )
+            
+            _send_task_notification(
+                account=publisher,
+                title="⏰ 任务已过期",
+                content=f"任务『{task['title']}』已过期，冻结的 {frozen_amount} 积分已解冻。",
+                task_id=task.get("id")
+            )
+    
+    task["status"] = "expired"
+    task["expiredAt"] = int(time.time())
+
+
+# ==========================================
+# 📖 获取单个任务详情
+# ==========================================
+@router.get("/api/tasks/{task_id}")
+async def get_task_detail(task_id: str):
+    """
+    获取任务详情
+    """
+    tasks_db = db.load_data("tasks.json", default_data=[])
+    
+    task = next((t for t in tasks_db if t.get("id") == task_id), None)
+    if not task:
+        raise HTTPException(status_code=404, detail="任务不存在")
+    
+    return {"status": "success", "data": task}
+
+
+# ==========================================
+# ✏️ 发布新任务（P2增强：余额预检+冻结）
+# ==========================================
+@router.post("/api/tasks")
+async def create_task(task_data: TaskCreate):
+    """
+    发布新任务
+    P2增强：发布时预检余额并冻结总金额
+    """
+    tasks_db = db.load_data("tasks.json", default_data=[])
+    users_db = db.load_data("users.json", default_data={})
+    
+    # 获取发布者信息
+    publisher_info = users_db.get(task_data.publisher, {})
+    
+    # 💰 P2增强：余额预检
+    current_balance = publisher_info.get("balance", 0)
+    frozen_balance = publisher_info.get("frozen_balance", 0)
+    available_balance = current_balance - frozen_balance
+    
+    if available_balance < task_data.totalPrice:
+        raise HTTPException(
+            status_code=400, 
+            detail=f"可用余额不足！当前可用 {available_balance} 积分，任务需要 {task_data.totalPrice} 积分"
+        )
+    
+    # 计算订金和尾款
+    deposit_amount = int(task_data.totalPrice * task_data.depositRatio / 100)
+    final_payment = task_data.totalPrice - deposit_amount
+    
+    # 💰 P2增强：冻结总金额
+    publisher_info["frozen_balance"] = frozen_balance + task_data.totalPrice
+    users_db[task_data.publisher] = publisher_info
+    db.save_data("users.json", users_db)
+    
+    # 记录冻结交易
+    _record_transaction(
+        account=task_data.publisher,
+        tx_type="task_freeze",
+        amount=task_data.totalPrice,
+        note=f"发布任务冻结: {task_data.title[:20]}"
+    )
+    
+    # 构建新任务对象
+    task_id = f"task_{uuid.uuid4().hex[:12]}"
+    new_task = {
+        "id": task_id,
+        "type": "task",
+        "title": task_data.title,
+        "description": task_data.description,
+        "referenceImages": task_data.referenceImages or [],
+        "referenceLink": task_data.referenceLink or "",
+        
+        # 💰 价格与订金
+        "totalPrice": task_data.totalPrice,
+        "depositRatio": task_data.depositRatio,
+        "depositAmount": deposit_amount,
+        "finalPayment": final_payment,
+        "frozenAmount": task_data.totalPrice,  # P2: 记录冻结金额
+        
+        # ⏰ 时间控制
+        "deadline": task_data.deadline,
+        "createdAt": int(time.time()),
+        
+        # 👤 参与者
+        "publisher": task_data.publisher,
+        "publisherName": publisher_info.get("name", task_data.publisher),
+        "publisherAvatar": publisher_info.get("avatarDataUrl", ""),
+        "applicants": [],           # 申请者列表 [{account, name, avatar, message, appliedAt}]
+        "assignee": None,           # 被选中的接单者
+        "assigneeName": None,
+        "assigneeAvatar": None,
+        
+        # 📊 状态机
+        "status": "open",           # open/assigned/in_progress/submitted/completed/expired/cancelled
+        "depositPaid": False,       # 订金已支付
+        "finalPaid": False,         # 尾款已支付
+        
+        # 📁 交付物
+        "deliverables": [],         # 接单者提交的成果
+        "deliverNote": "",          # 交付备注
+        "publisherFeedback": ""     # 发布者反馈
+    }
+    
+    tasks_db.insert(0, new_task)
+    db.save_data("tasks.json", tasks_db)
+    
+    return {"status": "success", "data": new_task, "message": f"任务发布成功，已冻结 {task_data.totalPrice} 积分"}
+
+
+# ==========================================
+# 🙋 申请接单
+# ==========================================
+@router.post("/api/tasks/apply")
+async def apply_task(req: TaskApply):
+    """
+    接单者申请接单
+    """
+    tasks_db = db.load_data("tasks.json", default_data=[])
+    users_db = db.load_data("users.json", default_data={})
+    
+    task_idx = next((i for i, t in enumerate(tasks_db) if t.get("id") == req.task_id), None)
+    if task_idx is None:
+        raise HTTPException(status_code=404, detail="任务不存在")
+    
+    task = tasks_db[task_idx]
+    
+    # 状态检查
+    if task.get("status") != "open":
+        raise HTTPException(status_code=400, detail="任务不在招募中")
+    
+    # 不能申请自己发布的任务
+    if task.get("publisher") == req.applicant:
+        raise HTTPException(status_code=400, detail="不能申请自己发布的任务")
+    
+    # 检查是否已申请
+    applicants = task.get("applicants", [])
+    if any(a.get("account") == req.applicant for a in applicants):
+        raise HTTPException(status_code=400, detail="您已申请过此任务")
+    
+    # 获取申请者信息
+    applicant_info = users_db.get(req.applicant, {})
+    
+    # 添加申请
+    applicants.append({
+        "account": req.applicant,
+        "name": applicant_info.get("name", req.applicant),
+        "avatar": applicant_info.get("avatarDataUrl", ""),
+        "message": req.message or "",
+        "appliedAt": int(time.time())
+    })
+    task["applicants"] = applicants
+    
+    db.save_data("tasks.json", tasks_db)
+    
+    # TODO: 发送通知给发布者
+    
+    return {"status": "success", "message": "申请成功，等待发布者选择"}
+
+
+# ==========================================
+# 👆 发布者指派接单者
+# ==========================================
+@router.post("/api/tasks/assign")
+async def assign_task(req: TaskAssign):
+    """
+    发布者指派接单者
+    """
+    tasks_db = db.load_data("tasks.json", default_data=[])
+    users_db = db.load_data("users.json", default_data={})
+    
+    task_idx = next((i for i, t in enumerate(tasks_db) if t.get("id") == req.task_id), None)
+    if task_idx is None:
+        raise HTTPException(status_code=404, detail="任务不存在")
+    
+    task = tasks_db[task_idx]
+    
+    # 权限校验
+    if task.get("publisher") != req.publisher:
+        raise HTTPException(status_code=403, detail="无权操作此任务")
+    
+    # 状态检查
+    if task.get("status") != "open":
+        raise HTTPException(status_code=400, detail="任务已不在招募中")
+    
+    # 检查指派的人是否在申请列表中
+    applicants = task.get("applicants", [])
+    assignee_info = next((a for a in applicants if a.get("account") == req.assignee), None)
+    if not assignee_info:
+        raise HTTPException(status_code=400, detail="该用户未申请此任务")
+    
+    # 更新任务状态
+    task["assignee"] = req.assignee
+    task["assigneeName"] = assignee_info.get("name", req.assignee)
+    task["assigneeAvatar"] = assignee_info.get("avatar", "")
+    task["status"] = "assigned"  # 等待支付订金
+    
+    db.save_data("tasks.json", tasks_db)
+    
+    # P2增强：发送通知给接单者
+    _send_task_notification(
+        account=req.assignee,
+        title="🎉 您已被选中接单",
+        content=f"您已被选中接单任务『{task['title']}』，请等待发布者支付订金后开始工作。",
+        task_id=task["id"]
+    )
+    
+    return {"status": "success", "message": "已指派接单者，请支付订金"}
+
+
+# ==========================================
+# 💰 支付订金（P2增强：从冻结余额扣款+交易记录+通知）
+# ==========================================
+@router.post("/api/tasks/{task_id}/pay_deposit")
+async def pay_deposit(task_id: str, publisher: str):
+    """
+    发布者支付订金
+    P2增强：从冻结余额中扣除订金
+    """
+    tasks_db = db.load_data("tasks.json", default_data=[])
+    users_db = db.load_data("users.json", default_data={})
+    
+    task_idx = next((i for i, t in enumerate(tasks_db) if t.get("id") == task_id), None)
+    if task_idx is None:
+        raise HTTPException(status_code=404, detail="任务不存在")
+    
+    task = tasks_db[task_idx]
+    
+    # 权限校验
+    if task.get("publisher") != publisher:
+        raise HTTPException(status_code=403, detail="无权操作此任务")
+    
+    # 状态检查
+    if task.get("status") != "assigned":
+        raise HTTPException(status_code=400, detail="当前状态不允许支付订金")
+    
+    if task.get("depositPaid"):
+        raise HTTPException(status_code=400, detail="订金已支付")
+    
+    deposit_amount = task.get("depositAmount", 0)
+    assignee = task.get("assignee")
+    publisher_info = users_db.get(publisher, {})
+    
+    # P2增强：从冻结余额中扣除订金
+    frozen_balance = publisher_info.get("frozen_balance", 0)
+    current_balance = publisher_info.get("balance", 0)
+    
+    # 订金从冻结金额中支付（已在发布时冻结）
+    # 扣减实际余额，同时减少冻结金额
+    publisher_info["balance"] = current_balance - deposit_amount
+    publisher_info["frozen_balance"] = frozen_balance - deposit_amount
+    users_db[publisher] = publisher_info
+    
+    # 订金转入接单者账户
+    if assignee not in users_db:
+        users_db[assignee] = {"balance": 0, "frozen_balance": 0}
+    users_db[assignee]["balance"] = users_db[assignee].get("balance", 0) + deposit_amount
+    
+    # 更新任务状态
+    task["depositPaid"] = True
+    task["status"] = "in_progress"
+    task["depositPaidAt"] = int(time.time())
+    
+    db.save_data("tasks.json", tasks_db)
+    db.save_data("users.json", users_db)
+    
+    # P2增强：记录交易明细
+    _record_transaction(
+        account=publisher,
+        tx_type="deposit_pay",
+        amount=deposit_amount,
+        related_task_id=task_id,
+        target_account=assignee,
+        note=f"支付订金: {task['title'][:20]}"
+    )
+    _record_transaction(
+        account=assignee,
+        tx_type="deposit_receive",
+        amount=deposit_amount,
+        related_task_id=task_id,
+        target_account=publisher,
+        note=f"收到订金: {task['title'][:20]}"
+    )
+    
+    # P2增强：发送通知
+    _send_task_notification(
+        account=assignee,
+        title="💰 订金已到账",
+        content=f"任务『{task['title']}』的订金 {deposit_amount} 积分已到账，请尽快开始工作！",
+        task_id=task_id
+    )
+    
+    return {"status": "success", "message": f"订金 {deposit_amount} 积分已支付，任务开始进行"}
+
+
+# ==========================================
+# 📤 接单者提交成果
+# ==========================================
+@router.post("/api/tasks/submit")
+async def submit_deliverables(req: TaskSubmit):
+    """
+    接单者提交成果
+    """
+    tasks_db = db.load_data("tasks.json", default_data=[])
+    
+    task_idx = next((i for i, t in enumerate(tasks_db) if t.get("id") == req.task_id), None)
+    if task_idx is None:
+        raise HTTPException(status_code=404, detail="任务不存在")
+    
+    task = tasks_db[task_idx]
+    
+    # 权限校验
+    if task.get("assignee") != req.assignee:
+        raise HTTPException(status_code=403, detail="您不是此任务的接单者")
+    
+    # 状态检查
+    if task.get("status") != "in_progress":
+        raise HTTPException(status_code=400, detail="当前状态不允许提交成果")
+    
+    # 更新交付物
+    task["deliverables"] = req.deliverables
+    task["deliverNote"] = req.note or ""
+    task["status"] = "submitted"
+    task["submittedAt"] = int(time.time())
+    
+    db.save_data("tasks.json", tasks_db)
+    
+    # P2增强：发送通知给发布者
+    _send_task_notification(
+        account=task.get("publisher"),
+        title="📥 任务成果已提交",
+        content=f"接单者已提交任务『{task['title']}』的成果，请查看并验收。",
+        task_id=req.task_id
+    )
+    
+    return {"status": "success", "message": "成果已提交，等待发布者验收"}
+
+
+# ==========================================
+# ✅ 发布者验收（P2增强：从冻结余额支付尾款+交易记录+通知）
+# ==========================================
+@router.post("/api/tasks/accept")
+async def accept_task(req: TaskAccept):
+    """
+    发布者验收成果
+    P2增强：尾款从冻结余额支付
+    """
+    tasks_db = db.load_data("tasks.json", default_data=[])
+    users_db = db.load_data("users.json", default_data={})
+    
+    task_idx = next((i for i, t in enumerate(tasks_db) if t.get("id") == req.task_id), None)
+    if task_idx is None:
+        raise HTTPException(status_code=404, detail="任务不存在")
+    
+    task = tasks_db[task_idx]
+    
+    # 权限校验
+    if task.get("publisher") != req.publisher:
+        raise HTTPException(status_code=403, detail="无权操作此任务")
+    
+    # 状态检查
+    if task.get("status") != "submitted":
+        raise HTTPException(status_code=400, detail="当前状态不允许验收")
+    
+    task["publisherFeedback"] = req.feedback or ""
+    publisher = task.get("publisher")
+    assignee = task.get("assignee")
+    
+    if req.is_accepted:
+        # 验收通过：支付尾款
+        final_payment = task.get("finalPayment", 0)
+        publisher_info = users_db.get(publisher, {})
+        
+        # P2增强：尾款从冻结余额中支付
+        frozen_balance = publisher_info.get("frozen_balance", 0)
+        current_balance = publisher_info.get("balance", 0)
+        
+        # 扣减实际余额，同时减少冻结金额
+        publisher_info["balance"] = current_balance - final_payment
+        publisher_info["frozen_balance"] = frozen_balance - final_payment
+        users_db[publisher] = publisher_info
+        
+        # 尾款转入接单者账户
+        if assignee not in users_db:
+            users_db[assignee] = {"balance": 0, "frozen_balance": 0}
+        users_db[assignee]["balance"] = users_db[assignee].get("balance", 0) + final_payment
+        
+        # 更新任务状态
+        task["finalPaid"] = True
+        task["status"] = "completed"
+        task["completedAt"] = int(time.time())
+        
+        db.save_data("users.json", users_db)
+        
+        # P2增强：记录交易明细
+        _record_transaction(
+            account=publisher,
+            tx_type="final_pay",
+            amount=final_payment,
+            related_task_id=req.task_id,
+            target_account=assignee,
+            note=f"支付尾款: {task['title'][:20]}"
+        )
+        _record_transaction(
+            account=assignee,
+            tx_type="final_receive",
+            amount=final_payment,
+            related_task_id=req.task_id,
+            target_account=publisher,
+            note=f"收到尾款: {task['title'][:20]}"
+        )
+        
+        # P2增强：发送通知
+        total_earned = task.get("depositAmount", 0) + final_payment
+        _send_task_notification(
+            account=assignee,
+            title="🎉 任务已完成",
+            content=f"任务『{task['title']}』已验收通过！尾款 {final_payment} 积分已到账，共计收入 {total_earned} 积分。",
+            task_id=req.task_id
+        )
+        
+        message = f"验收通过！尾款 {final_payment} 积分已支付给接单者"
+    else:
+        # 验收不通过：任务回到进行中状态
+        task["status"] = "in_progress"
+        task["deliverables"] = []  # 清空交付物
+        
+        # P2增强：发送通知
+        _send_task_notification(
+            account=assignee,
+            title="⚠️ 验收未通过",
+            content=f"任务『{task['title']}』验收未通过，请查看反馈并重新提交。反馈：{req.feedback or '无'}",
+            task_id=req.task_id
+        )
+        
+        message = "验收不通过，请接单者重新提交"
+    
+    db.save_data("tasks.json", tasks_db)
+    
+    return {"status": "success", "message": message}
+
+
+# ==========================================
+# ❌ 取消任务（P2增强：解冻余额+交易记录+通知）
+# ==========================================
+@router.post("/api/tasks/{task_id}/cancel")
+async def cancel_task(task_id: str, publisher: str):
+    """
+    发布者取消任务
+    P2增强：取消时解冻余额，退还订金
+    """
+    tasks_db = db.load_data("tasks.json", default_data=[])
+    users_db = db.load_data("users.json", default_data={})
+    
+    task_idx = next((i for i, t in enumerate(tasks_db) if t.get("id") == task_id), None)
+    if task_idx is None:
+        raise HTTPException(status_code=404, detail="任务不存在")
+    
+    task = tasks_db[task_idx]
+    
+    # 权限校验
+    if task.get("publisher") != publisher:
+        raise HTTPException(status_code=403, detail="无权操作此任务")
+    
+    status = task.get("status")
+    
+    # 只有 open 和 assigned 状态可以取消
+    if status not in ["open", "assigned"]:
+        raise HTTPException(status_code=400, detail="任务进行中或已完成，无法取消")
+    
+    publisher_info = users_db.get(publisher, {})
+    frozen_amount = task.get("frozenAmount", task.get("totalPrice", 0))
+    assignee = task.get("assignee")
+    
+    # P2增强：解冻余额
+    if status == "open":
+        # 招募中取消：解冻全部金额
+        publisher_info["frozen_balance"] = max(0, publisher_info.get("frozen_balance", 0) - frozen_amount)
+        users_db[publisher] = publisher_info
+        
+        _record_transaction(
+            account=publisher,
+            tx_type="task_unfreeze",
+            amount=frozen_amount,
+            related_task_id=task_id,
+            note=f"取消任务解冻: {task['title'][:20]}"
+        )
+        
+    elif status == "assigned":
+        if task.get("depositPaid"):
+            # 已支付订金：从接单者扣回订金，解冻剩余尾款
+            deposit_amount = task.get("depositAmount", 0)
+            final_payment = task.get("finalPayment", 0)
+            
+            # 从接单者扣除订金
+            if assignee in users_db:
+                users_db[assignee]["balance"] = max(0, users_db[assignee].get("balance", 0) - deposit_amount)
+            
+            # 退还给发布者
+            publisher_info["balance"] = publisher_info.get("balance", 0) + deposit_amount
+            # 解冻剩余尾款
+            publisher_info["frozen_balance"] = max(0, publisher_info.get("frozen_balance", 0) - final_payment)
+            users_db[publisher] = publisher_info
+            
+            # 记录退款交易
+            _record_transaction(
+                account=assignee,
+                tx_type="task_refund",
+                amount=-deposit_amount,
+                related_task_id=task_id,
+                target_account=publisher,
+                note=f"任务取消退回订金: {task['title'][:20]}"
+            )
+            _record_transaction(
+                account=publisher,
+                tx_type="task_refund",
+                amount=deposit_amount,
+                related_task_id=task_id,
+                target_account=assignee,
+                note=f"任务取消收回订金: {task['title'][:20]}"
+            )
+            
+            # 通知接单者
+            _send_task_notification(
+                account=assignee,
+                title="⚠️ 任务已取消",
+                content=f"任务『{task['title']}』已被发布者取消，订金 {deposit_amount} 积分已退回。",
+                task_id=task_id
+            )
+        else:
+            # 未支付订金：解冻全部金额
+            publisher_info["frozen_balance"] = max(0, publisher_info.get("frozen_balance", 0) - frozen_amount)
+            users_db[publisher] = publisher_info
+            
+            _record_transaction(
+                account=publisher,
+                tx_type="task_unfreeze",
+                amount=frozen_amount,
+                related_task_id=task_id,
+                note=f"取消任务解冻: {task['title'][:20]}"
+            )
+            
+            # 通知接单者
+            if assignee:
+                _send_task_notification(
+                    account=assignee,
+                    title="⚠️ 任务已取消",
+                    content=f"任务『{task['title']}』已被发布者取消。",
+                    task_id=task_id
+                )
+    
+    db.save_data("users.json", users_db)
+    
+    task["status"] = "cancelled"
+    task["cancelledAt"] = int(time.time())
+    
+    db.save_data("tasks.json", tasks_db)
+    
+    return {"status": "success", "message": "任务已取消"}
+
+
+# ==========================================
+# 📊 获取用户相关的任务
+# ==========================================
+@router.get("/api/tasks/user/{account}")
+async def get_user_tasks(account: str, role: str = "all"):
+    """
+    获取用户发布或参与的任务
+    
+    查询参数：
+        - role: publisher=我发布的, assignee=我接的, all=全部
+    """
+    tasks_db = db.load_data("tasks.json", default_data=[])
+    
+    user_tasks = []
+    for task in tasks_db:
+        is_publisher = task.get("publisher") == account
+        is_assignee = task.get("assignee") == account
+        is_applicant = any(a.get("account") == account for a in task.get("applicants", []))
+        
+        if role == "publisher" and is_publisher:
+            user_tasks.append({**task, "userRole": "publisher"})
+        elif role == "assignee" and (is_assignee or is_applicant):
+            user_tasks.append({**task, "userRole": "assignee" if is_assignee else "applicant"})
+        elif role == "all" and (is_publisher or is_assignee or is_applicant):
+            user_tasks.append({
+                **task, 
+                "userRole": "publisher" if is_publisher else ("assignee" if is_assignee else "applicant")
+            })
+    
+    user_tasks.sort(key=lambda x: x.get("createdAt", 0), reverse=True)
+    
+    return {"status": "success", "data": user_tasks}
+
+
+# ==========================================
+# 🔧 辅助函数
+# ==========================================
+def _parse_deadline(deadline_str: str) -> int:
+    """
+    解析截止时间字符串为时间戳
+    """
+    if not deadline_str:
+        return 0
+    try:
+        # 尝试多种格式
+        for fmt in ["%Y-%m-%dT%H:%M:%S", "%Y-%m-%d %H:%M:%S", "%Y-%m-%d"]:
+            try:
+                dt = datetime.strptime(deadline_str, fmt)
+                return int(dt.timestamp())
+            except ValueError:
+                continue
+        return 0
+    except:
+        return 0
+
+
+# ==========================================
+# 💰 P2增强：获取用户交易明细
+# ==========================================
+@router.get("/api/transactions/user/{account}")
+async def get_user_transactions(account: str, tx_type: str = "all", page: int = 1, page_size: int = 20):
+    """
+    获取用户交易明细
+    
+    查询参数：
+        - tx_type: 交易类型过滤 (all/deposit/final/freeze/refund)
+        - page: 页码
+        - page_size: 每页数量
+    """
+    transactions_db = db.load_data("transactions.json", default_data=[])
+    
+    # 过滤用户交易
+    user_transactions = [t for t in transactions_db if t.get("account") == account]
+    
+    # 按类型过滤
+    if tx_type != "all":
+        type_map = {
+            "deposit": ["deposit_pay", "deposit_receive"],
+            "final": ["final_pay", "final_receive"],
+            "freeze": ["task_freeze", "task_unfreeze"],
+            "refund": ["task_refund", "expired_refund"]
+        }
+        target_types = type_map.get(tx_type, [])
+        if target_types:
+            user_transactions = [t for t in user_transactions if t.get("type") in target_types]
+    
+    # 分页
+    total = len(user_transactions)
+    start = (page - 1) * page_size
+    end = start + page_size
+    paginated = user_transactions[start:end]
+    
+    return {
+        "status": "success",
+        "data": paginated,
+        "total": total,
+        "page": page,
+        "page_size": page_size
+    }
+
+
+# ==========================================
+# 📈 P2增强：获取用户任务收益统计
+# ==========================================
+@router.get("/api/tasks/stats/{account}")
+async def get_task_stats(account: str):
+    """
+    获取用户任务统计信息
+    """
+    tasks_db = db.load_data("tasks.json", default_data=[])
+    transactions_db = db.load_data("transactions.json", default_data=[])
+    
+    # 统计任务数量
+    published_tasks = [t for t in tasks_db if t.get("publisher") == account]
+    assigned_tasks = [t for t in tasks_db if t.get("assignee") == account]
+    
+    # 分状态统计
+    published_open = len([t for t in published_tasks if t.get("status") == "open"])
+    published_in_progress = len([t for t in published_tasks if t.get("status") in ["assigned", "in_progress", "submitted"]])
+    published_completed = len([t for t in published_tasks if t.get("status") == "completed"])
+    
+    assigned_in_progress = len([t for t in assigned_tasks if t.get("status") in ["in_progress", "submitted"]])
+    assigned_completed = len([t for t in assigned_tasks if t.get("status") == "completed"])
+    
+    # 统计收入（从交易记录中计算）
+    user_transactions = [t for t in transactions_db if t.get("account") == account]
+    
+    # 任务收入（收到的订金+尾款）
+    task_income = sum(
+        t.get("amount", 0) 
+        for t in user_transactions 
+        if t.get("type") in ["deposit_receive", "final_receive"]
+    )
+    
+    # 任务支出（支付的订金+尾款）
+    task_expense = sum(
+        t.get("amount", 0) 
+        for t in user_transactions 
+        if t.get("type") in ["deposit_pay", "final_pay"]
+    )
+    
+    # 冻结金额（当前招募中的任务）
+    frozen_for_tasks = sum(
+        t.get("frozenAmount", t.get("totalPrice", 0)) 
+        for t in published_tasks 
+        if t.get("status") == "open"
+    )
+    
+    return {
+        "status": "success",
+        "data": {
+            # 发布任务统计
+            "published": {
+                "total": len(published_tasks),
+                "open": published_open,
+                "in_progress": published_in_progress,
+                "completed": published_completed
+            },
+            # 接单任务统计
+            "assigned": {
+                "total": len(assigned_tasks),
+                "in_progress": assigned_in_progress,
+                "completed": assigned_completed
+            },
+            # 财务统计
+            "finance": {
+                "task_income": task_income,      # 任务收入
+                "task_expense": task_expense,    # 任务支出
+                "frozen_for_tasks": frozen_for_tasks  # 任务冻结金额
+            }
+        }
+    }
+
+
+# ==========================================
+# ⚖️ P3增强：发起申诉
+# ==========================================
+@router.post("/api/tasks/dispute")
+async def create_dispute(req: TaskDispute):
+    """
+    发起任务申诉
+    可由发布者或接单者发起
+    
+    触发条件：
+    - 验收不通过后，接单者可在 3 天内发起申诉
+    - 验收通过后，发布者可在 7 天内发起申诉（发现质量问题）
+    """
+    tasks_db = db.load_data("tasks.json", default_data=[])
+    disputes_db = db.load_data("disputes.json", default_data=[])
+    users_db = db.load_data("users.json", default_data={})
+    
+    # 查找任务
+    task = next((t for t in tasks_db if t.get("id") == req.task_id), None)
+    if not task:
+        raise HTTPException(status_code=404, detail="任务不存在")
+    
+    publisher = task.get("publisher")
+    assignee = task.get("assignee")
+    
+    # 权限校验：只有发布者或接单者可以发起申诉
+    if req.initiator not in [publisher, assignee]:
+        raise HTTPException(status_code=403, detail="您不是该任务的参与者，无法发起申诉")
+    
+    # 状态校验：只有特定状态可以申诉
+    status = task.get("status")
+    
+    # 接单者申诉：验收不通过后可申诉
+    if req.initiator == assignee:
+        if status != "in_progress":  # 验收不通过后任务回到 in_progress
+            raise HTTPException(status_code=400, detail="当前状态不允许申诉，仅在验收不通过后可发起申诉")
+    
+    # 发布者申诉：验收通过后发现问题可申诉
+    if req.initiator == publisher:
+        if status not in ["completed", "in_progress"]:
+            raise HTTPException(status_code=400, detail="当前状态不允许申诉")
+    
+    # 检查是否已有未处理的申诉
+    existing_dispute = next(
+        (d for d in disputes_db if d.get("task_id") == req.task_id and d.get("status") in ["pending", "responded"]), 
+        None
+    )
+    if existing_dispute:
+        raise HTTPException(status_code=400, detail="该任务已有未处理的申诉")
+    
+    # 确定被申诉方
+    respondent = assignee if req.initiator == publisher else publisher
+    respondent_info = users_db.get(respondent, {})
+    initiator_info = users_db.get(req.initiator, {})
+    
+    # 创建申诉记录
+    dispute_id = f"dispute_{uuid.uuid4().hex[:12]}"
+    dispute = {
+        "id": dispute_id,
+        "task_id": req.task_id,
+        "task_title": task.get("title", ""),
+        
+        # 申诉方信息
+        "initiator": req.initiator,
+        "initiator_name": initiator_info.get("name", req.initiator),
+        "initiator_avatar": initiator_info.get("avatarDataUrl", ""),
+        "initiator_role": "publisher" if req.initiator == publisher else "assignee",
+        "reason": req.reason,
+        "evidence": req.evidence or [],
+        
+        # 被申诉方信息
+        "respondent": respondent,
+        "respondent_name": respondent_info.get("name", respondent),
+        "respondent_avatar": respondent_info.get("avatarDataUrl", ""),
+        "response": None,
+        "response_evidence": [],
+        "responded_at": None,
+        
+        # 状态与时间
+        "status": "pending",  # pending -> responded -> resolved
+        "created_at": int(time.time()),
+        
+        # 仲裁信息
+        "admin_account": None,
+        "admin_result": None,
+        "admin_note": None,
+        "resolved_at": None,
+        
+        # 涉及金额（争议金额）
+        "disputed_amount": task.get("finalPayment", 0) if status == "in_progress" else task.get("totalPrice", 0)
+    }
+    
+    # 更新任务状态为申诉中
+    task_idx = next((i for i, t in enumerate(tasks_db) if t.get("id") == req.task_id), None)
+    if task_idx is not None:
+        tasks_db[task_idx]["status"] = "disputed"
+        tasks_db[task_idx]["dispute_id"] = dispute_id
+    
+    disputes_db.insert(0, dispute)
+    db.save_data("disputes.json", disputes_db)
+    db.save_data("tasks.json", tasks_db)
+    
+    # 发送通知给被申诉方
+    _send_task_notification(
+        account=respondent,
+        title="⚠️ 您有新的任务申诉",
+        content=f"任务『{task.get('title')}』被发起申诉，请尽快回应。申诉理由：{req.reason[:50]}...",
+        task_id=req.task_id
+    )
+    
+    # 记录交易
+    _record_transaction(
+        account=req.initiator,
+        tx_type="dispute_initiated",
+        amount=0,
+        related_task_id=req.task_id,
+        target_account=respondent,
+        note=f"发起申诉: {task.get('title', '')[:20]}"
+    )
+    
+    return {"status": "success", "data": dispute, "message": "申诉已提交，请等待对方回应"}
+
+
+# ==========================================
+# ⚖️ P3增强：被申诉方回应
+# ==========================================
+@router.post("/api/tasks/dispute/respond")
+async def respond_dispute(req: TaskDisputeResponse):
+    """
+    被申诉方回应申诉
+    """
+    disputes_db = db.load_data("disputes.json", default_data=[])
+    
+    # 查找申诉
+    dispute_idx = next((i for i, d in enumerate(disputes_db) if d.get("id") == req.dispute_id), None)
+    if dispute_idx is None:
+        raise HTTPException(status_code=404, detail="申诉不存在")
+    
+    dispute = disputes_db[dispute_idx]
+    
+    # 权限校验
+    if dispute.get("respondent") != req.respondent:
+        raise HTTPException(status_code=403, detail="您不是被申诉方，无法回应")
+    
+    # 状态校验
+    if dispute.get("status") != "pending":
+        raise HTTPException(status_code=400, detail="该申诉已回应或已处理")
+    
+    # 更新申诉记录
+    dispute["response"] = req.response
+    dispute["response_evidence"] = req.evidence or []
+    dispute["responded_at"] = int(time.time())
+    dispute["status"] = "responded"
+    
+    disputes_db[dispute_idx] = dispute
+    db.save_data("disputes.json", disputes_db)
+    
+    # 发送通知给申诉方
+    _send_task_notification(
+        account=dispute.get("initiator"),
+        title="📝 申诉已收到回应",
+        content=f"您对任务『{dispute.get('task_title')}』的申诉已收到对方回应，等待管理员仲裁。",
+        task_id=dispute.get("task_id")
+    )
+    
+    return {"status": "success", "message": "回应已提交，等待管理员仲裁"}
+
+
+# ==========================================
+# ⚖️ P3增强：管理员仲裁
+# ==========================================
+@router.post("/api/tasks/dispute/resolve")
+async def resolve_dispute(req: TaskDisputeResolve):
+    """
+    管理员仲裁申诉
+    
+    仲裁结果：
+    - support_initiator: 支持申诉方，争议金额全额给申诉方
+    - support_respondent: 支持被申诉方，争议金额全额给被申诉方
+    - split: 双方分成，按 split_ratio 分配
+    """
+    # 管理员权限校验
+    if req.admin_account != "123456":  # 管理员账号
+        raise HTTPException(status_code=403, detail="无管理员权限")
+    
+    disputes_db = db.load_data("disputes.json", default_data=[])
+    tasks_db = db.load_data("tasks.json", default_data=[])
+    users_db = db.load_data("users.json", default_data={})
+    
+    # 查找申诉
+    dispute_idx = next((i for i, d in enumerate(disputes_db) if d.get("id") == req.dispute_id), None)
+    if dispute_idx is None:
+        raise HTTPException(status_code=404, detail="申诉不存在")
+    
+    dispute = disputes_db[dispute_idx]
+    
+    # 状态校验
+    if dispute.get("status") == "resolved":
+        raise HTTPException(status_code=400, detail="该申诉已处理")
+    
+    task_id = dispute.get("task_id")
+    task = next((t for t in tasks_db if t.get("id") == task_id), None)
+    if not task:
+        raise HTTPException(status_code=404, detail="关联任务不存在")
+    
+    initiator = dispute.get("initiator")
+    respondent = dispute.get("respondent")
+    disputed_amount = dispute.get("disputed_amount", 0)
+    publisher = task.get("publisher")
+    assignee = task.get("assignee")
+    
+    # 根据仲裁结果分配资金
+    if req.result == "support_initiator":
+        # 支持申诉方
+        winner = initiator
+        loser = respondent
+        winner_amount = disputed_amount
+        loser_amount = 0
+        result_msg = f"申诉成功，争议金额 {disputed_amount} 积分已分配给申诉方"
+        
+    elif req.result == "support_respondent":
+        # 支持被申诉方
+        winner = respondent
+        loser = initiator
+        winner_amount = disputed_amount
+        loser_amount = 0
+        result_msg = f"申诉被驳回，争议金额 {disputed_amount} 积分已分配给被申诉方"
+        
+    elif req.result == "split":
+        # 双方分成
+        split_ratio = req.split_ratio or 50
+        winner_amount = int(disputed_amount * split_ratio / 100)
+        loser_amount = disputed_amount - winner_amount
+        result_msg = f"申诉调解成功，申诉方获得 {winner_amount} 积分，被申诉方获得 {loser_amount} 积分"
+    else:
+        raise HTTPException(status_code=400, detail="无效的仲裁结果")
+    
+    # 执行资金转移
+    # 如果申诉方是接单者且胜诉，尾款从发布者冻结中扣除并转给接单者
+    # 如果申诉方是发布者且胜诉，需要从接单者账户扣除并退还给发布者
+    
+    if req.result == "support_initiator":
+        if dispute.get("initiator_role") == "assignee":
+            # 接单者胜诉：尾款转给接单者
+            _execute_dispute_payment(users_db, publisher, assignee, disputed_amount, task, "assignee_wins")
+        else:
+            # 发布者胜诉：从接单者扣除已支付的订金
+            _execute_dispute_payment(users_db, assignee, publisher, disputed_amount, task, "publisher_wins")
+    elif req.result == "support_respondent":
+        if dispute.get("initiator_role") == "assignee":
+            # 接单者申诉失败：不进行额外资金转移，任务继续
+            pass
+        else:
+            # 发布者申诉失败：尾款继续留给接单者
+            pass
+    elif req.result == "split":
+        # 分成处理
+        _execute_dispute_split(users_db, publisher, assignee, initiator, respondent, winner_amount, loser_amount, task)
+    
+    db.save_data("users.json", users_db)
+    
+    # 更新申诉状态
+    dispute["status"] = "resolved"
+    dispute["admin_account"] = req.admin_account
+    dispute["admin_result"] = req.result
+    dispute["admin_note"] = req.admin_note
+    dispute["resolved_at"] = int(time.time())
+    if req.result == "split":
+        dispute["split_ratio"] = req.split_ratio
+    
+    disputes_db[dispute_idx] = dispute
+    db.save_data("disputes.json", disputes_db)
+    
+    # 更新任务状态
+    task_idx = next((i for i, t in enumerate(tasks_db) if t.get("id") == task_id), None)
+    if task_idx is not None:
+        tasks_db[task_idx]["status"] = "resolved"  # 申诉已解决
+        tasks_db[task_idx]["dispute_result"] = req.result
+        db.save_data("tasks.json", tasks_db)
+    
+    # 发送通知给双方
+    _send_task_notification(
+        account=initiator,
+        title="⚖️ 申诉已处理",
+        content=f"任务『{task.get('title')}』的申诉已由管理员处理。{result_msg}",
+        task_id=task_id
+    )
+    _send_task_notification(
+        account=respondent,
+        title="⚖️ 申诉已处理",
+        content=f"任务『{task.get('title')}』的申诉已由管理员处理。{result_msg}",
+        task_id=task_id
+    )
+    
+    # 记录交易
+    _record_transaction(
+        account=req.admin_account,
+        tx_type="dispute_resolved",
+        amount=disputed_amount,
+        related_task_id=task_id,
+        note=f"仲裁申诉: {task.get('title', '')[:20]} - {req.result}"
+    )
+    
+    return {"status": "success", "message": result_msg}
+
+
+def _execute_dispute_payment(users_db: dict, from_account: str, to_account: str, amount: int, task: dict, scenario: str):
+    """
+    执行申诉仲裁后的资金转移
+    """
+    from_info = users_db.get(from_account, {})
+    to_info = users_db.get(to_account, {})
+    
+    if scenario == "assignee_wins":
+        # 接单者胜诉：从发布者冻结中扣除尾款并转给接单者
+        from_info["balance"] = from_info.get("balance", 0) - amount
+        from_info["frozen_balance"] = max(0, from_info.get("frozen_balance", 0) - amount)
+        to_info["balance"] = to_info.get("balance", 0) + amount
+        
+        _record_transaction(from_account, "dispute_loss", amount, task.get("id"), to_account, "申诉裁决扣款")
+        _record_transaction(to_account, "dispute_win", amount, task.get("id"), from_account, "申诉裁决获得")
+        
+    elif scenario == "publisher_wins":
+        # 发布者胜诉：从接单者扣除已收到的订金并退给发布者
+        deposit_amount = task.get("depositAmount", 0)
+        from_info["balance"] = max(0, from_info.get("balance", 0) - deposit_amount)
+        to_info["balance"] = to_info.get("balance", 0) + deposit_amount
+        
+        _record_transaction(from_account, "dispute_loss", deposit_amount, task.get("id"), to_account, "申诉裁决退还订金")
+        _record_transaction(to_account, "dispute_win", deposit_amount, task.get("id"), from_account, "申诉裁决收回订金")
+    
+    users_db[from_account] = from_info
+    users_db[to_account] = to_info
+
+
+def _execute_dispute_split(users_db: dict, publisher: str, assignee: str, initiator: str, respondent: str, 
+                           initiator_amount: int, respondent_amount: int, task: dict):
+    """
+    执行申诉分成处理
+    """
+    # 从发布者冻结中扣除尾款
+    publisher_info = users_db.get(publisher, {})
+    final_payment = task.get("finalPayment", 0)
+    
+    publisher_info["balance"] = publisher_info.get("balance", 0) - final_payment
+    publisher_info["frozen_balance"] = max(0, publisher_info.get("frozen_balance", 0) - final_payment)
+    users_db[publisher] = publisher_info
+    
+    # 分配给双方
+    initiator_info = users_db.get(initiator, {})
+    respondent_info = users_db.get(respondent, {})
+    
+    initiator_info["balance"] = initiator_info.get("balance", 0) + initiator_amount
+    respondent_info["balance"] = respondent_info.get("balance", 0) + respondent_amount
+    
+    users_db[initiator] = initiator_info
+    users_db[respondent] = respondent_info
+    
+    _record_transaction(initiator, "dispute_split", initiator_amount, task.get("id"), note="申诉调解分成")
+    _record_transaction(respondent, "dispute_split", respondent_amount, task.get("id"), note="申诉调解分成")
+
+
+# ==========================================
+# ⚖️ P3增强：获取申诉列表
+# ==========================================
+@router.get("/api/tasks/disputes")
+async def get_disputes(status: str = "all", page: int = 1, page_size: int = 20):
+    """
+    获取申诉列表（管理员用）
+    """
+    disputes_db = db.load_data("disputes.json", default_data=[])
+    
+    # 过滤
+    if status != "all":
+        disputes_db = [d for d in disputes_db if d.get("status") == status]
+    
+    # 排序：未处理的优先
+    disputes_db.sort(key=lambda x: (0 if x.get("status") in ["pending", "responded"] else 1, -x.get("created_at", 0)))
+    
+    # 分页
+    total = len(disputes_db)
+    start = (page - 1) * page_size
+    end = start + page_size
+    paginated = disputes_db[start:end]
+    
+    return {
+        "status": "success",
+        "data": paginated,
+        "total": total,
+        "page": page,
+        "page_size": page_size
+    }
+
+
+# ==========================================
+# ⚖️ P3增强：获取单个申诉详情
+# ==========================================
+@router.get("/api/tasks/disputes/{dispute_id}")
+async def get_dispute_detail(dispute_id: str):
+    """
+    获取申诉详情
+    """
+    disputes_db = db.load_data("disputes.json", default_data=[])
+    
+    dispute = next((d for d in disputes_db if d.get("id") == dispute_id), None)
+    if not dispute:
+        raise HTTPException(status_code=404, detail="申诉不存在")
+    
+    return {"status": "success", "data": dispute}
+
+
+# ==========================================
+# ⚖️ P3增强：获取用户相关的申诉
+# ==========================================
+@router.get("/api/tasks/disputes/user/{account}")
+async def get_user_disputes(account: str):
+    """
+    获取用户发起或参与的申诉
+    """
+    disputes_db = db.load_data("disputes.json", default_data=[])
+    
+    user_disputes = [
+        d for d in disputes_db 
+        if d.get("initiator") == account or d.get("respondent") == account
+    ]
+    
+    user_disputes.sort(key=lambda x: x.get("created_at", 0), reverse=True)
+    
+    return {"status": "success", "data": user_disputes}