chore: update backend lib version and update Dockerfile

backend/router/auth.py

@@ -9,8 +9,8 @@ router = APIRouter(tags=["公共"])
 LoginResult = BaseSchema.Response[BaseSchema.LoginResult]
 
 
-@router.post("/login", summary="登录", response_model=LoginResult)
-async def login(data: BaseSchema.LoginForm):
+@router.post("/login", summary="登录")
+async def login(data: BaseSchema.LoginForm) -> LoginResult:
     return await AuthService.user_login(data)
 
 

backend/router/menu.py

@@ -9,22 +9,22 @@ router = APIRouter(prefix="/menu", tags=["菜单管理"])
 Response = BaseSchema.Response
 
 
-@router.post("", summary="菜单新增", response_model=Response[MenuSchema.MenuRead])
-async def menu_add(data: MenuSchema.MenuIn):
+@router.post("", summary="菜单新增")
+async def menu_add(data: MenuSchema.MenuIn) -> Response[MenuSchema.MenuRead]:
     return await MenuService.create_item(data)
 
 
-@router.get("", summary="菜单列表", response_model=Response)
-async def menu_arr():
+@router.get("", summary="菜单列表")
+async def menu_arr() -> Response:
     return await MenuService.get_items()
 
 
-@router.delete("/{pk}", summary="菜单删除", response_model=Response)
-async def menu_del(pk: int):
+@router.delete("/{pk}", summary="菜单删除")
+async def menu_del(pk: int) -> Response:
     return await MenuService.delete_item(pk)
 
 
-@router.put("/{pk}", summary="菜单更新", response_model=Response)
-async def menu_put(pk: int, data: MenuSchema.MenuIn):
+@router.put("/{pk}", summary="菜单更新")
+async def menu_put(pk: int, data: MenuSchema.MenuIn) -> Response:
     """更新菜单"""
     return await MenuService.update_item(pk, data)

backend/router/role.py

@@ -1,7 +1,8 @@
-from fastapi import APIRouter, Query
+from fastapi import APIRouter, Depends
 
 from schemas import common as BaseSchema
 from schemas import role as RoleSchema
+from schemas.common import QueryData
 from service.role import service as RoleService
 
 router = APIRouter(prefix="/role", tags=["角色管理"])
@@ -12,35 +13,32 @@ ListAll = BaseSchema.ListAll
 role_list_schema = ListAll[list[RoleSchema.RoleRead]]
 
 
-@router.get("", summary="角色列表", response_model=Response[role_list_schema])
-async def role_list(
-    offset: int = Query(default=1, description="偏移量-页码"),
-    limit: int = Query(default=10, description="数据量"),
-):
-    return await RoleService.get_items(offset, limit)
+@router.get("", summary="角色列表")
+async def role_list(query: QueryData = Depends()) -> Response[role_list_schema]:
+    return await RoleService.get_items(query.offset, query.limit)
 
 
-@router.post("/query", summary="角色查询", response_model=Response[role_list_schema])
-async def role_query(query: RoleSchema.RoleQuery):
+@router.post("/query", summary="角色查询")
+async def role_query(query: RoleSchema.RoleQuery) -> Response[role_list_schema]:
     return await RoleService.query_items(query)
 
 
-@router.post("", summary="角色新增", response_model=Response[RoleSchema.RoleInfo])
-async def role_create(data: RoleSchema.RoleIn):
+@router.post("", summary="角色新增")
+async def role_create(data: RoleSchema.RoleIn) -> Response[RoleSchema.RoleInfo]:
     return await RoleService.create_item(data)
 
 
-@router.get("/{rid}/menu", summary="查询角色拥有权限", response_model=Response)
-async def role_has_menu(rid: int):
+@router.get("/{rid}/menu", summary="查询角色拥有权限")
+async def role_has_menu(rid: int) -> Response:
     return await RoleService.has_tree_menus(rid)
 
 
-@router.delete("/{pk}", summary="角色删除", response_model=Response)
-async def role_del(pk: int):
+@router.delete("/{pk}", summary="角色删除")
+async def role_del(pk: int) -> Response:
     return await RoleService.delete_item(pk)
 
 
-@router.put("/{pk}", summary="角色更新", response_model=Response)
-async def role_put(pk: int, data: RoleSchema.RoleIn):
+@router.put("/{pk}", summary="角色更新")
+async def role_put(pk: int, data: RoleSchema.RoleIn) -> Response:
     """更新角色"""
     return await RoleService.update_item(pk, data)

backend/router/user.py

@@ -1,8 +1,9 @@
-from fastapi import APIRouter, Depends, Query
+from fastapi import APIRouter, Depends
 
 from core.security import check_permissions
 from schemas import common as BaseSchema
 from schemas import user as UserSchema
+from schemas.common import QueryData
 from service.user import service as UserService
 
 router = APIRouter(prefix="/user", tags=["用户管理"])
@@ -13,41 +14,38 @@ ListAll = BaseSchema.ListAll
 user_list_schema = ListAll[list[UserSchema.UserRead]]
 
 
-@router.get("", summary="用户列表", response_model=Response[user_list_schema])
-async def user_list(
-    offset: int = Query(default=1, description="偏移量-页码"),
-    limit: int = Query(default=10, description="数据量"),
-):
-    return await UserService.get_items(offset, limit)
+@router.get("", summary="用户列表")
+async def user_list(query: QueryData = Depends()) -> Response[user_list_schema]:
+    return await UserService.get_items(query.offset, query.limit)
 
 
-@router.post("/query", summary="用户查询", response_model=Response[user_list_schema])
-async def user_query(query: UserSchema.UserQuery):
+@router.post("/query", summary="用户查询")
+async def user_query(query: UserSchema.UserQuery) -> Response[user_list_schema]:
     return await UserService.query_items(query)
 
 
-@router.post("", summary="用户新增", response_model=Response[UserSchema.UserRead])
-async def user_create(data: UserSchema.UserAdd):
+@router.post("", summary="用户新增")
+async def user_create(data: UserSchema.UserAdd) -> Response[UserSchema.UserRead]:
     return await UserService.create_item(data)
 
 
-@router.delete("/{pk}", summary="用户删除", response_model=Response)
-async def user_delete(pk: int):
+@router.delete("/{pk}", summary="用户删除")
+async def user_delete(pk: int) -> Response:
     return await UserService.delete_item(pk)
 
 
-@router.get("/{pk}", summary="用户信息", response_model=Response[UserSchema.UserInfo])
-async def user_info(pk: int):
+@router.get("/{pk}", summary="用户信息")
+async def user_info(pk: int) -> Response[UserSchema.UserInfo]:
     return await UserService.get_item(pk)
 
 
-@router.put("/{pk}", summary="用户更新", response_model=Response)
-async def user_update(pk: int, data: UserSchema.UserPut):
+@router.put("/{pk}", summary="用户更新")
+async def user_update(pk: int, data: UserSchema.UserPut) -> Response:
     return await UserService.update_item(pk, data)
 
 
-@router.put("/role/{rid}", summary="用户切换角色", response_model=Response)
+@router.put("/role/{rid}", summary="用户切换角色")
 async def user_change_role(
     rid: int, user: UserSchema.UserRead = Depends(check_permissions)
-):
+) -> Response:
     return await UserService.change_current_role(user.id, rid)