OriusTecnologia/saas_api
6
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

[MVPTN-126] feat(CRUD): Implementa o crud de TServicoPEdido e TServicoItemPedido

Browse source
This commit is contained in:
Keven Willian Pereira de Souza 2025-10-30 16:00:08 -03:00
parent b85557194b
commit 12d39c4f87
39 changed files with 2286 additions and 39 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

112
.code-workspace → api.code-workspace
View file

@ -1,9 +1,11 @@
{
"folders": [
{ "path": "D:/IIS/Orius/api" }
{
"path": "D:/IIS/Orius/api"
}
],
"settings": {
// === GERAL ===
// === ⚙️ GERAL ===
"editor.formatOnSave": true,
"editor.codeActionsOnSave": {
"source.fixAll": "explicit",
@ -16,8 +18,9 @@
"files.autoSave": "onFocusChange",
"telemetry.telemetryLevel": "off",
"update.mode": "manual",
// === PERFORMANCE ===
"workbench.startupEditor": "none",
"workbench.editor.enablePreview": false,
// === ⚡ PERFORMANCE ===
"files.watcherExclude": {
"**/__pycache__/**": true,
"**/.mypy_cache/**": true,
@ -32,24 +35,55 @@
"**/.mypy_cache": true,
"**/.pytest_cache": true
},
// === PYTHON ===
// === 🐍 PYTHON ===
"python.defaultInterpreterPath": "D:/IIS/Orius/api/venv/Scripts/python.exe",
"python.analysis.typeCheckingMode": "off",
"python.analysis.useLibraryCodeForTypes": true,
"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"],
"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"],
"python.linting.flake8Args": [
"--max-line-length=100"
],
// === 🧩 FORMATAÇÃO LOCAL ===
"[python]": {
"editor.defaultFormatter": "ms-python.black-formatter",
"editor.formatOnSave": true
},
// === TERMINAIS INTEGRADOS ===
// === 🧠 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",
@ -65,34 +99,32 @@
"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"]
"args": [
"/k",
"cd D:\\IIS\\Orius\\api && venv\\Scripts\\activate"
]
},
"Git Bash": {
"path": "C:\\Program Files\\Git\\bin\\bash.exe"
}
},
"terminal.integrated.defaultProfile.windows": "Git Bash",
// === GIT ===
"git.enabled": true,
"git.autorefresh": false,
"git.fetchOnPull": true,
"git.confirmSync": false,
// === VISUAL ===
"workbench.colorTheme": "Default Dark Modern",
"window.zoomLevel": 0,
"breadcrumbs.enabled": true,
"explorer.compactFolders": false,
// === TESTES ===
"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,
// === MISC ===
// === 🗂️ ARQUIVOS ===
"files.exclude": {
"**/.DS_Store": true,
"**/*.log": true
@ -126,19 +158,29 @@
"type": "python",
"request": "launch",
"program": "${workspaceFolder}/venv/Scripts/pytest.exe",
"args": ["-v"],
"args": [
"-v"
],
"console": "integratedTerminal"
}
]
},
"extensions": {
"recommendations": [
// === PYTHON ===
// === 🐍 PYTHON ===
"ms-python.python",
"ms-python.pylance",
"ms-python.black-formatter",
"ms-python.flake8",
"ms-python.pylance",
"littlefoxteam.vscode-python-test-adapter",
// === GIT ===
// === 🔍 GIT ===
"eamodio.gitlens",
"mhutchie.git-graph",
"donjayamanne.githistory",
// === 🧰 UTILITÁRIOS ===
"formulahendry.code-runner",
"streetsidesoftware.code-spell-checker",
"tamasfe.even-better-toml"
]
}
}

16
packages/v1/administrativo/services/g_emolumento_periodo/go/g_emolumento_periodo_save_service.py
View file

@ -1,7 +1,13 @@
from api.packages.v1.administrativo.actions.g_emolumento_periodo.g_emolumento_periodo_save_action import GEmolumentoPeriodoSaveAction
from api.packages.v1.administrativo.actions.g_emolumento_periodo.g_emolumento_periodo_save_action import (
GEmolumentoPeriodoSaveAction,
)
from api.packages.v1.sequencia.schemas.g_sequencia import GSequenciaSchema
from api.packages.v1.administrativo.schemas.g_emolumento_periodo_schema import GEmolumentoPeriodoSaveSchema
from api.packages.v1.sequencia.services.g_sequencia.generate_service import GenerateService
from api.packages.v1.administrativo.schemas.g_emolumento_periodo_schema import (
GEmolumentoPeriodoSaveSchema,
)
from api.packages.v1.sequencia.services.g_sequencia.generate_service import (
GenerateService,
)
class GEmolumentoPeriodoSaveService:
@ -41,4 +47,6 @@ class GEmolumentoPeriodoSaveService:
# Instanciamento e execução da Action de salvamento
# ----------------------------------------------------
g_emolumento_periodo_save_action = GEmolumentoPeriodoSaveAction()
return g_emolumento_periodo_save_action.execute(g_emolumento_periodo_save_schema)
return g_emolumento_periodo_save_action.execute(
g_emolumento_periodo_save_schema
)

18
packages/v1/api.py
View file

@ -46,6 +46,10 @@ from packages.v1.administrativo.endpoints import t_imovel_unidade_endpoint
from packages.v1.administrativo.endpoints import t_pessoa_endpoint
from packages.v1.administrativo.endpoints import t_pessoa_representante_endpoint
from packages.v1.administrativo.endpoints import g_calculo_endpoint
from packages.v1.servicos.balcao.endpoints import (
t_servico_itempedido_endpoint,
t_servico_pedido_endpoint,
)
# Cria uma instância do APIRouter que vai agregar todas as rotas da API
api_router = APIRouter()
@ -333,3 +337,17 @@ api_router.include_router(
prefix="/administrativo/g_emolumento_item",
tags=["Itens do Emolumento"],
)
# Inclui as rotas de g_emolumento periodo
api_router.include_router(
t_servico_pedido_endpoint.router,
prefix="/servicos/balcao/t_servico_pedido",
tags=["Pedido"],
)
# Inclui as rotas de g_emolumento periodo
api_router.include_router(
t_servico_itempedido_endpoint.router,
prefix="/servicos/balcao/t_servico_itempedido",
tags=["Itens do Pedido"],
)

39
packages/v1/servicos/balcao/actions/t_servico_itempedido/t_servico_itempedido_delete_action.py Normal file
View file

@ -0,0 +1,39 @@
from abstracts.action import BaseAction
from packages.v1.servicos.balcao.repositories.t_servico_itempedido.t_servico_itempedido_delete_repository import (
TServicoItemPedidoDeleteRepository,
)
from packages.v1.servicos.balcao.schemas.t_servico_itempedido_schema import (
TServicoItemPedidoIdSchema,
)
class TServicoItemPedidoDeleteAction(BaseAction):
"""
Serviço responsável por encapsular a lógica de negócio para a operação
de exclusão de um registro na tabela T_SERVICO_ITEMPEDIDO.
"""
def execute(self, t_servico_itempedido_id_schema: TServicoItemPedidoIdSchema):
"""
Executa a operação de exclusão no banco de dados.
Args:
t_servico_itempedido_id_schema (TServicoItemPedidoIdSchema):
O esquema contendo o ID do registro a ser excluído.
Returns:
O resultado da operação de exclusão.
"""
# ----------------------------------------------------
# Instanciamento do repositório
# ----------------------------------------------------
t_servico_itempedido_delete_repository = TServicoItemPedidoDeleteRepository()
# ----------------------------------------------------
# Execução da exclusão
# ----------------------------------------------------
response = t_servico_itempedido_delete_repository.execute(
t_servico_itempedido_id_schema
)
return response

