feat(CRUD): Criação do CRUD Caixa Serviços

packages/v1/administrativo/actions/c_caixa_servico/c_caixa_servico_delete_action.py

@@ -0,0 +1,11 @@
+from packages.v1.administrativo.schemas.c_caixa_servico_schema import CCaixaServicoIdSchema
+from packages.v1.administrativo.repositories.c_caixa_servico.c_caixa_servico_delete_repository import DeleteRepository
+
+
+class DeleteAction:
+
+    def execute(self, usuario_schema : CCaixaServicoIdSchema):
+
+        delete_repository = DeleteRepository()
+
+        return delete_repository.execute(usuario_schema)

packages/v1/administrativo/actions/c_caixa_servico/c_caixa_servico_get_by_descricao_action.py

@@ -0,0 +1,16 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.schemas.c_caixa_servico_schema import CCaixaServicoDescricaoSchema
+from packages.v1.administrativo.repositories.c_caixa_servico.c_caixa_servico_get_by_descricao_repository import ShowRepository
+
+class ShowAction(BaseAction):
+
+    def execute(self, caixa_servico_schema : CCaixaServicoDescricaoSchema):
+
+        # Instânciamento do repositório sql
+        show_repository = ShowRepository()
+
+        # Execução do sql
+        response = show_repository.execute(caixa_servico_schema)
+
+        # Retorno da informação
+        return response

packages/v1/administrativo/actions/c_caixa_servico/c_caixa_servico_index_action.py

@@ -0,0 +1,15 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.c_caixa_servico.c_caixa_servico_index_repository import IndexRepository
+
+class IndexAction(BaseAction):
+
+    def execute(self):
+
+        # Instânciamento do repositório sql
+        index_repository = IndexRepository()
+
+        # Execução do sql
+        response = index_repository.execute()
+
+        # Retorno da informação
+        return response

packages/v1/administrativo/actions/c_caixa_servico/c_caixa_servico_save_action.py

@@ -0,0 +1,11 @@
+from packages.v1.administrativo.schemas.c_caixa_servico_schema import CCaixaServicoSaveSchema
+from packages.v1.administrativo.repositories.c_caixa_servico.c_caixa_servico_save_repository import SaveRepository
+
+
+class SaveAction:
+
+    def execute(self, usuario_schema : CCaixaServicoSaveSchema):
+
+        save_repository = SaveRepository()
+
+        return save_repository.execute(usuario_schema)

packages/v1/administrativo/actions/c_caixa_servico/c_caixa_servico_show_action.py

@@ -0,0 +1,16 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.schemas.c_caixa_servico_schema import CCaixaServicoSchema
+from packages.v1.administrativo.repositories.c_caixa_servico.c_caixa_servico_show_repository import ShowRepository
+
+class ShowAction(BaseAction):
+
+    def execute(self, usuario_schema : CCaixaServicoSchema):
+
+        # Instânciamento do repositório sql
+        show_repository = ShowRepository()
+
+        # Execução do sql
+        response = show_repository.execute(usuario_schema)
+
+        # Retorno da informação
+        return response

packages/v1/administrativo/actions/g_usuario/g_usuario_delete_action.py

@@ -1,10 +1,10 @@
-from packages.v1.administrativo.schemas.g_usuario_schema import GUsuarioSchema
+from packages.v1.administrativo.schemas.g_usuario_schema import GUsuarioIdSchema
 from packages.v1.administrativo.repositories.g_usuario.g_usuario_delete_repository import DeleteRepository
 
 
 class DeleteAction:
 
-    def execute(self, usuario_schema : GUsuarioSchema):
+    def execute(self, usuario_schema : GUsuarioIdSchema):
 
         delete_repository = DeleteRepository()
 

packages/v1/administrativo/actions/g_usuario/g_usuario_save_action.py

@@ -1,10 +1,10 @@
-from packages.v1.administrativo.schemas.g_usuario_schema import GUsuarioSchema
+from packages.v1.administrativo.schemas.g_usuario_schema import GUsuarioSaveSchema
 from packages.v1.administrativo.repositories.g_usuario.g_usuario_save_repository import SaveRepository
 
 
 class SaveAction:
 
-    def execute(self, usuario_schema : GUsuarioSchema):
+    def execute(self, usuario_schema : GUsuarioSaveSchema):
 
         save_repository = SaveRepository()
 

packages/v1/administrativo/controllers/c_caixa_servico_controller.py

