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

.gitignore

@@ -3,9 +3,6 @@ venv/
 .env
 .env.*
 
-# Ignora configuração de acesso ao banco de dados Firebird
-config/database/firebird.json
-
 # Bytecode compilado
 __pycache__/
 *.py[cod]
@@ -39,3 +36,11 @@ pip-wheel-metadata/
 *.egg
 .cache/
 .tox/
+
+# Arquivo s de conexão
+config/database/firebird.json
+storage/temp
+storage/temp.json
+
+# Ignorar arquivos storage
+storage/

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"]

README.md

@@ -1,150 +1,281 @@
-# 🧩 Projeto [SAAS]
+# Configuração do Projeto Python
 
-Este projeto é uma **API monolítica modular**, onde cada módulo representa um **domínio específico** da aplicação. Internamente, cada módulo é construído sobre a **Arquitetura Hexagonal**, promovendo separação de responsabilidades, testabilidade e independência da infraestrutura.
+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.
 
 ---
 
-## ⚙️ Visão Geral da Arquitetura
+## 1. Clonar o Projeto
 
-### 🏗️ Estrutura Monolítica Modular
+Clone o repositório do projeto a partir do Git:
 
-- Modelo **monolítico**, modularizado por **domínios**
+```bash
-- Cada domínio organizado dentro do diretório `packages/`
+git clone https://git.oriustecnologia.com/OriusTecnologia/saas_api.git
-- Componentes por domínio:
-  - **Controllers** (entrada)
-  - **Endpoints** (rotas)
-  - **Schemas** (validação e transformação)
-  - **Actions** (orquestração de lógica)
-  - **Services** (casos de uso)
-  - **Repositories** (acesso a dados)
-
-### 🧭 Arquitetura Hexagonal por Módulo
-
-```text
-/<domínio>
-  /actions        # Orquestra lógica entre services, schemas e repositories
-  /controllers    # Interface entre endpoints e actions
-  /endpoints      # Define as rotas da API
-  /repositories   # Acesso ao Firebird via SQLAlchemy
-  /schemas        # Entrada e saída de dados
-  /services       # Casos de uso
 ```
 
 ---
 
-## 🛠️ Tecnologias Utilizadas
+## 2. Criar o Ambiente Virtual
 
-- **Linguagem:** Python 3.11+
+Crie um **ambiente virtual** isolado para o projeto:
-- **ORM:** SQLAlchemy
+
-- **Banco de Dados:** Firebird
+```bash
-- **Driver:** fdb
+python -m venv venv
-- **Arquitetura:** Hexagonal por módulo
+```
-- **Organização:** Modular por domínio
 
 ---
 
-## 🗄️ Banco de Dados
+## 3. Ativar o Ambiente Virtual
 
-O projeto utiliza **Firebird** como banco principal.
+Ative o ambiente virtual antes de instalar as dependências:
 
-**Arquivo de configuração:**
+```bash
-
+venv\Scripts\activate
-```text
-Api/config/database/firebird.json
 ```
 
-**Exemplo:**
+> **Em sistemas Linux/Mac:**
+>
+> ```bash
+> source venv/bin/activate
+> ```
+
+---
+
+## 4. Instalar Dependências do Sistema
+
+O projeto depende de compiladores nativos para algumas bibliotecas Python.
+
+### 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:
+
+```
+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
+
+Com o ambiente virtual **ativado**, instale as dependências listadas no arquivo `requirements.txt`:
+
+```bash
+pip install -r requirements.txt
+```
+
+---
+
+## 6. Configurar o Banco de Dados (Firebird)
+
+O projeto utiliza o banco **Firebird**.
+Edite o arquivo de configuração em:
+
+```
+api/config/database/firebird.json
+```
+
+Exemplo:
 
 ```json
 {
   "host": "localhost",
+  "name": "/data/base/CAIAPONIA.FDB",
   "port": 3050,
-  "database": "/caminho/para/database.fdb",
   "user": "SYSDBA",
-  "password": "masterkey"
+  "password": "",
+  "charset": "UTF8",
+  "pool": {
+    "pre_ping": true,
+    "size": 5,
+    "max_overflow": 10
+  }
 }
 ```
 
-**Classe de conexão:**
+**Campos principais:**
 
-```text
+| Campo               | Descrição                          |
-Api/core/connections/firebird.py
+| ------------------- | ---------------------------------- |
-```
+| `host`              | Endereço do servidor Firebird      |
+| `name`              | Caminho completo do arquivo `.FDB` |
+| `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        |
 
 ---
 
-## 🧠 SQLAlchemy com Queries Manuais
+## 7. Modo Desenvolvimento
 
