[MVPTN-37] feat(Pesquisa): Adiciona query params nas conultas sqls

abstracts/repository.py

@@ -3,8 +3,10 @@ from typing import Any, Mapping, List, Optional, Literal, Union, overload
 
 # Função `text` para construir SQL parametrizado de forma segura.
 from sqlalchemy import text
+
 # Tipo de retorno de execução bruta de SQL (cursor/result set) do SQLAlchemy.
 from sqlalchemy.engine import CursorResult
+
 # Exceção base do SQLAlchemy para capturar erros de banco.
 from sqlalchemy.exc import SQLAlchemyError
 
@@ -16,23 +18,36 @@ from database.firebird import Firebird
 class BaseRepository:
     # Sobrecarga 1: quando `fetch="all"`, o retorno é uma lista de mapeamentos (coluna->valor).
     @overload
-    def _execute(self, sql: str, params: Optional[dict[str, Any]], fetch: Literal["all"]) -> List[Mapping[str, Any]]: ...
+    def _execute(
+        self, sql: str, params: Optional[dict[str, Any]], fetch: Literal["all"]
+    ) -> List[Mapping[str, Any]]: ...
+
     # Sobrecarga 2: quando `fetch="one"`, o retorno é um único mapeamento ou None.
     @overload
-    def _execute(self, sql: str, params: Optional[dict[str, Any]], fetch: Literal["one"]) -> Optional[Mapping[str, Any]]: ...
+    def _execute(
+        self, sql: str, params: Optional[dict[str, Any]], fetch: Literal["one"]
+    ) -> Optional[Mapping[str, Any]]: ...
+
     # Sobrecarga 3: quando `fetch="none"`, não há retorno (operações DML sem leitura).
     @overload
-    def _execute(self, sql: str, params: Optional[dict[str, Any]], fetch: Literal["none"]) -> None: ...
+    def _execute(
+        self, sql: str, params: Optional[dict[str, Any]], fetch: Literal["none"]
+    ) -> None: ...
+
     # Sobrecarga 4: quando `fetch="result"`, retorna o objeto `CursorResult` bruto do SQLAlchemy.
     @overload
