Upload 10 files

app.py

@@ -4,8 +4,11 @@ from fastapi.middleware.cors import CORSMiddleware
 import hashlib
 import 数据库连接 as db
 
-# 引入抽离出去的业务路由
-from routers import router
+# 引入拆分后的四大业务模块
+from router_users import router as users_router
+from router_items import router as items_router
+from router_comments import router as comments_router
+from router_messages import router as messages_router
 
 app = FastAPI(title="ComfyUI Ranking Community API")
 
@@ -17,8 +20,11 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# 挂载业务路由
-app.include_router(router)
+# 挂载并聚合所有业务子路由
+app.include_router(users_router)
+app.include_router(items_router)
+app.include_router(comments_router)
+app.include_router(messages_router)
 
 @app.get("/")
 def read_root(): 

router_comments.py

@@ -0,0 +1,83 @@
+# router_comments.py
+from fastapi import APIRouter, HTTPException
+import time
+import uuid
+import 数据库连接 as db
+from notifications import add_notification
+from models import InteractionToggle, CommentCreate
+
+router = APIRouter()
+
+@router.post("/api/interactions/toggle")
+async def toggle_interaction(interaction: InteractionToggle):
+    items_db = db.load_data("items.json", default_data=[])
+    target_item = next((item for item in items_db if item["id"] == interaction.item_id), None)
+    if not target_item: raise HTTPException(status_code=404, detail="目标存在问题")
+
+    list_key = f"{interaction.action_type}d_by" 
+    count_key = "likes" if interaction.action_type == "like" else "favorites"
+    if list_key not in target_item: target_item[list_key] = []; target_item[count_key] = 0
+
+    user_list = target_item[list_key]
+    if interaction.is_active:
+        if interaction.user_id not in user_list: 
+            user_list.append(interaction.user_id)
+            target_item[count_key] += 1
+            add_notification(target_item.get("author", ""), {"type": interaction.action_type, "from_user": interaction.user_id, "target_item_id": target_item["id"], "target_item_title": target_item["title"]})
+    else:
+        if interaction.user_id in user_list: 
+            user_list.remove(interaction.user_id)
+            target_item[count_key] = max(0, target_item[count_key] - 1)
+    db.save_data("items.json", items_db)
+    return {"status": "success", "new_count": target_item[count_key]}
+
+@router.post("/api/comments")
+async def post_comment(comment: CommentCreate):
+    comments_db = db.load_data("comments.json", default_data={}) 
+    users_db = db.load_data("users.json", default_data={})
+    author_info = users_db.get(comment.author, {})
+    reply_name = users_db.get(comment.reply_to_user, {}).get("name", comment.reply_to_user) if comment.reply_to_user else None
+
+    item_comments = comments_db.get(comment.item_id, [])
+    new_comment = {
+        "id": f"c_{int(time.time())}_{uuid.uuid4().hex[:6]}", "author": comment.author, 
+        "authorName": author_info.get("name", comment.author), "avatar": author_info.get("avatarDataUrl", "https://via.placeholder.com/150"),
+        "content": comment.content, "replyToUser": comment.reply_to_user, "replyToUserName": reply_name,
+        "isDeleted": False, "replies": [], "created_at": int(time.time())
+    }
+    
+    if comment.parent_id:
+        parent = next((c for c in item_comments if c["id"] == comment.parent_id), None)
+        if parent: 
+            parent["replies"].append(new_comment)
+            if comment.reply_to_user:
+                add_notification(comment.reply_to_user, {"type": "reply", "from_user": comment.author, "target_item_id": comment.item_id, "target_item_title": "收到新的回复", "content": comment.content})
+        else: raise HTTPException(status_code=404, detail="找不到要回复的评论")
+    else: 
+        item_comments.append(new_comment)
+        items_db = db.load_data("items.json", default_data=[])
+        target_item = next((item for item in items_db if item["id"] == comment.item_id), None)
+        if target_item:
+            add_notification(target_item.get("author", ""), {"type": "comment", "from_user": comment.author, "target_item_id": comment.item_id, "target_item_title": target_item["title"], "content": comment.content})
+        elif comment.item_id in users_db:
+            add_notification(comment.item_id, {"type": "comment", "from_user": comment.author, "target_item_id": comment.item_id, "target_item_title": "您的个人留言板", "content": comment.content})
+
+    comments_db[comment.item_id] = item_comments
+    db.save_data("comments.json", comments_db)
+    return {"status": "success", "data": new_comment}
+
+@router.delete("/api/comments/{item_id}/{comment_id}")
+async def soft_delete_comment(item_id: str, comment_id: str, author: str):
+    comments_db = db.load_data("comments.json", default_data={})
+    item_comments = comments_db.get(item_id, [])
+    def find_and_delete(comments_list):
+        for c in comments_list:
+            if c["id"] == comment_id:
+                if c["author"] != author: raise HTTPException(status_code=403, detail="无权删除他人的评论")
+                c["isDeleted"] = True; c["content"] = ""; return True
+            if "replies" in c and find_and_delete(c["replies"]): return True
+        return False
+    if find_and_delete(item_comments):
+        db.save_data("comments.json", comments_db)
+        return {"status": "success"}
+    raise HTTPException(status_code=404, detail="找不到该评论")