@@ -0,0 +1,113 @@
+from actions.dynamic_import.dynamic_import import DynamicImport
+from packages.v1.administrativo.schemas.c_caixa_servico_schema import (
+    CCaixaServicoSchema,
+    CCaixaServicoSaveSchema,
+    CCaixaServicoUpdateSchema,
+    CCaixaServicoIdSchema,
+    CCaixaServicoDescricaoSchema
+)
+
+class CCaixaServicoController:
+
+    def __init__(self):
+        # Action responsável por carregar as services de acodo com o estado
+        self.dynamic_import = DynamicImport()
+
+        # Define o pacote que deve ser carregado
+        self.dynamic_import.set_package("administrativo")
+
+        # Define a tabela que o pacote pertence
+        self.dynamic_import.set_table("c_caixa_servico")
+        pass
+
+    # Lista todos os caixa serviço
+    def index(self):
+        
+        # Importação da classe desejada
+        indexService = self.dynamic_import.service("c_caixa_servico_index_service", "IndexService")
+
+        # Instânciamento da classe service
+        self.indexService = indexService()
+
+        # Lista todos os caixa serviço
+        return {
+            'message': 'caixa serviço localizados com sucesso',
+            'data': self.indexService.execute()
+        }
+    
+    
+    # Busca um usuário especifico pelo ID 
+    def show(self, caixa_servico_schema : CCaixaServicoIdSchema):
+
+        #Importação da classe desejada
+        show_service = self.dynamic_import.service('c_caixa_servico_show_service', 'ShowService')
+
+        # Instânciamento da classe desejada
+        self.show_service = show_service()
+
+        # Busca e retorna o usuário desejado
+        return {
+            'message' : 'Caixa Serviço localizado com sucesso',
+            'data': self.show_service.execute(caixa_servico_schema)
+        }
+    
+
+    # Busca um caixa serviço pela descrição 
+    def getDescricao(self, caixa_servico_schema : CCaixaServicoDescricaoSchema):
+
+        #Importação da classe desejada
+        show_service = self.dynamic_import.service('c_caixa_servico_get_descricao_service', 'GetDescricaoService')
+
+        # Instânciamento da classe desejada
+        self.show_service = show_service()
+
+        # Busca e retorna o usuário desejado
+        return {
+            'message' : 'Caixa Serviço localizado com sucesso',
+            'data': self.show_service.execute(caixa_servico_schema, True)# True para retornar a mensagem de erro caso não localize o serviço
+        }    
+          
+    
+    # Cadastra um novo usuário
+    def save(self, caixa_servico_schema : CCaixaServicoSaveSchema):
+
+        #Importação da classe desejada
+        save_service = self.dynamic_import.service('c_caixa_servico_save_service', 'CCaixaServicoSaveService')
+
+        # Instânciamento da classe desejada
+        self.save_service = save_service()
+        # Busca e retorna o usuário desejado
+        return {
+            'message' : 'Caixa Serviço salvo com sucesso',
+            'data': self.save_service.execute(caixa_servico_schema)
+        }
+    
+    # Atualiza os dados de um usuário
+    def update(self, caixa_servico_schema : CCaixaServicoUpdateSchema):
+
+        #Importação da classe desejada
+        save_service = self.dynamic_import.service('c_caixa_servico_update_service', 'CCaixaServicoUpdateService')
+
+        # Instânciamento da classe desejada
+        self.save_service = save_service()
+
+        # Busca e retorna o usuário desejado
+        return {
+            'message' : 'Caixa Serviço atualizado com sucesso',
+            'data': self.save_service.execute(caixa_servico_schema)
+        }
+    
+    # Exclui um usuário
+    def delete(self, caixa_servico_schema : CCaixaServicoIdSchema):
+
+        #Importação da classe desejada
+        delete_service = self.dynamic_import.service('c_caixa_servico_delete_service', 'DeleteService')
+
+        # Instânciamento da classe desejada
+        self.delete_service = delete_service()
+
+        # Busca e retorna o usuário desejado
+        return {
+            'message' : 'Caixa Serviço removido com sucesso',
+            'data': self.delete_service.execute(caixa_servico_schema)
+        }

packages/v1/administrativo/controllers/g_usuario_controller.py

@@ -6,7 +6,8 @@ from packages.v1.administrativo.schemas.g_usuario_schema import (
     GUsuarioUpdateSchema,
     GUsuarioEmailSchema,
     GUsuarioCpfSchema,
-    GUsuarioLoginSchema
+    GUsuarioLoginSchema,
+    GUsuarioIdSchema
 )
 
 class GUsuarioController:
@@ -163,10 +164,10 @@ class GUsuarioController:
         }
     
     # Exclui um usuário
-    def delete(self, usuario_schema : GUsuarioSchema):
+    def delete(self, usuario_schema : GUsuarioIdSchema):
 
         #Importação da classe desejada
-        delete_service = self.dynamic_import.service('delete_service', 'DeleteService')
+        delete_service = self.dynamic_import.service('g_usuario_delete_service', 'DeleteService')
 
         # Instânciamento da classe desejada
         self.delete_service = delete_service()

packages/v1/administrativo/endpoints/c_caixa_servico_endpoint.py

