Merge branch 'release(MVP/Sprint11)'
This commit is contained in:
Keven
commit
8258ee97c3
742 changed files with 47470 additions and 549 deletions
File diff suppressed because it is too large
Load diff
|
|
@ -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):
|
||||
"""Executa uma consulta SQL e retorna o resultado como objeto ResultProxy"""
|
||||
return self._execute(sql, params, fetch="result")
|
||||
# Sobrecarga 1: quando `fetch="all"`, o retorno é uma lista de mapeamentos (coluna->valor).
|
||||
@overload
|
||||
def _execute(
|
||||
self, sql: str, params: Optional[dict[str, Any]], fetch: Literal["all"]
|
||||
) -> List[Mapping[str, Any]]: ...
|
||||
|
||||
def fetch_all(self, sql: str, params: Optional[dict] = None):
|
||||
"""Executa uma consulta SQL e retorna todos os registros com mapeamento de colunas"""
|
||||
return self._execute(sql, params, fetch="all")
|
||||
# Sobrecarga 2: quando `fetch="one"`, o retorno é um único mapeamento ou None.
|
||||
@overload
|
||||
def _execute(
|
||||
self, sql: str, params: Optional[dict[str, Any]], fetch: Literal["one"]
|
||||
) -> Optional[Mapping[str, Any]]: ...
|
||||
|
||||
def fetch_one(self, sql: str, params: Optional[dict] = None):
|
||||
"""Executa uma consulta SQL e retorna o primeiro registro com mapeamento de colunas"""
|
||||
return self._execute(sql, params, fetch="one")
|
||||
# Sobrecarga 3: quando `fetch="none"`, não há retorno (operações DML sem leitura).
|
||||
@overload
|
||||
def _execute(
|
||||
self, sql: str, params: Optional[dict[str, Any]], fetch: Literal["none"]
|
||||
) -> None: ...
|
||||
|
||||
def run(self, sql: str, params: Optional[dict] = None):
|
||||
"""Executa um SQL sem retorno de dados (ex: INSERT, UPDATE, DELETE)"""
|
||||
return self._execute(sql, params, fetch="none")
|
||||
|
||||
def run_and_return(self, sql: str, params: Optional[dict] = None):
|
||||
"""Executa SQL com RETURNING e retorna o primeiro registro como dict"""
|
||||
return self._execute(sql, params, fetch="one")
|
||||
# Sobrecarga 4: quando `fetch="result"`, retorna o objeto `CursorResult` bruto do SQLAlchemy.
|
||||
@overload
|
||||
def _execute(
|
||||
self, sql: str, params: Optional[dict[str, Any]], fetch: Literal["result"]
|
||||
) -> CursorResult[Any]: ...
|
||||
|
||||
# Implementação concreta que atende às quatro sobrecargas por meio de um retorno em união.
|
||||
def _execute(
|
||||
self,
|
||||
sql: str,
|
||||
params: Optional[dict] = None,
|
||||
fetch: Literal["all", "one", "result", "none"] = "result",
|
||||
):
|
||||
sql: str, # Comando SQL (SELECT/INSERT/UPDATE/DELETE) em texto.
|
||||
params: Optional[dict[str, Any]] = None, # Parâmetros nomeados para o SQL.
|
||||
fetch: Literal[
|
||||
"all", "one", "none", "result"
|
||||
] = "result", # Modo de leitura/retorno.
|
||||
) -> 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")
|
||||
|
|
|
|||
31
actions/data/dict_to_namespace.py
Normal file
31
actions/data/dict_to_namespace.py
Normal file
|
|
@ -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
|
||||
82
actions/data/dict_to_obj.py
Normal file
82
actions/data/dict_to_obj.py
Normal file
|
|
@ -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})"
|
||||
51
actions/data/generate_insert_sql.py
Normal file
51
actions/data/generate_insert_sql.py
Normal file
|
|
@ -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
|
||||
5
actions/data/get_url_params.py
Normal file
5
actions/data/get_url_params.py
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
from fastapi import Request
|
||||
|
||||
|
||||
async def get_url_params(request: Request):
|
||||
return dict(request.query_params)
|
||||
37
actions/data/json_to_dict.py
Normal file
37
actions/data/json_to_dict.py
Normal file
|
|
@ -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}")
|
||||
30
actions/data/prepare_update_data.py
Normal file
30
actions/data/prepare_update_data.py
Normal file
|
|
@ -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
|
||||
|
|
@ -1,20 +1,23 @@
|
|||
import importlib
|
||||
from actions.config.config import Config
|
||||
from typing import Optional, Any, Type
|
||||
|
||||
|
||||
class DynamicImport:
|
||||
|
||||
def __init__(self):
|
||||
self.config = Config.get('app.json')
|
||||
self.base = 'packages.v1'
|
||||
def __init__(self) -> None:
|
||||
self.config: dict[str, Any] = Config.get("app.json")
|
||||
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}"
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@ from actions.jwt.verify_token import VerifyToken # A classe que criamos anterio
|
|||
|
||||
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"]
|
||||
|
|
|
|||
12
actions/session/get_session.py
Normal file
12
actions/session/get_session.py
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
from typing import Any, Optional
|
||||
from fastapi import Depends, 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
|
||||
16
actions/session/session_services.py
Normal file
16
actions/session/session_services.py
Normal file
|
|
@ -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()
|
||||
|
|
@ -1,8 +1,7 @@
|
|||
|
||||
class CEP:
|
||||
|
||||
@staticmethod
|
||||
def validate(data: str) -> bool:
|
||||
|
||||
# Valida e retorna a informação
|
||||
return len(data) == 8
|
||||
return len(data) == 8
|
||||
|
|
|
|||
14
actions/values/values.py
Normal file
14
actions/values/values.py
Normal file
|
|
@ -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)
|
||||
186
api.code-workspace
Normal file
186
api.code-workspace
Normal file
|
|
@ -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"
|
||||
]
|
||||
}
|
||||
}
|
||||
58
main.py
58
main.py
|
|
@ -1,13 +1,19 @@
|
|||
# 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
|
||||
|
|
@ -15,18 +21,27 @@ 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 \
|
||||
StartupCheckService
|
||||
from packages.v1.system.service.startup_check_service import 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)
|
||||
|
|
@ -40,6 +55,16 @@ app.add_middleware(
|
|||
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.on_event("startup")
|
||||
async def on_startup():
|
||||
|
||||
|
|
@ -49,20 +74,21 @@ 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
|
||||
# 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
|
||||
file = Path(config.log.request.path) / config.log.request.name
|
||||
|
||||
|
|
@ -74,16 +100,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
|
||||
reload=True # Ativa auto-reload durante desenvolvimento
|
||||
"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
|
||||
reload=True, # Ativa auto-reload durante desenvolvimento
|
||||
)
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
@ -1,5 +1,8 @@
|
|||
from abstracts.action import BaseAction
|
||||
from packages.v1.administrativo.repositories.c_caixa_servico.c_caixa_servico_index_repository import IndexRepository
|
||||
from packages.v1.administrativo.repositories.c_caixa_servico.c_caixa_servico_index_repository import (
|
||||
IndexRepository,
|
||||
)
|
||||
|
||||
|
||||
class IndexAction(BaseAction):
|
||||
|
||||
|
|
@ -12,4 +15,4 @@ class IndexAction(BaseAction):
|
|||
response = index_repository.execute()
|
||||
|
||||
# Retorno da informação
|
||||
return response
|
||||
return response
|
||||
|
|
|
|||
|
|
@ -1,11 +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
|
||||
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):
|
||||
def execute(self, usuario_schema: CCaixaServicoSaveSchema):
|
||||
|
||||
save_repository = SaveRepository()
|
||||
|
||||
return save_repository.execute(usuario_schema)
|
||||
return save_repository.execute(usuario_schema)
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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)
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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)
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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]
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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)
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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)
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
from abstracts.action import BaseAction
|
||||
from packages.v1.administrativo.repositories.g_natureza_titulo.g_natureza_titulo_save_repository import (
|
||||
GNaturezaTituloSaveRepository,
|
||||
)
|
||||
from packages.v1.administrativo.schemas.g_natureza_titulo_schema import (
|
||||
GNaturezaTituloSaveSchema,
|
||||
)
|
||||
|
||||
|
||||
class GNaturezaTituloSaveAction(BaseAction):
|
||||
"""
|
||||
Serviço responsável por encapsular a lógica de negócio para a operação
|
||||
de salvamento de um novo registro na tabela G_NATUREZA_TITULO.
|
||||
"""
|
||||
|
||||
def execute(self, g_natureza_titulo_save_schema: GNaturezaTituloSaveSchema):
|
||||
"""
|
||||
Executa a operação de salvamento.
|
||||
|
||||
Args:
|
||||
g_natureza_titulo_schema (GNaturezaTituloSchema):
|
||||
O esquema com os dados a serem persistidos.
|
||||
|
||||
Returns:
|
||||
O resultado da operação de salvamento.
|
||||
"""
|
||||
# ----------------------------------------------------
|
||||
# Instanciamento do repositório
|
||||
# ----------------------------------------------------
|
||||
g_natureza_titulo_save_repository = GNaturezaTituloSaveRepository()
|
||||
|
||||
# ----------------------------------------------------
|
||||
# Execução do repositório
|
||||
# ----------------------------------------------------
|
||||
response = g_natureza_titulo_save_repository.execute(
|
||||
g_natureza_titulo_save_schema
|
||||
)
|
||||
|
||||
# ----------------------------------------------------
|
||||
# Retorno da informação
|
||||
# ----------------------------------------------------
|
||||
return response
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
from abstracts.action import BaseAction
|
||||
from packages.v1.administrativo.repositories.g_natureza_titulo.g_natureza_titulo_show_repository import (
|
||||
GNaturezaTituloShowRepository,
|
||||
)
|
||||
from packages.v1.administrativo.schemas.g_natureza_titulo_schema import (
|
||||
GNaturezaTituloIdSchema,
|
||||
)
|
||||
|
||||
|
||||
class GNaturezaTituloShowAction(BaseAction):
|
||||
"""
|
||||
Serviço responsável por encapsular a lógica de negócio para a exibição
|
||||
de um registro na tabela G_NATUREZA_TITULO.
|
||||
"""
|
||||
|
||||
def execute(self, g_natureza_titulo_id_schema: GNaturezaTituloIdSchema):
|
||||
"""
|
||||
Executa a operação de exibição.
|
||||
|
||||
Args:
|
||||
g_natureza_titulo_id_schema (GNaturezaTituloIdSchema):
|
||||
O esquema com o ID do registro a ser exibido.
|
||||
|
||||
Returns:
|
||||
O resultado da operação de exibição.
|
||||
"""
|
||||
# ----------------------------------------------------
|
||||
# Instanciamento do repositório
|
||||
# ----------------------------------------------------
|
||||
g_natureza_titulo_show_repository = GNaturezaTituloShowRepository()
|
||||
|
||||
# ----------------------------------------------------
|
||||
# Execução do repositório
|
||||
# ----------------------------------------------------
|
||||
response = g_natureza_titulo_show_repository.execute(
|
||||
g_natureza_titulo_id_schema
|
||||
)
|
||||
|
||||
# ----------------------------------------------------
|
||||
# Retorno da informação
|
||||
# ----------------------------------------------------
|
||||
return response
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
from abstracts.action import BaseAction
|
||||
from packages.v1.administrativo.repositories.g_natureza_titulo.g_natureza_titulo_update_repository import (
|
||||
GNaturezaTituloUpdateRepository,
|
||||
)
|
||||
from packages.v1.administrativo.schemas.g_natureza_titulo_schema import (
|
||||
GNaturezaTituloUpdateSchema,
|
||||
)
|
||||
|
||||
|
||||
class GNaturezaTituloUpdateAction(BaseAction):
|
||||
"""
|
||||
Serviço responsável por encapsular a lógica de negócio para a atualização
|
||||
de um registro na tabela G_NATUREZA_TITULO.
|
||||
"""
|
||||
|
||||
def execute(self, g_natureza_titulo_update_schema: GNaturezaTituloUpdateSchema):
|
||||
"""
|
||||
Executa a operação de atualização.
|
||||
|
||||
Args:
|
||||
g_natureza_titulo_update_schema (GNaturezaTituloUpdateSchema):
|
||||
O esquema com os dados a serem atualizados.
|
||||
|
||||
Returns:
|
||||
O resultado da operação de atualização.
|
||||
"""
|
||||
# ----------------------------------------------------
|
||||
# Instanciamento do repositório de atualização
|
||||
# ----------------------------------------------------
|
||||
g_natureza_titulo_update_repository = GNaturezaTituloUpdateRepository()
|
||||
|
||||
# ----------------------------------------------------
|
||||
# Execução do repositório
|
||||
# ----------------------------------------------------
|
||||
response = g_natureza_titulo_update_repository.execute(
|
||||
g_natureza_titulo_update_schema
|
||||
)
|
||||
|
||||
# ----------------------------------------------------
|
||||
# Retorno do resultado
|
||||
# ----------------------------------------------------
|
||||
return response
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
from abstracts.action import BaseAction
|
||||
from packages.v1.administrativo.repositories.g_selo_grupo.g_selo_grupo_delete_repository import (
|
||||
GSeloGrupoDeleteRepository,
|
||||
)
|
||||
from packages.v1.administrativo.schemas.g_selo_grupo_schema import GSeloGrupoIdSchema
|
||||
|
||||
|
||||
class GSeloGrupoDeleteAction(BaseAction):
|
||||
"""
|
||||
Serviço responsável por encapsular a lógica de negócio para a operação
|
||||
de exclusão de um registro na tabela G_SELO_GRUPO.
|
||||
"""
|
||||
|
||||
def execute(self, g_selo_grupo_id_schema: GSeloGrupoIdSchema):
|
||||
"""
|
||||
Executa a operação de exclusão no banco de dados.
|
||||
|
||||
Args:
|
||||
g_selo_grupo_id_schema (GSeloGrupoIdSchema):
|
||||
O esquema contendo o ID do registro a ser excluído.
|
||||
|
||||
Returns:
|
||||
O resultado da operação de exclusão.
|
||||
"""
|
||||
# ----------------------------------------------------
|
||||
# Instanciamento do repositório
|
||||
# ----------------------------------------------------
|
||||
g_selo_grupo_delete_repository = GSeloGrupoDeleteRepository()
|
||||
|
||||
# ----------------------------------------------------
|
||||
# Execução da exclusão
|
||||
# ----------------------------------------------------
|
||||
response = g_selo_grupo_delete_repository.execute(g_selo_grupo_id_schema)
|
||||
|
||||
return response
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
from abstracts.action import BaseAction
|
||||
from packages.v1.administrativo.repositories.g_selo_grupo.g_selo_grupo_index_repository import (
|
||||
GSeloGrupoIndexRepository,
|
||||
)
|
||||
|
||||
|
||||
class GSeloGrupoIndexAction(BaseAction):
|
||||
"""
|
||||
Serviço responsável por encapsular a lógica de negócio para a operação
|
||||
de listagem de todos os registros na tabela G_NATUREZA_TITULO.
|
||||
"""
|
||||
|
||||
def execute(self):
|
||||
"""
|
||||
Executa a operação de listagem no banco de dados.
|
||||
|
||||
Args:
|
||||
g_selo_grupo_index_schema (GSeloGrupoIndexSchema):
|
||||
Esquema contendo parâmetros opcionais de filtro.
|
||||
|
||||
Returns:
|
||||
A lista de registros encontrados.
|
||||
"""
|
||||
# ----------------------------------------------------
|
||||
# Instanciamento do repositório
|
||||
# ----------------------------------------------------
|
||||
g_selo_grupo_index_repository = GSeloGrupoIndexRepository()
|
||||
|
||||
# ----------------------------------------------------
|
||||
# Execução do repositório
|
||||
# ----------------------------------------------------
|
||||
response = g_selo_grupo_index_repository.execute()
|
||||
|
||||
# ----------------------------------------------------
|
||||
# Retorno da informação
|
||||
# --------------------------------
|
||||
return response
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
from abstracts.action import BaseAction
|
||||
from packages.v1.administrativo.repositories.g_selo_grupo.g_selo_grupo_save_repository import (
|
||||
GSeloGrupoSaveRepository,
|
||||
)
|
||||
from packages.v1.administrativo.schemas.g_selo_grupo_schema import GSeloGrupoSaveSchema
|
||||
|
||||
|
||||
class GSeloGrupoSaveAction(BaseAction):
|
||||
"""
|
||||
Serviço responsável por encapsular a lógica de negócio para a operação
|
||||
de salvamento de um novo registro na tabela G_GRAMATICA.
|
||||
"""
|
||||
|
||||
def execute(self, g_selo_grupo_save_schema: GSeloGrupoSaveSchema):
|
||||
"""
|
||||
Executa a operação de salvamento.
|
||||
|
||||
Args:
|
||||
g_selo_grupo_schema (GSeloGrupoSchema):
|
||||
O esquema com os dados a serem persistidos.
|
||||
|
||||
Returns:
|
||||
O resultado da operação de salvamento.
|
||||
"""
|
||||
# ----------------------------------------------------
|
||||
# Instanciamento do repositório
|
||||
# ----------------------------------------------------
|
||||
g_selo_grupo_save_repository = GSeloGrupoSaveRepository()
|
||||
|
||||
# ----------------------------------------------------
|
||||
# Execução do repositório
|
||||
# ----------------------------------------------------
|
||||
response = g_selo_grupo_save_repository.execute(g_selo_grupo_save_schema)
|
||||
|
||||
# ----------------------------------------------------
|
||||
# Retorno da informação
|
||||
# ----------------------------------------------------
|
||||
return response
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
from abstracts.action import BaseAction
|
||||
from packages.v1.administrativo.repositories.g_selo_grupo.g_selo_grupo_show_repository import (
|
||||
GSeloGrupoShowRepository,
|
||||
)
|
||||
from packages.v1.administrativo.schemas.g_selo_grupo_schema import GSeloGrupoIdSchema
|
||||
|
||||
|
||||
class GSeloGrupoShowAction(BaseAction):
|
||||
"""
|
||||
Serviço responsável por encapsular a lógica de negócio para a exibição
|
||||
de um registro na tabela G_NATUREZA_TITULO.
|
||||
"""
|
||||
|
||||
def execute(self, g_selo_grupo_id_schema: GSeloGrupoIdSchema):
|
||||
"""
|
||||
Executa a operação de exibição.
|
||||
|
||||
Args:
|
||||
g_selo_grupo_id_schema (GSeloGrupoIdSchema):
|
||||
O esquema com o ID do registro a ser exibido.
|
||||
|
||||
Returns:
|
||||
O resultado da operação de exibição.
|
||||
"""
|
||||
# ----------------------------------------------------
|
||||
# Instanciamento do repositório
|
||||
# ----------------------------------------------------
|
||||
g_selo_grupo_show_repository = GSeloGrupoShowRepository()
|
||||
|
||||
# ----------------------------------------------------
|
||||
# Execução do repositório
|
||||
# ----------------------------------------------------
|
||||
response = g_selo_grupo_show_repository.execute(g_selo_grupo_id_schema)
|
||||
|
||||
# ----------------------------------------------------
|
||||
# Retorno da informação
|
||||
# ----------------------------------------------------
|
||||
return response
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
from abstracts.action import BaseAction
|
||||
from packages.v1.administrativo.repositories.g_selo_grupo.g_selo_grupo_update_repository import (
|
||||
GSeloGrupoUpdateRepository,
|
||||
)
|
||||
from packages.v1.administrativo.schemas.g_selo_grupo_schema import (
|
||||
GSeloGrupoUpdateSchema,
|
||||
)
|
||||
|
||||
|
||||
class GSeloGrupoUpdateAction(BaseAction):
|
||||
"""
|
||||
Serviço responsável por encapsular a lógica de negócio para a atualização
|
||||
de um registro na tabela G_NATUREZA_TITULO.
|
||||
"""
|
||||
|
||||
def execute(self, g_selo_grupo_update_schema: GSeloGrupoUpdateSchema):
|
||||
"""
|
||||
Executa a operação de atualização.
|
||||
|
||||
Args:
|
||||
g_selo_grupo_update_schema (GSeloGrupoUpdateSchema):
|
||||
O esquema com os dados a serem atualizados.
|
||||
|
||||
Returns:
|
||||
O resultado da operação de atualização.
|
||||
"""
|
||||
# ----------------------------------------------------
|
||||
# Instanciamento do repositório de atualização
|
||||
# ----------------------------------------------------
|
||||
g_selo_grupo_update_repository = GSeloGrupoUpdateRepository()
|
||||
|
||||
# ----------------------------------------------------
|
||||
# Execução do repositório
|
||||
# ----------------------------------------------------
|
||||
response = g_selo_grupo_update_repository.execute(g_selo_grupo_update_schema)
|
||||
|
||||
# ----------------------------------------------------
|
||||
# Retorno do resultado
|
||||
# ----------------------------------------------------
|
||||
return response
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
from abstracts.action import BaseAction
|
||||
from packages.v1.administrativo.schemas.g_tb_bairro_schema import GTbBairroIdSchema
|
||||
from packages.v1.administrativo.repositories.g_tb_bairro.g_tb_bairro_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_tb_bairro.
|
||||
"""
|
||||
|
||||
def execute(self, bairro_schema: GTbBairroIdSchema):
|
||||
"""
|
||||
Executa a operação de exclusão no banco de dados.
|
||||
|
||||
Args:
|
||||
bairro_schema (GTbBairroIdSchema): 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(bairro_schema)
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
from abstracts.action import BaseAction
|
||||
from packages.v1.administrativo.schemas.g_tb_bairro_schema import GTbBairroDescricaoSchema
|
||||
from packages.v1.administrativo.repositories.g_tb_bairro.g_tb_bairro_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_tb_bairro por descrição.
|
||||
"""
|
||||
|
||||
def execute(self, bairro_schema: GTbBairroDescricaoSchema):
|
||||
"""
|
||||
Executa a operação de busca no banco de dados.
|
||||
|
||||
Args:
|
||||
bairro_schema (GTbBairroDescricaoSchema): 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(bairro_schema)
|
||||
|
||||
# Retorno da informação
|
||||
return response
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
from abstracts.action import BaseAction
|
||||
from packages.v1.administrativo.repositories.g_tb_bairro.g_tb_bairro_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_tb_bairro.
|
||||
"""
|
||||
|
||||
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
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
from abstracts.action import BaseAction
|
||||
from packages.v1.administrativo.schemas.g_tb_bairro_schema import GTbBairroSaveSchema
|
||||
from packages.v1.administrativo.repositories.g_tb_bairro.g_tb_bairro_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_tb_bairro.
|
||||
"""
|
||||
|
||||
def execute(self, bairro_schema: GTbBairroSaveSchema):
|
||||
"""
|
||||
Executa a operação de salvamento.
|
||||
|
||||
Args:
|
||||
bairro_schema (GTbBairroSaveSchema): 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(bairro_schema)
|
||||
|
||||
# Retorno da informação
|
||||
return response
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
from abstracts.action import BaseAction
|
||||
from packages.v1.administrativo.schemas.g_tb_bairro_schema import GTbBairroIdSchema
|
||||
from packages.v1.administrativo.repositories.g_tb_bairro.g_tb_bairro_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_tb_bairro.
|
||||
"""
|
||||
|
||||
def execute(self, bairro_schema: GTbBairroIdSchema):
|
||||
"""
|
||||
Executa a operação de exibição.
|
||||
|
||||
Args:
|
||||
bairro_schema (GTbBairroIdSchema): 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(bairro_schema)
|
||||
|
||||
# Retorno da informação
|
||||
return response
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
from packages.v1.administrativo.schemas.g_tb_bairro_schema import GTbBairroUpdateSchema
|
||||
from packages.v1.administrativo.repositories.g_tb_bairro.g_tb_bairro_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_tb_bairro.
|
||||
"""
|
||||
|
||||
def execute(self, tb_bairro_id: int, bairro_schema: GTbBairroUpdateSchema):
|
||||
"""
|
||||
Executa a operação de atualização.
|
||||
|
||||
Args:
|
||||
tb_bairro_id (int): O ID do registro a ser atualizado.
|
||||
bairro_schema (GTbBairroUpdateSchema): 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(tb_bairro_id, bairro_schema)
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
from abstracts.action import BaseAction
|
||||
from packages.v1.administrativo.schemas.g_tb_documentotipo_schema import GTbDocumentoTipoIdSchema
|
||||
from packages.v1.administrativo.repositories.g_tb_documentotipo.g_tb_documentotipo_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_tb_documentotipo.
|
||||
"""
|
||||
|
||||
def execute(self, documento_tipo_schema: GTbDocumentoTipoIdSchema):
|
||||
"""
|
||||
Executa a operação de exclusão no banco de dados.
|
||||
|
||||
Args:
|
||||
documento_tipo_schema (GTbDocumentoTipoIdSchema): 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(documento_tipo_schema)
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
from abstracts.action import BaseAction
|
||||
from packages.v1.administrativo.schemas.g_tb_documentotipo_schema import GTbDocumentoTipoDescricaoSchema
|
||||
from packages.v1.administrativo.repositories.g_tb_documentotipo.g_tb_documentotipo_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_tb_documentotipo por descrição.
|
||||
"""
|
||||
|
||||
def execute(self, documento_tipo_schema: GTbDocumentoTipoDescricaoSchema):
|
||||
"""
|
||||
Executa a operação de busca no banco de dados.
|
||||
|
||||
Args:
|
||||
documento_tipo_schema (GTbDocumentoTipoDescricaoSchema): 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(documento_tipo_schema)
|
||||
|
||||
# Retorno da informação
|
||||
return response
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
from abstracts.action import BaseAction
|
||||
from packages.v1.administrativo.repositories.g_tb_documentotipo.g_tb_documentotipo_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_tb_documentotipo.
|
||||
"""
|
||||
|
||||
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
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
from abstracts.action import BaseAction
|
||||
from packages.v1.administrativo.schemas.g_tb_documentotipo_schema import GTbDocumentoTipoSaveSchema
|
||||
from packages.v1.administrativo.repositories.g_tb_documentotipo.g_tb_documentotipo_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_tb_documentotipo.
|
||||
"""
|
||||
|
||||
def execute(self, documento_tipo_schema: GTbDocumentoTipoSaveSchema):
|
||||
"""
|
||||
Executa a operação de salvamento.
|
||||
|
||||
Args:
|
||||
documento_tipo_schema (GTbDocumentoTipoSaveSchema): 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(documento_tipo_schema)
|
||||
|
||||
# Retorno da informação
|
||||
return response
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
from abstracts.action import BaseAction
|
||||
from packages.v1.administrativo.schemas.g_tb_documentotipo_schema import GTbDocumentoTipoIdSchema
|
||||
from packages.v1.administrativo.repositories.g_tb_documentotipo.g_tb_documentotipo_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_tb_documentotipo.
|
||||
"""
|
||||
|
||||
def execute(self, documento_tipo_schema: GTbDocumentoTipoIdSchema):
|
||||
"""
|
||||
Executa a operação de exibição.
|
||||
|
||||
Args:
|
||||
documento_tipo_schema (GTbDocumentoTipoIdSchema): 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(documento_tipo_schema)
|
||||
|
||||
# Retorno da informação
|
||||
return response
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
from packages.v1.administrativo.schemas.g_tb_documentotipo_schema import GTbDocumentoTipoUpdateSchema
|
||||
from packages.v1.administrativo.repositories.g_tb_documentotipo.g_tb_documentotipo_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_tb_documentotipo.
|
||||
"""
|
||||
|
||||
def execute(self, documento_tipo_id: int, documento_tipo_schema: GTbDocumentoTipoUpdateSchema):
|
||||
"""
|
||||
Executa a operação de atualização.
|
||||
|
||||
Args:
|
||||
documento_tipo_id (int): O ID do registro a ser atualizado.
|
||||
documento_tipo_schema (GTbDocumentoTipoUpdateSchema): 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(documento_tipo_id, documento_tipo_schema)
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
from abstracts.action import BaseAction
|
||||
from packages.v1.administrativo.schemas.g_tb_estadocivil_schema import GTbEstadoCivilIdSchema
|
||||
from packages.v1.administrativo.repositories.g_tb_estadocivil.g_tb_estadocivil_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_tb_estadocivil.
|
||||
"""
|
||||
|
||||
def execute(self, estadocivil_schema: GTbEstadoCivilIdSchema):
|
||||
"""
|
||||
Executa a operação de exclusão no banco de dados.
|
||||
|
||||
Args:
|
||||
estadocivil_schema (GTbEstadoCivilIdSchema): 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(estadocivil_schema)
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
from abstracts.action import BaseAction
|
||||
from packages.v1.administrativo.schemas.g_tb_estadocivil_schema import GTbEstadoCivilDescricaoSchema
|
||||
from packages.v1.administrativo.repositories.g_tb_estadocivil.g_tb_estadocivil_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_tb_estadocivil por descrição.
|
||||
"""
|
||||
|
||||
def execute(self, estadocivil_schema: GTbEstadoCivilDescricaoSchema):
|
||||
"""
|
||||
Executa a operação de busca no banco de dados.
|
||||
|
||||
Args:
|
||||
estadocivil_schema (GTbEstadoCivilDescricaoSchema): 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(estadocivil_schema)
|
||||
|
||||
# Retorno da informação
|
||||
return response
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
from abstracts.action import BaseAction
|
||||
from packages.v1.administrativo.repositories.g_tb_estadocivil.g_tb_estadocivil_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_tb_estadocivil.
|
||||
"""
|
||||
|
||||
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
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
from abstracts.action import BaseAction
|
||||
from packages.v1.administrativo.schemas.g_tb_estadocivil_schema import GTbEstadoCivilSaveSchema
|
||||
from packages.v1.administrativo.repositories.g_tb_estadocivil.g_tb_estadocivil_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_tb_estadocivil.
|
||||
"""
|
||||
|
||||
def execute(self, estadocivil_schema: GTbEstadoCivilSaveSchema):
|
||||
"""
|
||||
Executa a operação de salvamento.
|
||||
|
||||
Args:
|
||||
estadocivil_schema (GTbEstadoCivilSaveSchema): 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(estadocivil_schema)
|
||||
|
||||
# Retorno da informação
|
||||
return response
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
from abstracts.action import BaseAction
|
||||
from packages.v1.administrativo.schemas.g_tb_estadocivil_schema import GTbEstadoCivilIdSchema
|
||||
from packages.v1.administrativo.repositories.g_tb_estadocivil.g_tb_estadocivil_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_tb_estadocivil.
|
||||
"""
|
||||
|
||||
def execute(self, estadocivil_schema: GTbEstadoCivilIdSchema):
|
||||
"""
|
||||
Executa a operação de exibição.
|
||||
|
||||
Args:
|
||||
estadocivil_schema (GTbEstadoCivilIdSchema): 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(estadocivil_schema)
|
||||
|
||||
# Retorno da informação
|
||||
return response
|
||||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Reference in a new issue