-    def _execute(self, sql: str, params: Optional[dict[str, Any]], fetch: Literal["result"]) -> CursorResult[Any]: ...
+    def _execute(
+        self, sql: str, params: Optional[dict[str, Any]], fetch: Literal["result"]
+    ) -> CursorResult[Any]: ...
 
     # Implementação concreta que atende às quatro sobrecargas por meio de um retorno em união.
     def _execute(
         self,
         sql: str,  # Comando SQL (SELECT/INSERT/UPDATE/DELETE) em texto.
         params: Optional[dict[str, Any]] = None,  # Parâmetros nomeados para o SQL.
-        fetch: Literal["all", "one", "none", "result"] = "result",  # Modo de leitura/retorno.
+        fetch: Literal[
+            "all", "one", "none", "result"
+        ] = "result",  # Modo de leitura/retorno.
     ) -> Union[
         List[Mapping[str, Any]],  # Retorno quando `fetch="all"`.
         Optional[Mapping[str, Any]],  # Retorno quando `fetch="one"`.
@@ -66,17 +81,23 @@ class BaseRepository:
             raise
 
     # Executa uma consulta e retorna o objeto `CursorResult` bruto (uso avançado ou stream).
-    def query(self, sql: str, params: Optional[dict[str, Any]] = None) -> CursorResult[Any]:
+    def query(
+        self, sql: str, params: Optional[dict[str, Any]] = None
+    ) -> CursorResult[Any]:
         """Executa uma consulta SQL e retorna o resultado como objeto ResultProxy."""
         return self._execute(sql, params, fetch="result")
 
     # Executa uma consulta e retorna todos os registros como lista de mapeamentos.
-    def fetch_all(self, sql: str, params: Optional[dict[str, Any]] = None) -> List[Mapping[str, Any]]:
+    def fetch_all(
+        self, sql: str, params: Optional[dict[str, Any]] = None
+    ) -> List[Mapping[str, Any]]:
         """Executa uma consulta SQL e retorna todos os registros com mapeamento de colunas."""
         return self._execute(sql, params, fetch="all")
 
     # Executa uma consulta e retorna apenas o primeiro registro ou None.
-    def fetch_one(self, sql: str, params: Optional[dict[str, Any]] = None) -> Optional[Mapping[str, Any]]:
+    def fetch_one(
+        self, sql: str, params: Optional[dict[str, Any]] = None
+    ) -> Optional[Mapping[str, Any]]:
         """Executa uma consulta SQL e retorna o primeiro registro com mapeamento de colunas."""
         return self._execute(sql, params, fetch="one")
 
@@ -86,6 +107,8 @@ class BaseRepository:
         self._execute(sql, params, fetch="none")
 
     # Executa comandos com cláusula RETURNING e devolve o registro retornado (ou None).
-    def run_and_return(self, sql: str, params: Optional[dict[str, Any]] = None) -> Optional[Mapping[str, Any]]:
+    def run_and_return(
+        self, sql: str, params: Optional[dict[str, Any]] = None
+    ) -> Optional[Mapping[str, Any]]:
         """Executa SQL com RETURNING e retorna o primeiro registro como dict."""
         return self._execute(sql, params, fetch="one")

actions/data/get_url_params.py

@@ -0,0 +1,5 @@
+from fastapi import Request
+
+
+async def get_url_params(request: Request):
+    return dict(request.query_params)

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

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

packages/v1/administrativo/actions/t_biometria_pessoa/t_biometria_pessoa_delete_action.py

@@ -0,0 +1,39 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.t_biometria_pessoa.t_biometria_pessoa_delete_repository import (
+    TBiometriaPessoaDeleteRepository,
+)
+from packages.v1.administrativo.schemas.t_biometria_pessoa_schema import (
+    TBiometriaPessoaIdSchema,
+)
+
+
+class TBiometriaPessoaDeleteAction(BaseAction):
+    """
+    Serviço responsável por encapsular a lógica de negócio para a operação
+    de exclusão de um registro na tabela T_BIOMETRIA_PESSOA.
+    """
+
+    def execute(self, t_biometria_pessoa_id_schema: TBiometriaPessoaIdSchema):
+        """
+        Executa a operação de exclusão no banco de dados.
+
+        Args:
+            t_biometria_pessoa_id_schema (TBiometriaPessoaIdSchema):
+                O esquema contendo o ID do registro a ser excluído.
+
+        Returns:
+            O resultado da operação de exclusão.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        t_biometria_pessoa_delete_repository = TBiometriaPessoaDeleteRepository()
+
+        # ----------------------------------------------------
+        # Execução da exclusão
+        # ----------------------------------------------------
+        response = t_biometria_pessoa_delete_repository.execute(
+            t_biometria_pessoa_id_schema
+        )
+
+        return response

packages/v1/administrativo/actions/t_biometria_pessoa/t_biometria_pessoa_index_action.py

@@ -0,0 +1,42 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.t_biometria_pessoa.t_biometria_pessoa_index_repository import (
+    TBiometriaPessoaIndexRepository,
+)
+from packages.v1.administrativo.schemas.t_biometria_pessoa_schema import (
+    TBiometriaPessoaIndexSchema,
+)
+
+
+class TBiometriaPessoaIndexAction(BaseAction):
+    """
+    Serviço responsável por encapsular a lógica de negócio para a operação
+    de listagem de todos os registros na tabela G_NATUREZA_TITULO.
+    """
+
+    def execute(self, biometria_pessoa_index_schema: TBiometriaPessoaIndexSchema):
+        """
+        Executa a operação de listagem no banco de dados.
+
+        Args:
+            t_biometria_pessoa_index_schema (TBiometriaPessoaIndexSchema):
+                Esquema contendo parâmetros opcionais de filtro.
+
+        Returns:
+            A lista de registros encontrados.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        t_biometria_pessoa_index_repository = TBiometriaPessoaIndexRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = t_biometria_pessoa_index_repository.execute(
+            biometria_pessoa_index_schema
+        )
+
+        # ----------------------------------------------------
+        # Retorno da informação
+        # --------------------------------
+        return response

packages/v1/administrativo/actions/t_biometria_pessoa/t_biometria_pessoa_save_action.py

@@ -0,0 +1,42 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.t_biometria_pessoa.t_biometria_pessoa_save_repository import (
+    TBiometriaPessoaSaveRepository,
+)
+from packages.v1.administrativo.schemas.t_biometria_pessoa_schema import (
+    TBiometriaPessoaSaveSchema,
+)
+
+
+class TBiometriaPessoaSaveAction(BaseAction):
+    """
+    Serviço responsável por encapsular a lógica de negócio para a operação
+    de salvamento de um novo registro na tabela T_BIOMETRIA_PESSOA.
+    """
+
+    def execute(self, t_biometria_pessoa_save_schema: TBiometriaPessoaSaveSchema):
+        """
+        Executa a operação de salvamento.
+
+        Args:
+            t_biometria_pessoa_schema (TBiometriaPessoaSchema):
+                O esquema com os dados a serem persistidos.
+
+        Returns:
+            O resultado da operação de salvamento.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        t_biometria_pessoa_save_repository = TBiometriaPessoaSaveRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = t_biometria_pessoa_save_repository.execute(
+            t_biometria_pessoa_save_schema
+        )
+
+        # ----------------------------------------------------
+        # Retorno da informação
+        # ----------------------------------------------------
+        return response

packages/v1/administrativo/actions/t_biometria_pessoa/t_biometria_pessoa_show_action.py

@@ -0,0 +1,42 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.t_biometria_pessoa.t_biometria_pessoa_show_repository import (
+    TBiometriaPessoaShowRepository,
+)
+from packages.v1.administrativo.schemas.t_biometria_pessoa_schema import (
+    TBiometriaPessoaIdSchema,
+)
+
+
+class TBiometriaPessoaShowAction(BaseAction):
+    """
+    Serviço responsável por encapsular a lógica de negócio para a exibição
+    de um registro na tabela G_NATUREZA_TITULO.
+    """
+
+    def execute(self, t_biometria_pessoa_id_schema: TBiometriaPessoaIdSchema):
+        """
+        Executa a operação de exibição.
+
+        Args:
+            t_biometria_pessoa_id_schema (TBiometriaPessoaIdSchema):
+                O esquema com o ID do registro a ser exibido.
+
+        Returns:
+            O resultado da operação de exibição.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        t_biometria_pessoa_show_repository = TBiometriaPessoaShowRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = t_biometria_pessoa_show_repository.execute(
+            t_biometria_pessoa_id_schema
+        )
+
+        # ----------------------------------------------------
+        # Retorno da informação
+        # ----------------------------------------------------
+        return response

packages/v1/administrativo/actions/t_biometria_pessoa/t_biometria_pessoa_update_action.py

@@ -0,0 +1,42 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.t_biometria_pessoa.t_biometria_pessoa_update_repository import (
+    TBiometriaPessoaUpdateRepository,
+)
+from packages.v1.administrativo.schemas.t_biometria_pessoa_schema import (
+    TBiometriaPessoaUpdateSchema,
+)
+
+
+class TBiometriaPessoaUpdateAction(BaseAction):
+    """
+    Serviço responsável por encapsular a lógica de negócio para a atualização
+    de um registro na tabela G_NATUREZA_TITULO.
+    """
+
+    def execute(self, t_biometria_pessoa_update_schema: TBiometriaPessoaUpdateSchema):
+        """
+        Executa a operação de atualização.
+
+        Args:
+            t_biometria_pessoa_update_schema (TBiometriaPessoaUpdateSchema):
+                O esquema com os dados a serem atualizados.
+
+        Returns:
+            O resultado da operação de atualização.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório de atualização
+        # ----------------------------------------------------
+        t_biometria_pessoa_update_repository = TBiometriaPessoaUpdateRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = t_biometria_pessoa_update_repository.execute(
+            t_biometria_pessoa_update_schema
+        )
+
+        # ----------------------------------------------------
+        # Retorno do resultado
+        # ----------------------------------------------------
+        return response

packages/v1/administrativo/actions/t_servico_tipo/t_servico_tipo_index_action.py

@@ -1,5 +1,11 @@
 from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.t_servico_tipo.t_servico_tipo_index_repository import IndexRepository
+from packages.v1.administrativo.repositories.t_servico_tipo.t_servico_tipo_index_repository import (
+    IndexRepository,
+)
+from packages.v1.administrativo.schemas.t_servico_tipo_schema import (
+    TServicoTipoIndexSchema,
+)
+
 
 class IndexAction(BaseAction):
     """
@@ -7,7 +13,7 @@ class IndexAction(BaseAction):
     de listagem de todos os registros na tabela T_SERVICO_TIPO.
     """
 
-    def execute(self):
+    def execute(self, t_servico_tipo_index_schema: TServicoTipoIndexSchema):
         """
         Executa a operação de listagem no banco de dados.
 
@@ -18,7 +24,7 @@ class IndexAction(BaseAction):
         index_repository = IndexRepository()
 
         # Execução do repositório
-        response = index_repository.execute()
+        response = index_repository.execute(t_servico_tipo_index_schema)
 
         # Retorno da informação
         return response

packages/v1/administrativo/controllers/g_emolumento_controller.py

@@ -1,5 +1,6 @@
 from actions.dynamic_import.dynamic_import import DynamicImport
 from packages.v1.administrativo.schemas.g_emolumento_schema import (
+    GEmolumentoIndexSchema,
     GEmolumentoSaveSchema,
     GEmolumentoSistemaIdSchema,
     GEmolumentoUpdateSchema,
@@ -21,24 +22,6 @@ class GEmolumentoController:
         self.dynamic_import.set_package("administrativo")
         self.dynamic_import.set_table("g_emolumento")
 
-    # ----------------------------------------------------
-    # Lista todos os registros de G_EMOLUMENTO
-    # ----------------------------------------------------
-    def index(self):
-        # Importação da classe desejada
-        index_service = self.dynamic_import.service(
-            "g_emolumento_index_service", "GEmolumentoIndexService"
-        )
-
-        # Instância da classe service
-        self.index_service = index_service()
-
-        # Execução da listagem
-        return {
-            "message": "Registros de G_EMOLUMENTO localizados com sucesso.",
-            "data": self.index_service.execute(),
-        }
-
     # ----------------------------------------------------
     # Lista todos os registros de G_EMOLUMENTO
     # ----------------------------------------------------

packages/v1/administrativo/controllers/g_usuario_controller.py

@@ -1,6 +1,7 @@
 from fastapi import Request
 from actions.dynamic_import.dynamic_import import DynamicImport
 from packages.v1.administrativo.schemas.g_usuario_schema import (
+    GUsuarioIndexSchema,
     GUsuarioSchema,
     GUsuarioAuthenticateSchema,
     GUsuarioSaveSchema,
@@ -66,7 +67,7 @@ class GUsuarioController:
         }
 
     # Lista todos os usuários
-    def index(self):
+    def index(self, g_usuario_index_schema: GUsuarioIndexSchema):
 
         # Importação da classe desejada
         indexService = self.dynamic_import.service(
@@ -79,7 +80,7 @@ class GUsuarioController:
         # Lista todos os usuários
         return {
             "message": "Usuários localizados com sucesso",
-            "data": self.indexService.execute(),
+            "data": self.indexService.execute(g_usuario_index_schema),
         }
 
     # Busca um usuário especifico pelo ID

packages/v1/administrativo/controllers/t_biometria_pessoa_controller.py

@@ -0,0 +1,113 @@
+from actions.dynamic_import.dynamic_import import DynamicImport
+from packages.v1.administrativo.schemas.t_biometria_pessoa_schema import (
+    TBiometriaPessoaIndexSchema,
+    TBiometriaPessoaSaveSchema,
+    TBiometriaPessoaUpdateSchema,
+    TBiometriaPessoaIdSchema,
+)
+
+
+class TBiometriaPessoaController:
+    """
+    Controller responsável por orquestrar as operações CRUD da tabela T_BIOMETRIA_PESSOA,
+    utilizando carregamento dinâmico de serviços via DynamicImport.
+    """
+
+    def __init__(self):
+        # ----------------------------------------------------
+        # Inicialização do DynamicImport
+        # ----------------------------------------------------
+        self.dynamic_import = DynamicImport()
+        self.dynamic_import.set_package("administrativo")
+        self.dynamic_import.set_table("t_biometria_pessoa")
+
+    # ----------------------------------------------------
+    # Lista todos os registros de T_BIOMETRIA_PESSOA
+    # ----------------------------------------------------
+    def index(self, biometria_pessoa_index_schema: TBiometriaPessoaIndexSchema):
+
+        # Importação da classe desejada
+        index_service = self.dynamic_import.service(
+            "t_biometria_pessoa_index_service", "TBiometriaPessoaIndexService"
+        )
+
+        # Instância da classe service
+        self.index_service = index_service()
+
+        # Execução da listagem
+        return {
+            "message": "Registros de T_BIOMETRIA_PESSOA localizados com sucesso.",
+            "data": self.index_service.execute(biometria_pessoa_index_schema),
+        }
+
+    # ----------------------------------------------------
+    # Busca um registro específico de T_BIOMETRIA_PESSOA pelo ID
+    # ----------------------------------------------------
+    def show(self, t_biometria_pessoa_id_schema: TBiometriaPessoaIdSchema):
+        # Importação da classe desejada
+        show_service = self.dynamic_import.service(
+            "t_biometria_pessoa_show_service", "TBiometriaPessoaShowService"
+        )
+
+        # Instância da classe service
+        self.show_service = show_service()
+
+        # Execução da busca
+        return {
+            "message": "Registro de T_BIOMETRIA_PESSOA localizado com sucesso.",
+            "data": self.show_service.execute(t_biometria_pessoa_id_schema),
+        }
+
+    # ----------------------------------------------------
+    # Cadastra um novo registro em T_BIOMETRIA_PESSOA
+    # ----------------------------------------------------
+    def save(self, t_biometria_pessoa_save_schema: TBiometriaPessoaSaveSchema):
+        # Importação da classe desejada
+        save_service = self.dynamic_import.service(
+            "t_biometria_pessoa_save_service", "TBiometriaPessoaSaveService"
+        )
+
+        # Instância da classe service
+        self.save_service = save_service()
+
+        # Execução do salvamento
+        return {
+            "message": "Registro de T_BIOMETRIA_PESSOA salvo com sucesso.",
+            "data": self.save_service.execute(t_biometria_pessoa_save_schema),
+        }
+
+    # ----------------------------------------------------
+    # Atualiza um registro existente de T_BIOMETRIA_PESSOA
+    # ----------------------------------------------------
+    def update(self, t_biometria_pessoa_update_schema: TBiometriaPessoaUpdateSchema):
+        # Importação da classe desejada
+        update_service = self.dynamic_import.service(
+            "t_biometria_pessoa_update_service", "TBiometriaPessoaUpdateService"
+        )
+
+        # Instância da classe service
+        self.update_service = update_service()
+
+        # Execução da atualização
+        return {
+            "message": "Registro de T_BIOMETRIA_PESSOA atualizado com sucesso.",
+            "data": self.update_service.execute(t_biometria_pessoa_update_schema),
+        }
+
+    # ----------------------------------------------------
+    # Exclui um registro de T_BIOMETRIA_PESSOA
+    # ----------------------------------------------------
+    def delete(self, t_biometria_pessoa_id_schema: TBiometriaPessoaIdSchema):
+        # Importação da classe desejada
+        delete_service = self.dynamic_import.service(
+            "t_biometria_pessoa_delete_service", "TBiometriaPessoaDeleteService"
+        )
+
+        # Instância da classe service
+        self.delete_service = delete_service()
+
+        # Execução da exclusão
+        return {
+            "message": "Registro de T_BIOMETRIA_PESSOA removido com sucesso.",
+            "data": self.delete_service.execute(t_biometria_pessoa_id_schema),
+        }

packages/v1/administrativo/controllers/t_servico_tipo_controller.py

@@ -1,12 +1,13 @@
 from actions.dynamic_import.dynamic_import import DynamicImport
 from packages.v1.administrativo.schemas.t_servico_tipo_schema import (
-    TServicoTipoSchema,
+    TServicoTipoIndexSchema,
     TServicoTipoSaveSchema,
     TServicoTipoUpdateSchema,
     TServicoTipoIdSchema,
-    TServicoTipoDescricaoSchema
+    TServicoTipoDescricaoSchema,
 )
 
+
 class TServicoTipoController:
 
     def __init__(self):
@@ -21,93 +22,104 @@ class TServicoTipoController:
         pass
 
     # Lista todos os registros de servico tipo
-    def index(self):
+    def index(self, t_servico_tipo_index_schema: TServicoTipoIndexSchema):
 
         # Importação da classe desejada
-        indexService = self.dynamic_import.service("t_servico_tipo_index_service", "IndexService")
+        indexService = self.dynamic_import.service(
+            "t_servico_tipo_index_service", "IndexService"
+        )
 
         # Instância da classe service
         self.indexService = indexService()
 
         # Lista todos os registros de servico tipo
         return {
-            'message': 'Registros de servico tipo localizados com sucesso',
+            "message": "Registros de servico tipo localizados com sucesso",
-            'data': self.indexService.execute()
+            "data": self.indexService.execute(t_servico_tipo_index_schema),
         }
 
-    
     # Busca um registro de servico tipo específico pelo ID
     def show(self, servico_tipo_schema: TServicoTipoIdSchema):
 
         # Importação da classe desejada
-        show_service = self.dynamic_import.service('t_servico_tipo_show_service', 'ShowService')
+        show_service = self.dynamic_import.service(
+            "t_servico_tipo_show_service", "ShowService"
+        )
 
         # Instância da classe desejada
         self.show_service = show_service()
 
         # Busca e retorna o registro de servico tipo desejado
         return {
-            'message': 'Registro de servico tipo localizado com sucesso',
+            "message": "Registro de servico tipo localizado com sucesso",
-            'data': self.show_service.execute(servico_tipo_schema)
+            "data": self.show_service.execute(servico_tipo_schema),
         }
 
-
     # Busca um registro de servico tipo pela descrição
     def get_by_descricao(self, servico_tipo_schema: TServicoTipoDescricaoSchema):
 
         # Importação da classe desejada
-        show_service = self.dynamic_import.service('t_servico_tipo_get_by_descricao_service', 'GetByDescricaoService')
+        show_service = self.dynamic_import.service(
+            "t_servico_tipo_get_by_descricao_service", "GetByDescricaoService"
+        )
 
         # Instância da classe desejada
         self.show_service = show_service()
 
         # Busca e retorna o registro de servico tipo desejado
         return {
-            'message': 'Registro de servico tipo localizado com sucesso',
+            "message": "Registro de servico tipo localizado com sucesso",
-            'data': self.show_service.execute(servico_tipo_schema, True)
+            "data": self.show_service.execute(servico_tipo_schema, True),
         }
 
-    
     # Cadastra um novo registro de servico tipo
     def save(self, servico_tipo_schema: TServicoTipoSaveSchema):
 
         # Importação da classe desejada
-        save_service = self.dynamic_import.service('t_servico_tipo_save_service', 'SaveService')
+        save_service = self.dynamic_import.service(
+            "t_servico_tipo_save_service", "SaveService"
+        )
 
         # Instância da classe desejada
         self.save_service = save_service()
         # Busca e retorna o registro de servico tipo desejado
         return {
-            'message': 'Registro de servico tipo salvo com sucesso',
+            "message": "Registro de servico tipo salvo com sucesso",
-            'data': self.save_service.execute(servico_tipo_schema)
+            "data": self.save_service.execute(servico_tipo_schema),
         }
 
     # Atualiza os dados de um registro de servico tipo
-    def update(self, servico_tipo_id: int, servico_tipo_schema: TServicoTipoUpdateSchema):
+    def update(
+        self, servico_tipo_id: int, servico_tipo_schema: TServicoTipoUpdateSchema
+    ):
 
         # Importação da classe desejada
-        update_service = self.dynamic_import.service('t_servico_tipo_update_service', 'UpdateService')
+        update_service = self.dynamic_import.service(
+            "t_servico_tipo_update_service", "UpdateService"
+        )
 
         # Instância da classe desejada
         self.update_service = update_service()
 
         # Busca e retorna o registro de servico tipo desejado
         return {
-            'message': 'Registro de servico tipo atualizado com sucesso',
+            "message": "Registro de servico tipo atualizado com sucesso",
-            'data': self.update_service.execute(servico_tipo_id, servico_tipo_schema)
+            "data": self.update_service.execute(servico_tipo_id, servico_tipo_schema),
         }
 
     # Exclui um registro de servico tipo
     def delete(self, servico_tipo_schema: TServicoTipoIdSchema):
 
         # Importação da classe desejada
-        delete_service = self.dynamic_import.service('t_servico_tipo_delete_service', 'DeleteService')
+        delete_service = self.dynamic_import.service(
+            "t_servico_tipo_delete_service", "DeleteService"
+        )
 
         # Instância da classe desejada
         self.delete_service = delete_service()
 
         # Busca e retorna o registro de servico tipo desejado
         return {
-            'message': 'Registro de servico tipo removido com sucesso',
+            "message": "Registro de servico tipo removido com sucesso",
-            'data': self.delete_service.execute(servico_tipo_schema)
+            "data": self.delete_service.execute(servico_tipo_schema),
         }

packages/v1/administrativo/endpoints/g_emolumento_endpoint.py

@@ -1,10 +1,12 @@
 # Importação de bibliotecas
 from fastapi import APIRouter, Depends, status
+from actions.data.get_url_params import get_url_params
 from actions.jwt.get_current_user import get_current_user
 from packages.v1.administrativo.controllers.g_emolumento_controller import (
     GEmolumentoController,
 )
 from packages.v1.administrativo.schemas.g_emolumento_schema import (
+    GEmolumentoIndexSchema,
     GEmolumentoSaveSchema,
     GEmolumentoSistemaIdSchema,
     GEmolumentoUpdateSchema,
@@ -20,23 +22,6 @@ router = APIRouter()
 g_emolumento_controller = GEmolumentoController()
 
 
-# ----------------------------------------------------
-# Lista todos os registros de G_EMOLUMENTO
-# ----------------------------------------------------
-@router.get(
-    "/",
-    status_code=status.HTTP_200_OK,
-    summary="Lista todos os registros de G_EMOLUMENTO cadastrados",
-    response_description="Lista todos os registros de G_EMOLUMENTO cadastrados",
-)
-async def index(current_user: dict = Depends(get_current_user)):
-    """
-    Retorna todos os registros da tabela G_EMOLUMENTO.
-    """
-    response = g_emolumento_controller.index()
-    return response
-
-
 # ----------------------------------------------------
 # Lista todos os registros de G_EMOLUMENTO
 # ----------------------------------------------------
@@ -46,12 +31,19 @@ async def index(current_user: dict = Depends(get_current_user)):
     summary="Lista todos os registros de G_EMOLUMENTO cadastrados",
     response_description="Lista todos os registros de G_EMOLUMENTO cadastrados",
 )
-async def index(sistema_id: int, current_user: dict = Depends(get_current_user)):
+async def index(
+    sistema_id: int,
+    current_user: dict = Depends(get_current_user),
+    url_params=Depends(get_url_params),
+):
+
+    print(url_params)
+
     """
     Retorna todos os registros da tabela G_EMOLUMENTO.
     """
     response = g_emolumento_controller.indexBySistemaId(
-        GEmolumentoSistemaIdSchema(sistema_id=sistema_id)
+        GEmolumentoSistemaIdSchema(sistema_id=sistema_id, **url_params)
     )
     return response
 

packages/v1/administrativo/endpoints/g_usuario_endpoint.py

@@ -1,13 +1,13 @@
 # Importação de bibliotecas
-from typing import Optional
+from fastapi import APIRouter, Depends, status, Request
-from fastapi import APIRouter, Body, Depends, status, Request
+from actions.data.get_url_params import get_url_params
 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,
     GUsuarioAuthenticateSchema,
+    GUsuarioIndexSchema,
     GUsuarioSaveSchema,
     GUsuarioUpdateSchema,
     GUsuarioEmailSchema,
@@ -30,7 +30,7 @@ g_usuario_controller = GUsuarioController()
     summary="Cria o token de acesso do usuário",
     response_description="Retorna o token de acesso do usuário",
 )
-async def index(
+async def authenticate(
     request: Request, g_usuario_authenticate_schema: GUsuarioAuthenticateSchema
 ):
 
@@ -64,10 +64,12 @@ async def me(current_user: dict = Depends(get_current_user)):
     summary="Lista todos os usuário cadastrados",
     response_description="Lista todos os usuário cadastrados",
 )
-async def index(current_user: dict = Depends(get_current_user)):
+async def index(
+    current_user: dict = Depends(get_current_user), url_params=Depends(get_url_params)
+):
 
     # Busca todos os usuários cadastrados
-    response = g_usuario_controller.index()
+    response = g_usuario_controller.index(GUsuarioIndexSchema(**url_params))
 
     # Retorna os dados localizados
     return response

packages/v1/administrativo/endpoints/t_biometria_pessoa_endpoint.py

@@ -0,0 +1,125 @@
+# Importação de bibliotecas
+from fastapi import APIRouter, Depends, status
+from actions.jwt.get_current_user import get_current_user
+from packages.v1.administrativo.controllers.t_biometria_pessoa_controller import (
+    TBiometriaPessoaController,
+)
+from packages.v1.administrativo.schemas.t_biometria_pessoa_schema import (
+    TBiometriaPessoaSaveSchema,
+    TBiometriaPessoaUpdateSchema,
+    TBiometriaPessoaIdSchema,
+    TBiometriaPessoaIndexSchema,
+)
+
+# ----------------------------------------------------
+# Inicializa o roteador para as rotas da tabela T_BIOMETRIA_PESSOA
+# ----------------------------------------------------
+router = APIRouter()
+
+# Instanciamento do controller
+t_biometria_pessoa_controller = TBiometriaPessoaController()
+
+
+# ----------------------------------------------------
+# Lista todos os registros de T_BIOMETRIA_PESSOA
+# ----------------------------------------------------
+@router.get(
+    "/pessoa/{chave_id}",
+    status_code=status.HTTP_200_OK,
+    summary="Lista todos os registros de T_BIOMETRIA_PESSOA cadastrados",
+    response_description="Lista todos os registros de T_BIOMETRIA_PESSOA cadastrados",
+)
+async def index(chave_id: int, current_user: dict = Depends(get_current_user)):
+    """
+    Retorna todos os registros da tabela T_BIOMETRIA_PESSOA.
+    """
+    response = t_biometria_pessoa_controller.index(
+        TBiometriaPessoaIndexSchema(chave_id=chave_id)
+    )
+    return response
+
+
+# ----------------------------------------------------
+# Busca um registro específico de T_BIOMETRIA_PESSOA pelo ID
+# ----------------------------------------------------
+@router.get(
+    "/{biometria_pessoa_id}",
+    status_code=status.HTTP_200_OK,
+    summary="Busca um registro de T_BIOMETRIA_PESSOA pelo ID",
+    response_description="Busca um registro de T_BIOMETRIA_PESSOA em específico",
+)
+async def show(
+    biometria_pessoa_id: int, current_user: dict = Depends(get_current_user)
+):
+    """
+    Retorna um registro específico de T_BIOMETRIA_PESSOA com base no ID informado.
+    """
+    t_biometria_pessoa_id_schema = TBiometriaPessoaIdSchema(
+        biometria_pessoa_id=biometria_pessoa_id
+    )
+    response = t_biometria_pessoa_controller.show(t_biometria_pessoa_id_schema)
+    return response
+
+
+# ----------------------------------------------------
+# Cadastra um novo registro em T_BIOMETRIA_PESSOA
+# ----------------------------------------------------
+@router.post(
+    "/",
+    status_code=status.HTTP_201_CREATED,
+    summary="Cadastra um novo registro em T_BIOMETRIA_PESSOA",
+    response_description="Cadastra um novo registro em T_BIOMETRIA_PESSOA",
+)
+async def save(
+    t_biometria_pessoa_schema: TBiometriaPessoaSaveSchema,
+    current_user: dict = Depends(get_current_user),
+):
+    """
+    Cria um novo registro na tabela T_BIOMETRIA_PESSOA.
+    """
+    response = t_biometria_pessoa_controller.save(t_biometria_pessoa_schema)
+    return response
+
+
+# ----------------------------------------------------
+# Atualiza um registro existente de T_BIOMETRIA_PESSOA
+# ----------------------------------------------------
+@router.put(
+    "/{biometria_pessoa_id}",
+    status_code=status.HTTP_200_OK,
+    summary="Atualiza um registro existente em T_BIOMETRIA_PESSOA",
+    response_description="Atualiza um registro existente em T_BIOMETRIA_PESSOA",
+)
+async def update(
+    biometria_pessoa_id: int,
+    t_biometria_pessoa_update_schema: TBiometriaPessoaUpdateSchema,
+    current_user: dict = Depends(get_current_user),
+):
+    """
+    Atualiza um registro existente de T_BIOMETRIA_PESSOA com base no ID informado.
+    """
+    t_biometria_pessoa_update_schema.biometria_pessoa_id = biometria_pessoa_id
+    response = t_biometria_pessoa_controller.update(t_biometria_pessoa_update_schema)
+    return response
+
+
+# ----------------------------------------------------
+# Exclui um registro de T_BIOMETRIA_PESSOA
+# ----------------------------------------------------
+@router.delete(
+    "/{biometria_pessoa_id}",
+    status_code=status.HTTP_200_OK,
+    summary="Remove um registro de T_BIOMETRIA_PESSOA",
+    response_description="Remove um registro de T_BIOMETRIA_PESSOA",
+)
+async def delete(
+    biometria_pessoa_id: int, current_user: dict = Depends(get_current_user)
+):
+    """
+    Remove um registro específico de T_BIOMETRIA_PESSOA com base no ID informado.
+    """
+    t_biometria_pessoa_id_schema = TBiometriaPessoaIdSchema(
+        biometria_pessoa_id=biometria_pessoa_id
+    )
+    response = t_biometria_pessoa_controller.delete(t_biometria_pessoa_id_schema)
+    return response

packages/v1/administrativo/endpoints/t_servico_tipo_endpoint.py

@@ -1,13 +1,16 @@
 # Importação de bibliotecas
-from typing import Optional
+from fastapi import APIRouter, Depends, status
-from fastapi import APIRouter, Body, Depends, status
+from actions.data.get_url_params import get_url_params
 from actions.jwt.get_current_user import get_current_user
-from packages.v1.administrativo.controllers.t_servico_tipo_controller import TServicoTipoController
+from packages.v1.administrativo.controllers.t_servico_tipo_controller import (
+    TServicoTipoController,
+)
 from packages.v1.administrativo.schemas.t_servico_tipo_schema import (
+    TServicoTipoIndexSchema,
     TServicoTipoSchema,
     TServicoTipoSaveSchema,
     TServicoTipoUpdateSchema,
-    TServicoTipoIdSchema
+    TServicoTipoIdSchema,
 )
 
 # Inicializa o roteador para as rotas do tipo de serviço
@@ -16,26 +19,35 @@ router = APIRouter()
 # Instanciamento do controller desejado
 t_servico_tipo_controller = TServicoTipoController()
 
+
 # Lista todos os registros de servico tipo
-@router.get('/',
+@router.get(
+    "/",
     status_code=status.HTTP_200_OK,
-            summary='Lista todos os registros de servico tipo cadastrados',
+    summary="Lista todos os registros de servico tipo cadastrados",
-            response_description='Lista todos os registros de servico tipo cadastrados')
+    response_description="Lista todos os registros de servico tipo cadastrados",
-async def index(current_user: dict = Depends(get_current_user)):
+)
+async def index(
+    current_user: dict = Depends(get_current_user), url_params=Depends(get_url_params)
+):
 
     # Busca todos os registros de servico tipo cadastrados
-    response = t_servico_tipo_controller.index()
+    response = t_servico_tipo_controller.index(TServicoTipoIndexSchema(**url_params))
 
     # Retorna os dados localizados
     return response
 
 
 # Localiza um registro de servico tipo pela descrição
-@router.get('/descricao',
+@router.get(
+    "/descricao",
     status_code=status.HTTP_200_OK,
-            summary='Busca um registro de servico tipo em específico pela descrição',
+    summary="Busca um registro de servico tipo em específico pela descrição",
-            response_description='Busca um registro de servico tipo em específico')
+    response_description="Busca um registro de servico tipo em específico",
-async def get_by_descricao(descricao : str, current_user: dict = Depends(get_current_user)):
+)
+async def get_by_descricao(
+    descricao: str, current_user: dict = Depends(get_current_user)
+):
 
     # Cria o schema com os dados recebidos. Nota: Assumindo que TServicoTipoSchema pode ser usado para descrição na rota get.
     servico_tipo_schema = TServicoTipoSchema(descricao=descricao)
@@ -48,10 +60,12 @@ async def get_by_descricao(descricao : str, current_user: dict = Depends(get_cur
 
 
 # Localiza um registro de servico tipo pelo ID
-@router.get('/{servico_tipo_id}',
+@router.get(
+    "/{servico_tipo_id}",
     status_code=status.HTTP_200_OK,
-            summary='Busca um registro de servico tipo em específico pelo ID',
+    summary="Busca um registro de servico tipo em específico pelo ID",
-            response_description='Busca um registro de servico tipo em específico')
+    response_description="Busca um registro de servico tipo em específico",
+)
 async def show(servico_tipo_id: int, current_user: dict = Depends(get_current_user)):
 
     # Cria o schema com os dados recebidos
@@ -65,11 +79,16 @@ async def show(servico_tipo_id : int, current_user: dict = Depends(get_current_u
 
 
 # Cadastro de registro de servico tipo
-@router.post('/',
+@router.post(
+    "/",
     status_code=status.HTTP_201_CREATED,
-            summary='Cadastra um registro de servico tipo',
+    summary="Cadastra um registro de servico tipo",
-            response_description='Cadastra um registro de servico tipo')
+    response_description="Cadastra um registro de servico tipo",
-async def save(servico_tipo_schema: TServicoTipoSaveSchema, current_user: dict = Depends(get_current_user)):
+)
+async def save(
+    servico_tipo_schema: TServicoTipoSaveSchema,
+    current_user: dict = Depends(get_current_user),
+):
 
     # Efetua o cadastro no banco de dados
     response = t_servico_tipo_controller.save(servico_tipo_schema)
@@ -79,11 +98,17 @@ async def save(servico_tipo_schema: TServicoTipoSaveSchema, current_user: dict =
 
 
 # Atualiza os dados de um registro de servico tipo
-@router.put('/{servico_tipo_id}',
+@router.put(
+    "/{servico_tipo_id}",
     status_code=status.HTTP_200_OK,
-            summary='Atualiza um registro de servico tipo',
+    summary="Atualiza um registro de servico tipo",
-            response_description='Atualiza um registro de servico tipo')
+    response_description="Atualiza um registro de servico tipo",
-async def update(servico_tipo_id: int, servico_tipo_schema: TServicoTipoUpdateSchema, current_user: dict = Depends(get_current_user)):
+)
+async def update(
+    servico_tipo_id: int,
+    servico_tipo_schema: TServicoTipoUpdateSchema,
+    current_user: dict = Depends(get_current_user),
+):
 
     # Efetua a atualização dos dados
     response = t_servico_tipo_controller.update(servico_tipo_id, servico_tipo_schema)
@@ -91,11 +116,14 @@ async def update(servico_tipo_id: int, servico_tipo_schema: TServicoTipoUpdateSc
     # Retorna os dados localizados
     return response
 
+
 # Exclui um determinado registro de servico tipo
-@router.delete('/{servico_tipo_id}',
+@router.delete(
+    "/{servico_tipo_id}",
     status_code=status.HTTP_200_OK,
-            summary='Remove um registro de servico tipo',
+    summary="Remove um registro de servico tipo",
-            response_description='Remove um registro de servico tipo')
+    response_description="Remove um registro de servico tipo",
+)
 async def delete(servico_tipo_id: int, current_user: dict = Depends(get_current_user)):
 
     # Cria o schema com os dados recebidos

packages/v1/administrativo/repositories/g_emolumento/g_emolumento_index_by_sistema_id_repository.py

@@ -21,10 +21,26 @@ class GEmolumentoIndexBySistemaIdRepository(BaseRepository):
         sql = """ SELECT
                     GE.*
                   FROM G_EMOLUMENTO GE
-                  WHERE GE.SISTEMA_ID = :sistema_id
             """
 
-        params = {"sistema_id": g_emolumento_sistema_id.sistema_id}
+        # lista de condições
+        where = []
+
+        # Verifica se deve filtrar a pesquisa
+        if getattr(g_emolumento_sistema_id, "sistema_id", None):
+
+            where.append("GE.SISTEMA_ID = :sistema_id")
+
+        # Verifica se deve filtrar a pesquisa
+        if getattr(g_emolumento_sistema_id, "situacao", None):
+
+            where.append("GE.SITUACAO LIKE :situacao")
+
+        if where:
+
+            sql += " WHERE " + " AND ".join(where)
+
+        params = g_emolumento_sistema_id.model_dump(exclude_unset=True)
 
         # Execução do sql
         response = self.fetch_all(sql, params)

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

@@ -1,14 +1,37 @@
 from abstracts.repository import BaseRepository
+from packages.v1.administrativo.controllers.g_usuario_controller import (
+    GUsuarioIndexSchema,
+)
+
 
 class IndexRepository(BaseRepository):
 
-    def execute(self):
+    def execute(self, g_usuario_index_schema: GUsuarioIndexSchema):
 
         # Montagem do sql
-        sql = """ SELECT * FROM g_usuario """
+        sql = "SELECT GU.* FROM G_USUARIO GU"
+
+        # lista de condições
+        where = []
+
+        # Verifica se deve filtrar a pesquisa
+        if getattr(g_usuario_index_schema, "assina", None):
+
+            where.append("GU.ASSINA LIKE :assina")
+
+        # Verifica se deve filtrar a pesquisa
+        if getattr(g_usuario_index_schema, "situacao", None):
+
+            where.append("GU.SITUACAO LIKE :situacao")
+
+        if where:
+            sql += " WHERE " + " AND ".join(where)
+
+        # Preenchimento de valores
+        params = g_usuario_index_schema.model_dump(exclude_unset=True)
 
         # Execução do sql
-        response = self.fetch_all(sql)
+        response = self.fetch_all(sql, params)
 
         # Retorna os dados localizados
         return response

packages/v1/administrativo/repositories/t_biometria_pessoa/t_biometria_pessoa_delete_repository.py

@@ -0,0 +1,49 @@
+from abstracts.repository import BaseRepository
+from fastapi import HTTPException, status
+
+from packages.v1.administrativo.schemas.t_biometria_pessoa_schema import (
+    TBiometriaPessoaIdSchema,
+)
+
+
+class TBiometriaPessoaDeleteRepository(BaseRepository):
+    """
+    Repositório responsável pela exclusão de registros na tabela
+    G_GRAMATICA.
+    """
+
+    def execute(self, t_biometria_pessoa_id_schema: TBiometriaPessoaIdSchema):
+        """
+        Executa a exclusão de um registro específico da tabela G_GRAMATICA
+        com base no ID informado.
+
+        Args:
+            t_biometria_pessoa_id_schema (TBiometriaPessoaIdSchema): Esquema contendo o ID do registro a ser excluído.
+
+        Returns:
+            O resultado da operação de exclusão.
+        """
+        try:
+            # Montagem do SQL
+            sql = """
+                DELETE FROM T_BIOMETRIA_PESSOA GG
+                WHERE GG.BIOMETRIA_PESSOA_ID = :biometria_pessoa_id
+            """
+
+            # Preenchimento dos parâmetros
+            params = {
+                "biometria_pessoa_id": t_biometria_pessoa_id_schema.biometria_pessoa_id
+            }
+
+            # Execução da instrução SQL
+            response = self.run(sql, params)
+
+            # Retorna o resultado da exclusão
+            return response
+
+        except Exception as e:
+            # Lança exceção HTTP em caso de erro
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail=f"Erro ao excluir registro de G_GRAMATICA: {e}",
+            )

packages/v1/administrativo/repositories/t_biometria_pessoa/t_biometria_pessoa_index_repository.py

@@ -0,0 +1,35 @@
+from typing import List
+from abstracts.repository import BaseRepository
+from packages.v1.administrativo.schemas.t_biometria_pessoa_schema import (
+    TBiometriaPessoaIndexSchema,
+    TBiometriaPessoaResponseSchema,
+)
+
+
+class TBiometriaPessoaIndexRepository(BaseRepository):
+    """
+    Repositório para a operação de listagem de todos os registros
+    na tabela t_censec_qualidade.
+    """
+
+    def execute(self, biometria_pessoa_index_schema: TBiometriaPessoaIndexSchema):
+        """
+        Executa a consulta SQL para buscar todos os registros.
+
+        Returns:
+            Uma lista de dicionários contendo os dados dos registros.
+        """
+        # Montagem do SQL
+        sql = """ SELECT
+                    tbp.BIOMETRIA_PESSOA_ID
+                  FROM T_BIOMETRIA_PESSOA TBP
+                  WHERE TBP.CHAVE_ID = :chave_id
+            """
+
+        params = {"chave_id": biometria_pessoa_index_schema.chave_id}
+
+        # Execução do sql
+        response = self.fetch_all(sql, params)
+
+        # Retorna os dados localizados
+        return response

packages/v1/administrativo/repositories/t_biometria_pessoa/t_biometria_pessoa_save_repository.py

@@ -0,0 +1,52 @@
+from fastapi import HTTPException, status
+from abstracts.repository import BaseRepository
+from actions.data.generate_insert_sql import generate_insert_sql
+from packages.v1.administrativo.schemas.t_biometria_pessoa_schema import (
+    TBiometriaPessoaSaveSchema,
+)
+
+
+class TBiometriaPessoaSaveRepository(BaseRepository):
+    """
+    Repositório responsável pela operação de salvamento de um novo registro
+    na tabela G_GRAMATICA.
+    """
+
+    def execute(self, t_biometria_pessoa_save_schema: TBiometriaPessoaSaveSchema):
+        """
+        Executa a operação de salvamento no banco de dados.
+
+        Args:
+            t_biometria_pessoa_save_schema (TBiometriaPessoaSchema): O esquema com os dados a serem salvos.
+
+        Returns:
+            O registro recém-criado.
+
+        Raises:
+            HTTPException: Caso ocorra um erro na execução da query.
+        """
+        try:
+
+            # ----------------------------------------------------
+            # Preenchimento dos parâmetros
+            # ----------------------------------------------------
+            params = t_biometria_pessoa_save_schema.model_dump(exclude_unset=True)
+
+            # ----------------------------------------------------
+            # Montagem do SQL dinâmico
+            # ----------------------------------------------------
+            sql = generate_insert_sql("T_BIOMETRIA_PESSOA", params)
+
+            # ----------------------------------------------------
+            # Execução do SQL e retorno do registro
+            # ----------------------------------------------------
+            return self.run_and_return(sql, params)
+
+        except Exception as e:
+            # ----------------------------------------------------
+            # Tratamento de erros e lançamento de exceção HTTP
+            # ----------------------------------------------------
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail=f"Erro ao salvar registro em T_BIOMETRIA_PESSOA: {e}",
+            )

packages/v1/administrativo/repositories/t_biometria_pessoa/t_biometria_pessoa_show_repository.py

@@ -0,0 +1,69 @@
+from abstracts.repository import BaseRepository
+from fastapi import HTTPException, status
+
+from packages.v1.administrativo.schemas.t_biometria_pessoa_schema import (
+    TBiometriaPessoaIdSchema,
+)
+
+
+class TBiometriaPessoaShowRepository(BaseRepository):
+    """
+    Repositório responsável pela operação de exibição de um registro
+    na tabela G_GRAMATICA.
+    """
+
+    def execute(self, t_biometria_pessoa_id_schema: TBiometriaPessoaIdSchema):
+        """
+        Busca um registro específico de G_GRAMATICA pelo ID.
+
+        Args:
+            t_biometria_pessoa_id_schema (TBiometriaPessoaIdSchema):
+                Esquema contendo o ID do registro a ser buscado.
+
+        Returns:
+            O registro encontrado ou levanta exceção HTTP 404 se não existir.
+
+        Raises:
+            HTTPException: Caso ocorra um erro na execução da query.
+        """
+        try:
+            # ----------------------------------------------------
+            # Montagem do SQL
+            # ----------------------------------------------------
+            sql = """
+                SELECT *
+                FROM T_BIOMETRIA_PESSOA GG
+                WHERE GG.BIOMETRIA_PESSOA_ID = :biometria_pessoa_id
+            """
+
+            # ----------------------------------------------------
+            # Preenchimento de parâmetros
+            # ----------------------------------------------------
+            params = t_biometria_pessoa_id_schema.model_dump(exclude_unset=True)
+
+            # ----------------------------------------------------
+            # Execução do SQL
+            # ----------------------------------------------------
+            result = self.fetch_one(sql, params)
+
+            # ----------------------------------------------------
+            # Validação de retorno
+            # ----------------------------------------------------
+            if not result:
+                raise HTTPException(
+                    status_code=status.HTTP_404_NOT_FOUND,
+                    detail="Registro de T_BIOMETRIA_PESSOA não encontrado.",
+                )
+
+            return result
+
+        except HTTPException:
+            # Repassa exceções HTTP explícitas (como 404)
+            raise
+
+        except Exception as e:
+            # Captura falhas inesperadas de execução
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail=f"Erro ao buscar registro em G_GRAMATICA: {e}",
+            )

packages/v1/administrativo/repositories/t_biometria_pessoa/t_biometria_pessoa_update_repository.py

@@ -0,0 +1,63 @@
+from abstracts.repository import BaseRepository
+from actions.data.prepare_update_data import prepare_update_data
+from fastapi import HTTPException, status
+
+from packages.v1.administrativo.schemas.t_biometria_pessoa_schema import (
+    TBiometriaPessoaUpdateSchema,
+)
+
+
+class TBiometriaPessoaUpdateRepository(BaseRepository):
+    """
+    Repositório responsável pela operação de atualização de registros
+    na tabela T_BIOMETRIA_PESSOA.
+    """
+
+    def execute(self, t_biometria_pessoa_update_schema: TBiometriaPessoaUpdateSchema):
+        """
+        Atualiza um registro existente na tabela T_BIOMETRIA_PESSOA.
+
+        Args:
+            t_biometria_pessoa_update_schema (TBiometriaPessoaUpdateSchema):
+                Esquema contendo os dados a serem atualizados.
+
+        Returns:
+            O registro atualizado (via RETURNING *).
+
+        Raises:
+            HTTPException: Caso ocorra um erro na execução do SQL.
+        """
+        try:
+            # ----------------------------------------------------
+            # Prepara parâmetros e colunas de atualização dinâmicas
+            # ----------------------------------------------------
+            params, update_columns = prepare_update_data(
+                t_biometria_pessoa_update_schema,
+                exclude_fields=["biometria_pessoa_id"],
+                id_field="biometria_pessoa_id",
+            )
+
+            # ----------------------------------------------------
+            # Montagem do SQL dinâmico
+            # ----------------------------------------------------
+            sql = f"""
+                UPDATE T_BIOMETRIA_PESSOA
+                SET {update_columns}
+                WHERE BIOMETRIA_PESSOA_ID = :biometria_pessoa_id
+                RETURNING *;
+            """
+
+            # ----------------------------------------------------
+            # Execução e retorno do registro atualizado
+            # ----------------------------------------------------
+            response = self.run_and_return(sql, params)
+            return response
+
+        except Exception as e:
+            # ----------------------------------------------------
+            # Tratamento de exceção e retorno HTTP padronizado
+            # ----------------------------------------------------
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail=f"Erro ao atualizar registro em T_BIOMETRIA_PESSOA: {str(e)}",
+            )

packages/v1/administrativo/repositories/t_servico_tipo/t_servico_tipo_index_repository.py

@@ -1,4 +1,8 @@
 from abstracts.repository import BaseRepository
+from packages.v1.administrativo.controllers.t_servico_tipo_controller import (
+    TServicoTipoIndexSchema,
+)
+
 
 class IndexRepository(BaseRepository):
     """
@@ -6,19 +10,27 @@ class IndexRepository(BaseRepository):
     na tabela T_SERVICO_TIPO.
     """
 
-    def execute(self):
+    def execute(self, t_servico_tipo_index_schema: TServicoTipoIndexSchema):
-        """
-        Executa a consulta SQL para buscar todos os registros.
 
-        Returns:
+        # Montagem do sql
-            Uma lista de dicionários contendo os dados dos registros.
+        sql = "SELECT TST.* FROM T_SERVICO_TIPO TST"
-        """
+
-        # Montagem do SQL
+        # lista de condições
-        # Tabela ajustada para T_SERVICO_TIPO
+        where = []
-        sql = """ SELECT * FROM T_SERVICO_TIPO """
+
+        # Verifica se deve filtrar a pesquisa
+        if getattr(t_servico_tipo_index_schema, "situacao", None):
+
+            where.append("TST.SITUACAO LIKE :situacao")
+
+        if where:
+            sql += " WHERE " + " AND ".join(where)
+
+        # Preenchimento de valores
+        params = t_servico_tipo_index_schema.model_dump(exclude_unset=True)
 
         # Execução do sql
-        response = self.fetch_all(sql)
+        response = self.fetch_all(sql, params)
 
         # Retorna os dados localizados
         return response

packages/v1/administrativo/schemas/g_emolumento_schema.py

@@ -3,6 +3,11 @@ from pydantic import BaseModel
 from typing import Optional
 
 
+class GEmolumentoIndexSchema(BaseModel):
+    class Config:
+        extra = "allow"
+
+
 # ----------------------------------------------------
 # Schema base - representa a tabela G_EMOLUMENTO
 # ----------------------------------------------------
@@ -47,6 +52,7 @@ class GEmolumentoSistemaIdSchema(BaseModel):
 
     class Config:
         from_attributes = True
+        extra = "allow"
 
 
 # ----------------------------------------------------

packages/v1/administrativo/schemas/g_gramatica_schema.py

@@ -1,6 +1,7 @@
 from pydantic import BaseModel
 from typing import Optional
 
+
 # ----------------------------------------------------
 # Schema base - representa a tabela G_GRAMATICA
 # ----------------------------------------------------

packages/v1/administrativo/schemas/g_usuario_schema.py

@@ -15,6 +15,15 @@ from actions.validations.email import Email
 # Funções para validar cpf
 from actions.validations.cpf import CPF
 
+
+# ----------------------------------------------------
+# Schema base
+# ----------------------------------------------------
+class GUsuarioIndexSchema(BaseModel):
+    class Config:
+        extra = "allow"  # permite parâmetros dinâmicos
+
+
 # ----------------------------------------------------
 # Schema base
 # ----------------------------------------------------
@@ -66,30 +75,28 @@ class GUsuarioAuthenticateSchema(BaseModel):
     senha_api: str  # senha_api obrigatório
 
     # Validação e sanitização do login
-    @field_validator('login')
+    @field_validator("login")
     def validar_e_sanitizar_login(cls, v):
 
         # Verifica se o login foi informado
         if not v:
 
             raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
+                status_code=status.HTTP_400_BAD_REQUEST, detail="Informe o login"
-                detail='Informe o login'
             )
 
         # Sanitiza o login para evitar XSS e SQL Injection
         return Text.sanitize_input(v)
 
     # Validação e sanitização da senha
-    @field_validator('senha_api')
+    @field_validator("senha_api")
     def validar_e_sanitizar_senha(cls, v):
 
         # Verifica se a senha foi informada
         if not v:
 
             raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
+                status_code=status.HTTP_400_BAD_REQUEST, detail="Informe a senha"
-                detail='Informe a senha'
             )
 
         # Sanitiza a senha para evitar XSS e SQL Injection
@@ -121,7 +128,7 @@ class GUsuarioSaveSchema(BaseModel):
     senha_api: str
 
     # Sanitiza os inputs enviados
-    @field_validator('login', 'email', 'cpf', 'situacao', 'nome_completo', 'funcao')
+    @field_validator("login", "email", "cpf", "situacao", "nome_completo", "funcao")
     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.
@@ -131,7 +138,7 @@ class GUsuarioSaveSchema(BaseModel):
         return Text.sanitize_input(v)
 
     # Verifica se os campos foram enviados
-    @model_validator(mode='after')
+    @model_validator(mode="after")
     def validate_all_fields(self):
 
         # Variavel responsavel em armaezar os erros
@@ -139,31 +146,33 @@ class GUsuarioSaveSchema(BaseModel):
 
         # Validação do login
         if not self.login or len(self.login.strip()) == 0:
-            errors.append({'input': 'login', 'message': 'O login é obrigatório.'})
+            errors.append({"input": "login", "message": "O login é obrigatório."})
 
         # Validação da situação
         if not self.situacao or len(self.situacao.strip()) == 0:
-            errors.append({'input': 'situacao', 'message': 'A situação é obrigatória.'})
+            errors.append({"input": "situacao", "message": "A situação é obrigatória."})
 
         # Validação do nome_completo
         if not self.nome_completo or len(self.nome_completo.strip()) == 0:
-            errors.append({'input': 'nome_completo', 'message': 'O nome completo é obrigatório.'})
+            errors.append(
+                {"input": "nome_completo", "message": "O nome completo é obrigatório."}
+            )
 
         # Validação da função
         if not self.funcao or len(self.funcao.strip()) == 0:
-            errors.append({'input': 'funcao', 'message': 'A função é obrigatória.'})
+            errors.append({"input": "funcao", "message": "A função é obrigatória."})
 
         # Validação do email
         if not self.email or len(self.email.strip()) == 0:
-            errors.append({'input': 'email', 'message': 'O e-mail é obrigatório.'})
+            errors.append({"input": "email", "message": "O e-mail é obrigatório."})
 
         # Validação do cpf
         if not self.cpf or len(self.cpf.strip()) == 0:
-            errors.append({'input': 'cpf', 'message': 'O CPF é obrigatório.'})
+            errors.append({"input": "cpf", "message": "O CPF é obrigatório."})
 
         # Validação da senha
         if not self.senha_api or len(self.senha_api.strip()) == 0:
-            errors.append({'input': 'senha_api', 'message': 'A senha é obrigatória.'})
+            errors.append({"input": "senha_api", "message": "A senha é obrigatória."})
 
         # Criptografa a senha
         self.senha_api = Security.hash_senha_api(self.senha_api)
@@ -173,8 +182,7 @@ class GUsuarioSaveSchema(BaseModel):
             # 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,
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=errors
-                detail=errors
             )
 
         return self
@@ -195,7 +203,7 @@ class GUsuarioUpdateSchema(BaseModel):
     senha_api: Optional[str] = None
 
     # Sanitiza os inputs enviados
-    @field_validator('login', 'email', 'cpf', 'situacao', 'nome_completo', 'funcao')
+    @field_validator("login", "email", "cpf", "situacao", "nome_completo", "funcao")
     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.
@@ -205,7 +213,7 @@ class GUsuarioUpdateSchema(BaseModel):
         return Text.sanitize_input(v)
 
     # Verifica se os campos foram enviados
-    @model_validator(mode='after')
+    @model_validator(mode="after")
     def validate_all_fields(self):
 
         # Variavel responsavel em armaezar os erros
@@ -213,39 +221,40 @@ class GUsuarioUpdateSchema(BaseModel):
 
         # Validação do login
         if not self.login or len(self.login.strip()) == 0:
-            errors.append({'input': 'login', 'message': 'O login é obrigatório.'})
+            errors.append({"input": "login", "message": "O login é obrigatório."})
 
         # Validação da situação
         if not self.situacao or len(self.situacao.strip()) == 0:
-            errors.append({'input': 'situacao', 'message': 'A situação é obrigatória.'})
+            errors.append({"input": "situacao", "message": "A situação é obrigatória."})
 
         # Validação do nome_completo
         if not self.nome_completo or len(self.nome_completo.strip()) == 0:
-            errors.append({'input': 'nome_completo', 'message': 'O nome completo é obrigatório.'})
+            errors.append(
+                {"input": "nome_completo", "message": "O nome completo é obrigatório."}
+            )
 
         # Validação da função
         if not self.funcao or len(self.funcao.strip()) == 0:
-            errors.append({'input': 'funcao', 'message': 'A função é obrigatória.'})
+            errors.append({"input": "funcao", "message": "A função é obrigatória."})
 
         # Validação do email
         if not self.email or len(self.email.strip()) == 0:
-            errors.append({'input': 'email', 'message': 'O e-mail é obrigatório.'})
+            errors.append({"input": "email", "message": "O e-mail é obrigatório."})
 
         # Validação do cpf
         if not self.cpf or len(self.cpf.strip()) == 0:
-            errors.append({'input': 'cpf', 'message': 'O CPF é obrigatório.'})
+            errors.append({"input": "cpf", "message": "O CPF é obrigatório."})
 
         # Validação da senha
         if not self.senha_api or len(self.senha_api.strip()) == 0:
-            errors.append({'input': 'senha_api', 'message': 'A senha é obrigatória.'})
+            errors.append({"input": "senha_api", "message": "A senha é obrigatória."})
 
         # 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,
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=errors
-                detail=errors
             )
 
         return self