42
packages/v1/servicos/balcao/actions/t_servico_itempedido/t_servico_itempedido_index_action.py Normal file
View file

@ -0,0 +1,42 @@
from abstracts.action import BaseAction
from packages.v1.servicos.balcao.repositories.t_servico_itempedido.t_servico_itempedido_index_repository import (
TServicoItemPedidoIndexRepository,
)
from packages.v1.servicos.balcao.schemas.t_servico_itempedido_schema import (
TServicoItemIndexSchema,
)
class TServicoItemPedidoIndexAction(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, t_servico_itempedido_index_schema: TServicoItemIndexSchema):
"""
Executa a operação de listagem no banco de dados.
Args:
t_servico_itempedido_index_schema (TServicoItemPedidoIndexSchema):
Esquema contendo parâmetros opcionais de filtro.
Returns:
A lista de registros encontrados.
"""
# ----------------------------------------------------
# Instanciamento do repositório
# ----------------------------------------------------
t_servico_itempedido_index_repository = TServicoItemPedidoIndexRepository()
# ----------------------------------------------------
# Execução do repositório
# ----------------------------------------------------
response = t_servico_itempedido_index_repository.execute(
t_servico_itempedido_index_schema
)
# ----------------------------------------------------
# Retorno da informação
# --------------------------------
return response

42
packages/v1/servicos/balcao/actions/t_servico_itempedido/t_servico_itempedido_save_action.py Normal file
View file

@ -0,0 +1,42 @@
from abstracts.action import BaseAction
from packages.v1.servicos.balcao.repositories.t_servico_itempedido.t_servico_itempedido_save_repository import (
TServicoItemPedidoSaveRepository,
)
from packages.v1.servicos.balcao.schemas.t_servico_itempedido_schema import (
TServicoItemPedidoSaveSchema,
)
class TServicoItemPedidoSaveAction(BaseAction):
"""
Serviço responsável por encapsular a lógica de negócio para a operação
de salvamento de um novo registro na tabela T_SERVICO_ITEMPEDIDO.
"""
def execute(self, t_servico_itempedido_save_schema: TServicoItemPedidoSaveSchema):
"""
Executa a operação de salvamento.
Args:
t_servico_itempedido_schema (TServicoItemPedidoSchema):
O esquema com os dados a serem persistidos.
Returns:
O resultado da operação de salvamento.
"""
# ----------------------------------------------------
# Instanciamento do repositório
# ----------------------------------------------------
t_servico_itempedido_save_repository = TServicoItemPedidoSaveRepository()
# ----------------------------------------------------
# Execução do repositório
# ----------------------------------------------------
response = t_servico_itempedido_save_repository.execute(
t_servico_itempedido_save_schema
)
# ----------------------------------------------------
# Retorno da informação
# ----------------------------------------------------
return response

42
packages/v1/servicos/balcao/actions/t_servico_itempedido/t_servico_itempedido_show_action.py Normal file
View file

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

44
packages/v1/servicos/balcao/actions/t_servico_itempedido/t_servico_itempedido_update_action.py Normal file
View file

@ -0,0 +1,44 @@
from abstracts.action import BaseAction
from packages.v1.servicos.balcao.repositories.t_servico_itempedido.t_servico_itempedido_update_repository import (
TServicoItemPedidoUpdateRepository,
)
from packages.v1.servicos.balcao.schemas.t_servico_itempedido_schema import (
TServicoItemPedidoUpdateSchema,
)
class TServicoItemPedidoUpdateAction(BaseAction):
"""
Serviço responsável por encapsular a lógica de negócio para a atualização
de um registro na tabela G_NATUREZA_TITULO.
"""
def execute(
self, t_servico_itempedido_update_schema: TServicoItemPedidoUpdateSchema
):
"""
Executa a operação de atualização.
Args:
t_servico_itempedido_update_schema (TServicoItemPedidoUpdateSchema):
O esquema com os dados a serem atualizados.
Returns:
O resultado da operação de atualização.
"""
# ----------------------------------------------------
# Instanciamento do repositório de atualização
# ----------------------------------------------------
t_servico_itempedido_update_repository = TServicoItemPedidoUpdateRepository()
# ----------------------------------------------------
# Execução do repositório
# ----------------------------------------------------
response = t_servico_itempedido_update_repository.execute(
t_servico_itempedido_update_schema
)
# ----------------------------------------------------
# Retorno do resultado
# ----------------------------------------------------
return response

39
packages/v1/servicos/balcao/actions/t_servico_pedido/t_servico_pedido_delete_action.py Normal file
View file

@ -0,0 +1,39 @@
from abstracts.action import BaseAction
from packages.v1.servicos.balcao.repositories.t_servico_pedido.t_servico_pedido_delete_repository import (
TServicoPedidoDeleteRepository,
)
from packages.v1.servicos.balcao.schemas.t_servico_pedido_schema import (
TServicoPedidoIdSchema,
)
class TServicoPedidoDeleteAction(BaseAction):
"""
Serviço responsável por encapsular a lógica de negócio para a operação
de exclusão de um registro na tabela T_SERVICO_PEDIDO.
"""
def execute(self, t_servico_pedido_id_schema: TServicoPedidoIdSchema):
"""
Executa a operação de exclusão no banco de dados.
Args:
t_servico_pedido_id_schema (TServicoPedidoIdSchema):
O esquema contendo o ID do registro a ser excluído.
Returns:
O resultado da operação de exclusão.
"""
# ----------------------------------------------------
# Instanciamento do repositório
# ----------------------------------------------------
t_servico_pedido_delete_repository = TServicoPedidoDeleteRepository()
# ----------------------------------------------------
# Execução da exclusão
# ----------------------------------------------------
response = t_servico_pedido_delete_repository.execute(
t_servico_pedido_id_schema
)
return response

37
packages/v1/servicos/balcao/actions/t_servico_pedido/t_servico_pedido_index_action.py Normal file
View file

