react cards and stored proc in backend

backend_fastapi/auth.py

@@ -1,6 +1,6 @@
 from fastapi import APIRouter
 import backend_fastapi.schemas as schemas
-from backend_fastapi.repositories import add_role, add_user, get_role_all, update_role, delete_role
+from backend_fastapi.repositories import get_stored_roles, add_role, add_user, get_role_all, update_role, delete_role, update_user,delete_user,get_users
 from typing import List
 router = APIRouter()
 
@@ -8,9 +8,13 @@ router = APIRouter()
 async def create_role(role: schemas.RoleCreate) -> schemas.Role:
     return await add_role(role)
 
+@router.get("/stored_role")
+async def get_stored_role() -> List[schemas.Role]:
+    return await get_stored_roles()
+
 @router.get("/role")
-async def get_role() -> List[schemas.Role]:
-    return await get_role_all()
+async def get_role(limit:int=10, page:int=0) -> List[schemas.Role]:
+    return await get_role_all(limit, page)
 
 @router.patch("/role")
 async def change_role(role: schemas.Role, id: int) -> None:
@@ -24,4 +28,20 @@ async def remove_role(id: int) -> schemas.Role:
 async def create_user(user: schemas.UserCreate) -> schemas.User:
     import hashlib
     user.hashed_password = hashlib.sha256(user.hashed_password.encode('utf-8')).hexdigest()
-    return await add_user(user)
+    return await add_user(user)
+
+
+@router.get('/user')
+async def show_users(limit:int=10, page:int=0):
+    return await get_users(limit, page)
+
+@router.patch('/user')
+async def change_users(user: schemas.User, id: int):
+    import hashlib
+    if user.hashed_password:
+        user.hashed_password = hashlib.sha256(user.hashed_password.encode('utf-8')).hexdigest()
+    return await update_user(user, id)
+
+@router.delete('/user')
+async def remove_users(id: int):
+    return await delete_user(id)

backend_fastapi/repositories.py

@@ -1,8 +1,11 @@
+from sqlalchemy import select, update, delete
+from fastapi.exceptions import HTTPException
+from backend_fastapi.stored import exec_procedure
 import backend_fastapi.models as models
 from .database import async_session
 import backend_fastapi.schemas as schemas
-from sqlalchemy import select, update, delete
-from fastapi.exceptions import HTTPException
+
+
 async def add_role(role: schemas.RoleCreate):
     async with async_session() as session:
         model = models.Role(name = role.name)
@@ -11,9 +14,9 @@ async def add_role(role: schemas.RoleCreate):
         await session.commit()
         return model
     
-async def get_role_all():
+async def get_role_all(limit:int=10,page:int=0):
     async with async_session() as session:
-        result = await session.scalars(select(models.Role))
+        result = await session.scalars(select(models.Role).order_by(models.Role.id).limit(limit).offset(page*limit))
         return result.all()
         
 async def delete_role(id: int):
@@ -29,6 +32,11 @@ async def delete_role(id: int):
     
 async def update_role(role: schemas.Role, id: int):
     async with async_session() as session:
+        data = await session.scalars(select(models.Role).filter(models.Role.id == id))
+        result = data.one_or_none()
+        if not result:
+            raise HTTPException(status_code=404, detail="Item not found")
+        
         query = update(models.Role).filter(models.Role.id == id).values(name = role.name)
         await session.execute(query)
         await session.commit()
@@ -45,4 +53,42 @@ async def add_user(user: schemas.UserCreate):
         return model
     
 
+async def get_users(limit:int=10,page:int=0):
+    async with async_session() as session:
+        result = await session.scalars(select(models.User).order_by(models.User.id).limit(limit).offset(page*limit))
+        return result.all()
+        
+async def delete_user(id: int):
+    async with async_session() as session:
+        data = await session.scalars(select(models.User).filter(models.User.id == id))
+        result = data.one_or_none()
+        if not result:
+            raise HTTPException(status_code=404, detail="Item not found")
+        await session.execute(delete(models.User).filter(models.User.id == id))
+        await session.commit()
+        return result
 
+
+
+async def update_user(user: schemas.User, id: int):
+    async with async_session() as session:
+        data = await session.scalars(select(models.User).filter(models.User.id == id))
+        result = data.one_or_none()
+        if not result:
+            raise HTTPException(status_code=404, detail="Item not found")
+        query = update(models.User).filter(models.User.id == id)\
+            .values(
+                firstname = user.firstname,
+                lastname = user.lastname,
+                email = user.email,
+                hashed_password= user.hashed_password,
+                is_active = user.is_active,
+                role_id  = user.role_id,
+            )
+        await session.execute(query)
+        await session.commit()
+        return {f"{id=} был обновлен"}
+    
+
+async def get_stored_roles():
+    return await exec_procedure('get_roles')

backend_fastapi/stored.py

@@ -0,0 +1,23 @@
+from sqlalchemy import text
+from .database import async_session
+
+async def exec_procedure(proc_name, params:dict = None, database: str = None):
+    async with async_session() as session:
+        sql_params = ""
+        if params:
+            sql_params = ",".join([f"@{key} = :{key}"
+                            for key, value in params.items()])
+        dbstr = ""
+        if database:
+            dbstr = f"[{database}]."
+        sql_string = text(f'''
+            DECLARE @return_value int;
+            EXEC    @return_value = {dbstr}[dbo].[{proc_name}] {sql_params};
+            SELECT 'Return Value' = @return_value;
+        ''')
+        datas = await session.execute(
+            sql_string, params)
+        await session.commit()
+        return [dict(data._mapping) for data in datas.fetchall()]
+    
+