Merge branch 'main' of https://git.oriustecnologia.com/OriusTecnologia/saas_api

Dockerfile

@@ -1,13 +1,9 @@
-# Usa a imagem oficial do Python
 FROM python:3.12-slim
 
-# Define diretório de trabalho no container
 WORKDIR /app
 
-# Copia o arquivo de dependências
 COPY requirements.txt .
 
-# Instala dependências no sistema e no Python
 RUN apt-get update && apt-get install -y \
     gcc libffi-dev libssl-dev python3-dev firebird-dev \
  && pip install --upgrade pip \
@@ -16,11 +12,13 @@ RUN apt-get update && apt-get install -y \
  && apt-get autoremove -y \
  && rm -rf /var/lib/apt/lists/*
 
-# Copia o restante do projeto para o container
+# ===============================
+# CRIA DIRETÓRIOS NECESSÁRIOS
+# ===============================
+RUN mkdir -p storage/temp
+
 COPY . .
 
-# Expõe a porta padrão do Uvicorn/FastAPI
 EXPOSE 8000
 
-# Comando para iniciar o servidor
+CMD ["gunicorn", "main:app", "-w", "4", "-k", "uvicorn.workers.UvicornWorker", "--bind", "0.0.0.0:8000"]
-CMD ["sh", "-c", "uvicorn main:app --host 0.0.0.0 --port 8000"]

Orius.postman_collection.json

@@ -70,7 +70,7 @@
 								"header": [],
 								"body": {
 									"mode": "raw",
-									"raw": "{\r\n    \"login\" : \"Kenio0\",\r\n    \"senha_api\": \"123123\"\r\n}",
+									"raw": "{\r\n    \"login\" : \"Kenio\",\r\n    \"senha_api\": \"123123\"\r\n}",
 									"options": {
 										"raw": {
 											"language": "json"
@@ -8501,6 +8501,81 @@
 							},
 							"response": []
 						},
+						{
+							"name": "GET GRUPO",
+							"event": [
+								{
+									"listen": "test",
+									"script": {
+										"exec": [
+											"pm.test(\"Status code é 201 ou 200\", function () {\r",
+											"    pm.expect(pm.response.code).to.be.oneOf([200, 201]);\r",
+											"});\r",
+											"\r",
+											"pm.test(\"Resposta contém ID ou confirmação\", function () {\r",
+											"    const jsonData = pm.response.json();\r",
+											"    pm.expect(jsonData).to.have.any.keys(\"id\", \"message\", \"status\");\r",
+											"});\r",
+											"\r",
+											"pm.test(\"Mensagem indica sucesso\", function () {\r",
+											"    const jsonData = pm.response.json();\r",
+											"    pm.expect(jsonData.message || \"\").to.match(/sucesso|criado|registrado/i);\r",
+											"});\r",
+											""
+										],
+										"type": "text/javascript",
+										"packages": {},
+										"requests": {}
+									}
+								}
+							],
+							"protocolProfileBehavior": {
+								"disableBodyPruning": true
+							},
+							"request": {
+								"auth": {
+									"type": "bearer",
+									"bearer": [
+										{
+											"key": "token",
+											"value": "{{BearerToken}}",
+											"type": "string"
+										}
+									]
+								},
+								"method": "GET",
+								"header": [],
+								"body": {
+									"mode": "raw",
+									"raw": ""
+								},
+								"url": {
+									"raw": "{{BaseUrlV1}}administrativo/g_marcacao_tipo/grupo?grupo=MODELO_ETIQUETA&sistema_id=2&situacao=A",
+									"host": [
+										"{{BaseUrlV1}}administrativo"
+									],
+									"path": [
+										"g_marcacao_tipo",
+										"grupo"
+									],
+									"query": [
+										{
+											"key": "grupo",
+											"value": "MODELO_ETIQUETA"
+										},
+										{
+											"key": "sistema_id",
+											"value": "2"
+										},
+										{
+											"key": "situacao",
+											"value": "A"
+										}
+									]
+								}
+							},
+							"response": []
+						},
 						{
 							"name": "GET ID",
 							"event": [
@@ -8741,6 +8816,65 @@
 						}
 					]
 				},
+				{
+					"name": "Emolumentos",
+					"item": [
+						{
+							"name": "GET",
+							"event": [
+								{
+									"listen": "test",
+									"script": {
+										"exec": [
+											"pm.test(\"Status code é 201 ou 200\", function () {\r",
+											"    pm.expect(pm.response.code).to.be.oneOf([200, 201]);\r",
+											"});\r",
+											"\r",
+											"pm.test(\"Resposta contém ID ou confirmação\", function () {\r",
+											"    const jsonData = pm.response.json();\r",
+											"    pm.expect(jsonData).to.have.any.keys(\"id\", \"message\", \"status\");\r",
+											"});\r",
+											"\r",
+											"pm.test(\"Mensagem indica sucesso\", function () {\r",
+											"    const jsonData = pm.response.json();\r",
+											"    pm.expect(jsonData.message || \"\").to.match(/sucesso|criado|registrado/i);\r",
+											"});\r",
+											""
+										],
+										"type": "text/javascript",
+										"packages": {},
+										"requests": {}
+									}
+								}
+							],
+							"request": {
+								"auth": {
+									"type": "bearer",
+									"bearer": [
+										{
+											"key": "token",
+											"value": "{{BearerToken}}",
+											"type": "string"
+										}
+									]
+								},
+								"method": "GET",
+								"header": [],
+								"url": {
+									"raw": "{{BaseUrlV1}}administrativo/g_emolumento/1",
+									"host": [
+										"{{BaseUrlV1}}administrativo"
+									],
+									"path": [
+										"g_emolumento",
+										"1"
+									]
+								}
+							},
+							"response": []
+						}
+					]
+				},
 				{
 					"name": "Andamento Serviço",
 					"item": [

README.md

@@ -1,12 +1,12 @@
 # Configuração do Projeto Python
 
-Este guia descreve o passo a passo para configurar o ambiente de desenvolvimento de um projeto Python, incluindo a preparação do ambiente virtual, instalação de dependências e configuração do banco de dados.
+Este guia descreve o passo a passo para configurar o ambiente de desenvolvimento e produção de um projeto Python, incluindo ambiente virtual, dependências, banco de dados, e ajuste de desempenho com múltiplos núcleos.
 
 ---
 
 ## 1. Clonar o Projeto
 
-Primeiro, clone o repositório do projeto a partir do Git:
+Clone o repositório do projeto a partir do Git:
 
 ```bash
 git clone https://git.oriustecnologia.com/OriusTecnologia/saas_api.git
@@ -16,7 +16,7 @@ git clone https://git.oriustecnologia.com/OriusTecnologia/saas_api.git
 
 ## 2. Criar o Ambiente Virtual
 
-O uso de um **ambiente virtual** garante que as bibliotecas instaladas para este projeto não afetem o Python global da sua máquina.
+Crie um **ambiente virtual** isolado para o projeto:
 
 ```bash
 python -m venv venv
@@ -26,14 +26,13 @@ python -m venv venv
 
 ## 3. Ativar o Ambiente Virtual
 
-Ative o ambiente virtual antes de instalar as dependências ou executar a aplicação.
+Ative o ambiente virtual antes de instalar as dependências:
 
 ```bash
 venv\Scripts\activate
 ```
 
-> **Observação:**
+> **Em sistemas Linux/Mac:**
-> Em sistemas Unix (Linux/Mac), o comando pode ser:
 >
 > ```bash
 > source venv/bin/activate
@@ -43,9 +42,11 @@ venv\Scripts\activate
 
 ## 4. Instalar Dependências do Sistema
 
-A biblioteca de criptografia utilizada no projeto requer uma extensão da Microsoft para ser instalada.
+O projeto depende de compiladores nativos para algumas bibliotecas Python.
-Baixe e instale o **Microsoft C++ Build Tools** através do link abaixo:
 
+### Windows
+
+Baixe e instale o **Microsoft C++ Build Tools**:
 [https://visualstudio.microsoft.com/pt-br/visual-cpp-build-tools/](https://visualstudio.microsoft.com/pt-br/visual-cpp-build-tools/)
 
 Durante a instalação, selecione o pacote:
@@ -54,6 +55,15 @@ Durante a instalação, selecione o pacote:
 Desktop Development With C++
 ```
 
+### Linux
+
+Execute no terminal:
+
+```bash
+sudo apt update
+sudo apt install -y build-essential libpq-dev
+```
+
 ---
 
 ## 5. Instalar as Bibliotecas do Projeto
@@ -66,21 +76,21 @@ pip install -r requirements.txt
 
 ---
 
-## 6. Configurar o Banco de Dados
+## 6. Configurar o Banco de Dados (Firebird)
 
-O projeto utiliza um banco **Firebird**.
+O projeto utiliza o banco **Firebird**.
-Edite o arquivo de configuração localizado em:
+Edite o arquivo de configuração em:
 
 ```
 api/config/database/firebird.json
 ```
 
-Exemplo do conteúdo padrão:
+Exemplo:
 
 ```json
 {
   "host": "localhost",
-  "name": "D:/Orius/Base/CAIAPONIA.FDB",
+  "name": "/data/base/CAIAPONIA.FDB",
   "port": 3050,
   "user": "SYSDBA",
   "password": "",
@@ -93,50 +103,179 @@ Exemplo do conteúdo padrão:
 }
 ```
 
-### Ajustes Necessários:
+**Campos principais:**
 
-* **host**: Endereço do servidor do banco de dados.
+| Campo               | Descrição                          |
-* **name**: Caminho completo do arquivo `.FDB`.
+| ------------------- | ---------------------------------- |
-* **port**: Porta do Firebird (padrão: `3050`).
+| `host`              | Endereço do servidor Firebird      |
-* **user**: Usuário do banco de dados.
+| `name`              | Caminho completo do arquivo `.FDB` |
-* **password**: Senha do usuário configurado.
+| `port`              | Porta padrão `3050`                |
+| `user`              | Usuário do banco                   |
+| `password`          | Senha do usuário                   |
+| `charset`           | Codificação (UTF8 recomendado)     |
+| `pool.size`         | Número de conexões fixas           |
+| `pool.max_overflow` | Conexões extras sob demanda        |
 
 ---
 
-## 7. Iniciar a Aplicação
+## 7. Modo Desenvolvimento
 
-Com o ambiente virtual **ativado**, execute o comando abaixo para iniciar a aplicação:
+Para ambiente local, execute:
 
 ```bash
 uvicorn main:app --reload
 ```
 
-> **Dica:**
+> O parâmetro `--reload` reinicia automaticamente a aplicação ao detectar alterações no código.
-> O parâmetro `--reload` reinicia automaticamente a aplicação sempre que houver alterações no código.
 
----
+Acesse:
 
-## 8. Testando a Aplicação
+```
-
-Após iniciar a aplicação, abra o navegador e acesse o seguinte endereço:
-
-```http
 http://localhost:8000/docs
 ```
 
-Você deverá visualizar a interface do **Swagger**, onde estarão listados todos os endpoints disponíveis da API.
+---
 
-> **Observação:**
+## 8. Modo Produção
-> O Swagger permite testar os endpoints diretamente pelo navegador, sem necessidade de ferramentas externas como Postman ou Insomnia.
+
+A execução em produção varia conforme o sistema operacional.
 
 ---
 
-## Resumo dos Comandos
+### **Windows (modo produção simulado)**
 
-| Etapa                   | Comando                                                                         |
+O **Gunicorn** não é compatível com Windows, pois depende do módulo `fcntl` exclusivo de sistemas Unix.
-| ----------------------- | ------------------------------------------------------------------------------- |
+Portanto, em ambiente Windows, recomenda-se usar o **Uvicorn** diretamente com múltiplos *workers*:
-| Clonar o projeto        | `git clone https://git.oriustecnologia.com/OriusTecnologia/saas_api.git`        |
+
-| Criar ambiente virtual  | `python -m venv venv`                                                           |
+```bash
-| Ativar ambiente virtual | `venv\Scripts\activate` *(Windows)*<br>`source venv/bin/activate` *(Linux/Mac)* |
+uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4
-| Instalar dependências   | `pip install -r requirements.txt`                                               |
+```
-| Iniciar a aplicação     | `uvicorn main:app --reload`                                                     |
+
+> O parâmetro `--workers` define quantos processos simultâneos serão utilizados.
+> Idealmente, use `(número_de_CPUs * 2) + 1`.
+
+#### Alternativa compatível (Windows)
+
+Instale e use o **Hypercorn**, uma alternativa semelhante ao Gunicorn:
+
+```bash
+pip install hypercorn
+hypercorn main:app --workers 4 --bind 0.0.0.0:8000
+```
+
+---
+
+### **Linux (modo produção real)**
+
+Em ambientes Linux (ou Docker), utilize o **Gunicorn** com o **Uvicorn Worker** para obter o máximo desempenho.
+
+#### Instalar Gunicorn (caso ainda não instalado)
+
+```bash
+pip install gunicorn uvicorn
+```
+
+#### Executar com múltiplos núcleos
+
+```bash
+gunicorn main:app \
+  -k uvicorn.workers.UvicornWorker \
+  --workers 4 \
+  --bind 0.0.0.0:8000 \
+  --timeout 120 \
+  --log-level info
+```
+
+#### Parâmetros principais
+
+| Parâmetro                          | Função                                   |
+| ---------------------------------- | ---------------------------------------- |
+| `-k uvicorn.workers.UvicornWorker` | Usa o Uvicorn como worker ASGI           |
+| `--workers 4`                      | Define o número de núcleos usados        |
+| `--bind 0.0.0.0:8000`              | Expõe a aplicação em todas as interfaces |
+| `--timeout 120`                    | Tempo limite de resposta (em segundos)   |
+| `--log-level info`                 | Define o nível de logs                   |
+
+#### Dica de cálculo de workers
+
+```
+(número_de_CPUs * 2) + 1
+```
+
+Exemplo: servidor com 2 CPUs → `--workers 5`
+
+---
+
+### **Execução em segundo plano (Linux)**
+
+Para rodar a aplicação continuamente:
+
+```bash
+nohup gunicorn main:app -k uvicorn.workers.UvicornWorker --workers 4 --bind 0.0.0.0:8000 &
+```
+
+Verifique se está rodando:
+
+```bash
+ps aux | grep gunicorn
+```
+
+---
+
+## 9. Logs e Monitoramento
+
+É possível direcionar os logs de acesso e erro para arquivos dedicados:
+
+```bash
+gunicorn main:app \
+  -k uvicorn.workers.UvicornWorker \
+  --workers 4 \
+  --bind 0.0.0.0:8000 \
+  --access-logfile logs/access.log \
+  --error-logfile logs/error.log
+```
+
+---
+
+## 10. Estrutura Recomendada de Deploy
+
+```
+/app
+├── main.py
+├── api/
+├── packages/
+├── requirements.txt
+├── logs/
+│   ├── access.log
+│   └── error.log
+└── systemd/
+    └── saas_api.service
+```
+
+---
+
+## 11. Resumo dos Comandos
+
+| Etapa                       | Comando                                                                              |
+| --------------------------- | ------------------------------------------------------------------------------------ |
+| Clonar projeto              | `git clone https://git.oriustecnologia.com/OriusTecnologia/saas_api.git`             |
+| Criar venv                  | `python -m venv venv`                                                                |
+| Ativar venv                 | `venv\Scripts\activate` *(Windows)*<br>`source venv/bin/activate` *(Linux/Mac)*      |
+| Instalar dependências       | `pip install -r requirements.txt`                                                    |
+| Rodar em desenvolvimento    | `uvicorn main:app --reload`                                                          |
+| Rodar em produção (Windows) | `uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4`                            |
+| Rodar em produção (Linux)   | `gunicorn main:app -k uvicorn.workers.UvicornWorker --workers 4 --bind 0.0.0.0:8000` |
+| Alternativa (Windows)       | `hypercorn main:app --workers 4 --bind 0.0.0.0:8000`                                 |
+
+---
+
+## 12. Recomendações Finais
+
+* Em **Windows**, use Uvicorn ou Hypercorn apenas para testes e ambientes locais.
+* Para **produção real**, use **Linux** com Gunicorn + Uvicorn Worker, idealmente em container **Docker**.
+* Monitore o consumo de CPU/RAM e ajuste o número de *workers* conforme o ambiente.
+* Automatize o serviço em produção via **systemd** (ex: `/etc/systemd/system/saas_api.service`) para iniciar junto com o servidor.
+
+---
+
+uvicorn main:app --host 0.0.0.0 --port 8000 --reload

abstracts/action.py

@@ -1,4 +1,4 @@
-from abc import ABC, abstractmethod
+from abc import abstractmethod
 
 
 class BaseAction:

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/config/config.py

@@ -11,10 +11,10 @@ class Config:
         base_dir = Path(__file__).resolve().parent
 
         # Caminho absoluto para o config.json (subindo dois níveis e entrando em config/)
-        config_path = base_dir.parent.parent / 'config' / name
+        config_path = base_dir.parent.parent / "config" / name
 
         # Carrega o JSON como objeto acessível por ponto
-        with open(config_path, 'r') as f:
+        with open(config_path, "r") as f:
             config = json.load(f, object_hook=lambda d: SimpleNamespace(**d))
 
         return config

actions/data/dict_to_namespace.py

@@ -0,0 +1,31 @@
+import json
+from types import SimpleNamespace
+
+
+def dict_to_namespace(d):
+    """
+    Converte dict (ou string JSON) recursivamente em SimpleNamespace.
+    """
+    # Caso venha uma string JSON
+    if isinstance(d, str):
+        try:
+            # tenta fazer parse do JSON interno
+            parsed = json.loads(d)
+            # se for mesmo JSON, converte recursivamente
+            return dict_to_namespace(parsed)
+        except (json.JSONDecodeError, TypeError):
+            # não era JSON, retorna string normal
+            return d
+
+    # Caso seja um dicionário
+    if isinstance(d, dict):
+        return SimpleNamespace(**{k: dict_to_namespace(v) for k, v in d.items()})
+
+    # Caso seja lista/tupla
+    if isinstance(d, list):
+        return [dict_to_namespace(i) for i in d]
+    if isinstance(d, tuple):
+        return tuple(dict_to_namespace(i) for i in d)
+
+    # Caso base (valor simples)
+    return d

actions/data/dict_to_obj.py

@@ -0,0 +1,82 @@
+from typing import Any, Mapping, Iterable
+
+
+class DictToObj:
+    """
+    Converte dicts (aninhados) em objetos com acesso por ponto.
+    - d["x"] -> o.x
+    - Listas/tuplas são convertidas recursivamente.
+    - Mantém método parse() para voltar ao dict original.
+    """
+
+    __slots__ = ("__data__",)
+
+    def __init__(self, data: Mapping[str, Any] | None = None):
+        object.__setattr__(self, "__data__", {})
+        if data:
+            for k, v in data.items():
+                self.__data__[k] = self._convert(v)
+
+    # ===== Conversões =====
+    @classmethod
+    def _convert(cls, value: Any) -> Any:
+        if isinstance(value, Mapping):
+            return cls(value)
+        if isinstance(value, list):
+            return [cls._convert(v) for v in value]
+        if isinstance(value, tuple):
+            return tuple(cls._convert(v) for v in value)
+        return value
+
+    def parse(self) -> dict[str, Any]:
+        def back(v: Any) -> Any:
+            if isinstance(v, DictToObj):
+                return v.parse()
+            if isinstance(v, list):
+                return [back(i) for i in v]
+            if isinstance(v, tuple):
+                return tuple(back(i) for i in v)
+            return v
+
+        return {k: back(v) for k, v in self.__data__.items()}
+
+    # ===== Acesso por ponto / item =====
+    def __getattr__(self, name: str) -> Any:
+        try:
+            return self.__data__[name]
+        except KeyError as e:
+            raise AttributeError(name) from e
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        # protege o atributo interno
+        if name == "__data__":
+            object.__setattr__(self, name, value)
+        else:
+            self.__data__[name] = self._convert(value)
+
+    def __getitem__(self, key: str) -> Any:
+        return self.__data__[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.__data__[key] = self._convert(value)
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.__data__
+
+    def keys(self) -> Iterable[str]:
+        return self.__data__.keys()
+
+    def items(self) -> Iterable[tuple[str, Any]]:
+        return self.__data__.items()
+
+    def values(self) -> Iterable[Any]:
+        return self.__data__.values()
+
+    def __iter__(self):
+        return iter(self.__data__)
+
+    def __len__(self) -> int:
+        return len(self.__data__)
+
+    def __repr__(self) -> str:
+        return f"DictToObj({self.__data__!r})"

actions/data/generate_insert_sql.py

@@ -0,0 +1,51 @@
+from pydantic import BaseModel
+from decimal import Decimal
+
+def generate_insert_sql(table_name: str, data: BaseModel | dict) -> str:
+    """
+    Gera um comando SQL INSERT seguro para Firebird.
+    - Aceita BaseModel (Pydantic) ou dict.
+    - Ignora *_ID None.
+    - Mantém colunas em MAIÚSCULAS e parâmetros em minúsculas (para bind funcionar).
+    """
+
+    # Converte o model em dict limpo
+    if isinstance(data, BaseModel):
+        data_dict = data.model_dump(exclude_unset=True)
+    elif isinstance(data, dict):
+        data_dict = data
+    else:
+        raise TypeError("O parâmetro 'data' deve ser um BaseModel ou dict.")
+
+    columns = []
+    params = []
+    returning_fields = []
+
+    for key, value in data_dict.items():
+        column_name = key.upper()
+
+        # Converte Decimal → float
+        if isinstance(value, Decimal):
+            data_dict[key] = float(value)
+
+        # Campos válidos para retorno
+        if value is not None:
+            returning_fields.append(column_name)
+
+        # Coluna em maiúsculo, parâmetro em minúsculo
+        columns.append(column_name)
+        params.append(f":{key}")
+
+    columns_str = ", ".join(columns)
+    params_str = ", ".join(params)
+    returning_str = ", ".join(returning_fields) if returning_fields else "*"
+
+    sql = (
+        f"INSERT INTO {table_name} (\n"
+        f"    {columns_str}\n"
+        f") VALUES (\n"
+        f"    {params_str}\n"
+        f") RETURNING {returning_str};"
+    )
+
+    return sql

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)

actions/data/json_to_dict.py

@@ -0,0 +1,37 @@
+import json
+from pathlib import Path
+from typing import Any, Union
+
+
+class JsonToDict:
+    """
+    Converte conteúdo JSON (string, bytes ou arquivo) em dicionário Python.
+    """
+
+    @staticmethod
+    def parse(data: Union[str, bytes, Path]) -> dict[str, Any]:
+        """
+        Recebe uma string JSON, bytes ou caminho de arquivo .json
+        e retorna um dicionário Python.
+        """
+
+        try:
+            # Caso seja um caminho de arquivo
+            if isinstance(data, Path):
+                with open(data, "r", encoding="utf-8") as file:
+                    return json.load(file)
+
+            # Caso seja conteúdo JSON (str ou bytes)
+            if isinstance(data, bytes):
+                data = data.decode("utf-8")
+
+            # Garante que é string JSON
+            if isinstance(data, str):
+                return json.loads(data)
+
+            raise TypeError("Tipo de entrada inválido. Use str, bytes ou Path.")
+
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Erro ao decodificar JSON: {e}")
+        except Exception as e:
+            raise ValueError(f"Erro ao converter JSON para dict: {e}")

actions/data/microtime.py

@@ -0,0 +1,31 @@
+import time
+
+
+class Microtime:
+    """
+    Utilitário para manipulação de tempo com alta precisão (microssegundos).
+    """
+
+    @staticmethod
+    def get() -> float:
+        """
+        Retorna o timestamp Unix atual com precisão de microssegundos.
+        Equivalente ao microtime(true) do PHP.
+        """
+        return time.time()
+
+    @staticmethod
+    def as_int() -> int:
+        """
+        Retorna o tempo atual puramente em microssegundos (Inteiro).
+        Útil para gerar IDs únicos ou ordenação precisa.
+        """
+        # Pega em nanosegundos e converte para microssegundos
+        return time.time_ns() // 1000
+
+    @staticmethod
+    def diff(start_time: float) -> float:
+        """
+        Calcula a diferença (duração) em segundos com precisão.
+        """
+        return time.time() - start_time

actions/data/prepare_update_data.py

@@ -1,7 +1,10 @@
 from typing import Tuple, Dict, Any
 from pydantic import BaseModel
 
-def prepare_update_data(schema: BaseModel, exclude_fields: list[str] = None, id_field: str = "id") -> Tuple[Dict[str, Any], str]:
+
+def prepare_update_data(
+    schema: BaseModel, exclude_fields: list[str] = None, id_field: str = "id"
+) -> Tuple[Dict[str, Any], str]:
     """
     Gera dinamicamente os dados e SQL para update com base em um schema Pydantic.
 
@@ -21,11 +24,7 @@ def prepare_update_data(schema: BaseModel, exclude_fields: list[str] = None, id_
     data_dict = schema.model_dump(exclude_unset=True)
 
     # Monta lista dinâmica de campos para o SET
-    update_fields = [
+    update_fields = [f"{k} = :{k}" for k in data_dict.keys() if k not in exclude_fields]
-        f"{k} = :{k}"
-        for k in data_dict.keys()
-        if k not in exclude_fields
-    ]
 
     update_sql = ", ".join(update_fields)
     return data_dict, update_sql

actions/data/text.py

@@ -0,0 +1,111 @@
+# Importa a biblioteca nativa 'zlib' usada para compressão/descompressão de dados binários.
+import zlib
+
+# Importa a função 'rtf_to_text' da biblioteca 'striprtf',
+# responsável por converter documentos RTF em texto plano legível.
+from striprtf.striprtf import rtf_to_text
+
+
+# Define uma classe utilitária chamada 'Text', contendo apenas métodos estáticos.
+# Essa abordagem permite o uso direto sem necessidade de instanciar a classe.
+class Text:
+    @staticmethod
+    def decompress(vf_string):
+        """
+        Descomprime e decodifica texto de origem WPTools/Firebird.
+
+        Finalidade:
+            Converter o conteúdo de campos BLOB ou strings compactadas (como no Delphi)
+            em texto legível, detectando automaticamente se o conteúdo está:
+              - Compactado com zlib
+              - Codificado em ISO-8859-1 (padrão ANSI)
+              - Representado como bytes puros
+        """
+        # Verifica se o valor recebido é nulo, vazio ou None.
+        if not vf_string:
+            return ""
+
+        # Caso seja um objeto tipo stream (ex: campo BLOB do Firebird)
+        if hasattr(vf_string, "read"):
+            vf_string = vf_string.read()
+
+        # Garante que o valor trabalhado é uma sequência de bytes
+        if isinstance(vf_string, str):
+            vf_bytes = vf_string.encode("latin1", errors="ignore")
+        else:
+            vf_bytes = vf_string
+
+        # Detecta assinatura zlib (0x78 0x9C ou 0x78 0xDA)
+        is_zlib = (
+            len(vf_bytes) > 2 and vf_bytes[0] == 0x78 and vf_bytes[1] in (0x9C, 0xDA)
+        )
+
+        # Se for zlib, tenta descompactar
+        if is_zlib:
+            try:
+                return zlib.decompress(vf_bytes).decode("iso-8859-1", errors="ignore")
+            except Exception:
+                pass
+
+        # Caso não seja zlib, trata como texto puro
+        try:
+            return vf_bytes.decode("iso-8859-1", errors="ignore")
+        except Exception:
+            return str(vf_string)
+
+    @staticmethod
+    def compress(text, *, encoding: str = "iso-8859-1"):
+        """
+        Comprime texto/dados com zlib SEM Base64.
+
+        Parâmetros:
+            text: str | bytes | stream (com .read())
+            encoding: encoding usado quando 'text' for str (padrão: ISO-8859-1)
+
+        Retorno:
+            - bytes comprimidos (zlib)
+
+        Observações:
+            - Ideal para armazenamento direto em BLOB (Firebird, PostgreSQL, etc.)
+            - Evita overhead e custo do Base64
+            - Totalmente compatível com 'decompress'
+        """
+        if text is None or text == "":
+            return b""
+
+        # Se for stream (ex.: BLOB do Firebird)
+        if hasattr(text, "read"):
+            raw = text.read()
+        else:
+            raw = text
+
+        # Garante bytes
+        if isinstance(raw, str):
+            raw_bytes = raw.encode(encoding, errors="ignore")
+        else:
+            raw_bytes = bytes(raw)
+
+        # Comprime com zlib e retorna bytes
+        return zlib.compress(raw_bytes)
+
+    @staticmethod
+    def to_text(raw_text: str) -> str:
+        """
+        Converte o conteúdo RTF em texto simples e retorna como string.
+
+        Finalidade:
+            - Detectar automaticamente se o conteúdo está em formato RTF.
+            - Converter para texto plano usando a função 'rtf_to_text'.
+            - Retornar uma string limpa e pronta para uso.
+        """
+        if not raw_text:
+            return ""
+
+        # Detecta cabeçalho RTF
+        if raw_text.strip().startswith("{\\rtf"):
+            try:
+                return rtf_to_text(raw_text).strip()
+            except Exception:
+                return raw_text
+
+        return raw_text.strip()

actions/dynamic_import/dynamic_import.py

@@ -3,7 +3,6 @@ from actions.config.config import Config
 from typing import Optional, Any, Type
 
 
-
 class DynamicImport:
 
     def __init__(self) -> None:
@@ -18,7 +17,7 @@ class DynamicImport:
     def set_table(self, table: str):
         self.table = table
 
-    def service(self, name: str, class_name : str) -> Type[Any]:
+    def service(self, name: str, class_name: str) -> Type[Any]:
         try:
             # Define o nome do Módulo
             module_file = f"{name}"

actions/dynamic_import/service_factory.py

@@ -0,0 +1,64 @@
+import importlib
+import re
+from functools import lru_cache
+from typing import Type, TypeVar, Optional
+from actions.config.config import Config
+from actions.env.env_config_loader import EnvConfigLoader
+
+# Genérico para garantir que o retorno respeite o Protocolo
+T = TypeVar("T")
+
+
+class ServiceFactory:
+
+    def __init__(self, package: str, table: str):
+
+        # Instancia o loader com o prefixo correto
+        env = EnvConfigLoader(".env")
+
+        # Ex: "packages.v1"
+        self.base_root = "packages.v1"
+        self.package = package
+        self.table = table
+
+        # Carrega config apenas uma vez
+        self.app_config = Config.get("app.json")
+
+        # Define a UF da aplicação
+        self.current_state = env.ORIUS_CLIENT_STATE
+
+    @lru_cache(maxsize=32)
+    def make(self, class_name: str, interface: Type[T]) -> T:
+        """
+        Instancia um serviço dinamicamente com comportamento de Autoload.
+        """
+        # 1. Converte CamelCase para snake_case (Autoload style)
+        # Ex: TAtoIndexService -> t_ato_index_service
+        module_name = re.sub(r"(?<!^)(?=[A-Z])", "_", class_name).lower()
+
+        # 2. Monta o caminho completo
+        # Ex: packages.v1.servicos.balcao.services.t_ato.SP.t_ato_index_service
+        import_path = (
+            f"{self.base_root}.{self.package}.services."
+            f"{self.table}.{self.current_state}.{module_name}"
+        )
+
+        try:
+            # 3. Importação Dinâmica
+            module = importlib.import_module(import_path)
+
+            # 4. Pega a classe do módulo
+            clazz = getattr(module, class_name)
+
+            # 5. Retorna a INSTÂNCIA da classe (já com () )
+            # Se seus serviços precisam de argumentos no __init__, altere aqui.
+            return clazz()
+
+        except ImportError as e:
+            raise ImportError(
+                f"FATAL: Não foi possível carregar o serviço '{class_name}' para o estado '{self.current_state}'.\nCaminho tentado: {import_path}\nErro: {e}"
+            )
+        except AttributeError:
+            raise AttributeError(
+                f"FATAL: O arquivo '{module_name}.py' existe, mas a classe '{class_name}' não foi encontrada dentro dele."
+            )

actions/env/env_config_loader.py

@@ -0,0 +1,36 @@
+from dotenv import dotenv_values, load_dotenv
+import os
+
+
+class EnvConfigLoader:
+    """
+    Classe para carregar todas as variáveis de ambiente (.env)
+    e permitir acesso via atributo (settings.VAR).
+    """
+
+    def __init__(self, env_file: str = ".env"):
+
+        # Garante que o .env será carregado no ambiente do sistema
+        load_dotenv(env_file)
+
+        # Lê todas as variáveis (do arquivo + sistema)
+        self._values = {
+            **dotenv_values(env_file),  # Conteúdo do .env
+            **os.environ,  # Variáveis já existentes no ambiente
+        }
+
+    def __getattr__(self, name: str):
+        """Permite acessar como settings.VAR"""
+        # Normaliza o nome para maiúsculo
+        key = name.upper()
+        if key in self._values:
+            return self._values[key]
+        raise AttributeError(f"A variável '{name}' não existe no .env")
+
+    def __repr__(self):
+        """Exibe todas as variáveis carregadas"""
+        return f"<Settings {self._values}>"
+
+    def all(self) -> dict:
+        """Retorna todas as variáveis como dicionário"""
+        return dict(self._values)

actions/jwt/create_token.py

@@ -5,32 +5,30 @@ from pytz import timezone
 from abstracts.action import BaseAction
 from actions.config.config import Config
 
+
 class CreateToken(BaseAction):
     def __init__(self):
+
         # Busca as configurações da aplicação
-        self.config = Config.get('app.json')
+        self.config = Config.get("app.json")
 
         # Cria o timedelta com base na config
         self.access_token_expire = timedelta(
             minutes=self.config.jwt.expire.minute,
             hours=self.config.jwt.expire.hours,
-            days=self.config.jwt.expire.days
+            days=self.config.jwt.expire.days,
         )
 
-    def execute(self, tipo_token: str, data : str) -> str:
+    def execute(self, tipo_token: str, data: str) -> str:
 
-        sp = timezone('America/Sao_Paulo')
+        sp = timezone("America/Sao_Paulo")
         agora = datetime.now(tz=sp)
         expira = agora + self.access_token_expire
 
         # Define os dados do token
-        payload = {
+        payload = {"type": tipo_token, "exp": expira, "iat": agora, "data": str(data)}
-            'type' : tipo_token,
-            'exp' : expira,
-            'iat' : agora,
-            'data' : str(data)
-        }
 
         # Retorna os dados codificados
-        return jwt.encode(payload, self.config.jwt.token, algorithm=self.config.jwt.algorithm)
+        return jwt.encode(
-        
+            payload, self.config.jwt.token, algorithm=self.config.jwt.algorithm
+        )

actions/jwt/get_current_user.py

@@ -1,10 +1,11 @@
-from fastapi import Depends, HTTPException, status, Request
+from fastapi import Depends, HTTPException, status
 from fastapi.security import OAuth2PasswordBearer
 
 from actions.jwt.verify_token import VerifyToken  # A classe que criamos anteriormente
 
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")  # Apenas requerido pelo FastAPI
 
+
 def get_current_user(token: str = Depends(oauth2_scheme)):
 
     # Ação que válida o tokne
@@ -13,12 +14,12 @@ def get_current_user(token: str = Depends(oauth2_scheme)):
     result = verify_token.execute(token)
 
     # Verifica se a resposta é diferente de inválida
-    if result['status'] != 'valid':
+    if result["status"] != "valid":
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED,
-            detail=result.get('message', 'Token inválido ou expirado'),
+            detail=result.get("message", "Token inválido ou expirado"),
             headers={"WWW-Authenticate": "Bearer"},
         )
 
     # Retorna apenas os dados do token
-    return result['payload']
+    return result["payload"]

actions/jwt/verify_token.py

@@ -1,6 +1,4 @@
-from datetime import datetime
 from jose import jwt, JWTError, ExpiredSignatureError
-from pytz import timezone
 
 from actions.config.config import Config
 

actions/session/get_session.py

@@ -0,0 +1,11 @@
+from fastapi import Request, HTTPException, status
+
+
+def get_session_user(request: Request) -> dict:
+    user = request.session.get("user")
+    if not user:
+        # ajuste conforme sua regra (pode só retornar None)
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED, detail="Sessão inválida"
+        )
+    return user

actions/session/session_services.py

@@ -0,0 +1,16 @@
+# services/session_service.py
+from fastapi import Request
+
+
+class SessionService:
+    def __init__(self, request: Request):
+        self._session = request.session
+
+    def set(self, k, v):
+        self._session[k] = v
+
+    def get(self, k, d=None):
+        return self._session.get(k, d)
+
+    def clear(self):
+        self._session.clear()

actions/system/handlers.py

@@ -1,5 +1,4 @@
 # handlers.py
-import json
 import traceback
 
 from fastapi import Request
@@ -13,74 +12,58 @@ from actions.log.log import Log
 
 def register_exception_handlers(app):
 
-    def __init__ (self):
+    def __init__(self):
         log = Log()
 
     @app.exception_handler(BusinessRuleException)
-    async def business_rule_exception_handler(request: Request, exc: BusinessRuleException):
+    async def business_rule_exception_handler(
+        request: Request, exc: BusinessRuleException
+    ):
 
-        response = {
+        response = {"status": "422", "error": "Regra de negócio", "detail": exc.message}
-                "status": "422",
-                "error": "Regra de negócio", 
-                "detail": exc.message
-            }
 
         # Salva o log em disco
-        Log.register(response, 'storage/temp/business_rule_exception_handler.json')
+        Log.register(response, "storage/temp/business_rule_exception_handler.json")
 
-        return JSONResponse(
+        return JSONResponse(status_code=422, content=response)
-            status_code=422,
-            content=response
-        )
 
     @app.exception_handler(StarletteHTTPException)
     async def http_exception_handler(request: Request, exc: StarletteHTTPException):
         response = {
-                "status": exc.status_code,
+            "status": exc.status_code,
-                    "error": "HTTP Error", 
+            "error": "HTTP Error",
-                    "detail": exc.detail
+            "detail": exc.detail,
-            }
+        }
 
         # Salva o log em disco
-        Log.register(response, 'storage/temp/http_exception_handler.json')
+        Log.register(response, "storage/temp/http_exception_handler.json")
 
-        return JSONResponse(
+        return JSONResponse(status_code=exc.status_code, content=response)
-            status_code=exc.status_code,
-            content=response
-        )
 
     @app.exception_handler(RequestValidationError)
-    async def validation_exception_handler(request: Request, exc: RequestValidationError):
+    async def validation_exception_handler(
+        request: Request, exc: RequestValidationError
+    ):
 
-        response = {
+        response = {"status": 400, "error": "Erro de validação", "detail": exc.errors()}
-                "status": 400,
-                "error": "Erro de validação", 
-                "detail": exc.errors()
-            }
 
         # Salva o log em disco
-        Log.register(response, 'storage/temp/validation_exception_handler.json')
+        Log.register(response, "storage/temp/validation_exception_handler.json")
 
-        return JSONResponse(
+        return JSONResponse(status_code=400, content=response)
-            status_code=400,
-            content=response
-        )
 
     @app.exception_handler(Exception)
     async def global_exception_handler(request: Request, exc: Exception):
 
         response = {
-                "status": 500,
+            "status": 500,
-                "error": "Erro Interno do Servidor",
+            "error": "Erro Interno do Servidor",
-                "type": type(exc).__name__,
+            "type": type(exc).__name__,
-                "message": str(exc),
+            "message": str(exc),
-                "trace": traceback.format_exc()
+            "trace": traceback.format_exc(),
-            }
+        }
 
         # Salva o log em disco
-        Log.register(response, 'storage/temp/validation_exception_handler.json')
+        Log.register(response, "storage/temp/validation_exception_handler.json")
 
-        return JSONResponse(
+        return JSONResponse(status_code=500, content=response)
-            status_code=500,
-            content=response
-        )

actions/validations/cep.py

@@ -1,4 +1,3 @@
-
 class CEP:
 
     @staticmethod

actions/values/values.py

@@ -0,0 +1,14 @@
+from decimal import ROUND_HALF_UP, Decimal
+
+
+class Values:
+
+    @staticmethod
+    def percent(value: Decimal, percent: Decimal) -> Decimal:
+
+        return value / percent
+
+    @staticmethod
+    def money(scale: str, value: Decimal) -> Decimal:
+
+        return value.quantize(scale, rounding=ROUND_HALF_UP)

api.code-workspace

@@ -0,0 +1,186 @@
+{
+  "folders": [
+    {
+      "path": "D:/IIS/Orius/api"
+    }
+  ],
+  "settings": {
+    // === ⚙️ GERAL ===
+    "editor.formatOnSave": true,
+    "editor.codeActionsOnSave": {
+      "source.fixAll": "explicit",
+      "source.organizeImports": "explicit"
+    },
+    "editor.formatOnPaste": false,
+    "editor.formatOnType": false,
+    "editor.minimap.enabled": false,
+    "files.trimTrailingWhitespace": true,
+    "files.autoSave": "onFocusChange",
+    "telemetry.telemetryLevel": "off",
+    "update.mode": "manual",
+    "workbench.startupEditor": "none",
+    "workbench.editor.enablePreview": false,
+    // === ⚡ PERFORMANCE ===
+    "files.watcherExclude": {
+      "**/__pycache__/**": true,
+      "**/.mypy_cache/**": true,
+      "**/.pytest_cache/**": true,
+      "**/.venv/**": true,
+      "**/venv/**": true,
+      "**/.git/**": true
+    },
+    "search.exclude": {
+      "**/__pycache__": true,
+      "**/.git": true,
+      "**/.mypy_cache": true,
+      "**/.pytest_cache": true
+    },
+    // === 🐍 PYTHON ===
+    "python.defaultInterpreterPath": "D:/IIS/Orius/api/venv/Scripts/python.exe",
+    "python.languageServer": "Pylance",
+    "python.analysis.autoImportCompletions": true,
+    "python.analysis.indexing": true,
+    "python.analysis.typeCheckingMode": "basic",
+    "python.analysis.useLibraryCodeForTypes": true,
+    "python.analysis.memory.keepLibraryAst": false,
+    // === 🧹 FORMATADOR ===
+    "python.formatting.provider": "black",
+    "python.formatting.blackArgs": [
+      "--line-length",
+      "100"
+    ],
+    // === ✅ LINTING ===
+    "python.linting.enabled": true,
+    "python.linting.pylintEnabled": false,
+    "python.linting.flake8Enabled": true,
+    "python.linting.flake8Args": [
+      "--max-line-length=100"
+    ],
+    // === 🧩 FORMATAÇÃO LOCAL ===
+    "[python]": {
+      "editor.defaultFormatter": "ms-python.black-formatter",
+      "editor.formatOnSave": true
+    },
+    // === 🧠 GIT ===
+    "git.enabled": true,
+    "git.autorefresh": true,
+    "git.confirmSync": false,
+    "git.fetchOnPull": true,
+    "git.countBadge": "tracked",
+    "git.pruneOnFetch": true,
+    "git.postCommitCommand": "sync",
+    "git.openDiffOnClick": true,
+    "git.decorations.enabled": true,
+    // === 🔍 GITLENS ===
+    "gitlens.advanced.messages": {
+      "suppressShowKeyBindingsNotice": true
+    },
+    "gitlens.codeLens.enabled": false,
+    "gitlens.currentLine.enabled": false,
+    "gitlens.hovers.enabled": true,
+    "gitlens.views.repositories.autoRefresh": true,
+    "gitlens.views.repositories.location": "scm",
+    "gitlens.defaultDateFormat": "DD/MM/YYYY HH:mm",
+    "gitlens.defaultDateShortFormat": "DD/MM HH:mm",
+    "gitlens.statusBar.enabled": true,
+    // === 💻 TERMINAIS INTEGRADOS ===
+    "terminal.integrated.profiles.windows": {
+      "FastAPI Dev": {
+        "path": "cmd.exe",
+        "args": [
+          "/k",
+          "cd D:\\IIS\\Orius\\api && venv\\Scripts\\activate && uvicorn main:app --reload --log-level debug"
+        ]
+      },
+      "FastAPI Prod": {
+        "path": "cmd.exe",
+        "args": [
+          "/k",
+          "cd D:\\IIS\\Orius\\api && venv\\Scripts\\activate && uvicorn main:app --host 0.0.0.0 --port 8000"
+        ]
+      },
+      "FastAPI Test": {
+        "path": "cmd.exe",
+        "args": [
+          "/k",
+          "cd D:\\IIS\\Orius\\api && venv\\Scripts\\activate && pytest -v"
+        ]
+      },
+      "Python Shell": {
+        "path": "cmd.exe",
+        "args": [
+          "/k",
+          "cd D:\\IIS\\Orius\\api && venv\\Scripts\\activate"
+        ]
+      },
+      "Git Bash": {
+        "path": "C:\\Program Files\\Git\\bin\\bash.exe"
+      }
+    },
+    "terminal.integrated.defaultProfile.windows": "FastAPI Dev",
+    "terminal.integrated.scrollback": 10000,
+    "terminal.integrated.enablePersistentSessions": false,
+    // === 🧪 TESTES ===
+    "python.testing.pytestEnabled": true,
+    "python.testing.unittestEnabled": false,
+    "python.testing.autoTestDiscoverOnSaveEnabled": true,
+    // === 🗂️ ARQUIVOS ===
+    "files.exclude": {
+      "**/.DS_Store": true,
+      "**/*.log": true
+    }
+  },
+  "launch": {
+    "version": "0.2.0",
+    "configurations": [
+      {
+        "name": "Debug FastAPI",
+        "type": "python",
+        "request": "launch",
+        "module": "uvicorn",
+        "args": [
+          "main:app",
+          "--reload",
+          "--host",
+          "127.0.0.1",
+          "--port",
+          "8000"
+        ],
+        "jinja": true,
+        "justMyCode": true,
+        "cwd": "${workspaceFolder}",
+        "env": {
+          "PYTHONPATH": "${workspaceFolder}"
+        }
+      },
+      {
+        "name": "Pytest All",
+        "type": "python",
+        "request": "launch",
+        "program": "${workspaceFolder}/venv/Scripts/pytest.exe",
+        "args": [
+          "-v"
+        ],
+        "console": "integratedTerminal"
+      }
+    ]
+  },
+  "extensions": {
+    "recommendations": [
+      // === 🐍 PYTHON ===
+      "ms-python.python",
+      "ms-python.pylance",
+      "ms-python.black-formatter",
+      "ms-python.flake8",
+      "littlefoxteam.vscode-python-test-adapter",
+      // === 🔍 GIT ===
+      "eamodio.gitlens",
+      "mhutchie.git-graph",
+      "donjayamanne.githistory",
+      // === 🧰 UTILITÁRIOS ===
+      "formulahendry.code-runner",
+      "streetsidesoftware.code-spell-checker",
+      "tamasfe.even-better-toml"
+    ]
+  }
+}