router_items.py

@@ -0,0 +1,57 @@
+# router_items.py
+from fastapi import APIRouter
+import time
+import uuid
+import 数据库连接 as db
+from models import ItemCreate
+
+router = APIRouter()
+
+@router.get("/api/items")
+async def get_items(type: str = "tool", sort: str = "time", limit: int = 20):
+    items_db = db.load_data("items.json", default_data=[])
+    comments_db = db.load_data("comments.json", default_data={})
+    filtered_items = [item for item in items_db if item.get("type") == type]
+    for item in filtered_items:
+        item["commentsData"] = comments_db.get(item["id"], [])
+        item["comments"] = len(item["commentsData"])
+    if sort == "likes": filtered_items.sort(key=lambda x: x.get("likes", 0), reverse=True)
+    elif sort == "favorites": filtered_items.sort(key=lambda x: x.get("favorites", 0), reverse=True)
+    elif sort == "downloads": filtered_items.sort(key=lambda x: x.get("uses", 0), reverse=True)
+    else: filtered_items.sort(key=lambda x: x.get("created_at", 0), reverse=True)
+    return {"status": "success", "data": filtered_items[:limit]}
+
+@router.get("/api/creators")
+async def get_creators(sort: str = "downloads", limit: int = 20):
+    users_db = db.load_data("users.json", default_data={})
+    items_db = db.load_data("items.json", default_data=[])
+    comments_db = db.load_data("comments.json", default_data={})
+    creators = []
+    for account, u in users_db.items():
+        u_items = [i for i in items_db if i.get("author") == account]
+        tools_count = sum(1 for i in u_items if i.get("type") == "tool")
+        apps_count = sum(1 for i in u_items if i.get("type") == "app")
+        creators.append({
+            "account": account, "name": u.get("name", account), "avatar": u.get("avatarDataUrl", "https://via.placeholder.com/150"),
+            "shortDesc": u.get("intro", "这个人很懒，什么都没写..."), "fullDesc": u.get("intro", "这个人很懒，什么都没写..."),
+            "likes": sum(i.get("likes", 0) for i in u_items), "favorites": sum(i.get("favorites", 0) for i in u_items), "downloads": sum(i.get("uses", 0) for i in u_items), 
+            "toolsCount": tools_count, "appsCount": apps_count, "followers": len(u.get("followers", [])), "created_at": u.get("created_at", 0),
+            "commentsData": comments_db.get(account, []), "trendData": {"tools": [0,0,0,0,0, tools_count], "apps": [0,0,0,0,0, apps_count]}
+        })
+    if sort == "likes": creators.sort(key=lambda x: x.get("likes", 0), reverse=True)
+    elif sort == "favorites": creators.sort(key=lambda x: x.get("favorites", 0), reverse=True)
+    elif sort == "downloads": creators.sort(key=lambda x: x.get("downloads", 0), reverse=True)
+    else: creators.sort(key=lambda x: x.get("created_at", 0), reverse=True)
+    return {"status": "success", "data": creators[:limit]}
+
+@router.post("/api/items")
+async def create_item(item: ItemCreate):
+    items_db = db.load_data("items.json", default_data=[])
+    new_item = {
+        "id": f"{item.type}_{int(time.time())}_{uuid.uuid4().hex[:6]}", "type": item.type, "title": item.title, "author": item.author,
+        "shortDesc": item.shortDesc, "fullDesc": item.fullDesc, "link": item.link, "coverUrl": item.coverUrl, "price": item.price, 
+        "likes": 0, "favorites": 0, "comments": 0, "uses": 0, "created_at": int(time.time()), "liked_by": [], "favorited_by": []
+    }
+    items_db.insert(0, new_item)
+    db.save_data("items.json", items_db)
+    return {"status": "success", "data": new_item}

router_messages.py

