chore: small change in api.

backend/src/module/api/__init__.py

@@ -6,6 +6,7 @@ from .config import router as config_router
 from .download import router as download_router
 from .log import router as log_router
 from .program import router as program_router
+from .rss import router as rss_router
 
 __all__ = "v1"
 
@@ -17,3 +18,4 @@ v1.include_router(program_router)
 v1.include_router(download_router)
 v1.include_router(bangumi_router)
 v1.include_router(config_router)
+v1.include_router(rss_router)

backend/src/module/api/auth.py

@@ -3,7 +3,7 @@ from datetime import timedelta
 from fastapi import APIRouter, Depends, HTTPException, status
 from fastapi.security import OAuth2PasswordRequestForm
 
-from module.models.user import User
+from module.models.user import User, UserUpdate
 from module.security.api import (
     auth_user,
     get_current_user,
@@ -16,10 +16,11 @@ router = APIRouter(prefix="/auth", tags=["auth"])
 
 @router.post("/login", response_model=dict)
 async def login(form_data: OAuth2PasswordRequestForm = Depends()):
-    username = form_data.username
-    password = form_data.password
-    auth_user(username, password)
-    token = create_access_token(data={"sub": username}, expires_delta=timedelta(days=1))
+    user = User(username=form_data.username, password=form_data.password)
+    auth_user(user)
+    token = create_access_token(
+        data={"sub": user.username}, expires_delta=timedelta(days=1)
+    )
 
     return {"access_token": token, "token_type": "bearer", "expire": 86400}
 
@@ -44,7 +45,9 @@ async def logout(current_user: User = Depends(get_current_user)):
 
 
 @router.post("/update", response_model=dict)
-async def update_user(user_data: User, current_user: User = Depends(get_current_user)):
+async def update_user(
+    user_data: UserUpdate, current_user: User = Depends(get_current_user)
+):
     if not current_user:
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED, detail="invalid token"

backend/src/module/api/bangumi.py

@@ -2,13 +2,13 @@ from fastapi import APIRouter, Depends, HTTPException, status
 from fastapi.responses import JSONResponse
 
 from module.manager import TorrentManager
-from module.models import Bangumi
+from module.models import Bangumi, BangumiUpdate
 from module.security.api import get_current_user
 
 router = APIRouter(prefix="/bangumi", tags=["bangumi"])
 
 
-@router.get("/getAll", response_model=list[Bangumi])
+@router.get("/get/all", response_model=list[Bangumi])
 async def get_all_data(current_user=Depends(get_current_user)):
     if not current_user:
         raise HTTPException(
@@ -18,7 +18,7 @@ async def get_all_data(current_user=Depends(get_current_user)):
         return manager.bangumi.search_all()
 
 
-@router.get("/getData/{bangumi_id}", response_model=Bangumi)
+@router.get("/get/{bangumi_id}", response_model=Bangumi)
 async def get_data(bangumi_id: str, current_user=Depends(get_current_user)):
     if not current_user:
         raise HTTPException(
@@ -28,17 +28,19 @@ async def get_data(bangumi_id: str, current_user=Depends(get_current_user)):
         return manager.search_one(bangumi_id)
 
 
-@router.post("/updateRule")
-async def update_rule(data: Bangumi, current_user=Depends(get_current_user)):
+@router.patch("/update/{bangumi_id}")
+async def update_rule(
+    bangumi_id: int, data: BangumiUpdate, current_user=Depends(get_current_user)
+):
     if not current_user:
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED, detail="invalid token"
         )
     with TorrentManager() as manager:
-        return manager.update_rule(data)
+        return manager.update_rule(bangumi_id, data)
 
 
-@router.delete("/deleteRule/{bangumi_id}")
+@router.delete("/delete/{bangumi_id}")
 async def delete_rule(
     bangumi_id: str, file: bool = False, current_user=Depends(get_current_user)
 ):
@@ -50,7 +52,7 @@ async def delete_rule(
         return manager.delete_rule(bangumi_id, file)
 
 
-@router.delete("/disableRule/{bangumi_id}")
+@router.delete("/disable/{bangumi_id}")
 async def disable_rule(
     bangumi_id: str, file: bool = False, current_user=Depends(get_current_user)
 ):
@@ -62,7 +64,7 @@ async def disable_rule(
         return manager.disable_rule(bangumi_id, file)
 
 
-@router.get("/enableRule/{bangumi_id}")
+@router.get("/enable/{bangumi_id}")
 async def enable_rule(bangumi_id: str, current_user=Depends(get_current_user)):
     if not current_user:
         raise HTTPException(
@@ -72,7 +74,7 @@ async def enable_rule(bangumi_id: str, current_user=Depends(get_current_user)):
         return manager.enable_rule(bangumi_id)
 
 
-@router.get("/resetAll")
+@router.get("/reset/all")
 async def reset_all(current_user=Depends(get_current_user)):
     if not current_user:
         raise HTTPException(

backend/src/module/api/program.py

@@ -1,7 +1,6 @@
 import logging
 import os
 import signal
-import sys
 
 from fastapi import APIRouter, Depends, HTTPException, status
 

backend/src/module/api/rss.py

@@ -1,9 +1,9 @@
 from fastapi import APIRouter, Depends, HTTPException, status
 from fastapi.responses import JSONResponse
 
-from module.models import RSSItem
+from module.models import RSSItem, RSSUpdate
 from module.rss import RSSEngine
-from module.security import get_current_user
+from module.security.api import get_current_user
 from module.downloader import DownloadClient
 
 
@@ -20,34 +20,36 @@ async def get_rss(current_user=Depends(get_current_user)):
         return engine.rss.search_all()
 
 
-@router.delete("/delete/{id}")
-async def delete_rss(_id: int, current_user=Depends(get_current_user)):
+@router.delete("/delete/{rss_id}")
+async def delete_rss(rss_id: int, current_user=Depends(get_current_user)):
     if not current_user:
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED, detail="invalid token"
         )
     with RSSEngine() as engine:
-        result = engine.rss.delete(_id)
+        result = engine.rss.delete(rss_id)
     if result:
         return JSONResponse(
             status_code=status.HTTP_200_OK,
-            content={"status": f"Success deleted {_id}"},
+            content={"status": f"Success deleted {rss_id}"},
         )
     else:
         return JSONResponse(
             status_code=status.HTTP_400_BAD_REQUEST,
-            content={"status": f"Failed to delete {_id}"},
+            content={"status": f"Failed to delete {rss_id}"},
         )
 
 
-@router.put("/update/{id}")
-async def update_rss(data: RSSItem, current_user=Depends(get_current_user)):
+@router.patch("/update/{rss_id}")
+async def update_rss(
+    rss_id: int, data: RSSUpdate, current_user=Depends(get_current_user)
+):
     if not current_user:
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED, detail="invalid token"
         )
     with RSSEngine() as engine:
-        result = engine.rss.update(data)
+        result = engine.rss.update(rss_id, data)
     if result:
         return JSONResponse(
             status_code=status.HTTP_200_OK,
@@ -66,8 +68,8 @@ async def refresh_all(current_user=Depends(get_current_user)):
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED, detail="invalid token"
         )
-    with RSSEngine() as engine:
-        response = engine.refresh_rss()
+    with RSSEngine() as engine, DownloadClient() as client:
+        response = engine.refresh_rss(client)
     if response:
         return JSONResponse(
             status_code=status.HTTP_200_OK,
@@ -80,21 +82,21 @@ async def refresh_all(current_user=Depends(get_current_user)):
         )
 
 
-@router.get("/refresh/{id}")
-async def refresh_rss(_id: int, current_user=Depends(get_current_user)):
+@router.get("/refresh/{rss_id}")
+async def refresh_rss(rss_id: int, current_user=Depends(get_current_user)):
     if not current_user:
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED, detail="invalid token"
         )
-    with RSSEngine() as engine:
-        response = engine.refresh_rss(_id)
+    with RSSEngine() as engine, DownloadClient() as client:
+        response = engine.refresh_rss(client, rss_id)
     if response:
         return JSONResponse(
             status_code=status.HTTP_200_OK,
-            content={"status": f"Success refresh {_id}"},
+            content={"status": f"Success refresh {rss_id}"},
         )
     else:
         return JSONResponse(
             status_code=status.HTTP_400_BAD_REQUEST,
-            content={"status": f"Failed to refresh {_id}"},
-        )
+            content={"status": f"Failed to refresh {rss_id}"},
+        )