@ -0,0 +1,37 @@
from abstracts.action import BaseAction
from packages.v1.servicos.balcao.repositories.t_servico_pedido.t_servico_pedido_index_repository import (
TServicoPedidoIndexRepository,
)
class TServicoPedidoIndexAction(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:
t_servico_pedido_index_schema (TServicoPedidoIndexSchema):
Esquema contendo parâmetros opcionais de filtro.
Returns:
A lista de registros encontrados.
"""
# ----------------------------------------------------
# Instanciamento do repositório
# ----------------------------------------------------
t_servico_pedido_index_repository = TServicoPedidoIndexRepository()
# ----------------------------------------------------
# Execução do repositório
# ----------------------------------------------------
response = t_servico_pedido_index_repository.execute()
# ----------------------------------------------------
# Retorno da informação
# --------------------------------
return response

42
packages/v1/servicos/balcao/actions/t_servico_pedido/t_servico_pedido_save_action.py Normal file
View file

@ -0,0 +1,42 @@
from abstracts.action import BaseAction
from packages.v1.servicos.balcao.repositories.t_servico_pedido.t_servico_pedido_save_repository import (
TServicoPedidoSaveRepository,
)
from packages.v1.servicos.balcao.schemas.t_servico_pedido_schema import (
TServicoPedidoSaveSchema,
)
class TServicoPedidoSaveAction(BaseAction):
"""
Serviço responsável por encapsular a lógica de negócio para a operação
de salvamento de um novo registro na tabela T_SERVICO_PEDIDO.
"""
def execute(self, t_servico_pedido_save_schema: TServicoPedidoSaveSchema):
"""
Executa a operação de salvamento.
Args:
t_servico_pedido_schema (TServicoPedidoSchema):
O esquema com os dados a serem persistidos.
Returns:
O resultado da operação de salvamento.
"""
# ----------------------------------------------------
# Instanciamento do repositório
# ----------------------------------------------------
t_servico_pedido_save_repository = TServicoPedidoSaveRepository()
# ----------------------------------------------------
# Execução do repositório
# ----------------------------------------------------
response = t_servico_pedido_save_repository.execute(
t_servico_pedido_save_schema
)
# ----------------------------------------------------
# Retorno da informação
# ----------------------------------------------------
return response

40
packages/v1/servicos/balcao/actions/t_servico_pedido/t_servico_pedido_show_action.py Normal file
View file

@ -0,0 +1,40 @@
from abstracts.action import BaseAction
from packages.v1.servicos.balcao.repositories.t_servico_pedido.t_servico_pedido_show_repository import (
TServicoPedidoShowRepository,
)
from packages.v1.servicos.balcao.schemas.t_servico_pedido_schema import (
TServicoPedidoIdSchema,
)
class TServicoPedidoShowAction(BaseAction):
"""
Serviço responsável por encapsular a lógica de negócio para a exibição
de um registro na tabela G_NATUREZA_TITULO.
"""
def execute(self, t_servico_pedido_id_schema: TServicoPedidoIdSchema):
"""
Executa a operação de exibição.
Args:
t_servico_pedido_id_schema (TServicoPedidoIdSchema):
O esquema com o ID do registro a ser exibido.
Returns:
O resultado da operação de exibição.
"""
# ----------------------------------------------------
# Instanciamento do repositório
# ----------------------------------------------------
t_servico_pedido_show_repository = TServicoPedidoShowRepository()
# ----------------------------------------------------
# Execução do repositório
# ----------------------------------------------------
response = t_servico_pedido_show_repository.execute(t_servico_pedido_id_schema)
# ----------------------------------------------------
# Retorno da informação
# ----------------------------------------------------
return response

42
packages/v1/servicos/balcao/actions/t_servico_pedido/t_servico_pedido_update_action.py Normal file
View file

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

114
packages/v1/servicos/balcao/controllers/t_servico_itempedido_controller.py Normal file
View file

@ -0,0 +1,114 @@
from actions.dynamic_import.dynamic_import import DynamicImport
from packages.v1.servicos.balcao.schemas.t_servico_itempedido_schema import (
TServicoItemIndexSchema,
TServicoItemPedidoSaveSchema,
TServicoItemPedidoUpdateSchema,
TServicoItemPedidoIdSchema,
)
class TServicoItemPedidoController:
"""
Controller responsável por orquestrar as operações CRUD da tabela T_SERVICO_ITEMPEDIDO,
utilizando carregamento dinâmico de serviços via DynamicImport.
"""
def __init__(self):
# ----------------------------------------------------
# Inicialização do DynamicImport
# ----------------------------------------------------
self.dynamic_import = DynamicImport()
self.dynamic_import.set_package("servicos.balcao")
self.dynamic_import.set_table("t_servico_itempedido")
# ----------------------------------------------------
# Lista todos os registros de T_SERVICO_ITEMPEDIDO
# ----------------------------------------------------
def index(self, t_servico_itempedido_index_schema: TServicoItemIndexSchema):
# Importação da classe desejada
index_service = self.dynamic_import.service(
"t_servico_itempedido_index_service", "TServicoItemPedidoIndexService"
)
# Instância da classe service
self.index_service = index_service()
# Execução da listagem
return {
"message": "Registros de T_SERVICO_ITEMPEDIDO localizados com sucesso.",
"data": self.index_service.execute(t_servico_itempedido_index_schema),
}
# ----------------------------------------------------
# Busca um registro específico de T_SERVICO_ITEMPEDIDO pelo ID
# ----------------------------------------------------
def show(self, t_servico_itempedido_id_schema: TServicoItemPedidoIdSchema):
# Importação da classe desejada
show_service = self.dynamic_import.service(
"t_servico_itempedido_show_service", "TServicoItemPedidoShowService"
)
# Instância da classe service
self.show_service = show_service()
# Execução da busca
return {
"message": "Registro de T_SERVICO_ITEMPEDIDO localizado com sucesso.",
"data": self.show_service.execute(t_servico_itempedido_id_schema),
}
# ----------------------------------------------------
# Cadastra um novo registro em T_SERVICO_ITEMPEDIDO
# ----------------------------------------------------
def save(self, t_servico_itempedido_save_schema: TServicoItemPedidoSaveSchema):
# Importação da classe desejada
save_service = self.dynamic_import.service(
"t_servico_itempedido_save_service", "TServicoItemPedidoSaveService"
)
# Instância da classe service
self.save_service = save_service()
# Execução do salvamento
return {
"message": "Registro de T_SERVICO_ITEMPEDIDO salvo com sucesso.",
"data": self.save_service.execute(t_servico_itempedido_save_schema),
}
# ----------------------------------------------------
# Atualiza um registro existente de T_SERVICO_ITEMPEDIDO
# ----------------------------------------------------
def update(
self, t_servico_itempedido_update_schema: TServicoItemPedidoUpdateSchema
):
# Importação da classe desejada
update_service = self.dynamic_import.service(
"t_servico_itempedido_update_service", "TServicoItemPedidoUpdateService"
)
# Instância da classe service
self.update_service = update_service()
# Execução da atualização
return {
"message": "Registro de T_SERVICO_ITEMPEDIDO atualizado com sucesso.",
"data": self.update_service.execute(t_servico_itempedido_update_schema),
}
# ----------------------------------------------------
# Exclui um registro de T_SERVICO_ITEMPEDIDO
# ----------------------------------------------------
def delete(self, t_servico_itempedido_id_schema: TServicoItemPedidoIdSchema):
# Importação da classe desejada
delete_service = self.dynamic_import.service(
"t_servico_itempedido_delete_service", "TServicoItemPedidoDeleteService"
)
# Instância da classe service
self.delete_service = delete_service()
# Execução da exclusão
return {
"message": "Registro de T_SERVICO_ITEMPEDIDO removido com sucesso.",
"data": self.delete_service.execute(t_servico_itempedido_id_schema),
}

111
packages/v1/servicos/balcao/controllers/t_servico_pedido_controller.py Normal file
View file

@ -0,0 +1,111 @@
from actions.dynamic_import.dynamic_import import DynamicImport
from packages.v1.servicos.balcao.schemas.t_servico_pedido_schema import (
TServicoPedidoSaveSchema,
TServicoPedidoUpdateSchema,
TServicoPedidoIdSchema,
)
class TServicoPedidoController:
"""
Controller responsável por orquestrar as operações CRUD da tabela T_SERVICO_PEDIDO,
utilizando carregamento dinâmico de serviços via DynamicImport.
"""
def __init__(self):
# ----------------------------------------------------
# Inicialização do DynamicImport
# ----------------------------------------------------
self.dynamic_import = DynamicImport()
self.dynamic_import.set_package("servicos.balcao")
self.dynamic_import.set_table("t_servico_pedido")
# ----------------------------------------------------
# Lista todos os registros de T_SERVICO_PEDIDO
# ----------------------------------------------------
def index(self):
# Importação da classe desejada
index_service = self.dynamic_import.service(
"t_servico_pedido_index_service", "TServicoPedidoIndexService"
)
# Instância da classe service
self.index_service = index_service()
# Execução da listagem
return {
"message": "Registros de T_SERVICO_PEDIDO localizados com sucesso.",
"data": self.index_service.execute(),
}
# ----------------------------------------------------
# Busca um registro específico de T_SERVICO_PEDIDO pelo ID
# ----------------------------------------------------
def show(self, t_servico_pedido_id_schema: TServicoPedidoIdSchema):
# Importação da classe desejada
show_service = self.dynamic_import.service(
"t_servico_pedido_show_service", "TServicoPedidoShowService"
)
# Instância da classe service
self.show_service = show_service()
# Execução da busca
return {
"message": "Registro de T_SERVICO_PEDIDO localizado com sucesso.",
"data": self.show_service.execute(t_servico_pedido_id_schema),
}
# ----------------------------------------------------
# Cadastra um novo registro em T_SERVICO_PEDIDO
# ----------------------------------------------------
def save(self, t_servico_pedido_save_schema: TServicoPedidoSaveSchema):
# Importação da classe desejada
save_service = self.dynamic_import.service(
"t_servico_pedido_save_service", "TServicoPedidoSaveService"
)
# Instância da classe service
self.save_service = save_service()
# Execução do salvamento
return {
"message": "Registro de T_SERVICO_PEDIDO salvo com sucesso.",
"data": self.save_service.execute(t_servico_pedido_save_schema),
}
# ----------------------------------------------------
# Atualiza um registro existente de T_SERVICO_PEDIDO
# ----------------------------------------------------
def update(self, t_servico_pedido_update_schema: TServicoPedidoUpdateSchema):
# Importação da classe desejada
update_service = self.dynamic_import.service(
"t_servico_pedido_update_service", "TServicoPedidoUpdateService"
)
# Instância da classe service
self.update_service = update_service()
# Execução da atualização
return {
"message": "Registro de T_SERVICO_PEDIDO atualizado com sucesso.",
"data": self.update_service.execute(t_servico_pedido_update_schema),
}
# ----------------------------------------------------
# Exclui um registro de T_SERVICO_PEDIDO
# ----------------------------------------------------
def delete(self, t_servico_pedido_id_schema: TServicoPedidoIdSchema):
# Importação da classe desejada
delete_service = self.dynamic_import.service(
"t_servico_pedido_delete_service", "TServicoPedidoDeleteService"
)
# Instância da classe service
self.delete_service = delete_service()
# Execução da exclusão
return {
"message": "Registro de T_SERVICO_PEDIDO removido com sucesso.",
"data": self.delete_service.execute(t_servico_pedido_id_schema),
}

128
packages/v1/servicos/balcao/endpoints/t_servico_itempedido_endpoint.py Normal file
View file

@ -0,0 +1,128 @@
# Importação de bibliotecas
from fastapi import APIRouter, Depends, status
from actions.jwt.get_current_user import get_current_user
from packages.v1.servicos.balcao.controllers.t_servico_itempedido_controller import (
TServicoItemPedidoController,
)
from packages.v1.servicos.balcao.schemas.t_servico_itempedido_schema import (
TServicoItemIndexSchema,
TServicoItemPedidoSaveSchema,
TServicoItemPedidoUpdateSchema,
TServicoItemPedidoIdSchema,
)
# ----------------------------------------------------
# Inicializa o roteador para as rotas da tabela T_SERVICO_ITEMPEDIDO
# ----------------------------------------------------
router = APIRouter()
# Instanciamento do controller
t_servico_itempedido_controller = TServicoItemPedidoController()
# ----------------------------------------------------
# Lista todos os registros de T_SERVICO_ITEMPEDIDO
# ----------------------------------------------------
@router.get(
"/{servico_pedido_id}",
status_code=status.HTTP_200_OK,
summary="Lista todos os registros de T_SERVICO_ITEMPEDIDO cadastrados",
response_description="Lista todos os registros de T_SERVICO_ITEMPEDIDO cadastrados",
)
async def index(servico_pedido_id: int, current_user: dict = Depends(get_current_user)):
"""
Retorna todos os registros da tabela T_SERVICO_ITEMPEDIDO.
"""
t_servico_itempedido_index_schema = TServicoItemIndexSchema(
servico_pedido_id=servico_pedido_id
)
response = t_servico_itempedido_controller.index(t_servico_itempedido_index_schema)
return response
# ----------------------------------------------------
# Busca um registro específico de T_SERVICO_ITEMPEDIDO pelo ID
# ----------------------------------------------------
@router.get(
"/{servico_itempedido_id}",
status_code=status.HTTP_200_OK,
summary="Busca um registro de T_SERVICO_ITEMPEDIDO pelo ID",
response_description="Busca um registro de T_SERVICO_ITEMPEDIDO em específico",
)
async def show(
servico_itempedido_id: int, current_user: dict = Depends(get_current_user)
):
"""
Retorna um registro específico de T_SERVICO_ITEMPEDIDO com base no ID informado.
"""
t_servico_itempedido_id_schema = TServicoItemPedidoIdSchema(
servico_itempedido_id=servico_itempedido_id
)
response = t_servico_itempedido_controller.show(t_servico_itempedido_id_schema)
return response
# ----------------------------------------------------
# Cadastra um novo registro em T_SERVICO_ITEMPEDIDO
# ----------------------------------------------------
@router.post(
"/",
status_code=status.HTTP_201_CREATED,
summary="Cadastra um novo registro em T_SERVICO_ITEMPEDIDO",
response_description="Cadastra um novo registro em T_SERVICO_ITEMPEDIDO",
)
async def save(
t_servico_itempedido_schema: TServicoItemPedidoSaveSchema,
current_user: dict = Depends(get_current_user),
):
"""
Cria um novo registro na tabela T_SERVICO_ITEMPEDIDO.
"""
response = t_servico_itempedido_controller.save(t_servico_itempedido_schema)
return response
# ----------------------------------------------------
# Atualiza um registro existente de T_SERVICO_ITEMPEDIDO
# ----------------------------------------------------
@router.put(
"/{servico_itempedido_id}",
status_code=status.HTTP_200_OK,
summary="Atualiza um registro existente em T_SERVICO_ITEMPEDIDO",
response_description="Atualiza um registro existente em T_SERVICO_ITEMPEDIDO",
)
async def update(
servico_itempedido_id: int,
t_servico_itempedido_update_schema: TServicoItemPedidoUpdateSchema,
current_user: dict = Depends(get_current_user),
):
"""
Atualiza um registro existente de T_SERVICO_ITEMPEDIDO com base no ID informado.
"""
t_servico_itempedido_update_schema.servico_itempedido_id = servico_itempedido_id
response = t_servico_itempedido_controller.update(
t_servico_itempedido_update_schema
)
return response
# ----------------------------------------------------
# Exclui um registro de T_SERVICO_ITEMPEDIDO
# ----------------------------------------------------
@router.delete(
"/{servico_itempedido_id}",
status_code=status.HTTP_200_OK,
summary="Remove um registro de T_SERVICO_ITEMPEDIDO",
response_description="Remove um registro de T_SERVICO_ITEMPEDIDO",
)
async def delete(
servico_itempedido_id: int, current_user: dict = Depends(get_current_user)
):
"""
Remove um registro específico de T_SERVICO_ITEMPEDIDO com base no ID informado.
"""
t_servico_itempedido_id_schema = TServicoItemPedidoIdSchema(
servico_itempedido_id=servico_itempedido_id
)
response = t_servico_itempedido_controller.delete(t_servico_itempedido_id_schema)
return response

120
packages/v1/servicos/balcao/endpoints/t_servico_pedido_endpoint.py Normal file
View file

@ -0,0 +1,120 @@
# Importação de bibliotecas
from fastapi import APIRouter, Depends, status
from actions.jwt.get_current_user import get_current_user
from packages.v1.servicos.balcao.controllers.t_servico_pedido_controller import (
TServicoPedidoController,
)
from packages.v1.servicos.balcao.schemas.t_servico_pedido_schema import (
TServicoPedidoSaveSchema,
TServicoPedidoUpdateSchema,
TServicoPedidoIdSchema,
)
# ----------------------------------------------------
# Inicializa o roteador para as rotas da tabela T_SERVICO_PEDIDO
# ----------------------------------------------------
router = APIRouter()
# Instanciamento do controller
t_servico_pedido_controller = TServicoPedidoController()
# ----------------------------------------------------
# Lista todos os registros de T_SERVICO_PEDIDO
# ----------------------------------------------------
@router.get(
"/",
status_code=status.HTTP_200_OK,
summary="Lista todos os registros de T_SERVICO_PEDIDO cadastrados",
response_description="Lista todos os registros de T_SERVICO_PEDIDO cadastrados",
)
async def index(current_user: dict = Depends(get_current_user)):
"""
Retorna todos os registros da tabela T_SERVICO_PEDIDO.
"""
response = t_servico_pedido_controller.index()
return response
# ----------------------------------------------------
# Busca um registro específico de T_SERVICO_PEDIDO pelo ID
# ----------------------------------------------------
@router.get(
"/{servico_pedido_id}",
status_code=status.HTTP_200_OK,
summary="Busca um registro de T_SERVICO_PEDIDO pelo ID",
response_description="Busca um registro de T_SERVICO_PEDIDO em específico",
)
async def show(servico_pedido_id: int, current_user: dict = Depends(get_current_user)):
"""
Retorna um registro específico de T_SERVICO_PEDIDO com base no ID informado.
"""
t_servico_pedido_id_schema = TServicoPedidoIdSchema(
servico_pedido_id=servico_pedido_id
)
response = t_servico_pedido_controller.show(t_servico_pedido_id_schema)
return response
# ----------------------------------------------------
# Cadastra um novo registro em T_SERVICO_PEDIDO
# ----------------------------------------------------
@router.post(
"/",
status_code=status.HTTP_201_CREATED,
summary="Cadastra um novo registro em T_SERVICO_PEDIDO",
response_description="Cadastra um novo registro em T_SERVICO_PEDIDO",
)
async def save(
t_servico_pedido_schema: TServicoPedidoSaveSchema,
current_user: dict = Depends(get_current_user),
):
"""
Cria um novo registro na tabela T_SERVICO_PEDIDO.
"""
response = t_servico_pedido_controller.save(t_servico_pedido_schema)
return response
# ----------------------------------------------------
# Atualiza um registro existente de T_SERVICO_PEDIDO
# ----------------------------------------------------
@router.put(
"/{servico_pedido_id}",
status_code=status.HTTP_200_OK,
summary="Atualiza um registro existente em T_SERVICO_PEDIDO",
response_description="Atualiza um registro existente em T_SERVICO_PEDIDO",
)
async def update(
servico_pedido_id: int,
t_servico_pedido_update_schema: TServicoPedidoUpdateSchema,
current_user: dict = Depends(get_current_user),
):
"""
Atualiza um registro existente de T_SERVICO_PEDIDO com base no ID informado.
"""
t_servico_pedido_update_schema.servico_pedido_id = servico_pedido_id
response = t_servico_pedido_controller.update(t_servico_pedido_update_schema)
return response
# ----------------------------------------------------
# Exclui um registro de T_SERVICO_PEDIDO
# ----------------------------------------------------
@router.delete(
"/{servico_pedido_id}",
status_code=status.HTTP_200_OK,
summary="Remove um registro de T_SERVICO_PEDIDO",
response_description="Remove um registro de T_SERVICO_PEDIDO",
)
async def delete(
servico_pedido_id: int, current_user: dict = Depends(get_current_user)
):
"""
Remove um registro específico de T_SERVICO_PEDIDO com base no ID informado.
"""
t_servico_pedido_id_schema = TServicoPedidoIdSchema(
servico_pedido_id=servico_pedido_id
)
response = t_servico_pedido_controller.delete(t_servico_pedido_id_schema)
return response

49
packages/v1/servicos/balcao/repositories/t_servico_itempedido/t_servico_itempedido_delete_repository.py Normal file
View file

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

98
packages/v1/servicos/balcao/repositories/t_servico_itempedido/t_servico_itempedido_index_repository.py Normal file
View file

@ -0,0 +1,98 @@
from abstracts.repository import BaseRepository
from packages.v1.servicos.balcao.schemas.t_servico_itempedido_schema import (
TServicoItemIndexSchema,
)
class TServicoItemPedidoIndexRepository(BaseRepository):
"""
Repositório para a operação de listagem de todos os registros
na tabela t_censec_qualidade.
"""
def execute(self, t_servico_itempedido_index_schema: TServicoItemIndexSchema):
"""
Executa a consulta SQL para buscar todos os registros.
Returns:
Uma lista de dicionários contendo os dados dos registros.
"""
# Montagem do SQL
sql = """ SELECT
GG.SERVICO_ITEMPEDIDO_ID,
GG.SERVICO_PEDIDO_ID,
GG.SERVICO_TIPO_ID,
GG.VALOR,
GG.QTD,
GG.PESSOA_ID,
GG.IMPRESSAO_ETIQUETA,
GG.SITUACAO,
GG.ETIQUETA_NUMERO,
GG.PESSOA_AUXILIAR_ID,
GG.PESSOA_SP_ABONO_REP,
GG.TIPO_ITEM,
GG.IMPRIMIR,
GG.OBSERVACAO,
GG.IMPRESSAO_DIRETA,
GG.SELO_LIVRO_ID,
GG.EMOLUMENTO,
GG.FUNDESP,
GG.TAXA_JUDICIARIA,
GG.DESCONTO,
GG.DESC_COMPLEMENTAR,
GG.VALOR_MANUAL,
GG.VALOR_DOCUMENTO,
GG.OUTRA_TAXA1,
GG.EMOLUMENTO_ITEM_ID,
GG.CERTIDAO_IMPRESSA,
GG.CERTIDAO_ATO_ID,
GG.EMOLUMENTO_ID,
GG.CERTIDAO_PREVISAO,
GG.CERTIDAO_ATO_ANTIGO,
GG.CERTIDAO_DATA_EMISSAO,
GG.ATO_ANTIGO_TIPO,
GG.VALOR_ISS,
GG.ID_ATO_ISENTADO,
GG.MOTIVO_ISENCAO,
GG.PESSOAS_ETIQUETAS,
GG.ABONADOR,
GG.SERVICO_CARTAO,
GG.VALOR_INFORMACOES_CENTRAIS,
GG.SITUACAO_DIFERIDO,
GG.SIGLA_NUMERO,
GG.MOTIVO_DIFERIDO,
GG.NOME_JURIDICO,
GG.ETIQUETA_APENAS_FRENTE,
GG.INDEXACAO_ID,
GG.CERTIDAO_DATA_LAVRATURA,
GG.NFSE_ID,
GG.QTD_PAGINA_CERTIDAO,
GG.PLACA,
GG.DUT,
GG.ETIQUETA_UNICA,
GG.FUNDO_ABONADOR,
GG.INSTRUMENTO_PUBLICO,
GG.DATA_LAVRATURA_ABONO,
GG.VALOR_BASE_CALCULO,
GG.VALOR_AVALIACAO,
GG.ATO_ABONADO,
GG.TRANSFERENCIA_VEICULO,
GG.USAR_A4,
GG.CPF_ABONO_REP,
GG.VRCEXT,
GG.VALOR_FUNDO_SELO,
GG.AVERBACAO
FROM T_SERVICO_ITEMPEDIDO GG
WHERE SERVICO_PEDIDO_ID = :servico_pedido_id
"""
# preenchimento de parâmetros
params = {
"servico_pedido_id": t_servico_itempedido_index_schema.servico_pedido_id
}
# Execução do sql
response = self.fetch_all(sql, params)
# Retorna os dados localizados
return response

52
packages/v1/servicos/balcao/repositories/t_servico_itempedido/t_servico_itempedido_save_repository.py Normal file
View file

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

69
packages/v1/servicos/balcao/repositories/t_servico_itempedido/t_servico_itempedido_show_repository.py Normal file
View file

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

65
packages/v1/servicos/balcao/repositories/t_servico_itempedido/t_servico_itempedido_update_repository.py Normal file
View file

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

47
packages/v1/servicos/balcao/repositories/t_servico_pedido/t_servico_pedido_delete_repository.py Normal file
View file

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

31
packages/v1/servicos/balcao/repositories/t_servico_pedido/t_servico_pedido_index_repository.py Normal file
View file

@ -0,0 +1,31 @@
from abstracts.repository import BaseRepository
class TServicoPedidoIndexRepository(BaseRepository):
"""
Repositório para a operação de listagem de todos os registros
na tabela t_censec_qualidade.
"""
def execute(self):
"""
Executa a consulta SQL para buscar todos os registros.
Returns:
Uma lista de dicionários contendo os dados dos registros.
"""
# Montagem do SQL
sql = """ SELECT
FIRST 1000
TSP.*,
GU.LOGIN
FROM T_SERVICO_PEDIDO TSP
JOIN G_USUARIO GU ON TSP.USUARIO_ID = GU.USUARIO_ID
ORDER By TSP.SERVICO_PEDIDO_ID DESC
"""
# Execução do sql
response = self.fetch_all(sql)
# Retorna os dados localizados
return response

52
packages/v1/servicos/balcao/repositories/t_servico_pedido/t_servico_pedido_save_repository.py Normal file
View file

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

69
packages/v1/servicos/balcao/repositories/t_servico_pedido/t_servico_pedido_show_repository.py Normal file
View file

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

63
packages/v1/servicos/balcao/repositories/t_servico_pedido/t_servico_pedido_update_repository.py Normal file
View file

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

167
packages/v1/servicos/balcao/schemas/t_servico_itempedido_schema.py Normal file
View file

@ -0,0 +1,167 @@
from pydantic import BaseModel
from typing import Optional
from decimal import Decimal
from datetime import datetime
# ----------------------------------------------------
# Schema base - representa a tabela T_SERVICO_ITEMPEDIDO
# ----------------------------------------------------
class TServicoItemPedidoSchema(BaseModel):
servico_itempedido_id: Optional[int] = None
servico_pedido_id: Optional[int] = None
servico_tipo_id: Optional[int] = None
pessoa_id: Optional[int] = None
pessoa_auxiliar_id: Optional[int] = None
valor: Optional[Decimal] = None
qtd: Optional[Decimal] = None
emolumento: Optional[Decimal] = None
fundesp: Optional[Decimal] = None
taxa_judiciaria: Optional[Decimal] = None
desconto: Optional[Decimal] = None
valor_base_calculo: Optional[Decimal] = None
valor_avaliacao: Optional[Decimal] = None
situacao: Optional[str] = None
tipo_item: Optional[str] = None
desc_complementar: Optional[str] = None
nome_juridico: Optional[str] = None
motivo_diferido: Optional[str] = None
etiqueta_apenas_frete: Optional[str] = None # (campo char/flag)
selo_livro_id: Optional[int] = None
etiqueta_numero: Optional[int] = None
certidao_ato_id: Optional[int] = None
indexacao_id: Optional[int] = None
nfse_id: Optional[int] = None
certidao_data_emissao: Optional[datetime] = None
certidao_data_lavratura: Optional[datetime] = None
certidao_texto: Optional[bytes] = None # BLOB (binário)
ato_antigo_tipo: Optional[str] = None
placa: Optional[str] = None
dut: Optional[str] = None
pessoa_sp_abono_rep: Optional[str] = None
chave_importacao: Optional[int] = None
class Config:
from_attributes = True
# ----------------------------------------------------
# Schema para localizar um registro pelo ID (GET /{id})
# ----------------------------------------------------
class TServicoItemIndexSchema(BaseModel):
servico_pedido_id: int
class Config:
from_attributes = True
# ----------------------------------------------------
# Schema para localizar um registro pelo ID (GET /{id})
# ----------------------------------------------------
class TServicoItemPedidoIdSchema(BaseModel):
servico_itempedido_id: int
class Config:
from_attributes = True
# ----------------------------------------------------
# Schema para criação (POST)
# - normalmente sem o ID (gerado pelo banco)
# ----------------------------------------------------
class TServicoItemPedidoSaveSchema(BaseModel):
servico_itempedido_id: Optional[int] = None
servico_pedido_id: Optional[int] = None
servico_tipo_id: Optional[int] = None
pessoa_id: Optional[int] = None
pessoa_auxiliar_id: Optional[int] = None
valor: Optional[Decimal] = None
qtd: Optional[Decimal] = None
emolumento: Optional[Decimal] = None
fundesp: Optional[Decimal] = None
taxa_judiciaria: Optional[Decimal] = None
desconto: Optional[Decimal] = None
valor_base_calculo: Optional[Decimal] = None
valor_avaliacao: Optional[Decimal] = None
situacao: Optional[str] = None
tipo_item: Optional[str] = None
desc_complementar: Optional[str] = None
nome_juridico: Optional[str] = None
motivo_diferido: Optional[str] = None
etiqueta_apenas_frete: Optional[str] = None
selo_livro_id: Optional[int] = None
etiqueta_numero: Optional[int] = None
certidao_ato_id: Optional[int] = None
indexacao_id: Optional[int] = None
nfse_id: Optional[int] = None
certidao_data_emissao: Optional[datetime] = None
certidao_data_lavratura: Optional[datetime] = None
certidao_texto: Optional[bytes] = None
ato_antigo_tipo: Optional[str] = None
placa: Optional[str] = None
dut: Optional[str] = None
pessoa_sp_abono_rep: Optional[str] = None
chave_importacao: Optional[int] = None
class Config:
from_attributes = True
# ----------------------------------------------------
# Schema para atualização (PUT)
# - inclui o ID + campos opcionais para alterar
# ----------------------------------------------------
class TServicoItemPedidoUpdateSchema(BaseModel):
servico_itempedido_id: Optional[int] = None
servico_pedido_id: Optional[int] = None
servico_tipo_id: Optional[int] = None
pessoa_id: Optional[int] = None
pessoa_auxiliar_id: Optional[int] = None
valor: Optional[Decimal] = None
qtd: Optional[Decimal] = None
emolumento: Optional[Decimal] = None
fundesp: Optional[Decimal] = None
taxa_judiciaria: Optional[Decimal] = None
desconto: Optional[Decimal] = None
valor_base_calculo: Optional[Decimal] = None
valor_avaliacao: Optional[Decimal] = None
situacao: Optional[str] = None
tipo_item: Optional[str] = None
desc_complementar: Optional[str] = None
nome_juridico: Optional[str] = None
motivo_diferido: Optional[str] = None
etiqueta_apenas_frete: Optional[str] = None
selo_livro_id: Optional[int] = None
etiqueta_numero: Optional[int] = None
certidao_ato_id: Optional[int] = None
indexacao_id: Optional[int] = None
nfse_id: Optional[int] = None
certidao_data_emissao: Optional[datetime] = None
certidao_data_lavratura: Optional[datetime] = None
certidao_texto: Optional[bytes] = None
ato_antigo_tipo: Optional[str] = None
placa: Optional[str] = None
dut: Optional[str] = None
pessoa_sp_abono_rep: Optional[str] = None
chave_importacao: Optional[int] = None
class Config:
from_attributes = True

85
packages/v1/servicos/balcao/schemas/t_servico_pedido_schema.py Normal file
View file

@ -0,0 +1,85 @@
from pydantic import BaseModel
from typing import Optional
from decimal import Decimal
from datetime import datetime
# ----------------------------------------------------
# Schema base - representa a tabela T_SERVICO_PEDIDO
# ----------------------------------------------------
class TServicoPedidoSchema(BaseModel):
servico_pedido_id: int
valor_pedido: Optional[Decimal] = None
valor_pago: Optional[Decimal] = None
usuario_id: Optional[int] = None
data_pedido: Optional[datetime] = None
mensalista_livrocaixa_id: Optional[int] = None
observacao: Optional[str] = None
escrevente_id: Optional[int] = None
situacao: Optional[str] = None
estornado: Optional[str] = None
apresentante: Optional[str] = None
nfse_id: Optional[int] = None
chave_importacao: Optional[int] = None
cpfcnpj_apresentante: Optional[str] = None
class Config:
from_attributes = True
# ----------------------------------------------------
# Schema para localizar um registro pelo ID (GET /{id})
# ----------------------------------------------------
class TServicoPedidoIdSchema(BaseModel):
servico_pedido_id: int
class Config:
from_attributes = True
# ----------------------------------------------------
# Schema para criação (POST)
# - normalmente sem o ID (gerado pelo banco)
# ----------------------------------------------------
class TServicoPedidoSaveSchema(BaseModel):
servico_pedido_id: Optional[int] = None
valor_pedido: Optional[Decimal] = None
valor_pago: Optional[Decimal] = None
usuario_id: Optional[int] = None
data_pedido: Optional[datetime] = None
mensalista_livrocaixa_id: Optional[int] = None
observacao: Optional[str] = None
escrevente_id: Optional[int] = None
situacao: Optional[str] = None
estornado: Optional[str] = None
apresentante: Optional[str] = None
nfse_id: Optional[int] = None
chave_importacao: Optional[int] = None
cpfcnpj_apresentante: Optional[str] = None
class Config:
from_attributes = True
# ----------------------------------------------------
# Schema para atualização (PUT)
# - inclui o ID + campos opcionais para alterar
# ----------------------------------------------------
class TServicoPedidoUpdateSchema(BaseModel):
servico_pedido_id: Optional[int] = None
valor_pedido: Optional[Decimal] = None
valor_pago: Optional[Decimal] = None
usuario_id: Optional[int] = None
data_pedido: Optional[datetime] = None
mensalista_livrocaixa_id: Optional[int] = None
observacao: Optional[str] = None
escrevente_id: Optional[int] = None
situacao: Optional[str] = None
estornado: Optional[str] = None
apresentante: Optional[str] = None
nfse_id: Optional[int] = None
chave_importacao: Optional[int] = None
cpfcnpj_apresentante: Optional[str] = None
class Config:
from_attributes = True

41
packages/v1/servicos/balcao/services/t_servico_itempedido/go/t_servico_itempedido_delete_service.py Normal file
View file

@ -0,0 +1,41 @@
from packages.v1.servicos.balcao.actions.t_servico_itempedido.t_servico_itempedido_delete_action import (
TServicoItemPedidoDeleteAction,
)
from packages.v1.servicos.balcao.schemas.t_servico_itempedido_schema import (
TServicoItemPedidoIdSchema,
)
class TServicoItemPedidoDeleteService:
"""
Serviço responsável por encapsular a lógica de negócio para a operação
de exclusão de um registro na tabela T_SERVICO_ITEMPEDIDO.
"""
def execute(self, t_servico_itempedido_id_schema: TServicoItemPedidoIdSchema):
"""
Executa a operação de exclusão do registro no banco de dados.
Args:
t_servico_itempedido_id_schema (TServicoItemPedidoIdSchema):
O esquema com o ID do registro a ser excluído.
Returns:
O resultado da operação de exclusão.
"""
# ----------------------------------------------------
# Instanciamento da ação
# ----------------------------------------------------
t_servico_itempedido_delete_action = TServicoItemPedidoDeleteAction()
# ----------------------------------------------------
# Execução da ação
# ----------------------------------------------------
data = t_servico_itempedido_delete_action.execute(
t_servico_itempedido_id_schema
)
# ----------------------------------------------------
# Retorno da informação
# ----------------------------------------------------
return data

52
packages/v1/servicos/balcao/services/t_servico_itempedido/go/t_servico_itempedido_index_service.py Normal file
View file

@ -0,0 +1,52 @@
from packages.v1.servicos.balcao.actions.t_servico_itempedido.t_servico_itempedido_index_action import (
TServicoItemPedidoIndexAction,
)
from fastapi import HTTPException, status
from packages.v1.servicos.balcao.schemas.t_servico_itempedido_schema import (
TServicoItemIndexSchema,
)
class TServicoItemPedidoIndexService:
"""
Serviço responsável por encapsular a lógica de negócio para a operação
de listagem de registros na tabela T_SERVICO_ITEMPEDIDO.
"""
def execute(self, t_servico_itempedido_index_schema: TServicoItemIndexSchema):
"""
Executa a operação de busca de todos os registros no banco de dados.
Args:
t_servico_itempedido_index_schema (TServicoItemPedidoIndexSchema):
Esquema que pode conter filtros ou parâmetros de busca.
Returns:
A lista de registros encontrados.
"""
# ----------------------------------------------------
# Instanciamento da ação
# ----------------------------------------------------
t_servico_itempedido_index_action = TServicoItemPedidoIndexAction()
# ----------------------------------------------------
# Execução da ação
# ----------------------------------------------------
data = t_servico_itempedido_index_action.execute(
t_servico_itempedido_index_schema
)
# ----------------------------------------------------
# Verificação de retorno
# ----------------------------------------------------
if not data:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="Não foi possível localizar registros de T_SERVICO_ITEMPEDIDO.",
)
# ----------------------------------------------------
# Retorno da informação
# ----------------------------------------------------
return data

52
packages/v1/servicos/balcao/services/t_servico_itempedido/go/t_servico_itempedido_save_service.py Normal file
View file

@ -0,0 +1,52 @@
from packages.v1.servicos.balcao.actions.t_servico_itempedido.t_servico_itempedido_save_action import (
TServicoItemPedidoSaveAction,
)
from packages.v1.sequencia.schemas.g_sequencia import GSequenciaSchema
from packages.v1.servicos.balcao.schemas.t_servico_itempedido_schema import (
TServicoItemPedidoSaveSchema,
)
from packages.v1.sequencia.services.g_sequencia.generate_service import (
GenerateService,
)
class TServicoItemPedidoSaveService:
"""
Serviço responsável por encapsular a lógica de negócio para a operação
de criação de registros na tabela T_SERVICO_ITEMPEDIDO.
"""
def execute(self, t_servico_itempedido_save_schema: TServicoItemPedidoSaveSchema):
"""
Executa a operação de salvamento do registro no banco de dados.
Args:
t_servico_itempedido_save_schema (TServicoItemPedidoSaveSchema):
O esquema com os dados a serem salvos.
Returns:
O registro recém-criado.
"""
# ----------------------------------------------------
# Geração automática de ID (sequência)
# ----------------------------------------------------
if not t_servico_itempedido_save_schema.servico_itempedido_id:
# Cria o schema de sequência
sequencia_schema = GSequenciaSchema()
sequencia_schema.tabela = "T_SERVICO_ITEMPEDIDO"
# Gera a sequência atualizada
generate = GenerateService()
sequencia = generate.execute(sequencia_schema)
# Atualiza o ID no schema
t_servico_itempedido_save_schema.servico_itempedido_id = sequencia.sequencia
# ----------------------------------------------------
# Instanciamento e execução da Action de salvamento
# ----------------------------------------------------
t_servico_itempedido_save_action = TServicoItemPedidoSaveAction()
return t_servico_itempedido_save_action.execute(
t_servico_itempedido_save_schema
)

49
packages/v1/servicos/balcao/services/t_servico_itempedido/go/t_servico_itempedido_show_service.py Normal file
View file

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

38
packages/v1/servicos/balcao/services/t_servico_itempedido/go/t_servico_itempedido_update_service.py Normal file
View file

@ -0,0 +1,38 @@
from packages.v1.servicos.balcao.actions.t_servico_itempedido.t_servico_itempedido_update_action import (
TServicoItemPedidoUpdateAction,
)
from packages.v1.servicos.balcao.schemas.t_servico_itempedido_schema import (
TServicoItemPedidoUpdateSchema,
)
class TServicoItemPedidoUpdateService:
"""
Serviço responsável pela operação de atualização de um registro
na tabela T_SERVICO_ITEMPEDIDO.
"""
def execute(
self, t_servico_itempedido_update_schema: TServicoItemPedidoUpdateSchema
):
"""
Executa a operação de atualização no banco de dados.
Args:
t_servico_itempedido_update_schema (TServicoItemPedidoUpdateSchema):
O esquema com os dados a serem atualizados.
Returns:
O resultado da operação de atualização.
"""
# ----------------------------------------------------
# Instanciamento da ação
# ----------------------------------------------------
t_servico_itempedido_update_action = TServicoItemPedidoUpdateAction()
# ----------------------------------------------------
# Execução da ação e retorno do resultado
# ----------------------------------------------------
return t_servico_itempedido_update_action.execute(
t_servico_itempedido_update_schema
)

39
packages/v1/servicos/balcao/services/t_servico_pedido/go/t_servico_pedido_delete_service.py Normal file
View file

@ -0,0 +1,39 @@
from packages.v1.servicos.balcao.actions.t_servico_pedido.t_servico_pedido_delete_action import (
TServicoPedidoDeleteAction,
)
from packages.v1.servicos.balcao.schemas.t_servico_pedido_schema import (
TServicoPedidoIdSchema,
)
class TServicoPedidoDeleteService:
"""
Serviço responsável por encapsular a lógica de negócio para a operação
de exclusão de um registro na tabela T_SERVICO_PEDIDO.
"""
def execute(self, t_servico_pedido_id_schema: TServicoPedidoIdSchema):
"""
Executa a operação de exclusão do registro no banco de dados.
Args:
t_servico_pedido_id_schema (TServicoPedidoIdSchema):
O esquema com o ID do registro a ser excluído.
Returns:
O resultado da operação de exclusão.
"""
# ----------------------------------------------------
# Instanciamento da ação
# ----------------------------------------------------
t_servico_pedido_delete_action = TServicoPedidoDeleteAction()
# ----------------------------------------------------
# Execução da ação
# ----------------------------------------------------
data = t_servico_pedido_delete_action.execute(t_servico_pedido_id_schema)
# ----------------------------------------------------
# Retorno da informação
# ----------------------------------------------------
return data

46
packages/v1/servicos/balcao/services/t_servico_pedido/go/t_servico_pedido_index_service.py Normal file
View file

@ -0,0 +1,46 @@
from packages.v1.servicos.balcao.actions.t_servico_pedido.t_servico_pedido_index_action import (
TServicoPedidoIndexAction,
)
from fastapi import HTTPException, status
class TServicoPedidoIndexService:
"""
Serviço responsável por encapsular a lógica de negócio para a operação
de listagem de registros na tabela T_SERVICO_PEDIDO.
"""
def execute(self):
"""
Executa a operação de busca de todos os registros no banco de dados.
Args:
t_servico_pedido_index_schema (TServicoPedidoIndexSchema):
Esquema que pode conter filtros ou parâmetros de busca.
Returns:
A lista de registros encontrados.
"""
# ----------------------------------------------------
# Instanciamento da ação
# ----------------------------------------------------
t_servico_pedido_index_action = TServicoPedidoIndexAction()
# ----------------------------------------------------
# Execução da ação
# ----------------------------------------------------
data = t_servico_pedido_index_action.execute()
# ----------------------------------------------------
# Verificação de retorno
# ----------------------------------------------------
if not data:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="Não foi possível localizar registros de T_SERVICO_PEDIDO.",
)
# ----------------------------------------------------
# Retorno da informação
# ----------------------------------------------------
return data

50
packages/v1/servicos/balcao/services/t_servico_pedido/go/t_servico_pedido_save_service.py Normal file
View file

@ -0,0 +1,50 @@
from packages.v1.servicos.balcao.actions.t_servico_pedido.t_servico_pedido_save_action import (
TServicoPedidoSaveAction,
)
from packages.v1.sequencia.schemas.g_sequencia import GSequenciaSchema
from packages.v1.servicos.balcao.schemas.t_servico_pedido_schema import (
TServicoPedidoSaveSchema,
)
from packages.v1.sequencia.services.g_sequencia.generate_service import (
GenerateService,
)
class TServicoPedidoSaveService:
"""
Serviço responsável por encapsular a lógica de negócio para a operação
de criação de registros na tabela T_SERVICO_PEDIDO.
"""
def execute(self, t_servico_pedido_save_schema: TServicoPedidoSaveSchema):
"""
Executa a operação de salvamento do registro no banco de dados.
Args:
t_servico_pedido_save_schema (TServicoPedidoSaveSchema):
O esquema com os dados a serem salvos.
Returns:
O registro recém-criado.
"""
# ----------------------------------------------------
# Geração automática de ID (sequência)
# ----------------------------------------------------
if not t_servico_pedido_save_schema.servico_pedido_id:
# Cria o schema de sequência
sequencia_schema = GSequenciaSchema()
sequencia_schema.tabela = "T_SERVICO_PEDIDO"
# Gera a sequência atualizada
generate = GenerateService()
sequencia = generate.execute(sequencia_schema)
# Atualiza o ID no schema
t_servico_pedido_save_schema.servico_pedido_id = sequencia.sequencia
# ----------------------------------------------------
# Instanciamento e execução da Action de salvamento
# ----------------------------------------------------
t_servico_pedido_save_action = TServicoPedidoSaveAction()
return t_servico_pedido_save_action.execute(t_servico_pedido_save_schema)

49
packages/v1/servicos/balcao/services/t_servico_pedido/go/t_servico_pedido_show_service.py Normal file
View file

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

34
packages/v1/servicos/balcao/services/t_servico_pedido/go/t_servico_pedido_update_service.py Normal file
View file

@ -0,0 +1,34 @@
from packages.v1.servicos.balcao.actions.t_servico_pedido.t_servico_pedido_update_action import (
TServicoPedidoUpdateAction,
)
from packages.v1.servicos.balcao.schemas.t_servico_pedido_schema import (
TServicoPedidoUpdateSchema,
)
class TServicoPedidoUpdateService:
"""
Serviço responsável pela operação de atualização de um registro
na tabela T_SERVICO_PEDIDO.
"""
def execute(self, t_servico_pedido_update_schema: TServicoPedidoUpdateSchema):
"""
Executa a operação de atualização no banco de dados.
Args:
t_servico_pedido_update_schema (TServicoPedidoUpdateSchema):
O esquema com os dados a serem atualizados.
Returns:
O resultado da operação de atualização.
"""
# ----------------------------------------------------
# Instanciamento da ação
# ----------------------------------------------------
t_servico_pedido_update_action = TServicoPedidoUpdateAction()
# ----------------------------------------------------
# Execução da ação e retorno do resultado
# ----------------------------------------------------
return t_servico_pedido_update_action.execute(t_servico_pedido_update_schema)