@@ -259,7 +268,7 @@ class GUsuarioEmailSchema(BaseModel):
     email: Optional[EmailStr] = None
 
     # Sanitiza o input
-    @field_validator('email')
+    @field_validator("email")
     def sanitize_email(cls, v):
         # A sanitização é feita apenas se o valor não for None ou vazio
         if v:
@@ -267,23 +276,23 @@ class GUsuarioEmailSchema(BaseModel):
         return v
 
     # Verifica se o e-mail é válido
-    @field_validator('email')
+    @field_validator("email")
     def check_email(cls, v):
         # A verificação é feita apenas se o valor não for None ou vazio
         if not Email.is_valid_email(v):
             raise HTTPException(
                 status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                detail='Informe um e-mail válido'
+                detail="Informe um e-mail válido",
             )
         return v
 
     # Valida se o campo não está vazio
-    @model_validator(mode='after')
+    @model_validator(mode="after")
     def validate_email(self):
         if not self.email or len(self.email.strip()) == 0:
             raise HTTPException(
                 status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                detail='Informe um e-mail'
+                detail="Informe um e-mail",
             )
         return self
 
@@ -299,7 +308,7 @@ class GUsuarioCpfSchema(BaseModel):
     cpf: Optional[str] = None
 
     # Sanitiza o input