-Utilizamos SQLAlchemy para:
+Para ambiente local, execute:
-
-- Gerenciar conexões
-- Preencher parâmetros em queries nativas
-
-**Exemplo:**
-
-```python
-sql = "SELECT * FROM CLIENTES WHERE ID = :id"
-params = {"id": 123}
-result = session.execute(text(sql), params).fetchall()
-```
-
----
-
-## 🗂️ Estrutura de Diretórios
-
-```text
-Api/
-├── api/
-│   └── v1/
-│       ├── packages/
-│       │   └── administrative/
-│       │       ├── actions/
-│       │       ├── controllers/
-│       │       ├── endpoints/
-│       │       ├── repositories/
-│       │       ├── schemas/
-│       │       └── services/
-│       └── api.py
-├── config/
-│   └── database/firebird.json
-├── core/
-│   ├── base/
-│   ├── connections/
-│   ├── system/
-│   ├── utils/
-│   └── auth.py
-```
-
----
-
-## ▶️ Executando a API
 
 ```bash
-# Criar ambiente virtual
+uvicorn main:app --reload
-python -m venv .venv
+```
 
-# Ativar ambiente virtual
+> O parâmetro `--reload` reinicia automaticamente a aplicação ao detectar alterações no código.
-source .venv/bin/activate       # Linux/macOS
-.venv\Scripts\activate        # Windows
 
-# Instalar dependências
+Acesse:
-pip install -r requirements.txt
 
-# Executar a API
+```
-uvicorn api.v1.api:app --reload
+http://localhost:8000/docs
 ```
 
 ---
 
-## 📌 Observações
+## 8. Modo Produção
 
-- Novos domínios devem seguir a estrutura modular.
+A execução em produção varia conforme o sistema operacional.
-- A arquitetura hexagonal facilita manutenção e futura extração para microsserviços.
-- A separação entre actions, services e repositories melhora a organização e testabilidade.
 
 ---
 
-## 👨‍💻 Autor
+### **Windows (modo produção simulado)**
 
-Desenvolvido por **Orius Tecnologia**  
+O **Gunicorn** não é compatível com Windows, pois depende do módulo `fcntl` exclusivo de sistemas Unix.
-GitHub / LinkedIn: [seu-link](#)
+Portanto, em ambiente Windows, recomenda-se usar o **Uvicorn** diretamente com múltiplos *workers*:
+
+```bash
+uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4
+```
+
+> 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

@@ -1,50 +1,114 @@
-from typing import Literal, Optional
+# Importa tipos utilitários para anotações estáticas e sobrecarga de assinaturas.
+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
 
+# Provedor do engine de conexão com o Firebird, centralizado no projeto.
 from database.firebird import Firebird
 
 
+# Define a classe base de repositórios, concentrando operações comuns de acesso a dados.
 class BaseRepository:
-    def query(self, sql: str, params: Optional[dict] = None):
+    # Sobrecarga 1: quando `fetch="all"`, o retorno é uma lista de mapeamentos (coluna->valor).
-        """Executa uma consulta SQL e retorna o resultado como objeto ResultProxy"""
+    @overload
-        return self._execute(sql, params, fetch="result")
+    def _execute(
+        self, sql: str, params: Optional[dict[str, Any]], fetch: Literal["all"]
+    ) -> List[Mapping[str, Any]]: ...
 
-    def fetch_all(self, sql: str, params: Optional[dict] = None):
+    # Sobrecarga 2: quando `fetch="one"`, o retorno é um único mapeamento ou None.
-        """Executa uma consulta SQL e retorna todos os registros com mapeamento de colunas"""
+    @overload
-        return self._execute(sql, params, fetch="all")
+    def _execute(
+        self, sql: str, params: Optional[dict[str, Any]], fetch: Literal["one"]
+    ) -> Optional[Mapping[str, Any]]: ...
 
-    def fetch_one(self, sql: str, params: Optional[dict] = None):
+    # Sobrecarga 3: quando `fetch="none"`, não há retorno (operações DML sem leitura).
-        """Executa uma consulta SQL e retorna o primeiro registro com mapeamento de colunas"""
+    @overload
-        return self._execute(sql, params, fetch="one")
+    def _execute(
+        self, sql: str, params: Optional[dict[str, Any]], fetch: Literal["none"]
+    ) -> None: ...
 
-    def run(self, sql: str, params: Optional[dict] = None):
+    # Sobrecarga 4: quando `fetch="result"`, retorna o objeto `CursorResult` bruto do SQLAlchemy.
-        """Executa um SQL sem retorno de dados (ex: INSERT, UPDATE, DELETE)"""
+    @overload
-        return self._execute(sql, params, fetch="none")
+    def _execute(
-    
+        self, sql: str, params: Optional[dict[str, Any]], fetch: Literal["result"]
-    def run_and_return(self, sql: str, params: Optional[dict] = None):
+    ) -> CursorResult[Any]: ...
-        """Executa SQL com RETURNING e retorna o primeiro registro como dict"""
-        return self._execute(sql, params, fetch="one")
 
+    # Implementação concreta que atende às quatro sobrecargas por meio de um retorno em união.
     def _execute(
         self,
-        sql: str,
+        sql: str,  # Comando SQL (SELECT/INSERT/UPDATE/DELETE) em texto.
-        params: Optional[dict] = None,
+        params: Optional[dict[str, Any]] = None,  # Parâmetros nomeados para o SQL.
-        fetch: Literal["all", "one", "result", "none"] = "result",
+        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"`.
+        None,  # Retorno quando `fetch="none"`.
+        CursorResult[Any],  # Retorno quando `fetch="result"`.
+    ]:
+        """Método interno que executa o SQL conforme o modo de fetch especificado."""
+        # Obtém o engine de conexão com o Firebird a partir do provider central.
         engine = Firebird.get_engine()
         try:
+            # Inicia um contexto transacional; `begin()` garante commit/rollback automáticos.
             with engine.begin() as conn:
+                # Executa o SQL com parâmetros (usa dict vazio quando `params` é None).
                 result = conn.execute(text(sql), params or {})
+                # Quando for solicitado "all", converte o resultado em lista de mapeamentos (coluna->valor).
                 if fetch == "all":
-                    return result.mappings().all()
+                    # retorna Sequence[RowMapping], compatível com List[Mapping[str, Any]]
+                    return list(result.mappings().all())
+                # Quando for solicitado "one", retorna apenas o primeiro registro (ou None).
                 elif fetch == "one":
                     return result.mappings().first()
+                # Quando for solicitado "none", não retorna dados (apenas executa o comando).
                 elif fetch == "none":
                     return None
-                return result  # Result object
+                # Caso padrão: retorna o objeto Result bruto para manipulações específicas.
+                return result
         except SQLAlchemyError as e:
+            # Log simples para facilitar diagnóstico em ambiente de desenvolvimento/produção.
             print(f"[ERRO SQL]: {e}")
+            # Propaga a exceção para camadas superiores tratarem (ex.: FastAPI Exception Handler).
             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]:
+        """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]]:
+        """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]]:
+        """Executa uma consulta SQL e retorna o primeiro registro com mapeamento de colunas."""
+        return self._execute(sql, params, fetch="one")
+
+    # Executa comandos DML (INSERT/UPDATE/DELETE) sem retorno de dados.
+    def run(self, sql: str, params: Optional[dict[str, Any]] = None) -> None:
+        """Executa um SQL sem retorno de dados (ex: INSERT, UPDATE, DELETE)."""
+        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]]:
+        """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

@@ -0,0 +1,30 @@
+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]:
+    """
+    Gera dinamicamente os dados e SQL para update com base em um schema Pydantic.
+
+    Args:
+        schema: Instância do schema (ex: t_pessoa_save_schema)
+        exclude_fields: Lista de campos a serem ignorados no SET (ex: ['pessoa_id'])
+        id_field: Nome do campo identificador primário (ex: 'pessoa_id')
+
+    Returns:
+        Tuple contendo:
+        - data_dict: dicionário com apenas campos preenchidos (sem unset)
+        - update_sql: string SQL do tipo "campo1 = :campo1, campo2 = :campo2"
+    """
+    exclude_fields = exclude_fields or [id_field]
+
+    # Cria o dicionário apenas com os campos enviados
+    data_dict = schema.model_dump(exclude_unset=True)
+
+    # Monta lista dinâmica de campos para o SET
+    update_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

@@ -1,20 +1,23 @@
 import importlib
 from actions.config.config import Config
+from typing import Optional, Any, Type
 
 
 class DynamicImport:
 
-    def __init__(self):
+    def __init__(self) -> None:
-        self.config = Config.get('app.json')
+        self.config: dict[str, Any] = Config.get("app.json")
-        self.base = 'packages.v1'
+        self.base: str = "packages.v1"
+        self.package: Optional[str] = None
+        self.table: Optional[str] = None
 
-    def set_package(self, name):
+    def set_package(self, name: str) -> None:
         self.package = name
 
-    def set_table(self, table):
+    def set_table(self, table: str):
         self.table = table
 
-    def service(self, name: str, class_name : str):
+    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,58 +12,45 @@ 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,
             "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):
@@ -74,13 +60,10 @@ def register_exception_handlers(app):
             "error": "Erro Interno do Servidor",
             "type": type(exc).__name__,
             "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

@@ -1,9 +1,9 @@
 {
   "host": "localhost",
-  "name": "CARTORIO",
+  "name": "/database/BASE.FDB",
   "port": 3050,
   "user": "SYSDBA",
-  "password": "masterkey",
+  "password": "302b3c",
   "charset": "UTF8",
   "pool" : {
     "pre_ping" : true,

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
         host="0.0.0.0",  # Disponibiliza a aplicação externamente
         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_delete_action.py

@@ -1,7 +1,5 @@
-from packages.v1.administrativo.repositories.c_caixa_item.delete import \
+from packages.v1.administrativo.repositories.c_caixa_item.c_caixa_item_delete import Delete
-    Delete
+from packages.v1.administrativo.schemas.c_caixa_item_schema import CaixaItemSchema
-from packages.v1.administrativo.schemas.c_caixa_item_schema import \
-    CaixaItemSchema
 from abstracts.action import BaseAction
 
 

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.index import \
+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_item/c_caixa_item_save_action.py

@@ -1,4 +1,4 @@
-from packages.v1.administrativo.repositories.c_caixa_item.save import Save
+from packages.v1.administrativo.repositories.c_caixa_item.c_caixa_item_save import Save
 from packages.v1.administrativo.schemas.c_caixa_item_schema import \
     CaixaItemSchema
 from abstracts.action import BaseAction

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

@@ -1,6 +1,5 @@
-from packages.v1.administrativo.repositories.c_caixa_item.show import Show
+from packages.v1.administrativo.repositories.c_caixa_item.c_caixa_item_show import Show
-from packages.v1.administrativo.schemas.c_caixa_item_schema import \
+from packages.v1.administrativo.schemas.c_caixa_item_schema import CaixaItemSchema
-    CaixaItemSchema
 from abstracts.action import BaseAction
 
 

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

@@ -0,0 +1,14 @@
+from packages.v1.administrativo.repositories.c_caixa_item.c_caixa_item_update_repository import UpdateRepository
+from packages.v1.administrativo.schemas.c_caixa_item_schema import CaixaItemSchema
+from abstracts.action import BaseAction
+
+
+class UpdateAction(BaseAction):
+
+    def execute(self, caixa_item_id : int, caixa_item_schema : CaixaItemSchema):
+
+        # Instância o repositório desejado
+        update = UpdateRepository()
+
+        # Executa o respositório desejado
+        return update.execute(caixa_item_id, caixa_item_schema)

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

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

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

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

packages/v1/administrativo/actions/c_caixa_servico/c_caixa_servico_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.g_usuario.g_usuario_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

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

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

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

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

@@ -0,0 +1,11 @@
+from packages.v1.administrativo.schemas.c_caixa_servico_schema import CCaixaServicoUpdateSchema
+from packages.v1.administrativo.repositories.c_caixa_servico.c_caixa_servico_update_repository import UpdateRepository
+
+
+class UpdateAction:
+
+    def execute(self, caixa_servico_id : int, c_caixa_servico_schema : CCaixaServicoUpdateSchema):
+
+        save_repository = UpdateRepository()
+
+        return save_repository.execute(caixa_servico_id, c_caixa_servico_schema)

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_cidade/g_cidade_delete_action.py

@@ -0,0 +1,26 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.schemas.g_cidade_schema import GCidadeIdSchema
+from packages.v1.administrativo.repositories.g_cidade.g_cidade_delete_repository import DeleteRepository
+
+
+class DeleteAction(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_CIDADE.
+    """
+
+    def execute(self, g_cidade_schema: GCidadeIdSchema):
+        """
+        Executa a operação de exclusão no banco de dados.
+
+        Args:
+            g_cidade_schema (GCidadeIdSchema): O esquema com o ID (CIDADE_ID) a ser excluído.
+
+        Returns:
+            O resultado da operação de exclusão.
+        """
+        # Instanciamento do repositório
+        delete_repository = DeleteRepository()
+
+        # Execução do repositório
+        return delete_repository.execute(g_cidade_schema)