@@ -0,0 +1,108 @@
+# Importação de bibliotecas
+from typing import Optional
+from fastapi import APIRouter, Body, Depends, status
+from actions.jwt.get_current_user import get_current_user
+from packages.v1.administrativo.controllers.c_caixa_servico_controller import CCaixaServicoController
+from packages.v1.administrativo.schemas.c_caixa_servico_schema import (
+    CCaixaServicoSchema,
+    CCaixaServicoSaveSchema,
+    CCaixaServicoUpdateSchema,
+    CCaixaServicoDescricaoSchema
+)
+
+# Inicializa o roteador para as rotas de usuário
+router = APIRouter()
+
+# Instânciamento do controller desejado
+c_caixa_servico_controller = CCaixaServicoController()
+  
+# Lista todos os serviços
+@router.get('/',
+            status_code=status.HTTP_200_OK,
+            summary='Lista todos os serviços cadastrados',
+            response_description='Lista todos os serviços cadastrados')
+async def index(current_user: dict = Depends(get_current_user)):
+
+    # Busca todos os usuários cadastrados
+    response = c_caixa_servico_controller.index()
+
+    # Retorna os dados localizados
+    return response
+
+
+# Localiza um caixa serviço pela descrição
+@router.get('/descricao',
+            status_code=status.HTTP_200_OK,
+            summary='Busca um registro em especifico pela descrição',
+            response_description='Busca um registro em especifico')
+async def getDescricao(descricao : str, current_user: dict = Depends(get_current_user)):
+
+    # Cria o schema com os dados recebidos
+    caixa_servico_schema = CCaixaServicoDescricaoSchema(descricao=descricao)
+
+    # Busca um usuário especifico pelo e-mail
+    response = c_caixa_servico_controller.getDescricao(caixa_servico_schema)
+
+    # Retorna os dados localizados
+    return response
+
+
+# Localiza um serviço pelo ID
+@router.get('/{caixa_servico_id}',
+            status_code=status.HTTP_200_OK,
+            summary='Busca um registro em especifico pelo ID do serviço',
+            response_description='Busca um registro em especifico')
+async def show(caixa_servico_id : int, current_user: dict = Depends(get_current_user)):
+
+    # Cria o schema com os dados recebidos
+    caixa_servico_schema = CCaixaServicoSchema(caixa_servico_id=caixa_servico_id)
+
+    # Busca um usuário especifico pelo ID
+    response = c_caixa_servico_controller.show(caixa_servico_schema)
+
+    # Retorna os dados localizados
+    return response
+
+
+# Cadastro de caixa servico
+@router.post('/',
+            status_code=status.HTTP_200_OK,
+            summary='Cadastra um caixa serviço',
+            response_description='Cadastra um serviço')
+async def save(caixa_servico_schema : CCaixaServicoSaveSchema, current_user: dict = Depends(get_current_user)):
+
+    # Efetua o cadastro do usuário junto ao banco de dados
+    response = c_caixa_servico_controller.save(caixa_servico_schema)
+
+    # Retorna os dados localizados
+    return response
+
+
+# Atualiza os dados de caixa serviço
+@router.put('/',
+            status_code=status.HTTP_200_OK,
+            summary='Atualiza um caixa serviço',
+            response_description='Atualiza um serviço')
+async def update(caixa_servico_schema : CCaixaServicoUpdateSchema, current_user: dict = Depends(get_current_user)):
+
+    # Efetua a atualização dos dados de usuário
+    response = c_caixa_servico_controller.update(caixa_servico_schema)
+
+    # Retorna os dados localizados
+    return response
+
+# Exclui um determinado usuário 
+@router.delete('/{caixa_servico_id}',
+            status_code=status.HTTP_200_OK,
+            summary='Remove um caixa serviço',
+            response_description='Remove um serviço')
+async def delete(caixa_servico_id : int, current_user: dict = Depends(get_current_user)):
+
+    # Cria o schema com os dados recebidos
+    caixa_servico_schema = CCaixaServicoSchema(caixa_servico_id=caixa_servico_id)
+
+    # Efetua a exclusão de um determinado usuário
+    response = c_caixa_servico_controller.delete(caixa_servico_schema)
+
+    # Retorna os dados localizados
+    return response

packages/v1/administrativo/endpoints/g_usuario_endpoint.py

@@ -1,10 +1,7 @@
 # Importação de bibliotecas
 from typing import Optional
-
 from fastapi import APIRouter, Body, Depends, status
-
 from actions.jwt.get_current_user import get_current_user