config/database/firebird.json

@@ -0,0 +1,13 @@
+{
+  "host": "localhost",
+  "name": "/database/BASE.FDB",
+  "port": 3050,
+  "user": "SYSDBA",
+  "password": "302b3c",
+  "charset": "UTF8",
+  "pool" : {
+    "pre_ping" : true,
+    "size" : 5,
+    "max_overflow" :10
+  }
+}

database/firebird.py

@@ -1,8 +1,7 @@
 from typing import Optional
 from sqlalchemy import create_engine
 from sqlalchemy.engine import Engine
-
+from actions.env.env_config_loader import EnvConfigLoader
-from actions.config.config import Config
 
 
 class Firebird:
@@ -10,28 +9,29 @@ class Firebird:
 
     @classmethod
     def get_engine(cls) -> Engine:
-        # Obtem as configurações do arquivo JSON
+
-        database = Config.get('database/firebird.json')
+        # Instancia o loader com o prefixo correto
+        env_database = EnvConfigLoader(".env")
 
         # Cria a engine apenas uma vez
         if cls._engine is None:
 
             # DSN para o SQLAlchemy usando firebird-driver
             dsn = (
-                f"firebird+firebird://{database.user}:"
+                f"firebird+firebird://{env_database.ORIUS_API_FDB_USER}:"
-                f"{database.password}@"
+                f"{env_database.ORIUS_API_FDB_PASSWORD}@"
-                f"{database.host}:"
+                f"{env_database.ORIUS_API_FDB_HOST}:"
-                f"{database.port}/"
+                f"{env_database.ORIUS_API_FDB_PORT}/"
-                f"{database.name}"
+                f"{env_database.ORIUS_API_FDB_NAME}"
             )
 
             # Criação da engine SQLAlchemy
             cls._engine = create_engine(
                 dsn,
-                connect_args={"charset": database.charset},
+                connect_args={"charset": env_database.ORIUS_API_FDB_CHARSET},
-                pool_pre_ping=bool(database.pool.pre_ping),
+                pool_pre_ping=bool(env_database.ORIUS_API_FDB_POOL_PRE_PING),
-                pool_size=database.pool.size,
+                pool_size=int(env_database.ORIUS_API_FDB_POOL_SIZE),
-                max_overflow=database.pool.max_overflow,
+                max_overflow=int(env_database.ORIUS_API_FDB_POOL_MAX_OVERFLOW),
             )
 
         return cls._engine