-    @field_validator('cpf')
+    @field_validator("cpf")
     def sanitize_cpf(cls, v):
         # A sanitização é feita apenas se o valor não for None ou vazio
         if v:
@@ -307,23 +316,23 @@ class GUsuarioCpfSchema(BaseModel):
         return v
 
     # Verifica se o e-mail é válido
-    @field_validator('cpf')
+    @field_validator("cpf")
     def check_email(cls, v):
         # A verificação é feita apenas se o valor não for None ou vazio
         if not CPF.is_valid_cpf(v):
             raise HTTPException(
                 status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                detail='Informe um CPF válido'
+                detail="Informe um CPF válido",
             )
         return v
 
     # Valida se o campo não está vazio
-    @model_validator(mode='after')
+    @model_validator(mode="after")
     def validate_cpf(self):
         if not self.cpf or len(self.cpf.strip()) == 0:
             raise HTTPException(
                 status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                detail='Informe um CPF'
+                detail="Informe um CPF",
             )
         return self
 
@@ -339,7 +348,7 @@ class GUsuarioLoginSchema(BaseModel):
     login: Optional[str] = None
 
     # Sanitiza o input
-    @field_validator('login')
+    @field_validator("login")
     def sanitize_login(cls, v):
         # A sanitização é feita apenas se o valor não for None ou vazio
         if v:
@@ -347,12 +356,12 @@ class GUsuarioLoginSchema(BaseModel):
         return v
 
     # Valida se o campo não está vazio
-    @model_validator(mode='after')
+    @model_validator(mode="after")
     def validate_login(self):
         if not self.login or len(self.login.strip()) == 0:
             raise HTTPException(
                 status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                detail='Informe um Login'
+                detail="Informe um Login",
             )
         return self
 

packages/v1/administrativo/schemas/t_biometria_pessoa_schema.py

@@ -0,0 +1,80 @@
+from datetime import datetime
+from decimal import Decimal
+from pydantic import BaseModel
+from typing import Optional, List
+
+
+# ----------------------------------------------------
+# Schema base - representa a tabela de Biometria
+# ----------------------------------------------------
+class TBiometriaPessoaSchema(BaseModel):
+    biometria_pessoa_id: Optional[Decimal] = None
+    digital_id: Optional[Decimal] = None
+    objeto: Optional[str] = None
+    chave_id: Optional[Decimal] = None
+    imagem_biometria: Optional[str] = None
+    objeto_backup: Optional[str] = None
+    objeto_strig_normal: Optional[str] = None
+    leitorbiometrico: Optional[str] = None
+    data_coleta: Optional[datetime] = None
+    pessoa_id: Optional[Decimal] = None
+
+    class Config:
+        from_attributes = True
+
+
+# ----------------------------------------------------
+# Schema para localizar um registro pelo ID (GET /{id})
+# ----------------------------------------------------
+class TBiometriaPessoaResponseSchema(BaseModel):
+    biometria_pessoa_id: Optional[Decimal] = None
+    digital_id: Optional[Decimal] = None
+    objeto: Optional[str] = None
+    chave_id: Optional[Decimal] = None
+    imagem_biometria: Optional[str] = None
+    objeto_backup: Optional[str] = None
+    objeto_strig_normal: Optional[str] = None
+    leitorbiometrico: Optional[str] = None
+    data_coleta: Optional[datetime] = None
+    pessoa_id: Optional[Decimal] = None
+
+    class Config:
+        from_attributes = True
+
+
+# ----------------------------------------------------
+# Schema para localizar um registro pelo ID (GET /{id})
+# ----------------------------------------------------
+class TBiometriaPessoaIndexSchema(BaseModel):
+    chave_id: Decimal
+
+    class Config:
+        from_attributes = True
+
+
+# ----------------------------------------------------
+# Schema para localizar um registro pelo ID (GET /{id})
+# ----------------------------------------------------
+class TBiometriaPessoaIdSchema(BaseModel):
+    biometria_pessoa_id: Decimal
+
+    class Config:
+        from_attributes = True
+
+
+# ----------------------------------------------------
+# Schema para criação (POST)
+# ----------------------------------------------------
+class TBiometriaPessoaSaveSchema(TBiometriaPessoaSchema):
+
+    class Config:
+        from_attributes = True
+
+
+# ----------------------------------------------------
+# Schema para atualização (PUT)
+# ----------------------------------------------------
+class TBiometriaPessoaUpdateSchema(TBiometriaPessoaSchema):
+
+    class Config:
+        from_attributes = True