-
 from packages.v1.administrativo.controllers.g_usuario_controller import GUsuarioController
 from packages.v1.administrativo.schemas.g_usuario_schema import (
     GUsuarioSchema,
@@ -13,7 +10,8 @@ from packages.v1.administrativo.schemas.g_usuario_schema import (
     GUsuarioUpdateSchema,
     GUsuarioEmailSchema,
     GUsuarioCpfSchema,
-    GUsuarioLoginSchema
+    GUsuarioLoginSchema,
+    GUsuarioIdSchema
 )
 
 # Inicializa o roteador para as rotas de usuário
@@ -118,7 +116,7 @@ async def getCpf(cpf : str, current_user: dict = Depends(get_current_user)):
 async def show(usuario_id : int, current_user: dict = Depends(get_current_user)):
 
     # Cria o schema com os dados recebidos
-    usuario_schema = GUsuarioSchema(usuario_id=usuario_id)
+    usuario_schema = GUsuarioIdSchema(usuario_id=usuario_id)
 
     # Busca um usuário especifico pelo ID
     response = g_usuario_controller.show(usuario_schema)
@@ -161,7 +159,7 @@ async def update(usuario_schema : GUsuarioUpdateSchema, current_user: dict = Dep
 async def delete(usuario_id : int, current_user: dict = Depends(get_current_user)):
 
     # Cria o schema com os dados recebidos
-    usuario_schema = GUsuarioSchema(usuario_id=usuario_id)
+    usuario_schema = GUsuarioIdSchema(usuario_id=usuario_id)
 
     # Efetua a exclusão de um determinado usuário
     response = g_usuario_controller.delete(usuario_schema)

packages/v1/administrativo/repositories/c_caixa_servico/c_caixa_servico_delete_repository.py

@@ -0,0 +1,33 @@
+from packages.v1.administrativo.schemas.c_caixa_servico_schema import \
+    CCaixaServicoIdSchema
+from abstracts.repository import BaseRepository
+from fastapi import HTTPException, status
+
+
+class DeleteRepository(BaseRepository):
+
+    def execute(self, caixa_servico_schema : CCaixaServicoIdSchema):
+            
+        try:
+
+            # Montagem do sql
+            sql = """ DELETE FROM c_caixa_servico ccs WHERE ccs.caixa_servico_id = :caixa_servico_id """
+
+            # Preenchimento de parâmetros
+            params = {
+                "caixa_servico_id" : caixa_servico_schema.caixa_servico_id
+            }
+
+            #Execução do sql
+            response = self.run(sql, params)
+
+            # Retorna o resultado
+            return response
+    
+        except Exception as e:
+        
+            # Informa que houve  uma falha na atualização do usuário
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail=f"Erro ao excluir caixa serviço: {e}"
+            ) 

packages/v1/administrativo/repositories/c_caixa_servico/c_caixa_servico_get_by_descricao_repository.py

@@ -0,0 +1,17 @@
+from abstracts.repository import BaseRepository
+from packages.v1.administrativo.schemas.c_caixa_servico_schema import CCaixaServicoDescricaoSchema
+
+class ShowRepository(BaseRepository):
+
+    def execute(self, caixa_servico_schema : CCaixaServicoDescricaoSchema):
+        
+        # Montagem do sql
+        sql = """ SELECT * FROM C_CAIXA_SERVICO ccs WHERE ccs.descricao = :descricao """
+
+        # Preenchimento de parâmetros
+        params = {
+            'descricao' : caixa_servico_schema.descricao
+        }
+
+        # Execução do sql
+        return self.fetch_one(sql, params)

packages/v1/administrativo/repositories/c_caixa_servico/c_caixa_servico_index_repository.py

@@ -0,0 +1,14 @@
+from abstracts.repository import BaseRepository
+
+class IndexRepository(BaseRepository):
+
+    def execute(self):
+
+        # Montagem do sql
+        sql = """ SELECT * FROM c_caixa_servico """
+
+        # Execução do sql
+        response = self.fetch_all(sql)
+
+        # Retorna os dados localizados
+        return response

packages/v1/administrativo/repositories/c_caixa_servico/c_caixa_servico_save_repository.py

@@ -0,0 +1,60 @@
+
+from fastapi import HTTPException, status
+from abstracts.repository import BaseRepository
+from packages.v1.administrativo.schemas.c_caixa_servico_schema import CCaixaServicoSaveSchema
+
+class SaveRepository(BaseRepository):
+
+    def execute(self, caixa_servico_schema : CCaixaServicoSaveSchema):
+            
+        try:
+
+            # Montagem do SQL
+            sql = """ INSERT INTO C_CAIXA_SERVICO(
+                        CAIXA_SERVICO_ID,
+                        TIPO_TRANSACAO,
+                        SISTEMA_ID,
+                        SITUACAO,
+                        INTERNO_SISTEMA,
+                        DESCRICAO,
+                        EMITIR_RELATORIO,
+                        TIPO_CONTA_CARNELEAO,
+                        CENTRO_DE_CUSTA_ID,
+                        REPETIR_DESCRICAO
+                        ) VALUES (
+                        :caixa_servico_id,
+                        :tipo_transacao,
+                        :sistema_id,
+                        :situacao,
+                        :interno_sistema,
+                        :descricao,
+                        :emitir_relatorio,
+                        :tipo_conta_carneleao,
+                        :centro_de_custa_id,
+                        :repetir_descricao
+                        ) RETURNING *;"""
+            
+            # Preenchimento de parâmetros
+            params = {
+                'caixa_servico_id': caixa_servico_schema.caixa_servico_id,
+                'tipo_transacao': caixa_servico_schema.tipo_transacao,
+                'sistema_id': caixa_servico_schema.sistema_id,
+                'situacao': caixa_servico_schema.situacao,
+                'interno_sistema': caixa_servico_schema.interno_sistema,
+                'descricao': caixa_servico_schema.descricao,
+                'emitir_relatorio': caixa_servico_schema.emitir_relatorio,
+                'tipo_conta_carneleao': caixa_servico_schema.tipo_conta_carneleao,
+                'centro_de_custa_id': caixa_servico_schema.centro_de_custa_id,
+                'repetir_descricao': caixa_servico_schema.repetir_descricao
+            }
+
+            # Excução do sql
+            return self.run_and_return(sql, params)
+    
+        except Exception as e:
+        
+            # Informa que houve  uma falha na atualização do usuário
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail=f"Erro ao salvar caixa serviço: {e}"
+            )     

packages/v1/administrativo/repositories/c_caixa_servico/c_caixa_servico_show_repository.py

@@ -0,0 +1,17 @@
+from abstracts.repository import BaseRepository
+from packages.v1.administrativo.schemas.c_caixa_servico_schema import CCaixaServicoIdSchema
+
+class ShowRepository(BaseRepository):
+
+    def execute(self, caixa_servico_schema : CCaixaServicoIdSchema):
+        
+        # Montagem do sql
+        sql = """ SELECT * FROM C_CAIXA_SERVICO ccs WHERE ccs.caixa_servico_id = :caixa_servico_id """
+
+        # Preenchimento de parâmetros
+        params = {
+            'caixa_servico_id' : caixa_servico_schema.caixa_servico_id
+        }
+
+        # Execução do sql
+        return self.fetch_one(sql, params)

packages/v1/administrativo/repositories/g_usuario/g_usuario_delete_repository.py

@@ -1,22 +1,34 @@
 from packages.v1.administrativo.schemas.g_usuario_schema import \
-    GUsuarioSchema
+    GUsuarioIdSchema
 from abstracts.repository import BaseRepository
+from fastapi import HTTPException, status
 
 
 class DeleteRepository(BaseRepository):
 
-    def execute(self, usuario_schema : GUsuarioSchema):
+    def execute(self, usuario_schema : GUsuarioIdSchema):
+            
+        try:
 
-        # Montagem do sql
-        sql = """ DELETE FROM g_usuario gu WHERE gu.usuario_id = :usuarioId """
+            # Montagem do sql
+            sql = """ DELETE FROM g_usuario gu WHERE gu.usuario_id = :usuarioId """
 
-        # Preenchimento de parâmetros
-        params = {
-            "usuarioId" : usuario_schema.usuario_id
-        }
+            # Preenchimento de parâmetros
+            params = {
+                "usuarioId" : usuario_schema.usuario_id
+            }
 
-        #Execução do sql
-        response = self.run(sql, params)
+            #Execução do sql
+            response = self.run(sql, params)
 
-        # Retorna o resultado
-        return response
+            # Retorna o resultado
+            return response
+    
+
+        except Exception as e:
+        
+            # Informa que houve  uma falha na atualização do usuário
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail=f"Erro ao excluir usuário: {e}"
+            )      