env.bat

@@ -0,0 +1,17 @@
+@echo off
+echo === Registrando variáveis de ambiente ORIUS_API ===
+
+setx ORIUS_API_FDB_HOST "localhost"
+setx ORIUS_API_FDB_NAME "S:\Bases\SANTARITA.FDB"
+setx ORIUS_API_FDB_PORT "3050"
+setx ORIUS_API_FDB_USER "SYSDBA"
+setx ORIUS_API_FDB_PASSWORD "302b3c"
+setx ORIUS_API_FDB_CHARSET "UTF8"
+setx ORIUS_API_FDB_POOL_PRE_PING "true"
+setx ORIUS_API_FDB_POOL_SIZE "5"
+setx ORIUS_API_FDB_POOL_MAX_OVERFLOW "10"
+
+echo.
+echo Variáveis ORIUS_API registradas com sucesso!
+echo Reinicie o terminal ou o computador para aplicar as alterações.
+pause

interfaces/service_protocols.py

@@ -0,0 +1,10 @@
+from typing import Protocol, Any, runtime_checkable
+
+
+@runtime_checkable
+class ServiceProtocolsInterface(Protocol):
+    """
+    Contrato que garante que todo serviço tenha um método execute.
+    """
+
+    def execute(self, schema: Any) -> Any: ...