packages/v1/administrativo/actions/g_cidade/g_cidade_get_by_nome_action.py

@@ -0,0 +1,29 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.schemas.g_cidade_schema import GCidadeNomeSchema
+from packages.v1.administrativo.repositories.g_cidade.g_cidade_get_by_nome_repository import GetByNomeRepository
+
+
+class GetByNomeAction(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_CIDADE por nome (CIDADE_NOME).
+    """
+
+    def execute(self, g_cidade_schema: GCidadeNomeSchema):
+        """
+        Executa a operação de busca no banco de dados.
+
+        Args:
+            g_cidade_schema (GCidadeNomeSchema): O esquema com o nome da cidade a ser buscada.
+
+        Returns:
+            O registro encontrado ou None.
+        """
+        # Instanciamento do repositório
+        show_repository = GetByNomeRepository()
+
+        # Execução do repositório
+        response = show_repository.execute(g_cidade_schema)
+
+        # Retorno da informação
+        return response

packages/v1/administrativo/actions/g_cidade/g_cidade_index_action.py

@@ -0,0 +1,24 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_cidade.g_cidade_index_repository import IndexRepository
+
+class IndexAction(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_CIDADE.
+    """
+
+    def execute(self):
+        """
+        Executa a operação de listagem no banco de dados.
+
+        Returns:
+            A lista de todos os registros.
+        """
+        # Instanciamento do repositório
+        index_repository = IndexRepository()
+
+        # Execução do repositório
+        response = index_repository.execute()
+
+        # Retorno da informação
+        return response

packages/v1/administrativo/actions/g_cidade/g_cidade_save_action.py

@@ -0,0 +1,28 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.schemas.g_cidade_schema import GCidadeSaveSchema
+from packages.v1.administrativo.repositories.g_cidade.g_cidade_save_repository import SaveRepository
+
+class SaveAction(BaseAction):
+    """
+    Serviço responsável por encapsular a lógica de negócio para a operação
+    de salvar (inserir ou atualizar) um registro na tabela G_CIDADE.
+    """
+
+    def execute(self, g_cidade_schema: GCidadeSaveSchema):
+        """
+        Executa a operação de salvamento.
+
+        Args:
+            g_cidade_schema (GCidadeSaveSchema): O esquema com os dados a serem salvos.
+
+        Returns:
+            O resultado da operação de salvamento.
+        """
+        # Instanciamento do repositório
+        save_repository = SaveRepository()
+
+        # Execução do repositório
+        response = save_repository.execute(g_cidade_schema)
+
+        # Retorno da informação
+        return response

packages/v1/administrativo/actions/g_cidade/g_cidade_show_action.py

@@ -0,0 +1,28 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.schemas.g_cidade_schema import GCidadeIdSchema
+from packages.v1.administrativo.repositories.g_cidade.g_cidade_show_repository import ShowRepository
+
+class ShowAction(BaseAction):
+    """
+    Serviço responsável por encapsular a lógica de negócio para a exibição
+    de um registro na tabela G_CIDADE, usando o CIDADE_ID.
+    """
+
+    def execute(self, g_cidade_schema: GCidadeIdSchema):
+        """
+        Executa a operação de exibição.
+        
+        Args:
+            g_cidade_schema (GCidadeIdSchema): O esquema com o ID (CIDADE_ID) do registro a ser exibido.
+
+        Returns:
+            O resultado da operação de exibição (o registro encontrado ou None).
+        """
+        # Instanciamento do repositório
+        show_repository = ShowRepository()
+
+        # Execução do repositório
+        response = show_repository.execute(g_cidade_schema)
+
+        # Retorno da informação
+        return response

packages/v1/administrativo/actions/g_cidade/g_cidade_update_action.py

@@ -0,0 +1,26 @@
+from packages.v1.administrativo.schemas.g_cidade_schema import GCidadeUpdateSchema
+from packages.v1.administrativo.repositories.g_cidade.g_cidade_update_repository import UpdateRepository
+
+
+class UpdateAction:
+    """
+        Serviço responsável por encapsular a lógica de negócio para a atualização
+        de um registro na tabela G_CIDADE.
+    """
+
+    def execute(self, cidade_id: int, g_cidade_schema: GCidadeUpdateSchema):
+        """
+        Executa a operação de atualização.
+
+        Args:
+            cidade_id (int): O ID (CIDADE_ID) do registro a ser atualizado.
+            g_cidade_schema (GCidadeUpdateSchema): O esquema com os dados a serem atualizados.
+
+        Returns:
+            O resultado da operação de atualização.
+        """
+        # Instância o repositório de atualização
+        update_repository = UpdateRepository()
+
+        # Chama o método de execução do repositório para realizar a atualização
+        return update_repository.execute(cidade_id, g_cidade_schema)

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_delete_action.py

@@ -0,0 +1,29 @@
+from abstracts.action import BaseAction
+# O schema TServicoTipoIdSchema deve ser substituído por GMarcacaoTipoIdSchema
+# que contém o campo-chave MARCACAO_TIPO_ID.
+from packages.v1.administrativo.schemas.g_marcacao_tipo_schema import GMarcacaoTipoIdSchema
+# O repositório TServicoTipoDeleteRepository deve ser substituído pelo GMarcacaoTipoDeleteRepository.
+from packages.v1.administrativo.repositories.g_marcacao_tipo.g_marcacao_tipo_delete_repository import DeleteRepository
+
+
+class DeleteAction(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_MARCACAO_TIPO.
+    """
+
+    def execute(self, marcacao_tipo_schema: GMarcacaoTipoIdSchema):
+        """
+        Executa a operação de exclusão no banco de dados.
+
+        Args:
+            marcacao_tipo_schema (GMarcacaoTipoIdSchema): O esquema com o ID (MARCACAO_TIPO_ID) a ser excluído.
+
+        Returns:
+            O resultado da operação de exclusão.
+        """
+        # Instanciamento do repositório
+        delete_repository = DeleteRepository()
+
+        # Execução do repositório
+        return delete_repository.execute(marcacao_tipo_schema)

packages/v1/administrativo/actions/g_marcacao_tipo/g_marcacao_tipo_get_by_descricao_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 GMarcacaoTipoDescricaoSchema
+# Ajuste do repositório
+from packages.v1.administrativo.repositories.g_marcacao_tipo.g_marcacao_tipo_get_by_descricao_repository import GetByDescricaoRepository
+
+
+class GetByDescricaoAction(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 descrição.
+    """
+
+    def execute(self, marcacao_tipo_schema: GMarcacaoTipoDescricaoSchema):
+        """
+        Executa a operação de busca no banco de dados.
+
+        Args:
+            marcacao_tipo_schema (GMarcacaoTipoDescricaoSchema): O esquema com a descrição a ser buscada.
+
+        Returns:
+            O registro encontrado ou None.
+        """
+        # Instanciamento do repositório
+        show_repository = GetByDescricaoRepository()
+
+        # Execução do repositório
+        response = show_repository.execute(marcacao_tipo_schema)
+
+        # Retorno da informação
+        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_marcacao_tipo/g_marcacao_tipo_index_action.py

@@ -0,0 +1,25 @@
+from abstracts.action import BaseAction
+# O repositório TServicoTipoIndexRepository deve ser substituído pelo GMarcacaoTipoIndexRepository.
+from packages.v1.administrativo.repositories.g_marcacao_tipo.g_marcacao_tipo_index_repository import IndexRepository
+
+class IndexAction(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_MARCACAO_TIPO.
+    """
+
+    def execute(self):
+        """
+        Executa a operação de listagem no banco de dados.
+
+        Returns:
+            A lista de todos os registros.
+        """
+        # Instanciamento do repositório
+        index_repository = IndexRepository()
+
+        # Execução do repositório
+        response = index_repository.execute()
+
+        # Retorno da informação
+        return response

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

@@ -0,0 +1,30 @@
+from abstracts.action import BaseAction
+# Ajuste do schema de entrada
+from packages.v1.administrativo.schemas.g_marcacao_tipo_schema import GMarcacaoTipoSaveSchema
+# Ajuste do repositório
+from packages.v1.administrativo.repositories.g_marcacao_tipo.g_marcacao_tipo_save_repository import SaveRepository
+
+class SaveAction(BaseAction):
+    """
+    Serviço responsável por encapsular a lógica de negócio para a operação
+    de salvar um novo registro na tabela G_MARCACAO_TIPO.
+    """
+
+    def execute(self, marcacao_tipo_schema: GMarcacaoTipoSaveSchema):
+        """
+        Executa a operação de salvamento.
+
+        Args:
+            marcacao_tipo_schema (GMarcacaoTipoSaveSchema): O esquema com os dados a serem salvos.
+
+        Returns:
+            O resultado da operação de salvamento.
+        """
+        # Instanciamento do repositório
+        save_repository = SaveRepository()
+
+        # Execução do repositório
+        response = save_repository.execute(marcacao_tipo_schema)
+
+        # Retorno da informação
+        return response

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

@@ -0,0 +1,30 @@
+from abstracts.action import BaseAction
+# Ajuste do schema de entrada
+from packages.v1.administrativo.schemas.g_marcacao_tipo_schema import GMarcacaoTipoIdSchema
+# Ajuste do repositório
+from packages.v1.administrativo.repositories.g_marcacao_tipo.g_marcacao_tipo_show_repository import ShowRepository
+
+class ShowAction(BaseAction):
+    """
+    Serviço responsável por encapsular a lógica de negócio para a exibição
+    de um registro na tabela G_MARCACAO_TIPO.
+    """
+
+    def execute(self, marcacao_tipo_schema: GMarcacaoTipoIdSchema):
+        """
+        Executa a operação de exibição.
+        
+        Args:
+            marcacao_tipo_schema (GMarcacaoTipoIdSchema): O esquema com o ID (MARCACAO_TIPO_ID) do registro a ser exibido.
+
+        Returns:
+            O resultado da operação de exibição.
+        """
+        # Instânciamento do repositório
+        show_repository = ShowRepository()
+
+        # Execução do repositório
+        response = show_repository.execute(marcacao_tipo_schema)
+
+        # Retorno da informação
+        return response

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

@@ -0,0 +1,28 @@
+# Importação do Schema ajustada
+from packages.v1.administrativo.schemas.g_marcacao_tipo_schema import GMarcacaoTipoUpdateSchema
+# Importação do Repositório ajustada
+from packages.v1.administrativo.repositories.g_marcacao_tipo.g_marcacao_tipo_update_repository import UpdateRepository
+# A classe UpdateAction não herda de BaseAction no arquivo original, mantemos o padrão.
+
+class UpdateAction:
+    """
+        Service responsável por encapsular a lógica de negócio para a atualização
+        de um registro na tabela G_MARCACAO_TIPO.
+    """
+
+    def execute(self, marcacao_tipo_id: int, marcacao_tipo_schema: GMarcacaoTipoUpdateSchema):
+        """
+        Executa a operação de atualização.
+
+        Args:
+            marcacao_tipo_id (int): O ID (MARCACAO_TIPO_ID) do registro a ser atualizado.
+            marcacao_tipo_schema (GMarcacaoTipoUpdateSchema): O esquema com os dados a serem atualizados.
+
+        Returns:
+            O resultado da operação de atualização.
+        """
+        # Instância o repositório de atualização
+        update_repository = UpdateRepository()
+
+        # Chama o método de execução do repositório para realizar a atualização
+        return update_repository.execute(marcacao_tipo_id, marcacao_tipo_schema)

packages/v1/administrativo/actions/g_medida_tipo/g_medida_tipo_delete_action.py

@@ -0,0 +1,26 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.schemas.g_medida_tipo_schema import GMedidaTipoIdSchema
+from packages.v1.administrativo.repositories.g_medida_tipo.g_medida_tipo_delete_repository import DeleteRepository
+
+
+class DeleteAction(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_medida_tipo.
+    """
+
+    def execute(self, medida_tipo_schema: GMedidaTipoIdSchema):
+        """
+        Executa a operação de exclusão no banco de dados.
+
+        Args:
+            medida_tipo_schema (GMedidaTipoIdSchema): O esquema com o ID a ser excluído.
+
+        Returns:
+            O resultado da operação de exclusão.
+        """
+        # Instanciamento do repositório
+        delete_repository = DeleteRepository()
+
+        # Execução do repositório
+        return delete_repository.execute(medida_tipo_schema)

packages/v1/administrativo/actions/g_medida_tipo/g_medida_tipo_get_by_descricao_action.py

@@ -0,0 +1,29 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.schemas.g_medida_tipo_schema import GMedidaTipoDescricaoSchema
+from packages.v1.administrativo.repositories.g_medida_tipo.g_medida_tipo_get_by_descricao_repository import GetByDescricaoRepository
+
+
+class GetByDescricaoAction(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_medida_tipo por descrição.
+    """
+
+    def execute(self, medida_tipo_schema: GMedidaTipoDescricaoSchema):
+        """
+        Executa a operação de busca no banco de dados.
+
+        Args:
+            medida_tipo_schema (GMedidaTipoDescricaoSchema): O esquema com a descrição a ser buscada.
+
+        Returns:
+            O registro encontrado ou None.
+        """
+        # Instanciamento do repositório
+        show_repository = GetByDescricaoRepository()
+
+        # Execução do repositório
+        response = show_repository.execute(medida_tipo_schema)
+
+        # Retorno da informação
+        return response

packages/v1/administrativo/actions/g_medida_tipo/g_medida_tipo_index_action.py

@@ -0,0 +1,24 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_medida_tipo.g_medida_tipo_index_repository import IndexRepository
+
+class IndexAction(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_medida_tipo.
+    """
+
+    def execute(self):
+        """
+        Executa a operação de listagem no banco de dados.
+
+        Returns:
+            A lista de todos os registros.
+        """
+        # Instanciamento do repositório
+        index_repository = IndexRepository()
+
+        # Execução do repositório
+        response = index_repository.execute()
+
+        # Retorno da informação
+        return response

packages/v1/administrativo/actions/g_medida_tipo/g_medida_tipo_save_action.py

@@ -0,0 +1,28 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.schemas.g_medida_tipo_schema import GMedidaTipoSaveSchema
+from packages.v1.administrativo.repositories.g_medida_tipo.g_medida_tipo_save_repository import SaveRepository
+
+class SaveAction(BaseAction):
+    """
+    Serviço responsável por encapsular a lógica de negócio para a operação
+    de salvar um novo registro na tabela g_medida_tipo.
+    """
+
+    def execute(self, medida_tipo_schema: GMedidaTipoSaveSchema):
+        """
+        Executa a operação de salvamento.
+
+        Args:
+            medida_tipo_schema (GMedidaTipoSaveSchema): O esquema com os dados a serem salvos.
+
+        Returns:
+            O resultado da operação de salvamento.
+        """
+        # Instanciamento do repositório
+        save_repository = SaveRepository()
+
+        # Execução do repositório
+        response = save_repository.execute(medida_tipo_schema)
+
+        # Retorno da informação
+        return response

packages/v1/administrativo/actions/g_medida_tipo/g_medida_tipo_show_action.py

@@ -0,0 +1,28 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.schemas.g_medida_tipo_schema import GMedidaTipoIdSchema
+from packages.v1.administrativo.repositories.g_medida_tipo.g_medida_tipo_show_repository import ShowRepository
+
+class ShowAction(BaseAction):
+    """
+    Serviço responsável por encapsular a lógica de negócio para a exibição
+    de um registro na tabela g_medida_tipo.
+    """
+
+    def execute(self, medida_tipo_schema: GMedidaTipoIdSchema):
+        """
+        Executa a operação de exibição.
+        
+        Args:
+            medida_tipo_schema (GMedidaTipoIdSchema): O esquema com o ID do registro a ser exibido.
+
+        Returns:
+            O resultado da operação de exibição.
+        """
+        # Instanciamento do repositório
+        show_repository = ShowRepository()
+
+        # Execução do repositório
+        response = show_repository.execute(medida_tipo_schema)
+
+        # Retorno da informação
+        return response

packages/v1/administrativo/actions/g_medida_tipo/g_medida_tipo_update_action.py

@@ -0,0 +1,26 @@
+from packages.v1.administrativo.schemas.g_medida_tipo_schema import GMedidaTipoUpdateSchema
+from packages.v1.administrativo.repositories.g_medida_tipo.g_medida_tipo_update_repository import UpdateRepository
+
+
+class UpdateAction:
+    """
+        Service responsável por encapsular a lógica de negócio para a atualização
+        de um registro na tabela g_medida_tipo.
+    """
+
+    def execute(self, medida_tipo_id: int, medida_tipo_schema: GMedidaTipoUpdateSchema):
+        """
+        Executa a operação de atualização.
+
+        Args:
+            medida_tipo_id (int): O ID do registro a ser atualizado.
+            medida_tipo_schema (GMedidaTipoUpdateSchema): O esquema com os dados a serem atualizados.
+
+        Returns:
+            O resultado da operação de atualização.
+        """
+        # Instância o repositório de atualização
+        update_repository = UpdateRepository()
+
+        # Chama o método de execução do repositório para realizar a atualização
+        return update_repository.execute(medida_tipo_id, medida_tipo_schema)

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

@@ -0,0 +1,26 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.schemas.g_natureza_schema import GNaturezaIdSchema
+from packages.v1.administrativo.repositories.g_natureza.g_natureza_delete_repository import DeleteRepository
+
+
+class DeleteAction(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.
+    """
+
+    def execute(self, natureza_schema: GNaturezaIdSchema):
+        """
+        Executa a operação de exclusão no banco de dados.
+
+        Args:
+            natureza_schema (GNaturezaIdSchema): O esquema com o ID a ser excluído.
+
+        Returns:
+            O resultado da operação de exclusão.
+        """
+        # Instanciamento do repositório
+        delete_repository = DeleteRepository()
+
+        # Execução do repositório
+        return delete_repository.execute(natureza_schema)

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

@@ -0,0 +1,29 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.schemas.g_natureza_schema import GNaturezaDescricaoSchema
+from packages.v1.administrativo.repositories.g_natureza.g_natureza_get_by_descricao_repository import GetByDescricaoRepository
+
+
+class GetByDescricaoAction(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_natureza por descrição.
+    """
+
+    def execute(self, natureza_schema: GNaturezaDescricaoSchema):
+        """
+        Executa a operação de busca no banco de dados.
+
+        Args:
+            natureza_schema (GNaturezaDescricaoSchema): O esquema com a descrição a ser buscada.
+
+        Returns:
+            O registro encontrado ou None.
+        """
+        # Instanciamento do repositório
+        show_repository = GetByDescricaoRepository()
+
+        # Execução do repositório
+        response = show_repository.execute(natureza_schema)
+
+        # Retorno da informação
+        return response

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

@@ -0,0 +1,24 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_natureza.g_natureza_index_repository import IndexRepository
+
+class IndexAction(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.
+    """
+
+    def execute(self):
+        """
+        Executa a operação de listagem no banco de dados.
+
+        Returns:
+            A lista de todos os registros.
+        """
+        # Instanciamento do repositório
+        index_repository = IndexRepository()
+
+        # Execução do repositório
+        response = index_repository.execute()
+
+        # Retorno da informação
+        return response

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

@@ -0,0 +1,30 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.repositories.g_natureza.g_natureza_index_by_sistema_id_repository import (
+    IndexBySistemaIdRepository,
+)
+from packages.v1.administrativo.schemas.g_natureza_schema import (
+    GNaturezaSistemaIdSchema,
+)
+
+
+class IndexActionBySistemaId(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.
+    """
+
+    def execute(self, g_natureza_sistema_id_schema: GNaturezaSistemaIdSchema):
+        """
+        Executa a operação de listagem no banco de dados.
+
+        Returns:
+            A lista de todos os registros.
+        """
+        # Instanciamento do repositório
+        index_repository = IndexBySistemaIdRepository()
+
+        # Execução do repositório
+        response = index_repository.execute(g_natureza_sistema_id_schema)
+
+        # Retorno da informação
+        return response

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

@@ -0,0 +1,28 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.schemas.g_natureza_schema import GNaturezaSaveSchema
+from packages.v1.administrativo.repositories.g_natureza.g_natureza_save_repository import SaveRepository
+
+class SaveAction(BaseAction):
+    """
+    Serviço responsável por encapsular a lógica de negócio para a operação
+    de salvar um novo registro na tabela g_natureza.
+    """
+
+    def execute(self, natureza_schema: GNaturezaSaveSchema):
+        """
+        Executa a operação de salvamento.
+
+        Args:
+            natureza_schema (GNaturezaSaveSchema): O esquema com os dados a serem salvos.
+
+        Returns:
+            O resultado da operação de salvamento.
+        """
+        # Instanciamento do repositório
+        save_repository = SaveRepository()
+
+        # Execução do repositório
+        response = save_repository.execute(natureza_schema)
+
+        # Retorno da informação
+        return response

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

@@ -0,0 +1,28 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.schemas.g_natureza_schema import GNaturezaIdSchema
+from packages.v1.administrativo.repositories.g_natureza.g_natureza_show_repository import ShowRepository
+
+class ShowAction(BaseAction):
+    """
+    Serviço responsável por encapsular a lógica de negócio para a exibição
+    de um registro na tabela g_natureza.
+    """
+
+    def execute(self, natureza_schema: GNaturezaIdSchema):
+        """
+        Executa a operação de exibição.
+        
+        Args:
+            natureza_schema (GNaturezaIdSchema): O esquema com o ID do registro a ser exibido.
+
+        Returns:
+            O resultado da operação de exibição.
+        """
+        # Instânciamento do repositório
+        show_repository = ShowRepository()
+
+        # Execução do repositório
+        response = show_repository.execute(natureza_schema)
+
+        # Retorno da informação
+        return response

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

@@ -0,0 +1,26 @@
+from packages.v1.administrativo.schemas.g_natureza_schema import GNaturezaUpdateSchema
+from packages.v1.administrativo.repositories.g_natureza.g_natureza_update_repository import UpdateRepository
+
+
+class UpdateAction:
+    """
+        Service responsável por encapsular a lógica de negócio para a atualização
+        de um registro na tabela g_natureza.
+    """
+
+    def execute(self, natureza_id: int, natureza_schema: GNaturezaUpdateSchema):
+        """
+        Executa a operação de atualização.
+
+        Args:
+            natureza_id (int): O ID do registro a ser atualizado.
+            natureza_schema (GNaturezaUpdateSchema): O esquema com os dados a serem atualizados.
+
+        Returns:
+            O resultado da operação de atualização.
+        """
+        # Instância o repositório de atualização
+        update_repository = UpdateRepository()
+
+        # Chama o método de execução do repositório para realizar a atualização
+        return update_repository.execute(natureza_id, natureza_schema)

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