packages/v1/administrativo/repositories/g_usuario/g_usuario_save_repository.py

@@ -1,47 +1,57 @@
 
+from fastapi import HTTPException, status
 from abstracts.repository import BaseRepository
-
 from packages.v1.administrativo.schemas.g_usuario_schema import GUsuarioSaveSchema
 
 class SaveRepository(BaseRepository):
 
     def execute(self, usuario_schema : GUsuarioSaveSchema):
+            
+        try:
 
-        # Montagem do SQL
-        sql = """ UPDATE OR INSERT INTO G_USUARIO(
-                    USUARIO_ID,
-                    TROCARSENHA,
-                    LOGIN,
-                    SITUACAO,
-                    NOME_COMPLETO,
-                    FUNCAO,
-                    EMAIL,
-                    CPF,
-                    SENHA_API
-                    ) VALUES (
-                        :usuario_id,
-                        :trocarsenha,
-                        :login,
-                        :situacao,
-                        :nome_completo,
-                        :funcao,
-                        :email,
-                        :cpf,
-                        :senha_api
-                    ) MATCHING (usuario_id) RETURNING *;"""
+            # Montagem do SQL
+            sql = """ UPDATE OR INSERT INTO G_USUARIO(
+                        USUARIO_ID,
+                        TROCARSENHA,
+                        LOGIN,
+                        SITUACAO,
+                        NOME_COMPLETO,
+                        FUNCAO,
+                        EMAIL,
+                        CPF,
+                        SENHA_API
+                        ) VALUES (
+                            :usuario_id,
+                            :trocarsenha,
+                            :login,
+                            :situacao,
+                            :nome_completo,
+                            :funcao,
+                            :email,
+                            :cpf,
+                            :senha_api
+                        ) MATCHING (usuario_id) RETURNING *;"""
+            
+            # Preenchimento de parâmetros
+            params = {
+                'usuario_id': usuario_schema.usuario_id,
+                'trocarsenha': usuario_schema.trocarsenha,
+                'login': usuario_schema.login,
+                'situacao': usuario_schema.situacao,
+                'nome_completo': usuario_schema.nome_completo,
+                'funcao': usuario_schema.funcao,
+                'email': usuario_schema.email,
+                'cpf': usuario_schema.cpf,
+                'senha_api': usuario_schema.senha_api
+            }
+
+            # Excução do sql
+            return self.run_and_return(sql, params)
+    
+        except Exception as e:
         
-        # Preenchimento de parâmetros
-        params = {
-            'usuario_id': usuario_schema.usuario_id,
-            'trocarsenha': usuario_schema.trocarsenha,
-            'login': usuario_schema.login,
-            'situacao': usuario_schema.situacao,
-            'nome_completo': usuario_schema.nome_completo,
-            'funcao': usuario_schema.funcao,
-            'email': usuario_schema.email,
-            'cpf': usuario_schema.cpf,
-            'senha_api': usuario_schema.senha_api
-        }
-
-        # Excução do sql
-        return self.run_and_return(sql, params)
+            # Informa que houve  uma falha na atualização do usuário
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail=f"Erro ao salvar usuário: {e}"
+            )     

packages/v1/administrativo/schemas/c_caixa_servico_schema.py

