Merge branch '3.1-dev' into webui

backend/src/module/api/auth.py

@@ -2,8 +2,10 @@ from datetime import timedelta
 
 from fastapi import APIRouter, Depends, HTTPException, status
 from fastapi.security import OAuth2PasswordRequestForm
+from fastapi.responses import JSONResponse
 
 from module.models.user import User, UserUpdate
+from module.models import APIResponse
 from module.security.api import (
     auth_user,
     get_current_user,
@@ -22,7 +24,14 @@ async def login(form_data: OAuth2PasswordRequestForm = Depends()):
         data={"sub": user.username}, expires_delta=timedelta(days=1)
     )
 
-    return {"access_token": token, "token_type": "bearer", "expire": 86400}
+    return JSONResponse(
+        status_code=status.HTTP_200_OK,
+        content={
+            "access_token": token,
+            "token_type": "bearer",
+            "expire": 86400,
+        },
+    )
 
 
 @router.get("/refresh_token", response_model=dict)
@@ -32,16 +41,29 @@ async def refresh(current_user: User = Depends(get_current_user)):
             status_code=status.HTTP_401_UNAUTHORIZED, detail="invalid token"
         )
     token = create_access_token(data={"sub": current_user.username})
-    return {"access_token": token, "token_type": "bearer", "expire": 86400}
+    return JSONResponse(
+        status_code=status.HTTP_200_OK,
+        content={
+            "access_token": token,
+            "token_type": "bearer",
+            "expire": 86400,
+        },
+    )
 
 
-@router.get("/logout", response_model=dict)
+@router.get("/logout", response_model=APIResponse)
 async def logout(current_user: User = Depends(get_current_user)):
     if not current_user:
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED, detail="invalid token"
         )
-    return {"message": "logout success"}
+    return JSONResponse(
+        status_code=status.HTTP_200_OK,
+        content={
+            "msg_en": "Logout success",
+            "msg_zh": "登出成功",
+        },
+    )
 
 
 @router.post("/update", response_model=dict)
@@ -53,9 +75,12 @@ async def update_user(
             status_code=status.HTTP_401_UNAUTHORIZED, detail="invalid token"
         )
     if update_user_info(user_data, current_user):
-        return {
-            "message": "update success",
-            "access_token": create_access_token({"sub": user_data.username}),
-            "token_type": "bearer",
-            "expire": 86400,
-        }
+        return JSONResponse(
+            status_code=status.HTTP_200_OK,
+            content={
+                "message": "update success",
+                "access_token": create_access_token({"sub": user_data.username}),
+                "token_type": "bearer",
+                "expire": 86400,
+            },
+        )

backend/src/module/api/bangumi.py