@@ -0,0 +1,106 @@
+# router_messages.py
+from fastapi import APIRouter
+import time
+import uuid
+import 数据库连接 as db
+from notifications import add_notification
+from models import PrivateMessage
+
+router = APIRouter()
+
+@router.post("/api/messages/private")
+async def send_private_message(msg: PrivateMessage):
+    chats_db = db.load_data("chats.json", default_data={})
+    conv_id = f"{min(msg.sender, msg.receiver)}_{max(msg.sender, msg.receiver)}"
+    if conv_id not in chats_db: chats_db[conv_id] = []
+    
+    chat_msg = {"id": f"chat_{int(time.time())}_{uuid.uuid4().hex[:6]}", "sender": msg.sender, "receiver": msg.receiver, "content": msg.content, "created_at": int(time.time()), "is_read": False}
+    chats_db[conv_id].append(chat_msg)
+    db.save_data("chats.json", chats_db)
+    
+    add_notification(msg.receiver, {"type": "private", "from_user": msg.sender, "content": msg.content})
+    return {"status": "success"}
+
+@router.get("/api/chats/{account}")
+async def get_chat_list(account: str):
+    chats_db = db.load_data("chats.json", default_data={})
+    users_db = db.load_data("users.json", default_data={})
+    chat_list = []
+    now = int(time.time())
+    seven_days = 7 * 24 * 3600
+    
+    for conv_id, msgs in chats_db.items():
+        accs = conv_id.split("_")
+        if account in accs and msgs:
+            # 列表中只统计有效消息
+            valid_msgs = [m for m in msgs if not m.get("is_read") or (now - m.get("created_at", 0) < seven_days)]
+            if valid_msgs:
+                target = accs[0] if accs[1] == account else accs[1]
+                target_info = users_db.get(target, {})
+                chat_list.append({
+                    "target_account": target, "target_name": target_info.get("name", target),
+                    "last_message": valid_msgs[-1]["content"], "last_time": valid_msgs[-1]["created_at"],
+                    "unread": sum(1 for m in valid_msgs if m["receiver"] == account and not m.get("is_read"))
+                })
+    chat_list.sort(key=lambda x: x["last_time"], reverse=True)
+    return {"status": "success", "data": chat_list}
+
+@router.get("/api/chats/{account}/{target}")
+async def get_chat_history(account: str, target: str):
+    chats_db = db.load_data("chats.json", default_data={})
+    conv_id = f"{min(account, target)}_{max(account, target)}"
+    msgs = chats_db.get(conv_id, [])
+    
+    now = int(time.time())
+    seven_days = 7 * 24 * 3600
+    valid_msgs = []
+    modified = False
+    
+    for m in msgs:
+        # 【核心策略】：未读的永远保留，已读的超过 7 天直接抛弃
+        if not m.get("is_read") or (now - m.get("created_at", 0) < seven_days):
+            valid_msgs.append(m)
+        else:
+            modified = True
+            
+        # 本次访问即为已读
+        if m["receiver"] == account and not m.get("is_read"): 
+            m["is_read"] = True
+            modified = True
+            
+    if modified or len(valid_msgs) != len(msgs): 
+        chats_db[conv_id] = valid_msgs
+        db.save_data("chats.json", chats_db)
+        
+    return {"status": "success", "data": valid_msgs}
+
+@router.get("/api/messages/{account}")
+async def get_messages(account: str):
+    msgs_db = db.load_data("messages.json", default_data={})
+    user_msgs = msgs_db.get(account, [])
+    
+    now = int(time.time())
+    seven_days = 7 * 24 * 3600
+    valid = []
+    modified = False
+    
+    for m in user_msgs:
+        if not m.get("is_read") or (now - m.get("created_at", 0) < seven_days):
+            valid.append(m)
+        else:
+            modified = True
+            
+    if modified:
+        msgs_db[account] = valid
+        db.save_data("messages.json", msgs_db)
+        
+    return {"status": "success", "data": valid, "unread_count": sum(1 for m in valid if not m.get("is_read"))}
+
+@router.post("/api/messages/{account}/read")
+async def mark_messages_read(account: str):
+    msgs_db = db.load_data("messages.json", default_data={})
+    user_msgs = msgs_db.get(account, [])
+    for m in user_msgs: m["is_read"] = True
+    msgs_db[account] = user_msgs
+    db.save_data("messages.json", msgs_db)
+    return {"status": "success"}

router_users.py