@@ -0,0 +1,237 @@
+from pydantic import BaseModel, field_validator, model_validator 
+from fastapi import HTTPException, status
+from typing import Optional
+
+# Funções para sanitização de entradas (evitar XSS, SQLi etc.)
+from actions.validations.text import Text
+
+# ----------------------------------------------------
+# Schema base
+# ----------------------------------------------------
+class CCaixaServicoSchema(BaseModel):
+
+    interno_sistema: Optional[str] = None
+    caixa_servico_id: int
+    descricao: Optional[str] = None
+    situacao: Optional[str] = None
+    tipo_transacao: Optional[str] = None
+    sistema_id: Optional[int] = None
+    selo_grupo_id: Optional[int] = None
+    emitir_relatorio: Optional[str] = None
+    repasse: Optional[str] = None
+    repetir_descricao: Optional[str] = None
+    codigo_conta: Optional[int] = None
+    tipo_conta_carneleao: Optional[str] = None
+    centro_de_custa_id: Optional[int] = None
+    devolucao_juizo: Optional[str] = None
+
+    class Config:
+        from_attributes = True
+
+
+# ----------------------------------------------------
+# Schema para criação de novo servico (POST)
+# ----------------------------------------------------
+class CCaixaServicoSaveSchema(BaseModel):
+
+    caixa_servico_id: Optional[int] = None
+    tipo_transacao: Optional[str] = None
+    sistema_id: Optional[int] = None
+    situacao: Optional[str] = None
+    interno_sistema: Optional[str] = None
+    descricao: Optional[str] = None
+    emitir_relatorio: Optional[str] = None
+    tipo_conta_carneleao: Optional[str] = None
+    centro_de_custa_id: Optional[int] = None
+    repetir_descricao: Optional[str] = None
+    
+    # Sanitiza os inputs enviados
+    @field_validator('tipo_transacao', 
+                     'situacao', 
+                     'interno_sistema', 
+                     'descricao', 
+                     'emitir_relatorio', 
+                     'tipo_conta_carneleao', 
+                     'repetir_descricao')
+    
+    def validate_required_fields(cls, v):
+
+        # Se for string e composta só por dígitos
+        if v is None or (isinstance(v, str) and len(v.strip()) == 0):
+            # Não lança exceção aqui, apenas retorna para o model_validator
+            pass
+
+        return Text.sanitize_input(v)    
+
+    # Validador para `sistema_id` e outros campos numéricos, se necessário
+    @field_validator('sistema_id')
+    def validate_sistema_id(cls, v):
+        if v is not None and v <= 0:
+            raise ValueError("O sistema precisa ser informado.")
+        return v    
+    
+    # Verifica se os campos foram enviados
+    @model_validator(mode='after')
+    def validate_all_fields(self):
+        
+        # Variavel responsavel em armaezar os erros
+        errors = []
+
+        # Validação do tipo_transacao
+        if not self.tipo_transacao or len(self.tipo_transacao.strip()) == 0:
+            errors.append({'input': 'tipo_transacao', 'message': 'O tipo transação é obrigatório.'})
+
+        # Validação da sistema_id
+        if not self.sistema_id or self.sistema_id == 0:
+            errors.append({'input': 'sistema_id', 'message': 'O sistema precisa ser informado.'})
+        
+        # Validação do situacao
+        if not self.situacao or len(self.situacao.strip()) == 0:
+            errors.append({'input': 'situacao', 'message': 'A situação é obrigatório.'})
+            
+        # Validação da interno_sistema
+        if not self.interno_sistema or len(self.interno_sistema.strip()) == 0:
+            errors.append({'input': 'interno_sistema', 'message': 'O uso interno é obrigatória.'})
+
+        # Validação do descricao
+        if not self.descricao or len(self.descricao.strip()) == 0:
+            errors.append({'input': 'descricao', 'message': 'A descrição é obrigatório.'})
+
+        # Validação do emitir_relatorio
+        if not self.emitir_relatorio or len(self.emitir_relatorio.strip()) == 0:
+            errors.append({'input': 'emitir_relatorio', 'message': 'Sair nos relatórios é obrigatório.'})
+
+        # Validação do repetir_descricao
+        if not self.repetir_descricao or len(self.repetir_descricao.strip()) == 0:
+            errors.append({'input': 'repetir_descricao', 'message': 'Repetir descrição de serviço no caixa é obrigatório.'})            
+
+        # Se houver errors, lança uma única exceção
+        if errors:
+            # Lança uma exceção do FastAPI para um tratamento limpo
+            # O `detail` da exceção será a lista de errors que criamos
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail=errors
+            )
+
+        return self
+    
+
+# ----------------------------------------------------
+# Schema para atualizar caixa serviço (PUT)
+# ----------------------------------------------------
+class CCaixaServicoUpdateSchema(BaseModel):
+
+    caixa_servico_id: int
+    tipo_transacao: Optional[str] = None
+    sistema_id: Optional[int] = None
+    situacao: Optional[str] = None
+    interno_sistema: Optional[str] = None
+    descricao: Optional[str] = None
+    emitir_relatorio: Optional[str] = None
+    tipo_conta_carneleao: Optional[str] = None
+    centro_de_custa_id: Optional[int] = None
+    repetir_descricao: Optional[str] = None
+    
+    # Sanitiza os inputs enviados
+    @field_validator('tipo_transacao', 
+                     'situacao', 
+                     'interno_sistema', 
+                     'descricao', 
+                     'emitir_relatorio', 
+                     'tipo_conta_carneleao', 
+                     'repetir_descricao')
+    
+    def validate_required_fields(cls, v):
+        if not v or len(v.strip()) == 0:
+            # Não lança exceção aqui. Apenas retorna para o model_validator.
+            # O Pydantic já faria a checagem básica.
+            # Este validador individual é mais para sanitização.
+            pass
+        return Text.sanitize_input(v)
+    
+    # Validador para `sistema_id` e outros campos numéricos, se necessário
+    @field_validator('sistema_id')
+    def validate_sistema_id(cls, v):
+        if v is not None and v <= 0:
+            raise ValueError("O sistema precisa ser informado.")
+        return v      
+    
+    # Verifica se os campos foram enviados
+    @model_validator(mode='after')
+    def validate_all_fields(self):
+        
+        # Variavel responsavel em armaezar os erros
+        errors = []
+
+        # Validação do tipo_transacao
+        if not self.tipo_transacao or len(self.tipo_transacao.strip()) == 0:
+            errors.append({'input': 'tipo_transacao', 'message': 'O tipo transação é obrigatório.'})
+
+        # Validação da sistema_id
+        if not self.sistema_id or self.sistema_id == 0:
+            errors.append({'input': 'sistema_id', 'message': 'O sistema precisa ser informado.'})
+        
+        # Validação do situacao
+        if not self.situacao or len(self.situacao.strip()) == 0:
+            errors.append({'input': 'situacao', 'message': 'A situação é obrigatório.'})
+            
+        # Validação da interno_sistema
+        if not self.interno_sistema or len(self.interno_sistema.strip()) == 0:
+            errors.append({'input': 'interno_sistema', 'message': 'O uso interno é obrigatória.'})
+
+        # Validação do descricao
+        if not self.descricao or len(self.descricao.strip()) == 0:
+            errors.append({'input': 'descricao', 'message': 'A descrição é obrigatório.'})
+
+        # Validação do emitir_relatorio
+        if not self.emitir_relatorio or len(self.emitir_relatorio.strip()) == 0:
+            errors.append({'input': 'emitir_relatorio', 'message': 'Sair nos relatórios é obrigatório.'})
+
+        # Validação do repetir_descricao
+        if not self.repetir_descricao or len(self.repetir_descricao.strip()) == 0:
+            errors.append({'input': 'repetir_descricao', 'message': 'Repetir descrição de serviço no caixa é obrigatório.'})            
+
+        # Se houver errors, lança uma única exceção
+        if errors:
+            # Lança uma exceção do FastAPI para um tratamento limpo
+            # O `detail` da exceção será a lista de errors que criamos
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail=errors
+            )
+
+        return self 
+    
+# ----------------------------------------------------
+# Schema para localizar um caixa serviço especifico pelo ID (GET)
+# ----------------------------------------------------
+class CCaixaServicoIdSchema(BaseModel):
+    caixa_servico_id: int    
+
+
+# ----------------------------------------------------
+# Schema para localizar um caixa serviço pela descrição (GET)
+# ----------------------------------------------------
+class CCaixaServicoDescricaoSchema(BaseModel):
+
+    # Campos utilizados
+    descricao: str  # senha_api obrigatório
+
+    # Validação e sanitização do login
+    @field_validator('descricao')
+    def validar_e_sanitizar_descricao(cls, v):
+
+        # Verifica se a descrição foi informada
+        if not v:
+
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail='Informe a descrição'
+            )  
+
+        # Sanitiza a decrição para evitar XSS e SQL Injection
+        return Text.sanitize_input(v)
+    
+    class Config:
+        from_attributes = True       

