Criação dos endpoint's da tabela client

packages/v1/administrativo/endpoints/client_endpoint.py

@@ -1,133 +1,120 @@
 # Importação de bibliotecas
 from typing import Optional
-from fastapi import APIRouter, Body, Depends, status
+from fastapi import APIRouter, Body, Depends, status, Query
 from actions.jwt.get_current_user import get_current_user
-from packages.v1.administrativo.controllers.user_controller import UserController
+# Adaptação para o Controller de Cliente
-from packages.v1.administrativo.schemas.user_schema import (
+from packages.v1.administrativo.controllers.client_controller import ClientController 
-    UserSchema,
+# Adaptação para os Schemas de Cliente
-    UserAuthenticateSchema,
+from packages.v1.administrativo.schemas.client_schema import (
-    UserSaveSchema,
+    ClientSchema,
-    UserUpdateSchema,
+    ClientSaveSchema,
-    UserEmailSchema,
+    ClientUpdateSchema,
-    UserIdSchema
+    ClientIdSchema,
+    ClientCNSSchema    # Usado para busca por 'cns'
 )
 
-# Inicializa o roteador para as rotas de usuário
+# Inicializa o roteador para as rotas de cliente
 router = APIRouter()
 
 # Instânciamento do controller desejado
-user_controller = UserController()
+client_controller = ClientController()
    
-# Autenticação de usuário
+# Lista todos os clientes com paginação
-@router.post('/authenticate',
-             status_code=status.HTTP_200_OK,
-             summary='Cria o token de acesso do usuário',
-             response_description='Retorna o token de acesso do usuário')
-async def index(user_authenticate_schema : UserAuthenticateSchema):
-
-    # Efetua a autenticação de um usuário junto ao sistema
-    response = user_controller.authenticate(user_authenticate_schema)
-
-    # Retorna os dados localizados
-    return response
-
-# Dados do usuário logado
-@router.get('/me',
-            status_code=status.HTTP_200_OK,
-            summary='Retorna os dados do usuário que efetuou o login',
-            response_description='Dados do usuário que efetuou o login'            )
-async def me(current_user: dict = Depends(get_current_user)):
-
-    # Busca os dados do usuário logado
-    response = user_controller.me(current_user)
-
-    # Retorna os dados localizados
-    return response
-    
-# Lista todos os usuários
 @router.get('/',
             status_code=status.HTTP_200_OK,
-            summary='Lista todos os usuário cadastrados',
+            summary='Lista todos os clientes cadastrados com paginação',
-            response_description='Lista todos os usuário cadastrados')
+            response_description='Lista todos os clientes cadastrados')
-async def index(current_user: dict = Depends(get_current_user)):
+async def index(
+    first: int = Query(20, description="Total de registros por página (LIMIT)"),
+    skip: int = Query(0, description="Total de registros a pular (OFFSET)"),
+    current_user: dict = Depends(get_current_user)
+):
 
-    # Busca todos os usuários cadastrados
+    # Busca todos os clientes cadastrados, passando os parâmetros de paginação
-    response = user_controller.index()
+    response = client_controller.index(first=first, skip=skip)
 
-    # Retorna os dados localizados
+    # Retorna os dados localizados com os metadados de paginação
     return response
 
-# Localiza um usuário pelo email
+
-@router.get('/email',
+# Busca cliente pelo ID (show)
+@router.get('/{client_id}',
             status_code=status.HTTP_200_OK,
-            summary='Busca um registro em especifico por e-mail informado',
+            summary='Busca um cliente específico pelo ID',
-            response_description='Busca um registro em especifico')
+            response_description='Busca registro específico do cliente')
-async def getEmail(email : str, current_user: dict = Depends(get_current_user)):
+async def show(client_id: int, current_user: dict = Depends(get_current_user)):
 
-    # Cria o schema com os dados recebidos
+    # Cria o schema com o ID recebido
-    usuario_schema = UserEmailSchema(email=email)
+    client_schema = ClientSchema(client_id=client_id)
 
-    # Busca um usuário especifico pelo e-mail
+    # Busca um cliente específico pelo ID
-    response = user_controller.getEmail(usuario_schema)
+    response = client_controller.show(client_schema)
 
     # Retorna os dados localizados
     return response
 