@@ -38,7 +38,7 @@ async def update_rule(
     return u_response(resp)
 
 
-@router.delete("/delete/{bangumi_id}", response_model=APIResponse)
+@router.delete(path="/delete/{bangumi_id}", response_model=APIResponse)
 async def delete_rule(
     bangumi_id: str, file: bool = False, current_user=Depends(get_current_user)
 ):
@@ -49,7 +49,7 @@ async def delete_rule(
     return u_response(resp)
 
 
-@router.delete("/delete/many/", response_model=APIResponse)
+@router.delete(path="/delete/many/", response_model=APIResponse)
 async def delete_many_rule(
     bangumi_id: list, file: bool = False, current_user=Depends(get_current_user)
 ):
@@ -57,10 +57,11 @@ async def delete_many_rule(
         raise UNAUTHORIZED
     with TorrentManager() as manager:
         for i in bangumi_id:
-            manager.delete_rule(i, file)
+            resp = manager.delete_rule(i, file)
+    return u_response(resp)
 
 
-@router.delete("/disable/{bangumi_id}", response_model=APIResponse)
+@router.delete(path="/disable/{bangumi_id}", response_model=APIResponse)
 async def disable_rule(
     bangumi_id: str, file: bool = False, current_user=Depends(get_current_user)
 ):
@@ -71,7 +72,7 @@ async def disable_rule(
     return u_response(resp)
 
 
-@router.delete("/disable/many/")
+@router.delete(path="/disable/many/", response_model=APIResponse)
 async def disable_many_rule(
     bangumi_id: list, file: bool = False, current_user=Depends(get_current_user)
 ):
@@ -79,10 +80,11 @@ async def disable_many_rule(
         raise UNAUTHORIZED
     with TorrentManager() as manager:
         for i in bangumi_id:
-            manager.disable_rule(i, file)
+            resp = manager.disable_rule(i, file)
+    return u_response(resp)
 
 
-@router.get("/enable/{bangumi_id}", response_model=APIResponse)
+@router.get(path="/enable/{bangumi_id}", response_model=APIResponse)
 async def enable_rule(bangumi_id: str, current_user=Depends(get_current_user)):
     if not current_user:
         raise UNAUTHORIZED

backend/src/module/api/rss.py

@@ -3,16 +3,17 @@ from fastapi.responses import JSONResponse
 
 from .response import u_response
 
-from module.models import RSSItem, RSSUpdate, Torrent, APIResponse
-from module.rss import RSSEngine
+from module.models import RSSItem, RSSUpdate, Torrent, APIResponse, Bangumi
+from module.rss import RSSEngine, RSSAnalyser
 from module.security.api import get_current_user, UNAUTHORIZED
 from module.downloader import DownloadClient
+from module.manager import SeasonCollector
 
 
 router = APIRouter(prefix="/rss", tags=["rss"])
 
 
-@router.get("", response_model=list[RSSItem])
+@router.get(path="", response_model=list[RSSItem])
 async def get_rss(current_user=Depends(get_current_user)):
     if not current_user:
         raise UNAUTHORIZED
@@ -20,7 +21,7 @@ async def get_rss(current_user=Depends(get_current_user)):
         return engine.rss.search_all()
 
 
-@router.post("/add", response_model=APIResponse)
+@router.post(path="/add", response_model=APIResponse)
 async def add_rss(rss: RSSItem, current_user=Depends(get_current_user)):
     if not current_user:
         raise UNAUTHORIZED
@@ -29,45 +30,43 @@ async def add_rss(rss: RSSItem, current_user=Depends(get_current_user)):
     return u_response(result)
 
 
-@router.delete("/delete/{rss_id}", response_model=APIResponse)
+@router.delete(path="/delete/{rss_id}", response_model=APIResponse)
 async def delete_rss(rss_id: int, current_user=Depends(get_current_user)):
     if not current_user:
         raise UNAUTHORIZED
     with RSSEngine() as engine:
-        result = engine.rss.delete(rss_id)
-    if result:
-        return JSONResponse(
-            status_code=200,
-            content={"msg_en": "Delete RSS successfully.", "msg_zh": "删除 RSS 成功。"},
-        )
-    else:
-        return JSONResponse(
-            status_code=406,
-            content={"msg_en": "Delete RSS failed.", "msg_zh": "删除 RSS 失败。"},
-        )
+        if engine.rss.delete(rss_id):
+            return JSONResponse(
+                status_code=200,
+                content={"msg_en": "Delete RSS successfully.", "msg_zh": "删除 RSS 成功。"},
+            )
+        else:
+            return JSONResponse(
+                status_code=406,
+                content={"msg_en": "Delete RSS failed.", "msg_zh": "删除 RSS 失败。"},
+            )
 
 
-@router.patch("/update/{rss_id}", response_model=APIResponse)
+@router.patch(path="/update/{rss_id}", response_model=APIResponse)
 async def update_rss(
     rss_id: int, data: RSSUpdate, current_user=Depends(get_current_user)
 ):
     if not current_user:
         raise UNAUTHORIZED
     with RSSEngine() as engine:
-        result = engine.rss.update(rss_id, data)
-    if result:
-        return JSONResponse(
-            status_code=200,
-            content={"msg_en": "Update RSS successfully.", "msg_zh": "更新 RSS 成功。"},
-        )
-    else:
-        return JSONResponse(
-            status_code=406,
-            content={"msg_en": "Update RSS failed.", "msg_zh": "更新 RSS 失败。"},
-        )
+        if engine.rss.update(rss_id, data):
+            return JSONResponse(
+                status_code=200,
+                content={"msg_en": "Update RSS successfully.", "msg_zh": "更新 RSS 成功。"},
+            )
+        else:
+            return JSONResponse(
+                status_code=406,
+                content={"msg_en": "Update RSS failed.", "msg_zh": "更新 RSS 失败。"},
+            )
 
 
-@router.get("/refresh/all", response_model=APIResponse)
+@router.get(path="/refresh/all", response_model=APIResponse)
 async def refresh_all(current_user=Depends(get_current_user)):
     if not current_user:
         raise UNAUTHORIZED
@@ -79,7 +78,7 @@ async def refresh_all(current_user=Depends(get_current_user)):
         )
 
 
-@router.get("/refresh/{rss_id}", response_model=APIResponse)
+@router.get(path="/refresh/{rss_id}", response_model=APIResponse)
 async def refresh_rss(rss_id: int, current_user=Depends(get_current_user)):
     if not current_user:
         raise UNAUTHORIZED
@@ -91,9 +90,41 @@ async def refresh_rss(rss_id: int, current_user=Depends(get_current_user)):
         )
 
 
-@router.get("/torrent/{rss_id}", response_model=list[Torrent])
+@router.get(path="/torrent/{rss_id}", response_model=list[Torrent])
 async def get_torrent(rss_id: int, current_user=Depends(get_current_user)):
     if not current_user:
         raise UNAUTHORIZED
     with RSSEngine() as engine:
         return engine.get_rss_torrents(rss_id)
+
+
+# Old API
+analyser = RSSAnalyser()
+
+
+@router.post("/analysis", response_model=Bangumi)
+async def analysis(rss: RSSItem, current_user=Depends(get_current_user)):
+    if not current_user:
+        raise UNAUTHORIZED
+    data = analyser.link_to_data(rss)
+    if isinstance(data, Bangumi):
+        return data
+    else:
+        return u_response(data)
+
+
+@router.post("/collect", response_model=APIResponse)
+async def download_collection(data: Bangumi, current_user=Depends(get_current_user)):
+    if not current_user:
+        raise UNAUTHORIZED
+    with SeasonCollector() as collector:
+        resp = collector.collect_season(data, data.rss_link[0])
+        return u_response(resp)
+
+@router.post("/subscribe", response_model=APIResponse)
+async def subscribe(data: Bangumi, current_user=Depends(get_current_user)):
+    if not current_user:
+        raise UNAUTHORIZED
+    with SeasonCollector() as collector:
+        resp = collector.subscribe_season(data)
+        return u_response(resp)