packages/v1/administrativo/schemas/g_usuario_schema.py

@@ -99,7 +99,10 @@ class GUsuarioAuthenticateSchema(BaseModel):
         from_attributes = True   
 
 
-class GUsuarioMe(BaseModel):
+# ----------------------------------------------------
+# Schema para localizar um usuário especifico pelo ID (GET)
+# ----------------------------------------------------
+class GUsuarioIdSchema(BaseModel):
     usuario_id: int
 
 

packages/v1/administrativo/services/c_caixa_servico/go/c_caixa_servico_delete_service.py

@@ -0,0 +1,15 @@
+from packages.v1.administrativo.schemas.c_caixa_servico_schema import CCaixaServicoIdSchema
+from packages.v1.administrativo.actions.c_caixa_servico.c_caixa_servico_delete_action import DeleteAction
+
+class DeleteService:
+
+    def execute(self, caixa_servico_schema: CCaixaServicoIdSchema):
+
+        # Instânciamento de ação
+        delete_action = DeleteAction()
+
+        # Executa a ação em questão
+        data = delete_action.execute(caixa_servico_schema)
+
+        # Retorno da informação
+        return data

packages/v1/administrativo/services/c_caixa_servico/go/c_caixa_servico_get_descricao_service.py

@@ -0,0 +1,26 @@
+from fastapi import HTTPException, status
+
+from packages.v1.administrativo.schemas.c_caixa_servico_schema import CCaixaServicoDescricaoSchema
+from packages.v1.administrativo.actions.c_caixa_servico.c_caixa_servico_get_by_descricao_action import ShowAction
+
+class GetDescricaoService:
+
+    def execute(self, caixa_servico_schema: CCaixaServicoDescricaoSchema, messageValidate: bool):
+
+        # Instânciamento de ação
+        show_action = ShowAction()
+
+        # Executa a ação em questão
+        data = show_action.execute(caixa_servico_schema)
+
+        if messageValidate:
+            
+            if not data:
+                # Retorna uma exceção
+                raise HTTPException(
+                    status_code=status.HTTP_404_NOT_FOUND,
+                    detail='Não foi possível localizar o registro'
+                )
+
+        # Retorno da informação
+        return data

packages/v1/administrativo/services/c_caixa_servico/go/c_caixa_servico_index_service.py

@@ -0,0 +1,24 @@
+from fastapi import HTTPException, status
+from packages.v1.administrativo.schemas.c_caixa_servico_schema import CCaixaServicoSchema
+from packages.v1.administrativo.actions.c_caixa_servico.c_caixa_servico_index_action import IndexAction
+
+class IndexService:
+
+    def execute(self):
+
+        # Instânciamento de acções
+        index_action = IndexAction()
+
+        # Executa a busca de todas as ações
+        data = index_action.execute()
+
+        # Verifica se foi loalizado registros
+        if not data:
+            # Retorna uma exeção
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail='Não foi possível localizar os usuários'
+            )
+        
+        # Retorna as informações localizadas
+        return data

packages/v1/administrativo/services/c_caixa_servico/go/c_caixa_servico_save_service.py

@@ -0,0 +1,73 @@
+from actions.dynamic_import.dynamic_import import DynamicImport
+from packages.v1.sequencia.schemas.g_sequencia import GSequenciaSchema
+from packages.v1.sequencia.services.g_sequencia.generate_service import GenerateService
+from packages.v1.administrativo.schemas.c_caixa_servico_schema import CCaixaServicoSaveSchema, CCaixaServicoDescricaoSchema
+from packages.v1.administrativo.actions.c_caixa_servico.c_caixa_servico_save_action import SaveAction
+from fastapi import HTTPException, status
+
+class CCaixaServicoSaveService:
+
+    def __init__(self):
+        # Action responsável por carregar as services de acodo com o estado
+        self.dynamic_import = DynamicImport()
+
+        # Define o pacote que deve ser carregado
+        self.dynamic_import.set_package("administrativo")
+
+        # Define a tabela que o pacote pertence
+        self.dynamic_import.set_table("c_caixa_servico")
+        pass    
+
+    # Cadastra o novo caixa serviço
+    def execute(self, caixa_servico_schema: CCaixaServicoSaveSchema):  
+
+
+        # Armazena possíveis erros
+        errors = []
+
+        # Verifica se o e-mail já esta sendo utilizado
+        # Importação de service de email
+        descricao_service = self.dynamic_import.service("c_caixa_servico_get_descricao_service", "GetDescricaoService")
+
+        # Instânciamento da service
+        self.descricao_service = descricao_service()     
+
+        # Verifica se o email já esta sendo utilizado
+        self.response = self.descricao_service.execute(CCaixaServicoDescricaoSchema(descricao=caixa_servico_schema.descricao), False)
+
+        # Se houver retorno significa que a descrição já esta sendo utiizada
+        if self.response:
+            errors.append({'input': 'descricao', 'message': 'a descrição informada já esta sendo utilizada.'})  
+
+
+        # Se houver erros, informo
+        if errors:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail=errors
+            ) 
+        
+
+        # Verifica se precisa gerar o id de sequencia
+        if not caixa_servico_schema.caixa_servico_id:
+
+            # Crio um objeto de sequencia
+            sequencia_schema = GSequenciaSchema()
+
+            # Define os dados para atualizar a sequencia
+            sequencia_schema.tabela = 'C_CAIXA_SERVICO'
+
+            # Busco a sequência atualizada
+            generate = GenerateService()
+
+            # Busco a sequência atualizada
+            sequencia = generate.execute(sequencia_schema)
+
+            # Atualiza os dados da chave primária
+            caixa_servico_schema.caixa_servico_id = sequencia.sequencia
+
+        # Instânciamento de ações
+        saveAction = SaveAction()
+
+        # Retorna todos produtos desejados
+        return saveAction.execute(caixa_servico_schema)