main.py

@@ -1,32 +1,46 @@
 # Ajuste para garantir que o diretório base do projeto seja incluído no PYTHONPATH
 import os
+import platform
 import sys
 
+from starlette.middleware.sessions import SessionMiddleware
+
 # Adiciona o diretório atual (onde está o main.py) ao sys.path
-sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+from firebird.driver import driver_config
 
 # Importa a classe principal do FastAPI
 from fastapi import FastAPI, Request
 from pathlib import Path
+
 # Importa o middleware de CORS
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import Response
+from fastapi.staticfiles import StaticFiles
-from starlette.middleware.base import BaseHTTPMiddleware
 
 # Importa o roteador principal da API versão 1
 from packages.v1.api import api_router
-from packages.v1.system.service.startup_check_service import \
+from packages.v1.system.service.startup_check_service import StartupCheckService
-    StartupCheckService
 
 # Importa as configurações globais da aplicação
 from actions.log.log import Log
 from actions.config.config import Config
 from actions.system.handlers import register_exception_handlers
 
-config = Config.get('app.json')
+if platform.system() == "Windows":
+
+    # Ajuste o caminho abaixo para onde o Firebird está instalado:
+    FB_DIR = r"C:\Program Files\Firebird\Firebird_4_0"
+    os.add_dll_directory(FB_DIR)
+
+    driver_config.fb_client_library.value = (
+        r"C:\Program Files\Firebird\Firebird_4_0\fbclient.dll"
+    )
+
+config = Config.get("app.json")
 
 # Instancia o app FastAPI com um título personalizado
-app = FastAPI(title='SAAS Orius')
+app = FastAPI(title="SAAS Orius")
 
 # Controle de erros personalizados
 register_exception_handlers(app)
@@ -34,12 +48,24 @@ register_exception_handlers(app)
 # Adiciona o middleware de CORS
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["http://localhost:3000"],  # Domínio do frontend
+    allow_origins=["*"],  # Domínio do frontend
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
+app.add_middleware(
+    SessionMiddleware,
+    secret_key="coloque-uma-secret-bem-grande-e-aleatoria",
+    session_cookie="sid",
+    same_site="lax",
+    https_only=True,
+    max_age=60 * 60 * 8,
+)
+
+app.mount(path="/temp", app=StaticFiles(directory="./storage/temp"), name="temp")
+
+
 @app.on_event("startup")
 async def on_startup():
 
@@ -49,18 +75,19 @@ async def on_startup():
     # Exibe o amarzenamento do servidor
     print(startupCheckService.execute())
 
+
 @app.middleware("http")
 async def log_tempo_requisicao(request: Request, call_next):
 
     # Ação responsavel por registrar o log de requisição
     log = Log()
-    config = Config.get('app.json')
+    config = Config.get("app.json")
 
     # Obtem os dados da requisição
     log_data = {
         "method": request.method,
         "url": str(request.url),
-        "headers": dict(request.headers)
+        "headers": dict(request.headers),
     }
 
     # Gera o nome do arquivo
@@ -74,16 +101,18 @@ async def log_tempo_requisicao(request: Request, call_next):
 
     return response
 
+
 # Inclui as rotas da versão 1 da API com prefixo definido em settings (ex: /api/v1)
 app.include_router(api_router, prefix=config.url)
 
 # Executa o servidor com Uvicorn se este arquivo for executado diretamente
-if __name__ == '__main__':
+if __name__ == "__main__":
     import uvicorn
+
     uvicorn.run(
-        "main:app",           # Caminho do app para execução
+        "main:app",  # Caminho do app para execução
-        host="0.0.0.0",       # Disponibiliza a aplicação externamente
+        host="0.0.0.0",  # Disponibiliza a aplicação externamente
-        port=8000,            # Porta padrão
+        port=8000,  # Porta padrão
-        log_level='info',     # Define o nível de log para desenvolvimento
+        log_level="info",  # Define o nível de log para desenvolvimento
-        reload=True           # Ativa auto-reload durante desenvolvimento
+        reload=True,  # Ativa auto-reload durante desenvolvimento
     )

packages/v1/administrativo/actions/c_caixa_item/c_caixa_item_index_action.py

@@ -1,7 +1,5 @@
 from packages.v1.administrativo.repositories.c_caixa_item.c_caixa_item_index import \
     Index
-from packages.v1.administrativo.schemas.c_caixa_item_schema import \
-    CaixaItemSearchSchema
 from abstracts.action import BaseAction
 
 

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

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

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

@@ -1,5 +1,8 @@
 from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.c_caixa_servico.c_caixa_servico_index_repository import IndexRepository
+from packages.v1.administrativo.repositories.c_caixa_servico.c_caixa_servico_index_repository import (
+    IndexRepository,
+)
+
 
 class IndexAction(BaseAction):
 

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

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

packages/v1/administrativo/actions/g_cartorio/g_cartorio_delete_action.py

