refactor the crud & paginate

2024-12-01 11:19:51 +09:00
parent 49d9475304
commit 77516b8814
8 changed files with 376 additions and 48 deletions
--- a/backend/app/api/api_v1/routers/platform.py
+++ b/backend/app/api/api_v1/routers/platform.py
@@ -9,13 +9,26 @@ from app.db.schemas import *
 from typing import List, Optional
 from app.core.auth import get_current_active_user,get_current_user
 from app.core.apiexception import APIException
-from app.core.common import ApiReturnModel
+from app.core.common import ApiReturnModel,ApiReturnPage
+#from fastapi_pagination import Page 
+from app.db.cruddb.dbdomain import dbdomain

 import httpx
 import app.core.config as config

 platform_router = r = APIRouter()

+@r.get(
+    "/test",
+    response_model_exclude_none=True,
+)
+async def test(
+    request: Request,
+    user = Depends(get_current_active_user),
+    db=Depends(get_db),
+):
+    dbdomain.select(db,{"tenantid":1,"name":["b","c"]})
+

@r.get(
    "/apps",
@@ -255,8 +268,8 @@ async def flow_delete(
        raise APIException('platform:flow',request.url._url,f"Error occurred while delete flow:",e)

@r.get(
-    "/domains",
-    response_model=ApiReturnModel[List[Domain]],
+    "/domains",tags=["Domain"],
+    response_model=ApiReturnPage[Domain],
    response_model_exclude_none=True,
 )
 async def domain_details(
@@ -266,14 +279,16 @@ async def domain_details(
 ):
    try:
        if user.is_superuser:
-            domains =get_alldomains(db)
+            domains = dbdomain.get_domains(db)
        else:
-            domains = get_domains(db,user.id)
-        return  ApiReturnModel(data = domains)
+            domains = dbdomain.get_domains_by_owner(db,user.id)
+        return  domains
    except Exception as e:
        raise APIException('platform:domains',request.url._url,f"Error occurred while get domains:",e)

-@r.post("/domain", response_model=ApiReturnModel[Domain], response_model_exclude_none=True)
+@r.post("/domain", tags=["Domain"],
+        response_model=ApiReturnModel[Domain], 
+        response_model_exclude_none=True)
 async def domain_create(
    request: Request,
    domain: DomainIn,
@@ -281,13 +296,15 @@ async def domain_create(
    db=Depends(get_db),
 ):
    try:
-        return ApiReturnModel(data = create_domain(db, domain,user.id))
+        return ApiReturnModel(data = dbdomain.create_domain(db, domain,user.id))
    except Exception as e:
        raise APIException('platform:domain',request.url._url,f"Error occurred while create domain:",e)


@r.put(
-    "/domain", response_model=ApiReturnModel[Domain], response_model_exclude_none=True
+    "/domain", tags=["Domain"],
+    response_model=ApiReturnModel[Domain|None], 
+    response_model_exclude_none=True
 )
 async def domain_edit(
    request: Request,
@@ -296,13 +313,14 @@ async def domain_edit(
    db=Depends(get_db),
 ):
    try:
-        return ApiReturnModel(data = edit_domain(db, domain,user.id))
+        return ApiReturnModel(data = dbdomain.edit_domain(db, domain,user.id))
    except Exception as e:
        raise APIException('platform:domain',request.url._url,f"Error occurred while edit domain:",e)


@r.delete(
-    "/domain/{id}",
+    "/domain/{id}",tags=["Domain"],
+    response_model=ApiReturnModel[Domain|None], 
    response_model_exclude_none=True,
 )
 async def domain_delete(
@@ -311,8 +329,7 @@ async def domain_delete(
    db=Depends(get_db),
 ):
    try:
-        if delete_domain(db,id):
-            return ApiReturnModel(data = None)
+        return ApiReturnModel(data = dbdomain.delete_domain(db,id))
    except Exception as e:
        raise APIException('platform:domain',request.url._url,f"Error occurred while delete domain:",e)

@@ -334,7 +351,7 @@ async def userdomain_details(
        raise APIException('platform:domain',request.url._url,f"Error occurred while get user({user.id}) domain:",e)

@r.post(
-    "/domain/{userid}",
+    "/domain/{userid}",tags=["Domain"],
    response_model=ApiReturnModel[DomainOut|None],
    response_model_exclude_none=True,
 )
@@ -347,52 +364,53 @@ async def create_userdomain(
 ):
    try:
        if user.is_superuser:
-            domain = add_admindomain(db,userid,domainid)
+            domain = dbdomain.add_userdomain(db,user.id,userid,domainid)
        else:
-            domain = add_userdomain(db,user.id,userid,domainid)
+            domain = dbdomain.add_userdomain_by_owner(db,user.id,userid,domainid)
        return ApiReturnModel(data = domain)
    except Exception as e:
        raise APIException('platform:domain',request.url._url,f"Error occurred while add user({userid}) domain:",e)

@r.delete(
-    "/domain/{domainid}/{userid}",
+    "/domain/{domainid}/{userid}",tags=["Domain"],
+    response_model=ApiReturnModel[DomainOut|None],
    response_model_exclude_none=True,
 )
-async def userdomain_delete(
+async def delete_userdomain(
    request: Request,
    domainid:int,
    userid: int,
+    user=Depends(get_current_active_user),
    db=Depends(get_db),
 ):
    try:
-        if delete_userdomain(db, userid,domainid):
-            return ApiReturnModel(data = None)
+        return ApiReturnModel(data = dbdomain.delete_userdomain(db,userid,domainid))
    except Exception as e:
        raise APIException('platform:delete',request.url._url,f"Error occurred while delete user({userid}) domain:",e)


@r.get(
-    "/activedomain",
-    response_model=ApiReturnModel[ActiveDomain|None],
+    "/defaultdomain",tags=["Domain"],
+    response_model=ApiReturnModel[DomainOut|None],
    response_model_exclude_none=True,
 )
-async def get_activeuserdomain(
+async def get_defaultuserdomain(
    request: Request,
    user=Depends(get_current_active_user),
    db=Depends(get_db),
 ):
    try:
-        # domain = get_activedomain(db, user.id)
-        domain = get_activedomain(db, user.id)
-        # if domain is None:
-        #     return JSONResponse(content=None,status_code=HTTPStatus.OK)
-        return ApiReturnModel(data = domain)
+        userdomain = dbdomain.get_default_domain(db, user.id)
+        if userdomain:
+            return ApiReturnModel(data = userdomain.domain)
+        else:
+            return ApiReturnModel(data = None)

    except Exception as e:
-        raise APIException('platform:activedomain',request.url._url,f"Error occurred while get user({user.id}) activedomain:",e)
-
+        raise APIException('platform:defaultdomain',request.url._url,f"Error occurred while get user({user.id}) defaultdomain:",e)
+    
@r.put(
-    "/activedomain/{domainid}",
+    "/defaultdomain/{domainid}",tags=["Domain"],
    response_model=ApiReturnModel[DomainOut|None],
    response_model_exclude_none=True,
 )
@@ -403,10 +421,28 @@ async def update_activeuserdomain(
    db=Depends(get_db),
 ):
    try:
-        domain = active_userdomain(db,user.id,domainid)
+        domain = dbdomain.set_default_domain(db,user.id,domainid)
        return ApiReturnModel(data= domain)
    except Exception as e:
-        raise APIException('platform:activedomain',request.url._url,f"Error occurred while update user({user.id}) activedomain:",e)
+        raise APIException('platform:defaultdomain',request.url._url,f"Error occurred while update user({user.id}) defaultdomain:",e)
+
+
+@r.get(
+    "/domainshareduser/{domainid}",tags=["Domain"],
+    response_model=ApiReturnPage[UserOut|None],
+    response_model_exclude_none=True,
+)
+async def get_domainshareduser(
+    request: Request,
+    domainid:int,
+    user=Depends(get_current_active_user),
+    db=Depends(get_db),
+):
+    try:
+        return dbdomain.get_shareddomain_users(db,user.id,domainid)
+    except Exception as e:
+        raise APIException('platform:sharedomain',request.url._url,f"Error occurred while get user({user.id}) sharedomain:",e)
+

@r.get(
    "/events",