packages/v1/administrativo/services/c_caixa_servico/go/c_caixa_servico_show_service.py

@@ -0,0 +1,24 @@
+from fastapi import HTTPException, status
+
+from packages.v1.administrativo.schemas.c_caixa_servico_schema import CCaixaServicoIdSchema
+from packages.v1.administrativo.actions.c_caixa_servico.c_caixa_servico_show_action import ShowAction
+
+class ShowService:
+
+    def execute(self, caixa_servico_schema: CCaixaServicoIdSchema):
+
+        # Instânciamento de ação
+        show_action = ShowAction()
+
+        # Executa a ação em questão
+        data = show_action.execute(caixa_servico_schema)
+
+        if not data:
+            # Retorna uma exceção
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail='Não foi possível localizar o registro'
+            )
+
+        # Retorno da informação
+        return data

packages/v1/administrativo/services/g_usuario/go/g_usuario_delete_service.py

@@ -1,9 +1,9 @@
-from packages.v1.administrativo.schemas.g_usuario_schema import GUsuarioSchema
-from packages.v1.administrativo.actions.g_usuario.delete_action import DeleteAction
+from packages.v1.administrativo.schemas.g_usuario_schema import GUsuarioIdSchema
+from packages.v1.administrativo.actions.g_usuario.g_usuario_delete_action import DeleteAction
 
 class DeleteService:
 
-    def execute(self, usuario_schema: GUsuarioSchema):
+    def execute(self, usuario_schema: GUsuarioIdSchema):
 
         # Instânciamento de ação
         delete_action = DeleteAction()

packages/v1/administrativo/services/g_usuario/go/g_usuario_index_service.py

@@ -1,6 +1,6 @@
 from fastapi import HTTPException, status
 from packages.v1.administrativo.schemas.g_usuario_schema import GUsuarioSchema
-from packages.v1.administrativo.actions.g_usuario.index_action import IndexAction
+from packages.v1.administrativo.actions.g_usuario.g_usuario_index_action import IndexAction
 
 class IndexService:
 

packages/v1/administrativo/services/g_usuario/go/g_usuario_me_service.py

@@ -1,5 +1,5 @@
 import ast
-from packages.v1.administrativo.schemas.g_usuario_schema import GUsuarioMe
+from packages.v1.administrativo.schemas.g_usuario_schema import GUsuarioIdSchema
 from packages.v1.administrativo.actions.g_usuario.g_usuario_get_by_usuario_id_action import GetByUsuarioIdAction
 
 class MeService:
@@ -12,7 +12,7 @@ class MeService:
         usuario_data = ast.literal_eval(current_user["data"])
 
         # Define os dados do schema
-        g_usuario_schema = GUsuarioMe(usuario_id=int(usuario_data["usuario_id"]))
+        g_usuario_schema = GUsuarioIdSchema(usuario_id=int(usuario_data["usuario_id"]))
 
         # Executa a ação em questão
         return get_by_usuario_id_action.execute(g_usuario_schema)

packages/v1/api.py

@@ -2,8 +2,7 @@
 from fastapi import APIRouter
 
 # Importa os módulos de rotas específicos
-from packages.v1.administrativo.endpoints import c_caixa_item
-from packages.v1.administrativo.endpoints import g_usuario_endpoint
+from packages.v1.administrativo.endpoints import c_caixa_item, g_usuario_endpoint, c_caixa_servico_endpoint
 
 # Cria uma instância do APIRouter que vai agregar todas as rotas da API
 api_router = APIRouter()
@@ -13,7 +12,13 @@ api_router.include_router(
     c_caixa_item.router, prefix="/administrativo/caixa", tags=["Caixa"]
 )
 
-# Inclui as rotas de caixa
+# Inclui as rotas de usuários
 api_router.include_router(
-    g_usuario_endpoint.router, prefix="/administrativo/usuarios", tags=["Usuário"]
+    g_usuario_endpoint.router, prefix="/administrativo/g_usuario", tags=["Usuário"]
 )
+
+# Inclui as rotas de caixa_servico
+api_router.include_router(
+    c_caixa_servico_endpoint.router, prefix="/administrativo/c_caixa_servico", tags=["Caixa Serviço"]
+)
+

storage/temp.json

@@ -708,5 +708,101 @@
     "storage/temp/http_exception_handler.json",
     "storage/temp/http_exception_handler.json",
     "storage/temp/http_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/validation_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
+    "storage/temp/http_exception_handler.json",
     "storage/temp/http_exception_handler.json"
 ]