@@ -0,0 +1,35 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_cartorio.g_cartorio_delete_repository import (
+    GCartorioDeleteRepository,
+)
+from packages.v1.administrativo.schemas.g_cartorio_schema import GCartorioIdSchema
+
+
+class GCartorioDeleteAction(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 G_CARTORIO.
+    """
+
+    def execute(self, g_cartorio_id_schema: GCartorioIdSchema):
+        """
+        Executa a operação de exclusão no banco de dados.
+
+        Args:
+            g_cartorio_id_schema (GCartorioIdSchema):
+                O esquema contendo o ID do registro a ser excluído.
+
+        Returns:
+            O resultado da operação de exclusão.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        g_cartorio_delete_repository = GCartorioDeleteRepository()
+
+        # ----------------------------------------------------
+        # Execução da exclusão
+        # ----------------------------------------------------
+        response = g_cartorio_delete_repository.execute(g_cartorio_id_schema)
+
+        return response

packages/v1/administrativo/actions/g_cartorio/g_cartorio_index_action.py

@@ -0,0 +1,37 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_cartorio.g_cartorio_index_repository import (
+    GCartorioIndexRepository,
+)
+
+
+class GCartorioIndexAction(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):
+        """
+        Executa a operação de listagem no banco de dados.
+
+        Args:
+            g_cartorio_index_schema (GCartorioIndexSchema):
+                Esquema contendo parâmetros opcionais de filtro.
+
+        Returns:
+            A lista de registros encontrados.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        g_cartorio_index_repository = GCartorioIndexRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = g_cartorio_index_repository.execute()
+
+        # ----------------------------------------------------
+        # Retorno da informação
+        # --------------------------------
+        return response

packages/v1/administrativo/actions/g_cartorio/g_cartorio_save_action.py

@@ -0,0 +1,38 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_cartorio.g_cartorio_save_repository import (
+    GCartorioSaveRepository,
+)
+from packages.v1.administrativo.schemas.g_cartorio_schema import GCartorioSaveSchema
+
+
+class GCartorioSaveAction(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 G_GRAMATICA.
+    """
+
+    def execute(self, g_cartorio_save_schema: GCartorioSaveSchema):
+        """
+        Executa a operação de salvamento.
+
+        Args:
+            g_cartorio_schema (GCartorioSchema):
+                O esquema com os dados a serem persistidos.
+
+        Returns:
+            O resultado da operação de salvamento.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        g_cartorio_save_repository = GCartorioSaveRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = g_cartorio_save_repository.execute(g_cartorio_save_schema)
+
+        # ----------------------------------------------------
+        # Retorno da informação
+        # ----------------------------------------------------
+        return response

packages/v1/administrativo/actions/g_cartorio/g_cartorio_show_action.py

@@ -0,0 +1,38 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_cartorio.g_cartorio_show_repository import (
+    GCartorioShowRepository,
+)
+from packages.v1.administrativo.schemas.g_cartorio_schema import GCartorioIdSchema
+
+
+class GCartorioShowAction(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, g_cartorio_id_schema: GCartorioIdSchema):
+        """
+        Executa a operação de exibição.
+
+        Args:
+            g_cartorio_id_schema (GCartorioIdSchema):
+                O esquema com o ID do registro a ser exibido.
+
+        Returns:
+            O resultado da operação de exibição.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        g_cartorio_show_repository = GCartorioShowRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = g_cartorio_show_repository.execute(g_cartorio_id_schema)
+
+        # ----------------------------------------------------
+        # Retorno da informação
+        # ----------------------------------------------------
+        return response

packages/v1/administrativo/actions/g_cartorio/g_cartorio_update_action.py

@@ -0,0 +1,38 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_cartorio.g_cartorio_update_repository import (
+    GCartorioUpdateRepository,
+)
+from packages.v1.administrativo.schemas.g_cartorio_schema import GCartorioUpdateSchema
+
+
+class GCartorioUpdateAction(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, g_cartorio_update_schema: GCartorioUpdateSchema):
+        """
+        Executa a operação de atualização.
+
+        Args:
+            g_cartorio_update_schema (GCartorioUpdateSchema):
+                O esquema com os dados a serem atualizados.
+
+        Returns:
+            O resultado da operação de atualização.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório de atualização
+        # ----------------------------------------------------
+        g_cartorio_update_repository = GCartorioUpdateRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = g_cartorio_update_repository.execute(g_cartorio_update_schema)
+
+        # ----------------------------------------------------
+        # Retorno do resultado
+        # ----------------------------------------------------
+        return response

packages/v1/administrativo/actions/g_emolumento/g_emolumento_delete_action.py

@@ -0,0 +1,35 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_emolumento.g_emolumento_delete_repository import (
+    GEmolumentoDeleteRepository,
+)
+from packages.v1.administrativo.schemas.g_emolumento_schema import GEmolumentoIdSchema
+
+
+class GEmolumentoDeleteAction(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 G_EMOLUMENTO.
+    """
+
+    def execute(self, g_emolumento_id_schema: GEmolumentoIdSchema):
+        """
+        Executa a operação de exclusão no banco de dados.
+
+        Args:
+            g_emolumento_id_schema (GEmolumentoIdSchema):
+                O esquema contendo o ID do registro a ser excluído.
+
+        Returns:
+            O resultado da operação de exclusão.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        g_emolumento_delete_repository = GEmolumentoDeleteRepository()
+
+        # ----------------------------------------------------
+        # Execução da exclusão
+        # ----------------------------------------------------
+        response = g_emolumento_delete_repository.execute(g_emolumento_id_schema)
+
+        return response

packages/v1/administrativo/actions/g_emolumento/g_emolumento_index_by_sistema_id_action.py

@@ -0,0 +1,44 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_emolumento.g_emolumento_index_by_sistema_id_repository import (
+    GEmolumentoIndexBySistemaIdRepository,
+)
+from packages.v1.administrativo.schemas.g_emolumento_schema import (
+    GEmolumentoSistemaIdSchema,
+)
+
+
+class GEmolumentoIndexBySistemaIdAction(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, g_emolumento_sistema_id_schema: GEmolumentoSistemaIdSchema):
+        """
+        Executa a operação de exibição.
+
+        Args:
+            g_emolumento_id_schema (GEmolumentoIdSchema):
+                O esquema com o ID do registro a ser exibido.
+
+        Returns:
+            O resultado da operação de exibição.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        g_emolumento_index_by_sistema_id_repository = (
+            GEmolumentoIndexBySistemaIdRepository()
+        )
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = g_emolumento_index_by_sistema_id_repository.execute(
+            g_emolumento_sistema_id_schema
+        )
+
+        # ----------------------------------------------------
+        # Retorno da informação
+        # ----------------------------------------------------
+        return response

packages/v1/administrativo/actions/g_emolumento/g_emolumento_save_action.py

@@ -0,0 +1,38 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_emolumento.g_emolumento_save_repository import (
+    GEmolumentoSaveRepository,
+)
+from packages.v1.administrativo.schemas.g_emolumento_schema import GEmolumentoSaveSchema
+
+
+class GEmolumentoSaveAction(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 G_EMOLUMENTO.
+    """
+
+    def execute(self, g_emolumento_save_schema: GEmolumentoSaveSchema):
+        """
+        Executa a operação de salvamento.
+
+        Args:
+            g_emolumento_schema (GEmolumentoSchema):
+                O esquema com os dados a serem persistidos.
+
+        Returns:
+            O resultado da operação de salvamento.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        g_emolumento_save_repository = GEmolumentoSaveRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = g_emolumento_save_repository.execute(g_emolumento_save_schema)
+
+        # ----------------------------------------------------
+        # Retorno da informação
+        # ----------------------------------------------------
+        return response

packages/v1/administrativo/actions/g_emolumento/g_emolumento_show_action.py

@@ -0,0 +1,38 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_emolumento.g_emolumento_show_repository import (
+    GEmolumentoShowRepository,
+)
+from packages.v1.administrativo.schemas.g_emolumento_schema import GEmolumentoIdSchema
+
+
+class GEmolumentoShowAction(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, g_emolumento_id_schema: GEmolumentoIdSchema):
+        """
+        Executa a operação de exibição.
+
+        Args:
+            g_emolumento_id_schema (GEmolumentoIdSchema):
+                O esquema com o ID do registro a ser exibido.
+
+        Returns:
+            O resultado da operação de exibição.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        g_emolumento_show_repository = GEmolumentoShowRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = g_emolumento_show_repository.execute(g_emolumento_id_schema)
+
+        # ----------------------------------------------------
+        # Retorno da informação
+        # ----------------------------------------------------
+        return response

packages/v1/administrativo/actions/g_emolumento/g_emolumento_update_action.py

@@ -0,0 +1,40 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_emolumento.g_emolumento_update_repository import (
+    GEmolumentoUpdateRepository,
+)
+from packages.v1.administrativo.schemas.g_emolumento_schema import (
+    GEmolumentoUpdateSchema,
+)
+
+
+class GEmolumentoUpdateAction(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, g_emolumento_update_schema: GEmolumentoUpdateSchema):
+        """
+        Executa a operação de atualização.
+
+        Args:
+            g_emolumento_update_schema (GEmolumentoUpdateSchema):
+                O esquema com os dados a serem atualizados.
+
+        Returns:
+            O resultado da operação de atualização.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório de atualização
+        # ----------------------------------------------------
+        g_emolumento_update_repository = GEmolumentoUpdateRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = g_emolumento_update_repository.execute(g_emolumento_update_schema)
+
+        # ----------------------------------------------------
+        # Retorno do resultado
+        # ----------------------------------------------------
+        return response

packages/v1/administrativo/actions/g_emolumento_item/g_emolumento_item_delete_action.py

@@ -0,0 +1,39 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_emolumento_item.g_emolumento_item_delete_repository import (
+    GEmolumentoItemDeleteRepository,
+)
+from packages.v1.administrativo.schemas.g_emolumento_item_schema import (
+    GEmolumentoItemIdSchema,
+)
+
+
+class GEmolumentoItemDeleteAction(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 G_EMOLUMENTO_ITEM.
+    """
+
+    def execute(self, g_emolumento_item_id_schema: GEmolumentoItemIdSchema):
+        """
+        Executa a operação de exclusão no banco de dados.
+
+        Args:
+            g_emolumento_item_id_schema (GEmolumentoItemIdSchema):
+                O esquema contendo o ID do registro a ser excluído.
+
+        Returns:
+            O resultado da operação de exclusão.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        g_emolumento_item_delete_repository = GEmolumentoItemDeleteRepository()
+
+        # ----------------------------------------------------
+        # Execução da exclusão
+        # ----------------------------------------------------
+        response = g_emolumento_item_delete_repository.execute(
+            g_emolumento_item_id_schema
+        )
+
+        return response

packages/v1/administrativo/actions/g_emolumento_item/g_emolumento_item_get_faixa_valor_action.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from decimal import Decimal
+from typing import Iterable, Optional, Protocol, Any
+
+
+class EmolumentoItemLike(Protocol):
+    """Protocolo mínimo esperado para um item de emolumento."""
+
+    valor_inicio: Optional[Decimal]
+    valor_fim: Optional[Decimal]
+
+
+class GEmolumentoItemGetFaixaValorAction:
+    """
+    Responsável por escolher, dentre uma coleção de itens de emolumento,
+    aquele cuja faixa [valor_inicio, valor_fim] contem o valor_documento.
+    - Se houver mais de um candidato, prioriza o de maior valor_inicio (faixa mais específica).
+    - Se não houver faixa que contenha o valor_documento, tenta a faixa 'aberta' (valor_fim nulo).
+    - Persistindo a ausência, retorna o item cujo valor_inicio é o mais próximo abaixo do valor_documento.
+    """
+
+    @staticmethod
+    def _para_decimal(valor: Any, padrao: str = "0") -> Decimal:
+        return valor if isinstance(valor, Decimal) else Decimal(str(valor or padrao))
+
+    def execute(
+        self,
+        itens: Iterable[EmolumentoItemLike],
+        valor_documento: Decimal,
+    ) -> EmolumentoItemLike:
+        lista = list(itens)
+        if not lista:
+            raise ValueError("Nenhum item de emolumento foi informado.")
+
+        valor_doc = self._para_decimal(valor_documento)
+
+        candidatos: list[tuple[Decimal, Decimal, EmolumentoItemLike]] = []
+        abertos: list[tuple[Decimal, EmolumentoItemLike]] = []
+        abaixo: list[tuple[Decimal, EmolumentoItemLike]] = []
+
+        for item in lista:
+            ini = self._para_decimal(getattr(item, "valor_inicio", None))
+            fim_raw = getattr(item, "valor_fim", None)
+            fim = (
+                self._para_decimal(fim_raw, padrao="Infinity")
+                if fim_raw is not None
+                else Decimal("Infinity")
+            )
+
+            if ini <= valor_doc <= fim:
+                candidatos.append((ini, fim, item))
+            elif fim == Decimal("Infinity") and ini <= valor_doc:
+                abertos.append((ini, item))
+            elif ini <= valor_doc:
+                abaixo.append((ini, item))
+
+        if candidatos:
+            candidatos.sort(key=lambda t: (t[0], t[1]))  # maior ini e menor fim
+            return candidatos[-1][2]
+
+        if abertos:
+            abertos.sort(key=lambda t: t[0])  # maior ini
+            return abertos[-1][1]
+
+        if abaixo:
+            abaixo.sort(key=lambda t: t[0])  # maior ini
+            return abaixo[-1][1]
+
+        # Fallback: não há faixa adequada nem valores abaixo; devolve o de menor valor_inicio
+        lista_ordenada = sorted(
+            lista, key=lambda it: self._para_decimal(getattr(it, "valor_inicio", None))
+        )
+        return lista_ordenada[0]

packages/v1/administrativo/actions/g_emolumento_item/g_emolumento_item_index_action.py

@@ -0,0 +1,44 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_emolumento_item.g_emolumento_item_index_repository import (
+    GEmolumentoItemIndexRepository,
+)
+from packages.v1.administrativo.schemas.g_emolumento_item_schema import (
+    GEmolumentoItemIndexSchema,
+)
+
+
+class GEmolumentoItemIndexAction(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, g_emolumento_item_emolumento_index_schema: GEmolumentoItemIndexSchema
+    ):
+        """
+        Executa a operação de listagem no banco de dados.
+
+        Args:
+            g_emolumento_item_index_schema (GEmolumentoItemIndexSchema):
+                Esquema contendo parâmetros opcionais de filtro.
+
+        Returns:
+            A lista de registros encontrados.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        g_emolumento_item_index_repository = GEmolumentoItemIndexRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = g_emolumento_item_index_repository.execute(
+            g_emolumento_item_emolumento_index_schema
+        )
+
+        # ----------------------------------------------------
+        # Retorno da informação
+        # --------------------------------
+        return response

packages/v1/administrativo/actions/g_emolumento_item/g_emolumento_item_save_action.py

@@ -0,0 +1,36 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_emolumento_item.g_emolumento_item_save_repository import GEmolumentoItemSaveRepository
+from packages.v1.administrativo.schemas.g_emolumento_item_schema import GEmolumentoItemSaveSchema
+
+
+class GEmolumentoItemSaveAction(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 G_EMOLUMENTO_ITEM.
+    """
+
+    def execute(self, g_emolumento_item_save_schema: GEmolumentoItemSaveSchema):
+        """
+        Executa a operação de salvamento.
+
+        Args:
+            g_emolumento_item_schema (GEmolumentoItemSchema):
+                O esquema com os dados a serem persistidos.
+
+        Returns:
+            O resultado da operação de salvamento.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        g_emolumento_item_save_repository = GEmolumentoItemSaveRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = g_emolumento_item_save_repository.execute(g_emolumento_item_save_schema)
+
+        # ----------------------------------------------------
+        # Retorno da informação
+        # ----------------------------------------------------
+        return response

packages/v1/administrativo/actions/g_emolumento_item/g_emolumento_item_show_action.py

@@ -0,0 +1,42 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_emolumento_item.g_emolumento_item_show_repository import (
+    GEmolumentoItemShowRepository,
+)
+from packages.v1.administrativo.schemas.g_emolumento_item_schema import (
+    GEmolumentoItemIdSchema,
+)
+
+
+class GEmolumentoItemShowAction(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, g_emolumento_item_id_schema: GEmolumentoItemIdSchema):
+        """
+        Executa a operação de exibição.
+
+        Args:
+            g_emolumento_item_id_schema (GEmolumentoItemIdSchema):
+                O esquema com o ID do registro a ser exibido.
+
+        Returns:
+            O resultado da operação de exibição.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        g_emolumento_item_show_repository = GEmolumentoItemShowRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = g_emolumento_item_show_repository.execute(
+            g_emolumento_item_id_schema
+        )
+
+        # ----------------------------------------------------
+        # Retorno da informação
+        # ----------------------------------------------------
+        return response

packages/v1/administrativo/actions/g_emolumento_item/g_emolumento_item_update_action.py

@@ -0,0 +1,42 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_emolumento_item.g_emolumento_item_update_repository import (
+    GEmolumentoItemUpdateRepository,
+)
+from packages.v1.administrativo.schemas.g_emolumento_item_schema import (
+    GEmolumentoItemUpdateSchema,
+)
+
+
+class GEmolumentoItemUpdateAction(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, g_emolumento_item_update_schema: GEmolumentoItemUpdateSchema):
+        """
+        Executa a operação de atualização.
+
+        Args:
+            g_emolumento_item_update_schema (GEmolumentoItemUpdateSchema):
+                O esquema com os dados a serem atualizados.
+
+        Returns:
+            O resultado da operação de atualização.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório de atualização
+        # ----------------------------------------------------
+        g_emolumento_item_update_repository = GEmolumentoItemUpdateRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = g_emolumento_item_update_repository.execute(
+            g_emolumento_item_update_schema
+        )
+
+        # ----------------------------------------------------
+        # Retorno do resultado
+        # ----------------------------------------------------
+        return response

packages/v1/administrativo/actions/g_emolumento_item/g_emolumento_item_valor_action.py

@@ -0,0 +1,44 @@
+from abstracts.action import BaseAction
+# O Schema precisa ser adaptado para GEmolumentoItem, talvez recebendo um ID de Emolumento
+# ou um ID do próprio Item, dependendo da necessidade de listagem.
+# Vamos sugerir um Schema específico para a listagem (Index) que pode receber um Emolumento ID
+# para listar todos os seus itens, mantendo o padrão do arquivo original que usava um 'SistemaIdSchema'.
+# Para simplificar, vamos assumir um schema de filtro ou um schema base para Index.
+# Sugerimos a criação de:
+# from packages.v1.administrativo.schemas.g_emolumento_item_schema import GEmolumentoItemIndexSchema 
+# (ou GEmolumentoItemEmolumentoIdSchema se for o padrão da aplicação)
+from packages.v1.administrativo.schemas.g_emolumento_item_schema import GEmolumentoItemValorSchema 
+
+# O repositório ValorRepository deve ser substituído pelo GEmolumentoItemValorRepository.
+from packages.v1.administrativo.repositories.g_emolumento_item.g_emolumento_item_valor_repository import ValorRepository
+
+class ValorAction(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_EMOLUMENTO_ITEM,
+    utilizando a DDL fornecida.
+    """
+
+    # Mantendo o padrão de nome de método do arquivo original
+    def execute(self, emolumento_item_schema: GEmolumentoItemValorSchema):
+        """
+        Executa a operação de listagem de G_EMOLUMENTO_ITEM no banco de dados.
+
+        Args:
+            emolumento_item_schema: Esquema com parâmetros de filtro/listagem
+                                    (por exemplo, ID do Emolumento pai, se a listagem for
+                                    filtrada por ele, ou parâmetros de paginação).
+
+        Returns:
+            A lista de todos os registros de G_EMOLUMENTO_ITEM que satisfazem o filtro.
+        """
+        # Instanciamento do repositório
+        # O nome do repositório foi adaptado com o prefixo 'GEmolumentoItem'
+        index_repository = ValorRepository()
+
+        # Execução do repositório
+        # O nome do parâmetro foi adaptado para 'emolumento_item_schema'
+        response = index_repository.execute(emolumento_item_schema)
+
+        # Retorno da informação
+        return response

packages/v1/administrativo/actions/g_emolumento_periodo/g_emolumento_periodo_delete_action.py

@@ -0,0 +1,39 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_emolumento_periodo.g_emolumento_periodo_delete_repository import (
+    GEmolumentoPeriodoDeleteRepository,
+)
+from packages.v1.administrativo.schemas.g_emolumento_periodo_schema import (
+    GEmolumentoPeriodoIdSchema,
+)
+
+
+class GEmolumentoPeriodoDeleteAction(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 G_EMOLUMENTO_PERIODO.
+    """
+
+    def execute(self, g_emolumento_periodo_id_schema: GEmolumentoPeriodoIdSchema):
+        """
+        Executa a operação de exclusão no banco de dados.
+
+        Args:
+            g_emolumento_periodo_id_schema (GEmolumentoPeriodoIdSchema):
+                O esquema contendo o ID do registro a ser excluído.
+
+        Returns:
+            O resultado da operação de exclusão.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        g_emolumento_periodo_delete_repository = GEmolumentoPeriodoDeleteRepository()
+
+        # ----------------------------------------------------
+        # Execução da exclusão
+        # ----------------------------------------------------
+        response = g_emolumento_periodo_delete_repository.execute(
+            g_emolumento_periodo_id_schema
+        )
+
+        return response

packages/v1/administrativo/actions/g_emolumento_periodo/g_emolumento_periodo_index_action.py

@@ -0,0 +1,37 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_emolumento_periodo.g_emolumento_periodo_index_repository import (
+    GEmolumentoPeriodoIndexRepository,
+)
+
+
+class GEmolumentoPeriodoIndexAction(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):
+        """
+        Executa a operação de listagem no banco de dados.
+
+        Args:
+            g_emolumento_periodo_index_schema (GEmolumentoPeriodoIndexSchema):
+                Esquema contendo parâmetros opcionais de filtro.
+
+        Returns:
+            A lista de registros encontrados.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        g_emolumento_periodo_index_repository = GEmolumentoPeriodoIndexRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = g_emolumento_periodo_index_repository.execute()
+
+        # ----------------------------------------------------
+        # Retorno da informação
+        # --------------------------------
+        return response

packages/v1/administrativo/actions/g_emolumento_periodo/g_emolumento_periodo_save_action.py

@@ -0,0 +1,42 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_emolumento_periodo.g_emolumento_periodo_save_repository import (
+    GEmolumentoPeriodoSaveRepository,
+)
+from packages.v1.administrativo.schemas.g_emolumento_periodo_schema import (
+    GEmolumentoPeriodoSaveSchema,
+)
+
+
+class GEmolumentoPeriodoSaveAction(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 G_GRAMATICA.
+    """
+
+    def execute(self, g_emolumento_periodo_save_schema: GEmolumentoPeriodoSaveSchema):
+        """
+        Executa a operação de salvamento.
+
+        Args:
+            g_emolumento_periodo_schema (GEmolumentoPeriodoSchema):
+                O esquema com os dados a serem persistidos.
+
+        Returns:
+            O resultado da operação de salvamento.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        g_emolumento_periodo_save_repository = GEmolumentoPeriodoSaveRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = g_emolumento_periodo_save_repository.execute(
+            g_emolumento_periodo_save_schema
+        )
+
+        # ----------------------------------------------------
+        # Retorno da informação
+        # ----------------------------------------------------
+        return response

packages/v1/administrativo/actions/g_emolumento_periodo/g_emolumento_periodo_show_action.py

@@ -0,0 +1,42 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_emolumento_periodo.g_emolumento_periodo_show_repository import (
+    GEmolumentoPeriodoShowRepository,
+)
+from packages.v1.administrativo.schemas.g_emolumento_periodo_schema import (
+    GEmolumentoPeriodoIdSchema,
+)
+
+
+class GEmolumentoPeriodoShowAction(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, g_emolumento_periodo_id_schema: GEmolumentoPeriodoIdSchema):
+        """
+        Executa a operação de exibição.
+
+        Args:
+            g_emolumento_periodo_id_schema (GEmolumentoPeriodoIdSchema):
+                O esquema com o ID do registro a ser exibido.
+
+        Returns:
+            O resultado da operação de exibição.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        g_emolumento_periodo_show_repository = GEmolumentoPeriodoShowRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = g_emolumento_periodo_show_repository.execute(
+            g_emolumento_periodo_id_schema
+        )
+
+        # ----------------------------------------------------
+        # Retorno da informação
+        # ----------------------------------------------------
+        return response

packages/v1/administrativo/actions/g_emolumento_periodo/g_emolumento_periodo_update_action.py

@@ -0,0 +1,44 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_emolumento_periodo.g_emolumento_periodo_update_repository import (
+    GEmolumentoPeriodoUpdateRepository,
+)
+from packages.v1.administrativo.schemas.g_emolumento_periodo_schema import (
+    GEmolumentoPeriodoUpdateSchema,
+)
+
+
+class GEmolumentoPeriodoUpdateAction(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, g_emolumento_periodo_update_schema: GEmolumentoPeriodoUpdateSchema
+    ):
+        """
+        Executa a operação de atualização.
+
+        Args:
+            g_emolumento_periodo_update_schema (GEmolumentoPeriodoUpdateSchema):
+                O esquema com os dados a serem atualizados.
+
+        Returns:
+            O resultado da operação de atualização.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório de atualização
+        # ----------------------------------------------------
+        g_emolumento_periodo_update_repository = GEmolumentoPeriodoUpdateRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = g_emolumento_periodo_update_repository.execute(
+            g_emolumento_periodo_update_schema
+        )
+
+        # ----------------------------------------------------
+        # Retorno do resultado
+        # ----------------------------------------------------
+        return response

packages/v1/administrativo/actions/g_gramatica/g_gramatica_delete_action.py

@@ -0,0 +1,35 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_gramatica.g_gramatica_delete_repository import (
+    GGramaticaDeleteRepository,
+)
+from packages.v1.administrativo.schemas.g_gramatica_schema import GGramaticaIdSchema
+
+
+class GGramaticaDeleteAction(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 G_GRAMATICA.
+    """
+
+    def execute(self, g_gramatica_id_schema: GGramaticaIdSchema):
+        """
+        Executa a operação de exclusão no banco de dados.
+
+        Args:
+            g_gramatica_id_schema (GGramaticaIdSchema):
+                O esquema contendo o ID do registro a ser excluído.
+
+        Returns:
+            O resultado da operação de exclusão.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        g_gramatica_delete_repository = GGramaticaDeleteRepository()
+
+        # ----------------------------------------------------
+        # Execução da exclusão
+        # ----------------------------------------------------
+        response = g_gramatica_delete_repository.execute(g_gramatica_id_schema)
+
+        return response

packages/v1/administrativo/actions/g_gramatica/g_gramatica_index_action.py

@@ -0,0 +1,37 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_gramatica.g_gramatica_index_repository import (
+    GGramaticaIndexRepository,
+)
+
+
+class GGramaticaIndexAction(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):
+        """
+        Executa a operação de listagem no banco de dados.
+
+        Args:
+            g_gramatica_index_schema (GGramaticaIndexSchema):
+                Esquema contendo parâmetros opcionais de filtro.
+
+        Returns:
+            A lista de registros encontrados.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        g_gramatica_index_repository = GGramaticaIndexRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = g_gramatica_index_repository.execute()
+
+        # ----------------------------------------------------
+        # Retorno da informação
+        # --------------------------------
+        return response

packages/v1/administrativo/actions/g_gramatica/g_gramatica_save_action.py

@@ -0,0 +1,38 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_gramatica.g_gramatica_save_repository import (
+    GGramaticaSaveRepository,
+)
+from packages.v1.administrativo.schemas.g_gramatica_schema import GGramaticaSaveSchema
+
+
+class GGramaticaSaveAction(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 G_GRAMATICA.
+    """
+
+    def execute(self, g_gramatica_save_schema: GGramaticaSaveSchema):
+        """
+        Executa a operação de salvamento.
+
+        Args:
+            g_gramatica_schema (GGramaticaSchema):
+                O esquema com os dados a serem persistidos.
+
+        Returns:
+            O resultado da operação de salvamento.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        g_gramatica_save_repository = GGramaticaSaveRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = g_gramatica_save_repository.execute(g_gramatica_save_schema)
+
+        # ----------------------------------------------------
+        # Retorno da informação
+        # ----------------------------------------------------
+        return response

packages/v1/administrativo/actions/g_gramatica/g_gramatica_show_action.py

@@ -0,0 +1,38 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_gramatica.g_gramatica_show_repository import (
+    GGramaticaShowRepository,
+)
+from packages.v1.administrativo.schemas.g_gramatica_schema import GGramaticaIdSchema
+
+
+class GGramaticaShowAction(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, g_gramatica_id_schema: GGramaticaIdSchema):
+        """
+        Executa a operação de exibição.
+
+        Args:
+            g_gramatica_id_schema (GGramaticaIdSchema):
+                O esquema com o ID do registro a ser exibido.
+
+        Returns:
+            O resultado da operação de exibição.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        g_gramatica_show_repository = GGramaticaShowRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = g_gramatica_show_repository.execute(g_gramatica_id_schema)
+
+        # ----------------------------------------------------
+        # Retorno da informação
+        # ----------------------------------------------------
+        return response

packages/v1/administrativo/actions/g_gramatica/g_gramatica_update_action.py

@@ -0,0 +1,38 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_gramatica.g_gramatica_update_repository import (
+    GGramaticaUpdateRepository,
+)
+from packages.v1.administrativo.schemas.g_gramatica_schema import GGramaticaUpdateSchema
+
+
+class GGramaticaUpdateAction(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, g_gramatica_update_schema: GGramaticaUpdateSchema):
+        """
+        Executa a operação de atualização.
+
+        Args:
+            g_gramatica_update_schema (GGramaticaUpdateSchema):
+                O esquema com os dados a serem atualizados.
+
+        Returns:
+            O resultado da operação de atualização.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório de atualização
+        # ----------------------------------------------------
+        g_gramatica_update_repository = GGramaticaUpdateRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = g_gramatica_update_repository.execute(g_gramatica_update_schema)
+
+        # ----------------------------------------------------
+        # Retorno do resultado
+        # ----------------------------------------------------
+        return response

packages/v1/administrativo/actions/g_marcacao_tipo/g_marcacao_tipo_get_by_grupo_action.py

@@ -0,0 +1,31 @@
+from abstracts.action import BaseAction
+# Ajuste do schema de entrada
+from packages.v1.administrativo.schemas.g_marcacao_tipo_schema import GMarcacaoTipoGrupoSchema
+# Ajuste do repositório
+from packages.v1.administrativo.repositories.g_marcacao_tipo.g_marcacao_tipo_get_by_grupo_repository import GetByGrupoRepository
+
+
+class GetByGrupoAction(BaseAction):
+    """
+    Serviço responsável por encapsular a lógica de negócio para a operação
+    de busca de um registro na tabela G_MARCACAO_TIPO por filtro.
+    """
+
+    def execute(self, marcacao_tipo_schema: GMarcacaoTipoGrupoSchema):
+        """
+        Executa a operação de busca no banco de dados.
+
+        Args:
+            marcacao_tipo_schema (GMarcacaoTipoGrupoSchema): O esquema com os filtros a serem buscados.
+
+        Returns:
+            O registro encontrado ou None.
+        """
+        # Instanciamento do repositório
+        show_repository = GetByGrupoRepository()
+
+        # Execução do repositório
+        response = show_repository.execute(marcacao_tipo_schema)
+
+        # Retorno da informação
+        return response

packages/v1/administrativo/actions/g_natureza/g_natureza_index_by_sistema_id_action.py

@@ -1,6 +1,11 @@
 from abstracts.action import BaseAction
-from api.packages.v1.administrativo.repositories.g_natureza.g_natureza_index_by_sistema_id_repository import IndexBySistemaIdRepository
+from packages.v1.administrativo.repositories.g_natureza.g_natureza_index_by_sistema_id_repository import (
-from api.packages.v1.administrativo.schemas.g_natureza_schema import GNaturezaSistemaIdSchema
+    IndexBySistemaIdRepository,
+)
+from packages.v1.administrativo.schemas.g_natureza_schema import (
+    GNaturezaSistemaIdSchema,
+)
+
 
 class IndexActionBySistemaId(BaseAction):
     """

packages/v1/administrativo/actions/g_natureza_titulo/g_natureza_titulo_delete_action.py

@@ -0,0 +1,39 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_natureza_titulo.g_natureza_titulo_delete_repository import (
+    GNaturezaTituloDeleteRepository,
+)
+from packages.v1.administrativo.schemas.g_natureza_titulo_schema import (
+    GNaturezaTituloIdSchema,
+)
+
+
+class GNaturezaTituloDeleteAction(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 G_NATUREZA_TITULO.
+    """
+
+    def execute(self, g_natureza_titulo_id_schema: GNaturezaTituloIdSchema):
+        """
+        Executa a operação de exclusão no banco de dados.
+
+        Args:
+            g_natureza_titulo_id_schema (GNaturezaTituloIdSchema):
+                O esquema contendo o ID do registro a ser excluído.
+
+        Returns:
+            O resultado da operação de exclusão.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        g_natureza_titulo_delete_repository = GNaturezaTituloDeleteRepository()
+
+        # ----------------------------------------------------
+        # Execução da exclusão
+        # ----------------------------------------------------
+        response = g_natureza_titulo_delete_repository.execute(
+            g_natureza_titulo_id_schema
+        )
+
+        return response

packages/v1/administrativo/actions/g_natureza_titulo/g_natureza_titulo_index_action.py

@@ -0,0 +1,42 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_natureza_titulo.g_natureza_titulo_index_repository import (
+    GNaturezaTituloIndexRepository,
+)
+from packages.v1.administrativo.schemas.g_natureza_titulo_schema import (
+    GNaturezaTituloIndexSchema,
+)
+
+
+class GNaturezaTituloIndexAction(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, g_natureza_titulo_index_schema: GNaturezaTituloIndexSchema):
+        """
+        Executa a operação de listagem no banco de dados.
+
+        Args:
+            g_natureza_titulo_index_schema (GNaturezaTituloIndexSchema):
+                Esquema contendo parâmetros opcionais de filtro.
+
+        Returns:
+            A lista de registros encontrados.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        g_natureza_titulo_index_repository = GNaturezaTituloIndexRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = g_natureza_titulo_index_repository.execute(
+            g_natureza_titulo_index_schema
+        )
+
+        # ----------------------------------------------------
+        # Retorno da informação
+        # --------------------------------
+        return response

packages/v1/administrativo/actions/g_natureza_titulo/g_natureza_titulo_save_action.py

@@ -0,0 +1,42 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_natureza_titulo.g_natureza_titulo_save_repository import (
+    GNaturezaTituloSaveRepository,
+)
+from packages.v1.administrativo.schemas.g_natureza_titulo_schema import (
+    GNaturezaTituloSaveSchema,
+)
+
+
+class GNaturezaTituloSaveAction(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 G_NATUREZA_TITULO.
+    """
+
+    def execute(self, g_natureza_titulo_save_schema: GNaturezaTituloSaveSchema):
+        """
+        Executa a operação de salvamento.
+
+        Args:
+            g_natureza_titulo_schema (GNaturezaTituloSchema):
+                O esquema com os dados a serem persistidos.
+
+        Returns:
+            O resultado da operação de salvamento.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        g_natureza_titulo_save_repository = GNaturezaTituloSaveRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = g_natureza_titulo_save_repository.execute(
+            g_natureza_titulo_save_schema
+        )
+
+        # ----------------------------------------------------
+        # Retorno da informação
+        # ----------------------------------------------------
+        return response

packages/v1/administrativo/actions/g_natureza_titulo/g_natureza_titulo_show_action.py

@@ -0,0 +1,42 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_natureza_titulo.g_natureza_titulo_show_repository import (
+    GNaturezaTituloShowRepository,
+)
+from packages.v1.administrativo.schemas.g_natureza_titulo_schema import (
+    GNaturezaTituloIdSchema,
+)
+
+
+class GNaturezaTituloShowAction(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, g_natureza_titulo_id_schema: GNaturezaTituloIdSchema):
+        """
+        Executa a operação de exibição.
+
+        Args:
+            g_natureza_titulo_id_schema (GNaturezaTituloIdSchema):
+                O esquema com o ID do registro a ser exibido.
+
+        Returns:
+            O resultado da operação de exibição.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        g_natureza_titulo_show_repository = GNaturezaTituloShowRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = g_natureza_titulo_show_repository.execute(
+            g_natureza_titulo_id_schema
+        )
+
+        # ----------------------------------------------------
+        # Retorno da informação
+        # ----------------------------------------------------
+        return response

packages/v1/administrativo/actions/g_natureza_titulo/g_natureza_titulo_update_action.py

@@ -0,0 +1,42 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_natureza_titulo.g_natureza_titulo_update_repository import (
+    GNaturezaTituloUpdateRepository,
+)
+from packages.v1.administrativo.schemas.g_natureza_titulo_schema import (
+    GNaturezaTituloUpdateSchema,
+)
+
+
+class GNaturezaTituloUpdateAction(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, g_natureza_titulo_update_schema: GNaturezaTituloUpdateSchema):
+        """
+        Executa a operação de atualização.
+
+        Args:
+            g_natureza_titulo_update_schema (GNaturezaTituloUpdateSchema):
+                O esquema com os dados a serem atualizados.
+
+        Returns:
+            O resultado da operação de atualização.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório de atualização
+        # ----------------------------------------------------
+        g_natureza_titulo_update_repository = GNaturezaTituloUpdateRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = g_natureza_titulo_update_repository.execute(
+            g_natureza_titulo_update_schema
+        )
+
+        # ----------------------------------------------------
+        # Retorno do resultado
+        # ----------------------------------------------------
+        return response

packages/v1/administrativo/actions/g_selo_grupo/g_selo_grupo_delete_action.py

@@ -0,0 +1,35 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_selo_grupo.g_selo_grupo_delete_repository import (
+    GSeloGrupoDeleteRepository,
+)
+from packages.v1.administrativo.schemas.g_selo_grupo_schema import GSeloGrupoIdSchema
+
+
+class GSeloGrupoDeleteAction(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 G_SELO_GRUPO.
+    """
+
+    def execute(self, g_selo_grupo_id_schema: GSeloGrupoIdSchema):
+        """
+        Executa a operação de exclusão no banco de dados.
+
+        Args:
+            g_selo_grupo_id_schema (GSeloGrupoIdSchema):
+                O esquema contendo o ID do registro a ser excluído.
+
+        Returns:
+            O resultado da operação de exclusão.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        g_selo_grupo_delete_repository = GSeloGrupoDeleteRepository()
+
+        # ----------------------------------------------------
+        # Execução da exclusão
+        # ----------------------------------------------------
+        response = g_selo_grupo_delete_repository.execute(g_selo_grupo_id_schema)
+
+        return response

packages/v1/administrativo/actions/g_selo_grupo/g_selo_grupo_index_action.py

@@ -0,0 +1,37 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_selo_grupo.g_selo_grupo_index_repository import (
+    GSeloGrupoIndexRepository,
+)
+
+
+class GSeloGrupoIndexAction(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):
+        """
+        Executa a operação de listagem no banco de dados.
+
+        Args:
+            g_selo_grupo_index_schema (GSeloGrupoIndexSchema):
+                Esquema contendo parâmetros opcionais de filtro.
+
+        Returns:
+            A lista de registros encontrados.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        g_selo_grupo_index_repository = GSeloGrupoIndexRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = g_selo_grupo_index_repository.execute()
+
+        # ----------------------------------------------------
+        # Retorno da informação
+        # --------------------------------
+        return response

packages/v1/administrativo/actions/g_selo_grupo/g_selo_grupo_save_action.py

@@ -0,0 +1,38 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_selo_grupo.g_selo_grupo_save_repository import (
+    GSeloGrupoSaveRepository,
+)
+from packages.v1.administrativo.schemas.g_selo_grupo_schema import GSeloGrupoSaveSchema
+
+
+class GSeloGrupoSaveAction(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 G_GRAMATICA.
+    """
+
+    def execute(self, g_selo_grupo_save_schema: GSeloGrupoSaveSchema):
+        """
+        Executa a operação de salvamento.
+
+        Args:
+            g_selo_grupo_schema (GSeloGrupoSchema):
+                O esquema com os dados a serem persistidos.
+
+        Returns:
+            O resultado da operação de salvamento.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        g_selo_grupo_save_repository = GSeloGrupoSaveRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = g_selo_grupo_save_repository.execute(g_selo_grupo_save_schema)
+
+        # ----------------------------------------------------
+        # Retorno da informação
+        # ----------------------------------------------------
+        return response

packages/v1/administrativo/actions/g_selo_grupo/g_selo_grupo_show_action.py

@@ -0,0 +1,38 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_selo_grupo.g_selo_grupo_show_repository import (
+    GSeloGrupoShowRepository,
+)
+from packages.v1.administrativo.schemas.g_selo_grupo_schema import GSeloGrupoIdSchema
+
+
+class GSeloGrupoShowAction(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, g_selo_grupo_id_schema: GSeloGrupoIdSchema):
+        """
+        Executa a operação de exibição.
+
+        Args:
+            g_selo_grupo_id_schema (GSeloGrupoIdSchema):
+                O esquema com o ID do registro a ser exibido.
+
+        Returns:
+            O resultado da operação de exibição.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        g_selo_grupo_show_repository = GSeloGrupoShowRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = g_selo_grupo_show_repository.execute(g_selo_grupo_id_schema)
+
+        # ----------------------------------------------------
+        # Retorno da informação
+        # ----------------------------------------------------
+        return response

packages/v1/administrativo/actions/g_selo_grupo/g_selo_grupo_update_action.py

@@ -0,0 +1,40 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_selo_grupo.g_selo_grupo_update_repository import (
+    GSeloGrupoUpdateRepository,
+)
+from packages.v1.administrativo.schemas.g_selo_grupo_schema import (
+    GSeloGrupoUpdateSchema,
+)
+
+
+class GSeloGrupoUpdateAction(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, g_selo_grupo_update_schema: GSeloGrupoUpdateSchema):
+        """
+        Executa a operação de atualização.
+
+        Args:
+            g_selo_grupo_update_schema (GSeloGrupoUpdateSchema):
+                O esquema com os dados a serem atualizados.
+
+        Returns:
+            O resultado da operação de atualização.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório de atualização
+        # ----------------------------------------------------
+        g_selo_grupo_update_repository = GSeloGrupoUpdateRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = g_selo_grupo_update_repository.execute(g_selo_grupo_update_schema)
+
+        # ----------------------------------------------------
+        # Retorno do resultado
+        # ----------------------------------------------------
+        return response

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

@@ -1,11 +1,15 @@
 from abstracts.action import BaseAction
-from packages.v1.administrativo.schemas.g_usuario_schema import GUsuarioAuthenticateSchema
+from packages.v1.administrativo.schemas.g_usuario_schema import (
-from packages.v1.administrativo.repositories.g_usuario.g_usuario_get_by_authenticate_repository import GetByAuthenticateRepository
+    GUsuarioAuthenticateSchema,
+)
+from packages.v1.administrativo.repositories.g_usuario.g_usuario_get_by_authenticate_repository import (
+    GetByAuthenticateRepository,
+)
 
 
 class GetByAuthenticateAction(BaseAction):
 
-    def execute(self, g_usuario_authenticate_schema : GUsuarioAuthenticateSchema):
+    def execute(self, g_usuario_authenticate_schema: GUsuarioAuthenticateSchema):
 
         # Instânciamento do repositório de busca pelo authenticate
         get_by_authenticate_repository = GetByAuthenticateRepository()

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

@@ -1,10 +1,13 @@
 from abstracts.action import BaseAction
 from packages.v1.administrativo.schemas.g_usuario_schema import GUsuarioLoginSchema
-from packages.v1.administrativo.repositories.g_usuario.g_usuario_get_by_login_repository import GetByUsuarioLoginRepository
+from packages.v1.administrativo.repositories.g_usuario.g_usuario_get_by_login_repository import (
+    GetByUsuarioLoginRepository,
+)
+
 
 class GetByUsuarioLoginAction(BaseAction):
 
-    def execute(self, g_usuario_schema = GUsuarioLoginSchema):
+    def execute(self, g_usuario_schema=GUsuarioLoginSchema):
 
         # Importação do repositório
         get_by_login_repository = GetByUsuarioLoginRepository()

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_ato_partetipo/t_ato_partetipo_delete_action.py

@@ -1,6 +1,11 @@
 from abstracts.action import BaseAction
-from api.packages.v1.administrativo.repositories.t_ato_partetipo.t_ato_partetipo_delete_repository import TAtoParteTipoDeleteRepository
+from packages.v1.administrativo.repositories.t_ato_partetipo.t_ato_partetipo_delete_repository import (
-from api.packages.v1.administrativo.schemas.t_ato_partetipo_schema import TAtoParteTipoIdSchema
+    TAtoParteTipoDeleteRepository,
+)
+from packages.v1.administrativo.schemas.t_ato_partetipo_schema import (
+    TAtoParteTipoIdSchema,
+)
+
 
 class TAtoParteTipoDeleteAction(BaseAction):
     """

packages/v1/administrativo/actions/t_ato_partetipo/t_ato_partetipo_index_action.py

@@ -1,5 +1,8 @@
 from abstracts.action import BaseAction
-from api.packages.v1.administrativo.repositories.t_ato_partetipo.t_ato_partetipo_index_repository import TAtoParteTipoIndexRepository
+from packages.v1.administrativo.repositories.t_ato_partetipo.t_ato_partetipo_index_repository import (
+    TAtoParteTipoIndexRepository,
+)
+
 
 class TAtoParteTipoIndexAction(BaseAction):
     """

packages/v1/administrativo/actions/t_ato_partetipo/t_ato_partetipo_save_action.py

@@ -1,6 +1,11 @@
 from abstracts.action import BaseAction
-from api.packages.v1.administrativo.repositories.t_ato_partetipo.t_ato_partetipo_save_repository import TAtoParteTipoSaveRepository
+from packages.v1.administrativo.repositories.t_ato_partetipo.t_ato_partetipo_save_repository import (
-from api.packages.v1.administrativo.schemas.t_ato_partetipo_schema import TAtoParteTipoSaveSchema
+    TAtoParteTipoSaveRepository,
+)
+from packages.v1.administrativo.schemas.t_ato_partetipo_schema import (
+    TAtoParteTipoSaveSchema,
+)
+
 
 class TAtoParteTipoSaveAction(BaseAction):
     """

packages/v1/administrativo/actions/t_ato_partetipo/t_ato_partetipo_show_action.py

@@ -1,6 +1,11 @@
 from abstracts.action import BaseAction
-from api.packages.v1.administrativo.repositories.t_ato_partetipo.t_ato_partetipo_show_repository import TAtoParteTipoShowRepository
+from packages.v1.administrativo.repositories.t_ato_partetipo.t_ato_partetipo_show_repository import (
-from api.packages.v1.administrativo.schemas.t_ato_partetipo_schema import TAtoParteTipoIdSchema
+    TAtoParteTipoShowRepository,
+)
+from packages.v1.administrativo.schemas.t_ato_partetipo_schema import (
+    TAtoParteTipoIdSchema,
+)
+
 
 class TAtoParteTipoShowAction(BaseAction):
     """

packages/v1/administrativo/actions/t_ato_partetipo/t_ato_partetipo_update_action.py

@@ -1,6 +1,10 @@
 from abstracts.action import BaseAction
-from api.packages.v1.administrativo.repositories.t_ato_partetipo.t_ato_partetipo_update_repository import TAtoParteTipoUpdateRepository
+from packages.v1.administrativo.repositories.t_ato_partetipo.t_ato_partetipo_update_repository import (
-from api.packages.v1.administrativo.schemas.t_ato_partetipo_schema import TAtoParteTipoUpdateSchema
+    TAtoParteTipoUpdateRepository,
+)
+from packages.v1.administrativo.schemas.t_ato_partetipo_schema import (
+    TAtoParteTipoUpdateSchema,
+)
 
 
 class TAtoParteTipoUpdateAction(BaseAction):

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_censec_naturezatipo/t_censec_tiponatureza_delete_action.py

@@ -0,0 +1,39 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.t_censec_tiponatureza.t_censec_tiponatureza_delete_repository import (
+    TCensecTipoNaturezaDeleteRepository,
+)
+from packages.v1.administrativo.schemas.t_censec_tiponatureza_schema import (
+    TCensecTipoNaturezaIdSchema,
+)
+
+
+class TCensecTipoNaturezaDeleteAction(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_CENSEC_TIPOATO.
+    """
+
+    def execute(self, t_censec_tiponatureza_id_schema: TCensecTipoNaturezaIdSchema):
+        """
+        Executa a operação de exclusão no banco de dados.
+
+        Args:
+            t_censec_tiponatureza_id_schema (TCensecTipoNaturezaIdSchema):
+                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_censec_tiponatureza_delete_repository = TCensecTipoNaturezaDeleteRepository()
+
+        # ----------------------------------------------------
+        # Execução da exclusão
+        # ----------------------------------------------------
+        response = t_censec_tiponatureza_delete_repository.execute(
+            t_censec_tiponatureza_id_schema
+        )
+
+        return response

packages/v1/administrativo/actions/t_censec_naturezatipo/t_censec_tiponatureza_index_action.py

@@ -0,0 +1,37 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.t_censec_tiponatureza.t_censec_tiponatureza_index_repository import (
+    TCensecTipoNaturezaIndexRepository,
+)
+
+
+class TCensecTipoNaturezaIndexAction(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 T_CENSEC_TIPOATO.
+    """
+
+    def execute(self):
+        """
+        Executa a operação de listagem no banco de dados.
+
+        Args:
+            t_censec_tiponatureza_index_schema (TCensecTipoNaturezaIndexSchema):
+                Esquema contendo parâmetros opcionais de filtro.
+
+        Returns:
+            A lista de registros encontrados.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        t_censec_tiponatureza_index_repository = TCensecTipoNaturezaIndexRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = t_censec_tiponatureza_index_repository.execute()
+
+        # ----------------------------------------------------
+        # Retorno da informação
+        # --------------------------------
+        return response

packages/v1/administrativo/actions/t_censec_naturezatipo/t_censec_tiponatureza_save_action.py

@@ -0,0 +1,42 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.t_censec_tiponatureza.t_censec_tiponatureza_save_repository import (
+    TCensecTipoNaturezaSaveRepository,
+)
+from packages.v1.administrativo.schemas.t_censec_tiponatureza_schema import (
+    TCensecTipoNaturezaSaveSchema,
+)
+
+
+class TCensecTipoNaturezaSaveAction(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_CENSEC_TIPOATO.
+    """
+
+    def execute(self, t_censec_tiponatureza_save_schema: TCensecTipoNaturezaSaveSchema):
+        """
+        Executa a operação de salvamento.
+
+        Args:
+            t_censec_tiponatureza_schema (TCensecTipoNaturezaSchema):
+                O esquema com os dados a serem persistidos.
+
+        Returns:
+            O resultado da operação de salvamento.
+        """
+        # ----------------------------------------------------
+        # Instanciamento do repositório
+        # ----------------------------------------------------
+        t_censec_tiponatureza_save_repository = TCensecTipoNaturezaSaveRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = t_censec_tiponatureza_save_repository.execute(
+            t_censec_tiponatureza_save_schema
+        )
+
+        # ----------------------------------------------------
+        # Retorno da informação
+        # ----------------------------------------------------
+        return response

packages/v1/administrativo/actions/t_censec_naturezatipo/t_censec_tiponatureza_show_action.py

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

packages/v1/administrativo/actions/t_censec_naturezatipo/t_censec_tiponatureza_update_action.py

@@ -0,0 +1,44 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.t_censec_tiponatureza.t_censec_tiponatureza_update_repository import (
+    TCensecTipoNaturezaUpdateRepository,
+)
+from packages.v1.administrativo.schemas.t_censec_tiponatureza_schema import (
+    TCensecTipoNaturezaUpdateSchema,
+)
+
+
+class TCensecTipoNaturezaUpdateAction(BaseAction):
+    """
+    Serviço responsável por encapsular a lógica de negócio para a atualização
+    de um registro na tabela T_CENSEC_TIPOATO.
+    """
+
+    def execute(
+        self, t_censec_tiponatureza_update_schema: TCensecTipoNaturezaUpdateSchema
+    ):
+        """
+        Executa a operação de atualização.
+
+        Args:
+            t_censec_tiponatureza_update_schema (TCensecTipoNaturezaUpdateSchema):
+                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_censec_tiponatureza_update_repository = TCensecTipoNaturezaUpdateRepository()
+
+        # ----------------------------------------------------
+        # Execução do repositório
+        # ----------------------------------------------------
+        response = t_censec_tiponatureza_update_repository.execute(
+            t_censec_tiponatureza_update_schema
+        )
+
+        # ----------------------------------------------------
+        # Retorno do resultado
+        # ----------------------------------------------------
+        return response

packages/v1/administrativo/actions/t_censec_qualidadeato/t_censec_qualidadeato_delete_action.py

@@ -1,6 +1,10 @@
 from abstracts.action import BaseAction
-from api.packages.v1.administrativo.repositories.t_censec_qualidadeato.t_censec_qualidadeato_delete_repository import TCensecQualidadeAtoDeleteRepository
+from packages.v1.administrativo.repositories.t_censec_qualidadeato.t_censec_qualidadeato_delete_repository import (
-from api.packages.v1.administrativo.schemas.t_censec_qualidadeato_schema import TCensecQualidadeAtoIdSchema
+    TCensecQualidadeAtoDeleteRepository,
+)
+from packages.v1.administrativo.schemas.t_censec_qualidadeato_schema import (
+    TCensecQualidadeAtoIdSchema,
+)
 
 
 class TCensecQualidadeAtoDeleteAction(BaseAction):
@@ -28,7 +32,9 @@ class TCensecQualidadeAtoDeleteAction(BaseAction):
         # ----------------------------------------------------
         # Execução da exclusão
         # ----------------------------------------------------
-        response = t_censec_qualidadeato_delete_repository.execute(t_censec_qualidadeato_id_schema)
+        response = t_censec_qualidadeato_delete_repository.execute(
+            t_censec_qualidadeato_id_schema
+        )
 
         # ----------------------------------------------------
         # Retorno do resultado

packages/v1/administrativo/actions/t_censec_qualidadeato/t_censec_qualidadeato_index_action.py

@@ -1,6 +1,10 @@
 from abstracts.action import BaseAction
-from api.packages.v1.administrativo.repositories.t_censec_qualidadeato.t_censec_qualidadeato_index_repository import TCensecQualidadeAtoIndexRepository
+from packages.v1.administrativo.repositories.t_censec_qualidadeato.t_censec_qualidadeato_index_repository import (
-from api.packages.v1.administrativo.schemas.t_censec_qualidadeato_schema import TCensecQualidadeAtoIndexSchema
+    TCensecQualidadeAtoIndexRepository,
+)
+from packages.v1.administrativo.schemas.t_censec_qualidadeato_schema import (
+    TCensecQualidadeAtoIndexSchema,
+)
 
 
 class TCensecQualidadeAtoIndexAction(BaseAction):
@@ -9,7 +13,9 @@ class TCensecQualidadeAtoIndexAction(BaseAction):
     de listagem de todos os registros na tabela T_CENSEC_QUALIDADEATO.
     """
 
-    def execute(self, censec_qualidade_ato_index_schema: TCensecQualidadeAtoIndexSchema):
+    def execute(
+        self, censec_qualidade_ato_index_schema: TCensecQualidadeAtoIndexSchema
+    ):
         """
         Executa a operação de listagem no banco de dados.
 
@@ -24,7 +30,9 @@ class TCensecQualidadeAtoIndexAction(BaseAction):
         # ----------------------------------------------------
         # Execução do repositório
         # ----------------------------------------------------
-        response = t_censec_qualidadeato_index_repository.execute(censec_qualidade_ato_index_schema)
+        response = t_censec_qualidadeato_index_repository.execute(
+            censec_qualidade_ato_index_schema
+        )
 
         # ----------------------------------------------------
         # Retorno da informação

packages/v1/administrativo/actions/t_censec_qualidadeato/t_censec_qualidadeato_save_action.py

@@ -1,6 +1,10 @@
 from abstracts.action import BaseAction
-from api.packages.v1.administrativo.repositories.t_censec_qualidadeato.t_censec_qualidadeato_save_repository import TCensecQualidadeAtoSaveRepository
+from packages.v1.administrativo.repositories.t_censec_qualidadeato.t_censec_qualidadeato_save_repository import (
-from api.packages.v1.administrativo.schemas.t_censec_qualidadeato_schema import TCensecQualidadeAtoSaveSchema
+    TCensecQualidadeAtoSaveRepository,
+)
+from packages.v1.administrativo.schemas.t_censec_qualidadeato_schema import (
+    TCensecQualidadeAtoSaveSchema,
+)
 
 
 class TCensecQualidadeAtoSaveAction(BaseAction):
@@ -28,7 +32,9 @@ class TCensecQualidadeAtoSaveAction(BaseAction):
         # ----------------------------------------------------
         # Execução do repositório
         # ----------------------------------------------------
-        response = t_censec_qualidadeato_save_repository.execute(t_censec_qualidadeato_save_schema)
+        response = t_censec_qualidadeato_save_repository.execute(
+            t_censec_qualidadeato_save_schema
+        )
 
         # ----------------------------------------------------
         # Retorno da informação

packages/v1/administrativo/actions/t_censec_qualidadeato/t_censec_qualidadeato_show_action.py

@@ -1,6 +1,10 @@
 from abstracts.action import BaseAction
-from api.packages.v1.administrativo.repositories.t_censec_qualidadeato.t_censec_qualidadeato_show_repository import TCensecQualidadeAtoShowRepository
+from packages.v1.administrativo.repositories.t_censec_qualidadeato.t_censec_qualidadeato_show_repository import (
-from api.packages.v1.administrativo.schemas.t_censec_qualidadeato_schema import TCensecQualidadeAtoIdSchema
+    TCensecQualidadeAtoShowRepository,
+)
+from packages.v1.administrativo.schemas.t_censec_qualidadeato_schema import (
+    TCensecQualidadeAtoIdSchema,
+)
 
 
 class TCensecQualidadeAtoShowAction(BaseAction):
@@ -28,7 +32,9 @@ class TCensecQualidadeAtoShowAction(BaseAction):
         # ----------------------------------------------------
         # Execução do repositório
         # ----------------------------------------------------
-        response = t_censec_qualidadeato_show_repository.execute(t_censec_qualidadeato_id_schema)
+        response = t_censec_qualidadeato_show_repository.execute(
+            t_censec_qualidadeato_id_schema
+        )
 
         # ----------------------------------------------------
         # Retorno da informação

packages/v1/administrativo/actions/t_censec_qualidadeato/t_censec_qualidadeato_update_action.py

@@ -1,6 +1,10 @@
 from abstracts.action import BaseAction
-from api.packages.v1.administrativo.repositories.t_censec_qualidadeato.t_censec_qualidadeato_update_repository import TCensecQualidadeAtoUpdateRepository
+from packages.v1.administrativo.repositories.t_censec_qualidadeato.t_censec_qualidadeato_update_repository import (
-from api.packages.v1.administrativo.schemas.t_censec_qualidadeato_schema import TCensecQualidadeAtoUpdateSchema
+    TCensecQualidadeAtoUpdateRepository,
+)
+from packages.v1.administrativo.schemas.t_censec_qualidadeato_schema import (
+    TCensecQualidadeAtoUpdateSchema,
+)
 
 
 class TCensecQualidadeAtoUpdateAction(BaseAction):
@@ -9,7 +13,9 @@ class TCensecQualidadeAtoUpdateAction(BaseAction):
     de um registro na tabela T_CENSEC_QUALIDADEATO.
     """
 
-    def execute(self, t_censec_qualidadeato_update_schema: TCensecQualidadeAtoUpdateSchema):
+    def execute(
+        self, t_censec_qualidadeato_update_schema: TCensecQualidadeAtoUpdateSchema
+    ):
         """
         Executa a operação de atualização.
 
@@ -28,7 +34,9 @@ class TCensecQualidadeAtoUpdateAction(BaseAction):
         # ----------------------------------------------------
         # Execução do repositório
         # ----------------------------------------------------
-        response = t_censec_qualidadeato_update_repository.execute(t_censec_qualidadeato_update_schema)
+        response = t_censec_qualidadeato_update_repository.execute(
+            t_censec_qualidadeato_update_schema
+        )
 
         # ----------------------------------------------------
         # Retorno do resultado

packages/v1/administrativo/actions/t_censec_tipoato/t_censec_tipoato_delete_action.py

@@ -1,6 +1,10 @@
 from abstracts.action import BaseAction
-from api.packages.v1.administrativo.repositories.t_censec_tipoato.t_censec_tipoato_delete_repository import TCensecTipoAtoDeleteRepository
+from packages.v1.administrativo.repositories.t_censec_tipoato.t_censec_tipoato_delete_repository import (
-from api.packages.v1.administrativo.schemas.t_censec_tipoato_schema import TCensecTipoAtoIdSchema
+    TCensecTipoAtoDeleteRepository,
+)
+from packages.v1.administrativo.schemas.t_censec_tipoato_schema import (
+    TCensecTipoAtoIdSchema,
+)
 
 
 class TCensecTipoAtoDeleteAction(BaseAction):
@@ -28,6 +32,8 @@ class TCensecTipoAtoDeleteAction(BaseAction):
         # ----------------------------------------------------
         # Execução da exclusão
         # ----------------------------------------------------
-        response = t_censec_tipoato_delete_repository.execute(t_censec_tipoato_id_schema)
+        response = t_censec_tipoato_delete_repository.execute(
+            t_censec_tipoato_id_schema
+        )
 
         return response

packages/v1/administrativo/actions/t_censec_tipoato/t_censec_tipoato_index_action.py

@@ -1,5 +1,7 @@
 from abstracts.action import BaseAction
-from api.packages.v1.administrativo.repositories.t_censec_tipoato.t_censec_tipoato_index_repository import TCensecTipoAtoIndexRepository
+from packages.v1.administrativo.repositories.t_censec_tipoato.t_censec_tipoato_index_repository import (
+    TCensecTipoAtoIndexRepository,
+)
 
 
 class TCensecTipoAtoIndexAction(BaseAction):