@@ -0,0 +1,88 @@
+# router_users.py
+from fastapi import APIRouter, HTTPException
+import time
+import re
+import 数据库连接 as db
+from notifications import add_notification
+from models import UserRegister, UserLogin, UserUpdate, PasswordReset, FollowToggle
+
+router = APIRouter()
+
+@router.post("/api/users/register")
+async def register_user(user: UserRegister):
+    users_db = db.load_data("users.json", default_data={})
+    if len(user.account) <= 5: raise HTTPException(status_code=400, detail="账号必须大于5个字符")
+    if not re.match(r'^[a-zA-Z0-9_]{6,20}$', user.account): raise HTTPException(status_code=400, detail="账号仅支持大小写英文字母、数字及下划线")
+    if len(user.password) < 6: raise HTTPException(status_code=400, detail="密码必须大于等于6个字符")
+    if not re.match(r'^[a-zA-Z0-9!@#$%^&*()_+\-=\[\]{};\':"\\|,.<>\/?]{6,}$', user.password): raise HTTPException(status_code=400, detail="密码包含不支持的特殊字符")
+    if user.intro and len(user.intro) > 100: raise HTTPException(status_code=400, detail="个人介绍不能超过100个字符")
+    if user.account in users_db: raise HTTPException(status_code=400, detail="该账号已被注册")
+    for existing_user in users_db.values():
+        if existing_user.get("email") == user.email: raise HTTPException(status_code=400, detail="该邮箱已被绑定")
+        if existing_user.get("phone") == user.phone: raise HTTPException(status_code=400, detail="该手机号已被绑定")
+    
+    new_user = user.dict()
+    new_user.update({"created_at": int(time.time()), "followers": [], "following": [], "privacy": {"follows": False, "likes": False, "favorites": False, "downloads": False}})
+    users_db[user.account] = new_user
+    db.save_data("users.json", users_db)
+    return {"status": "success", "message": "注册成功", "data": {k: v for k, v in new_user.items() if k != "password"}}
+
+@router.post("/api/users/login")
+async def login_user(user: UserLogin):
+    users_db = db.load_data("users.json", default_data={})
+    if user.account not in users_db: raise HTTPException(status_code=404, detail="账号不存在")
+    user_data = users_db[user.account]
+    if user_data.get("password") != user.password: raise HTTPException(status_code=401, detail="密码错误")
+    return {"status": "success", "token": f"mock_token_{user.account}", "account": user.account, "name": user_data["name"], "avatar": user_data.get("avatarDataUrl", "https://via.placeholder.com/150")}
+
+@router.get("/api/users/{account}")
+async def get_user_profile(account: str):
+    users_db = db.load_data("users.json", default_data={})
+    if account not in users_db: raise HTTPException(status_code=404, detail="用户不存在")
+    user_data = users_db[account]
+    items_db = db.load_data("items.json", default_data=[])
+    user_items = [item for item in items_db if item.get("author") == account]
+    user_data["receivedLikes"] = sum(item.get("likes", 0) for item in user_items)
+    user_data["receivedFavorites"] = sum(item.get("favorites", 0) for item in user_items)
+    user_data["receivedUses"] = sum(item.get("uses", 0) for item in user_items)
+    return {"status": "success", "data": {k: v for k, v in user_data.items() if k != "password"}}
+
+@router.put("/api/users/{account}")
+async def update_user_profile(account: str, update_data: UserUpdate):
+    users_db = db.load_data("users.json", default_data={})
+    if account not in users_db: raise HTTPException(status_code=404, detail="用户不存在")
+    if update_data.intro and len(update_data.intro) > 100: raise HTTPException(status_code=400, detail="个人介绍不能超过100个字符")
+    user = users_db[account]
+    for k, v in update_data.dict(exclude_unset=True).items():
+        if v is not None: user[k] = v
+    db.save_data("users.json", users_db)
+    return {"status": "success", "data": {k: v for k, v in user.items() if k != "password"}}
+
+@router.post("/api/users/{account}/reset-password")
+async def reset_password(account: str, pwd_data: PasswordReset):
+    users_db = db.load_data("users.json", default_data={})
+    if account not in users_db: raise HTTPException(status_code=404, detail="用户不存在")
+    if len(pwd_data.new_password) < 6: raise HTTPException(status_code=400, detail="新密码必须大于等于6个字符")
+    if not re.match(r'^[a-zA-Z0-9!@#$%^&*()_+\-=\[\]{};\':"\\|,.<>\/?]{6,}$', pwd_data.new_password): raise HTTPException(status_code=400, detail="新密码包含不支持的特殊字符")
+    user = users_db[account]
+    if user.get("password") != pwd_data.old_password: raise HTTPException(status_code=401, detail="原密码错误")
+    user["password"] = pwd_data.new_password
+    db.save_data("users.json", users_db)
+    return {"status": "success"}
+
+@router.post("/api/users/follow")
+async def toggle_follow(follow: FollowToggle):
+    users_db = db.load_data("users.json", default_data={})
+    if follow.target_account not in users_db or follow.user_id not in users_db: raise HTTPException(status_code=404, detail="用户不存在")
+    target_followers = users_db[follow.target_account].setdefault("followers", [])
+    current_following = users_db[follow.user_id].setdefault("following", [])
+    if follow.is_active:
+        if follow.user_id not in target_followers: 
+            target_followers.append(follow.user_id)
+            add_notification(follow.target_account, {"type": "follow", "from_user": follow.user_id})
+        if follow.target_account not in current_following: current_following.append(follow.target_account)
+    else:
+        if follow.user_id in target_followers: target_followers.remove(follow.user_id)
+        if follow.target_account in current_following: current_following.remove(follow.target_account)
+    db.save_data("users.json", users_db)
+    return {"status": "success"}