packages/v1/administrativo/schemas/t_servico_tipo_schema.py

@@ -7,6 +7,15 @@ from decimal import Decimal
 # Assumindo que a classe Text está disponível no caminho 'actions.validations.text'
 from actions.validations.text import Text
 
+
+# ----------------------------------------------------
+# Schema base
+# ----------------------------------------------------
+class TServicoTipoIndexSchema(BaseModel):
+    class Config:
+        extra = "allow"  # permite parâmetros dinâmicos
+
+
 # ----------------------------------------------------
 # Schema base
 # ----------------------------------------------------
@@ -107,13 +116,34 @@ class TServicoTipoSaveSchema(BaseModel):
 
     # Sanitização dos campos string (para prevenir XSS e entradas inválidas)
     @field_validator(
-        'descricao', 'tipo_item', 'requer_autorizacao', 'requer_biometria',
+        "descricao",
-        'tipo_pessoa', 'tipo_permissao_cpf', 'requer_abonador', 'requer_representante',
+        "tipo_item",
-        'situacao', 'requer_cpf', 'servico_padrao', 'alterar_valor', 'lancar_taxa',
+        "requer_autorizacao",
-        'lancar_fundesp', 'liberar_desconto', 'fundesp_automatica',
+        "requer_biometria",
-        'lancar_valor_documento', 'valor_fixo', 'ato_praticado', 'selar',
+        "tipo_pessoa",
-        'frenteverso', 'pagina_acrescida', 'apresentante_selo', 'renovacao_cartao',
+        "tipo_permissao_cpf",
-        'etiqueta_unica', 'transferencia_veiculo', 'usar_a4', 'averbacao'
+        "requer_abonador",
+        "requer_representante",
+        "situacao",
+        "requer_cpf",
+        "servico_padrao",
+        "alterar_valor",
+        "lancar_taxa",
+        "lancar_fundesp",
+        "liberar_desconto",
+        "fundesp_automatica",
+        "lancar_valor_documento",
+        "valor_fixo",
+        "ato_praticado",
+        "selar",
+        "frenteverso",
+        "pagina_acrescida",
+        "apresentante_selo",
+        "renovacao_cartao",
+        "etiqueta_unica",
+        "transferencia_veiculo",
+        "usar_a4",
+        "averbacao",
     )
     def sanitize_fields(cls, v):
         if isinstance(v, str) and v:
@@ -121,15 +151,18 @@ class TServicoTipoSaveSchema(BaseModel):
         return v
 
     # Validação de obrigatoriedade apenas para o campo 'descricao'
-    @model_validator(mode='after')
+    @model_validator(mode="after")
     def validate_required_fields(self):
         if not self.descricao or not self.descricao.strip():
             raise HTTPException(
                 status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                detail=[{'input': 'descricao', 'message': 'A descrição é obrigatória.'}]
+                detail=[
+                    {"input": "descricao", "message": "A descrição é obrigatória."}
+                ],
             )
         return self
 
