Add POST /client/all endpoint to list all user clients

app/client/router.py

@@ -2,22 +2,23 @@
 from fastapi import APIRouter, Depends
 
 from app.dependencies import auth_required, get_page, get_size
-from app.utils import pagination, pagination_dict
+from app.utils import pagination, paginated_response
 from app.schemas import ClientResponse
 from app.database import get_session
 from app.models import Client, User
 from app.client import service
 from app import constants
 
 from app.client.dependencies import (
+    validate_unverified_client,
     validate_client_create,
     validate_user_client,
     validate_client,
-    validate_unverified_client,
 )
 from app.client.schemas import (
     ClientPaginationResponse,
     ClientFullResponse,
+    ListAllClientsArgs,
     ClientCreate,
     ClientUpdate,
 )
@@ -41,10 +42,34 @@ async def list_user_clients(
     total = await service.count_user_clients(session, user, offset, limit)
     clients = await service.list_user_clients(session, user, offset, limit)
 
-    return {
-        "pagination": pagination_dict(total, page, limit),
-        "list": clients.all(),
-    }
+    return paginated_response(clients.all(), total, page, limit)
+
+
+@router.post(
+    "/all",
+    summary="List all clients",
+    response_model=ClientPaginationResponse,
+    dependencies=[
+        Depends(
+            auth_required(
+                scope=[constants.SCOPE_READ_CLIENT_LIST],
+                permissions=[constants.PERMISSION_CLIENT_LIST_ALL],
+            )
+        )
+    ],
+)
+async def list_all_clients(
+    args: ListAllClientsArgs,
+    page: int = Depends(get_page),
+    size: int = Depends(get_size),
+    session: AsyncSession = Depends(get_session),
+):
+    limit, offset = pagination(page, size)
+
+    total = await service.count_all_clients(session, args)
+    clients = await service.list_all_clients(session, args, offset, limit)
+
+    return paginated_response(clients.all(), total, page, limit)
 
 
 @router.get(

app/client/schemas.py

@@ -90,3 +90,7 @@ def validate_endpoint(cls, v: HttpUrl | None) -> HttpUrl | None:
             )
 
         return v
+
+
+class ListAllClientsArgs(CustomModel):
+    query: str | None = Field(None, description="Search by name")

app/client/service.py

@@ -1,11 +1,11 @@
 import secrets
 import uuid
 
+from sqlalchemy import select, func, ScalarResult, Select
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import joinedload
-from sqlalchemy import select, func, ScalarResult
 
-from app.client.schemas import ClientCreate, ClientUpdate
+from app.client.schemas import ClientCreate, ClientUpdate, ListAllClientsArgs
 from app.models import User, Client
 from app.utils import utcnow
 
@@ -122,3 +122,35 @@ async def verify_client(session: AsyncSession, client: Client) -> Client:
     client.verified = True
     await session.commit()
     return client
+
+
+def apply_all_clients_filters(
+    query: Select, args: ListAllClientsArgs
+) -> Select:
+    if args.query is not None:
+        query = query.filter(Client.name.ilike(f"%{args.query}%"))
+
+    return query
+
+
+async def count_all_clients(
+    session: AsyncSession, args: ListAllClientsArgs
+) -> int:
+    return await session.scalar(
+        apply_all_clients_filters(select(func.count(Client.id)), args)
+    )
+
+
+async def list_all_clients(
+    session: AsyncSession, args: ListAllClientsArgs, offset: int, limit: int
+) -> ScalarResult[Client]:
+    return await session.scalars(
+        apply_all_clients_filters(
+            select(Client)
+            .options(joinedload(Client.user))
+            .order_by(Client.created.desc())
+            .offset(offset)
+            .limit(limit),
+            args,
+        )
+    )

app/constants.py

@@ -349,6 +349,7 @@
 PERMISSION_CLIENT_DELETE = "client:delete"
 PERMISSION_CLIENT_VERIFY = "client:verify"
 PERMISSION_CLIENT_DELETE_ADMIN = "client:delete_admin"
+PERMISSION_CLIENT_LIST_ALL = "client:list_all"
 
 USER_PERMISSIONS = [
     PERMISSION_EDIT_CREATE,
@@ -378,6 +379,7 @@
     PERMISSION_COLLECTION_DELETE_MODERATOR,
     PERMISSION_EDIT_UPDATE_MODERATOR,
     PERMISSION_CLIENT_VERIFY,
+    PERMISSION_CLIENT_LIST_ALL,
 ]
 
 ADMIN_PERMISSIONS = [

app/utils.py

@@ -1,8 +1,10 @@
 from starlette.middleware.base import BaseHTTPMiddleware
 from dateutil.relativedelta import relativedelta
 from fastapi.responses import JSONResponse
+from sqlalchemy.orm import DeclarativeBase
 from datetime import timezone, timedelta
 from fastapi import FastAPI, Request
+from collections.abc import Sequence
 from datetime import datetime, UTC
 from app.models import AuthToken
 from functools import lru_cache
@@ -16,10 +18,15 @@
 import asyncio
 import secrets
 import bcrypt
+import typing
 import math
 import re
 
 
+if typing.TYPE_CHECKING:
+    from app.schemas import CustomModel
+
+
 # Timeout middleware (class name is pretty self explanatory)
 class TimeoutMiddleware(BaseHTTPMiddleware):
     def __init__(self, app: FastAPI, timeout: int) -> None:
@@ -266,6 +273,18 @@ def pagination_dict(total, page, limit):
     }
 
 
+def paginated_response(
+    items: Sequence[typing.Union[DeclarativeBase, "CustomModel"]],
+    total: int,
+    page: int,
+    limit: int,
+) -> dict[str, dict[str, int] | list]:
+    return {
+        "list": items,
+        "pagination": pagination_dict(total, page, limit),
+    }
+
+
 # Convert month to season str
 def get_season(date):
     # Anime seasons start from first month of the year

tests/client/test_list_all.py

@@ -0,0 +1,24 @@
+from tests.client_requests import request_list_all_clients
+
+
+async def test_normal(client, moderator_token, test_thirdparty_client):
+    response = await request_list_all_clients(client, moderator_token)
+    print(response.json())
+    assert response.status_code == 200
+
+    assert response.json()["pagination"] == {
+        "page": 1,
+        "pages": 1,
+        "total": 1,
+    }
+
+    response_client = response.json()["list"][0]
+    assert response_client["description"] == test_thirdparty_client.description
+    assert response_client["reference"] == test_thirdparty_client.reference
+    assert response_client["name"] == test_thirdparty_client.name
+
+
+async def test_no_permission(client, test_token):
+    response = await request_list_all_clients(client, test_token)
+    print(response.json())
+    assert response.status_code == 403

tests/client_requests/__init__.py

@@ -11,6 +11,7 @@
 from .auth import request_login
 
 from .client import request_client_full_info
+from .client import request_list_all_clients
 from .client import request_client_create
 from .client import request_client_update
 from .client import request_client_verify
@@ -131,6 +132,7 @@
     "request_signup",
     "request_login",
     "request_client_full_info",
+    "request_list_all_clients",
     "request_client_create",
     "request_client_update",
     "request_client_verify",

tests/client_requests/client.py

@@ -58,6 +58,16 @@ def request_list_clients(client, token: str):
     )
 
 
+def request_list_all_clients(client, token: str, query: str | None = None):
+    return client.post(
+        "/client/all",
+        headers={"Auth": token},
+        json={
+            "query": query
+        }
+    )
+
+
 def request_client_verify(client, token: str, client_reference: str):
     return client.post(
         f"/client/{client_reference}/verify",