-# Localiza um usuário pelo ID
+
-@router.get('/{user_id}',
+# Busca cliente pelo CNS
+@router.get('/cns/{cns}',
             status_code=status.HTTP_200_OK,
-            summary='Busca um registro em especifico pelo ID do usuário',
+            summary='Busca um cliente específico pelo CNS',
-            response_description='Busca um registro em especifico')
+            response_description='Busca registro específico do cliente pelo CNS')
-async def show(user_id : int, current_user: dict = Depends(get_current_user)):
+async def get_by_cns(cns: str, current_user: dict = Depends(get_current_user)):
 
-    # Cria o schema com os dados recebidos
+    # Cria o schema com o CNS recebido
-    usuario_schema = UserIdSchema(user_id=user_id)
+    client_schema = ClientCNSSchema(cns=cns)
 
-    # Busca um usuário especifico pelo ID
+    # Busca um cliente específico pelo CNS
-    response = user_controller.show(usuario_schema)
+    response = client_controller.getByCns(client_schema)
 
     # Retorna os dados localizados
     return response
 
 
-# Cadastro de usuários
+# Cadastra um novo cliente
 @router.post('/',
-            status_code=status.HTTP_200_OK,
+             status_code=status.HTTP_201_CREATED,
-            summary='Cadastra um usuário',
+             summary='Cadastra um novo cliente',
-            response_description='Cadastra um usuário')
+             response_description='Cadastra um novo cliente')
-async def save(usuario_schema : UserSaveSchema, current_user: dict = Depends(get_current_user)):
+async def save(client_schema: ClientSaveSchema = Body(...), current_user: dict = Depends(get_current_user)):
 
-    # Efetua o cadastro do usuário junto ao banco de dados
+    # Executa a ação de save
-    response = user_controller.save(usuario_schema)
+    response = client_controller.save(client_schema)
 
-    # Retorna os dados localizados
+    # Retorna o ID do registro salvo
     return response
 
-# Atualiza os dados de usuário
+
-@router.put('/{user_id}',
+# Atualiza um cliente existente
+@router.put('/{client_id}',
             status_code=status.HTTP_200_OK,
-            summary='Atualiza um usuário',
+            summary='Atualiza um cliente existente',
-            response_description='Atualiza um usuário')
+            response_description='Atualiza um cliente existente')
-async def update(user_id : int, usuario_schema : UserUpdateSchema, current_user: dict = Depends(get_current_user)):
+async def update(client_id: int, client_schema: ClientUpdateSchema = Body(...), current_user: dict = Depends(get_current_user)):
 
-    # Efetua a atualização dos dados de usuário
+    # Executa a ação de update
-    response = user_controller.update(user_id, usuario_schema)
+    response = client_controller.update(client_id, client_schema)
 
-    # Retorna os dados localizados
+    # Retorna o resultado da operação
     return response
 
-# Exclui um determinado usuário 
+
-@router.delete('/{user_id}',
+# Deleta um cliente
+@router.delete('/{client_id}',
                status_code=status.HTTP_200_OK,
-            summary='Remove um usuário',
+               summary='Deleta um cliente',
-            response_description='Remove um usuário')
+               response_description='Deleta um cliente')
-async def delete(user_id : int, current_user: dict = Depends(get_current_user)):
+async def delete(client_id: int, current_user: dict = Depends(get_current_user)):
     
-    # Cria o schema com os dados recebidos
+    # Cria o schema apenas com o ID para deleção
-    usuario_schema = UserIdSchema(user_id=user_id)
+    client_schema = ClientIdSchema(client_id=client_id)
 
-    # Efetua a exclusão de um determinado usuário
+    # Executa a ação de delete
-    response = user_controller.delete(usuario_schema)
+    response = client_controller.delete(client_schema)
 
-    # Retorna os dados localizados
+    # Retorna o resultado da operação
     return response
+
+
+# Rotas específicas de Log (getGed, getServer, getDatabase, getBackup, getDisk, getWarning) foram removidas
+# por não se aplicarem à entidade 'client'.

packages/v1/api.py

@@ -21,7 +21,7 @@ api_router.include_router(
 
 # Inclui as rotas de client
 api_router.include_router(
-    client_endpoint.router, prefix="/administrativo/client", tags=["Gerenciamento de client's"]
+    client_endpoint.router, prefix="/administrativo/client", tags=["Gerenciamento de clientes"]
 )