+
 # ----------------------------------------------------
 # Schema para atualizar SERVICO (PUT)
 # ----------------------------------------------------
@@ -172,13 +205,34 @@ class TServicoTipoUpdateSchema(BaseModel):
 
     # Campos que devem ser sanitizados (strings)
     @field_validator(
-        'descricao', 'tipo_item', 'requer_autorizacao', 'requer_biometria', 
+        "descricao",
-        'tipo_pessoa', 'tipo_permissao_cpf', 'requer_abonador', 'requer_representante', 
+        "tipo_item",
-        'situacao', 'requer_cpf', 'servico_padrao', 'alterar_valor', 'lancar_taxa', 
+        "requer_autorizacao",
-        'lancar_fundesp', 'liberar_desconto', 'fundesp_automatica', 
+        "requer_biometria",
-        'lancar_valor_documento', 'valor_fixo', 'ato_praticado', 'selar', 
+        "tipo_pessoa",
-        'frenteverso', 'pagina_acrescida', 'apresentante_selo', 'renovacao_cartao', 
+        "tipo_permissao_cpf",
-        'etiqueta_unica', 'transferencia_veiculo', 'usar_a4', 'averbacao'
+        "requer_abonador",
+        "requer_representante",
+        "situacao",
+        "requer_cpf",
+        "servico_padrao",
+        "alterar_valor",
+        "lancar_taxa",
+        "lancar_fundesp",
+        "liberar_desconto",
+        "fundesp_automatica",
+        "lancar_valor_documento",
+        "valor_fixo",
+        "ato_praticado",
+        "selar",
+        "frenteverso",
+        "pagina_acrescida",
+        "apresentante_selo",
+        "renovacao_cartao",
+        "etiqueta_unica",
+        "transferencia_veiculo",
+        "usar_a4",
+        "averbacao",
     )
     def sanitize_fields(cls, v):
         if isinstance(v, str) and v:
@@ -187,45 +241,45 @@ class TServicoTipoUpdateSchema(BaseModel):
 
     # Verifica se pelo menos um campo foi enviado, se não, lança exceção.
     # Se algum campo for enviado, ele deve ser válido (ex: 'descricao' não pode ser string vazia).
-    @model_validator(mode='after')
+    @model_validator(mode="after")
     def validate_all_fields(self):
         # Campos que, se fornecidos, não podem ser None ou strings vazias/apenas espaços.
         # Todos os campos da DDL, exceto os IDs que são Opcionais (FKs), são verificados.
 
         updatable_fields = {
-            'descricao': 'A descrição não pode ser vazia.',
+            "descricao": "A descrição não pode ser vazia.",
-            'valor': 'O valor não pode ser vazio.',
+            "valor": "O valor não pode ser vazio.",
-            'tipo_item': 'O Tipo do Item não pode ser vazio.',
+            "tipo_item": "O Tipo do Item não pode ser vazio.",
-            'requer_autorizacao': 'O Requer Autorização não pode ser vazio.',
+            "requer_autorizacao": "O Requer Autorização não pode ser vazio.",
-            'requer_biometria': 'O Requer Biometria não pode ser vazio.',
+            "requer_biometria": "O Requer Biometria não pode ser vazio.",
-            'tipo_pessoa': 'O Tipo Pessoa não pode ser vazio.',
+            "tipo_pessoa": "O Tipo Pessoa não pode ser vazio.",
-            'tipo_permissao_cpf': 'O Tipo Permissão CPF não pode ser vazio.',
+            "tipo_permissao_cpf": "O Tipo Permissão CPF não pode ser vazio.",
-            'requer_abonador': 'O Requer Abonador não pode ser vazio.',
+            "requer_abonador": "O Requer Abonador não pode ser vazio.",
-            'requer_representante': 'O Requer Representante não pode ser vazio.',
+            "requer_representante": "O Requer Representante não pode ser vazio.",
-            'situacao': 'A situação não pode ser vazia.',
+            "situacao": "A situação não pode ser vazia.",
-            'requer_cpf': 'O Requer CPF não pode ser vazio.',
+            "requer_cpf": "O Requer CPF não pode ser vazio.",
-            'servico_padrao': 'O Serviço Padrão não pode ser vazio.',
+            "servico_padrao": "O Serviço Padrão não pode ser vazio.",
-            'maximo_pessoa': 'O Máximo Pessoa não pode ser vazio.',
+            "maximo_pessoa": "O Máximo Pessoa não pode ser vazio.",
-            'alterar_valor': 'O Alterar Valor não pode ser vazio.',
+            "alterar_valor": "O Alterar Valor não pode ser vazio.",
-            'servico_caixa_id': 'O Servico Caixa ID não pode ser vazio.',
+            "servico_caixa_id": "O Servico Caixa ID não pode ser vazio.",
-            'lancar_taxa': 'O Lançar Taxa não pode ser vazio.',
+            "lancar_taxa": "O Lançar Taxa não pode ser vazio.",
-            'lancar_fundesp': 'O Lançar FUNDESP não pode ser vazio.',
+            "lancar_fundesp": "O Lançar FUNDESP não pode ser vazio.",
-            'liberar_desconto': 'O Liberar Desconto não pode ser vazio.',
+            "liberar_desconto": "O Liberar Desconto não pode ser vazio.",
-            'fundesp_automatica': 'O FUNDESP Automática não pode ser vazio.',
+            "fundesp_automatica": "O FUNDESP Automática não pode ser vazio.",
-            'lancar_valor_documento': 'O Lançar Valor Documento não pode ser vazio.',
+            "lancar_valor_documento": "O Lançar Valor Documento não pode ser vazio.",
-            'valor_fixo': 'O Valor Fixo não pode ser vazio.',
+            "valor_fixo": "O Valor Fixo não pode ser vazio.",
-            'emolumento_id': 'O Emolumento ID não pode ser vazio.',
+            "emolumento_id": "O Emolumento ID não pode ser vazio.",
-            'ato_praticado': 'O Ato Praticado não pode ser vazio.',
+            "ato_praticado": "O Ato Praticado não pode ser vazio.",
-            'selar': 'O Selar não pode ser vazio.',
+            "selar": "O Selar não pode ser vazio.",
-            'frenteverso': 'O FrenteVerso não pode ser vazio.',
+            "frenteverso": "O FrenteVerso não pode ser vazio.",
-            'pagina_acrescida': 'A Página Acrescida não pode ser vazia.',
+            "pagina_acrescida": "A Página Acrescida não pode ser vazia.",
-            'emolumento_obrigatorio': 'O Emolumento Obrigatório não pode ser vazio.',
+            "emolumento_obrigatorio": "O Emolumento Obrigatório não pode ser vazio.",
-            'apresentante_selo': 'O Apresentante Selo não pode ser vazio.',
+            "apresentante_selo": "O Apresentante Selo não pode ser vazio.",
-            'renovacao_cartao': 'A Renovação Cartão não pode ser vazia.',
+            "renovacao_cartao": "A Renovação Cartão não pode ser vazia.",
-            'etiqueta_unica': 'A Etiqueta Única não pode ser vazia.',
+            "etiqueta_unica": "A Etiqueta Única não pode ser vazia.",
-            'transferencia_veiculo': 'A Transferência Veículo não pode ser vazia.',
+            "transferencia_veiculo": "A Transferência Veículo não pode ser vazia.",
-            'usar_a4': 'O Usar A4 não pode ser vazio.',
+            "usar_a4": "O Usar A4 não pode ser vazio.",
-            'averbacao': 'A Averbação não pode ser vazia.',
+            "averbacao": "A Averbação não pode ser vazia.",
         }
 
         has_data = False
@@ -238,19 +292,21 @@ class TServicoTipoUpdateSchema(BaseModel):
                 has_data = True
                 # Verifica se o campo é uma string vazia ou só espaços
                 if isinstance(field_value, str) and len(field_value.strip()) == 0:
-                    errors.append({'input': field_name, 'message': message})
+                    errors.append({"input": field_name, "message": message})
                 # Caso seja um campo numérico, verifica se é zero (opcional: a regra de negócio pode permitir zero)
                 # elif isinstance(field_value, (int, float)) and field_value <= 0:
                 #     errors.append({'input': field_name, 'message': message})
 
-
         if not has_data:
-            errors.append({'message': 'Pelo menos um campo deve ser fornecido para a atualização.'})
+            errors.append(
+                {
+                    "message": "Pelo menos um campo deve ser fornecido para a atualização."
+                }
+            )
 
         if errors:
             raise HTTPException(
-                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=errors
-                detail=errors
             )
 
         return self

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

@@ -1,23 +1,29 @@
 from fastapi import HTTPException, status
+from packages.v1.administrativo.controllers.g_usuario_controller import (
+    GUsuarioIndexSchema,
+)
 from packages.v1.administrativo.schemas.g_usuario_schema import GUsuarioSchema
-from packages.v1.administrativo.actions.g_usuario.g_usuario_index_action import IndexAction
+from packages.v1.administrativo.actions.g_usuario.g_usuario_index_action import (
+    IndexAction,
+)
+
 
 class IndexService:
 
-    def execute(self):
+    def execute(self, g_usuario_index_schema: GUsuarioIndexSchema):
 
         # Instânciamento de acções
         index_action = IndexAction()
 
         # Executa a busca de todas as ações
-        data = index_action.execute()
+        data = index_action.execute(g_usuario_index_schema)
 
         # 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'
+                detail="Não foi possível localizar os usuários",
             )
 
         # Retorna as informações localizadas

packages/v1/administrativo/services/t_biometria_pessoa/go/t_biometria_pessoa_delete_service.py

@@ -0,0 +1,39 @@
+from packages.v1.administrativo.actions.t_biometria_pessoa.t_biometria_pessoa_delete_action import (
+    TBiometriaPessoaDeleteAction,
+)
+from packages.v1.administrativo.schemas.t_biometria_pessoa_schema import (
+    TBiometriaPessoaIdSchema,
+)
+
+
+class TBiometriaPessoaDeleteService:
+    """
+    Serviço responsável por encapsular a lógica de negócio para a operação
+    de exclusão de um registro na tabela T_BIOMETRIA_PESSOA.
+    """
+
+    def execute(self, t_biometria_pessoa_id_schema: TBiometriaPessoaIdSchema):
+        """
+        Executa a operação de exclusão do registro no banco de dados.
+
+        Args:
+            t_biometria_pessoa_id_schema (TBiometriaPessoaIdSchema):
+                O esquema com o ID do registro a ser excluído.
+
+        Returns:
+            O resultado da operação de exclusão.
+        """
+        # ----------------------------------------------------
+        # Instanciamento da ação
+        # ----------------------------------------------------
+        t_biometria_pessoa_delete_action = TBiometriaPessoaDeleteAction()
+
+        # ----------------------------------------------------
+        # Execução da ação
+        # ----------------------------------------------------
+        data = t_biometria_pessoa_delete_action.execute(t_biometria_pessoa_id_schema)
+
+        # ----------------------------------------------------
+        # Retorno da informação
+        # ----------------------------------------------------
+        return data

packages/v1/administrativo/services/t_biometria_pessoa/go/t_biometria_pessoa_index_service.py

@@ -1,21 +1,25 @@
-from packages.v1.administrativo.actions.g_emolumento.g_emolumento_index_action import (
+from packages.v1.administrativo.actions.t_biometria_pessoa.t_biometria_pessoa_index_action import (
-    GEmolumentoIndexAction,
+    TBiometriaPessoaIndexAction,
 )
 from fastapi import HTTPException, status
 
+from packages.v1.administrativo.schemas.t_biometria_pessoa_schema import (
+    TBiometriaPessoaIndexSchema,
+)
 
-class GEmolumentoIndexService:
+
+class TBiometriaPessoaIndexService:
     """
     Serviço responsável por encapsular a lógica de negócio para a operação
-    de listagem de registros na tabela G_EMOLUMENTO.
+    de listagem de registros na tabela T_BIOMETRIA_PESSOA.
     """
 
-    def execute(self):
+    def execute(self, biometria_pessoa_index_schema: TBiometriaPessoaIndexSchema):
         """
         Executa a operação de busca de todos os registros no banco de dados.
 
         Args:
-            g_emolumento_index_schema (GEmolumentoIndexSchema):
+            t_biometria_pessoa_index_schema (TBiometriaPessoaIndexSchema):
                 Esquema que pode conter filtros ou parâmetros de busca.
 
         Returns:
@@ -24,12 +28,12 @@ class GEmolumentoIndexService:
         # ----------------------------------------------------
         # Instanciamento da ação
         # ----------------------------------------------------
-        g_emolumento_index_action = GEmolumentoIndexAction()
+        t_biometria_pessoa_index_action = TBiometriaPessoaIndexAction()
 
         # ----------------------------------------------------
         # Execução da ação
         # ----------------------------------------------------
-        data = g_emolumento_index_action.execute()
+        data = t_biometria_pessoa_index_action.execute(biometria_pessoa_index_schema)
 
         # ----------------------------------------------------
         # Verificação de retorno
@@ -37,7 +41,7 @@ class GEmolumentoIndexService:
         if not data:
             raise HTTPException(
                 status_code=status.HTTP_404_NOT_FOUND,
-                detail="Não foi possível localizar registros de G_EMOLUMENTO.",
+                detail="Não foi possível localizar registros de T_BIOMETRIA_PESSOA.",
             )
 
         # ----------------------------------------------------

packages/v1/administrativo/services/t_biometria_pessoa/go/t_biometria_pessoa_save_service.py

@@ -0,0 +1,48 @@
+from packages.v1.administrativo.actions.t_biometria_pessoa.t_biometria_pessoa_save_action import (
+    TBiometriaPessoaSaveAction,
+)
+from packages.v1.sequencia.schemas.g_sequencia import GSequenciaSchema
+from packages.v1.administrativo.schemas.t_biometria_pessoa_schema import (
+    TBiometriaPessoaSaveSchema,
+)
+from packages.v1.sequencia.services.g_sequencia.generate_service import GenerateService
+
+
+class TBiometriaPessoaSaveService:
+    """
+    Serviço responsável por encapsular a lógica de negócio para a operação
+    de criação de registros na tabela T_BIOMETRIA_PESSOA.
+    """
+
+    def execute(self, t_biometria_pessoa_save_schema: TBiometriaPessoaSaveSchema):
+        """
+        Executa a operação de salvamento do registro no banco de dados.
+
+        Args:
+            t_biometria_pessoa_save_schema (TBiometriaPessoaSaveSchema):
+                O esquema com os dados a serem salvos.
+
+        Returns:
+            O registro recém-criado.
+        """
+
+        # ----------------------------------------------------
+        # Geração automática de ID (sequência)
+        # ----------------------------------------------------
+        if not t_biometria_pessoa_save_schema.biometria_pessoa_id:
+            # Cria o schema de sequência
+            sequencia_schema = GSequenciaSchema()
+            sequencia_schema.tabela = "T_BIOMETRIA_PESSOA"
+
+            # Gera a sequência atualizada
+            generate = GenerateService()
+            sequencia = generate.execute(sequencia_schema)
+
+            # Atualiza o ID no schema
+            t_biometria_pessoa_save_schema.biometria_pessoa_id = sequencia.sequencia
+
+        # ----------------------------------------------------
+        # Instanciamento e execução da Action de salvamento
+        # ----------------------------------------------------
+        t_biometria_pessoa_save_action = TBiometriaPessoaSaveAction()
+        return t_biometria_pessoa_save_action.execute(t_biometria_pessoa_save_schema)

packages/v1/administrativo/services/t_biometria_pessoa/go/t_biometria_pessoa_show_service.py

@@ -0,0 +1,49 @@
+from packages.v1.administrativo.actions.t_biometria_pessoa.t_biometria_pessoa_show_action import (
+    TBiometriaPessoaShowAction,
+)
+from packages.v1.administrativo.schemas.t_biometria_pessoa_schema import (
+    TBiometriaPessoaIdSchema,
+)
+from fastapi import HTTPException, status
+
+
+class TBiometriaPessoaShowService:
+    """
+    Serviço responsável por encapsular a lógica de negócio para a operação
+    de busca de um registro na tabela T_BIOMETRIA_PESSOA.
+    """
+
+    def execute(self, t_biometria_pessoa_id_schema: TBiometriaPessoaIdSchema):
+        """
+        Executa a operação de busca no banco de dados.
+
+        Args:
+            t_biometria_pessoa_id_schema (TBiometriaPessoaIdSchema):
+                O esquema com o ID do registro a ser buscado.
+
+        Returns:
+            O resultado da busca.
+        """
+        # ----------------------------------------------------
+        # Instanciamento da ação
+        # ----------------------------------------------------
+        t_biometria_pessoa_show_action = TBiometriaPessoaShowAction()
+
+        # ----------------------------------------------------
+        # Execução da ação
+        # ----------------------------------------------------
+        data = t_biometria_pessoa_show_action.execute(t_biometria_pessoa_id_schema)
+
+        # ----------------------------------------------------
+        # Verificação de resultado
+        # ----------------------------------------------------
+        if not data:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Não foi possível localizar o registro de T_BIOMETRIA_PESSOA.",
+            )
+
+        # ----------------------------------------------------
+        # Retorno da informação
+        # ----------------------------------------------------
+        return data

packages/v1/administrativo/services/t_biometria_pessoa/go/t_biometria_pessoa_update_service.py

@@ -0,0 +1,36 @@
+from packages.v1.administrativo.actions.t_biometria_pessoa.t_biometria_pessoa_update_action import (
+    TBiometriaPessoaUpdateAction,
+)
+from packages.v1.administrativo.schemas.t_biometria_pessoa_schema import (
+    TBiometriaPessoaUpdateSchema,
+)
+
+
+class TBiometriaPessoaUpdateService:
+    """
+    Serviço responsável pela operação de atualização de um registro
+    na tabela T_BIOMETRIA_PESSOA.
+    """
+
+    def execute(self, t_biometria_pessoa_update_schema: TBiometriaPessoaUpdateSchema):
+        """
+        Executa a operação de atualização no banco de dados.
+
+        Args:
+            t_biometria_pessoa_update_schema (TBiometriaPessoaUpdateSchema):
+                O esquema com os dados a serem atualizados.
+
+        Returns:
+            O resultado da operação de atualização.
+        """
+        # ----------------------------------------------------
+        # Instanciamento da ação
+        # ----------------------------------------------------
+        t_biometria_pessoa_update_action = TBiometriaPessoaUpdateAction()
+
+        # ----------------------------------------------------
+        # Execução da ação e retorno do resultado
+        # ----------------------------------------------------
+        return t_biometria_pessoa_update_action.execute(
+            t_biometria_pessoa_update_schema
+        )

packages/v1/administrativo/services/t_servico_tipo/go/t_servico_tipo_index_service.py

@@ -1,6 +1,13 @@
 from fastapi import HTTPException, status
+
 # Importação da Action ajustada para o novo prefixo
-from packages.v1.administrativo.actions.t_servico_tipo.t_servico_tipo_index_action import IndexAction
+from packages.v1.administrativo.actions.t_servico_tipo.t_servico_tipo_index_action import (
+    IndexAction,
+)
+from packages.v1.administrativo.controllers.t_servico_tipo_controller import (
+    TServicoTipoIndexSchema,
+)
+
 
 class IndexService:
     """
@@ -8,7 +15,7 @@ class IndexService:
     de listagem de registros na tabela T_SERVICO_TIPO.
     """
 
-    def execute(self):
+    def execute(self, t_servico_tipo_index_schema: TServicoTipoIndexSchema):
         """
         Executa a operação de busca de todos os registros no banco de dados.
 
@@ -19,14 +26,14 @@ class IndexService:
         index_action = IndexAction()
 
         # Executa a busca de todas as ações
-        data = index_action.execute()
+        data = index_action.execute(t_servico_tipo_index_schema)
 
         # Verifica se foram localizados registros
         if not data:
             # Retorna uma exceção
             raise HTTPException(
                 status_code=status.HTTP_404_NOT_FOUND,
-                detail='Não foi possível localizar os registros de T_SERVICO_TIPO' # Mensagem de erro ajustada
+                detail="Não foi possível localizar os registros de T_SERVICO_TIPO",  # Mensagem de erro ajustada
             )
 
         # Retorna as informações localizadas

packages/v1/api.py

@@ -10,6 +10,7 @@ from packages.v1.administrativo.endpoints import (
     g_natureza_titulo_endpoint,
     g_selo_grupo_endpoint,
     t_ato_partetipo_endpoint,
+    t_biometria_pessoa_endpoint,
     t_censec_tiponatureza_endpoint,
 )
 from packages.v1.administrativo.endpoints import (
@@ -367,3 +368,10 @@ api_router.include_router(
     prefix="/servicos/balcao/t_pessoa_cartao",
     tags=["Pessoa Cartao"],
 )
+
+# Inclui as rotas de g_emolumento periodo
+api_router.include_router(
+    t_biometria_pessoa_endpoint.router,
+    prefix="/administrativo/t_biometria_pessoa",
+    tags=["Pessoa Cartao"],
+)

packages/v1/servicos/balcao/repositories/t_servico_itempedido/t_servico_itempedido_index_repository.py

@@ -32,10 +32,16 @@ class TServicoItemPedidoIndexRepository(BaseRepository):
                         TSP.VALOR,
                         TST.DESCRICAO,
                         GE.DESCRICAO AS EMOLUMENTO_DESCRICAO,
-                        TSP.SITUACAO
+                        TSP.SITUACAO,
+                        TE.NOME,
+                        TE.CPF_CNPJ,
+                        GMT.GRUPO
                     FROM T_SERVICO_ITEMPEDIDO TSP
                     JOIN T_SERVICO_TIPO TST ON TSP.SERVICO_TIPO_ID = TST.SERVICO_TIPO_ID
+                    LEFT JOIN T_SERVICO_ETIQUETA TSE ON TST.SERVICO_TIPO_ID = TSE.SERVICO_TIPO_ID
+                    LEFT JOIN G_MARCACAO_TIPO GMT ON TSE.ETIQUETA_MODELO_ID = GMT.MARCACAO_TIPO_ID
                     JOIN G_EMOLUMENTO GE ON TSP.EMOLUMENTO_ID = GE.EMOLUMENTO_ID
+                    LEFT JOIN T_PESSOA TE ON TSP.PESSOA_ID = TE.PESSOA_ID
                   WHERE SERVICO_PEDIDO_ID = :servico_pedido_id
             """
 

schemas/ControllerSchema.py

@@ -0,0 +1,13 @@
+# ----------------------------------------------------
+# Schema base - representa a tabela de Biometria
+# ----------------------------------------------------
+from typing import Any, List
+from pydantic.main import BaseModel
+
+
+class ControllerResponseSchema(BaseModel):
+    message: str = None
+    data: List[Any]
+
+    class Config:
+        from_attributes = True

schemas/dynamic_query.py

@@ -0,0 +1,6 @@
+from pydantic import BaseModel
+
+
+class DynamicQuery(BaseModel):
+    class Config:
+        extra = "allow"  # ← permite receber qualquer campo dinamicamente

schemas/endpoint_schema.py

@@ -0,0 +1,10 @@
+from typing import Any, List
+from pydantic.main import BaseModel
+
+
+class EndpointResponseSchema(BaseModel):
+    message: str = None
+    data: List[Any]
+
+    class Config:
+        from_attributes = True