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

[MVPTN-126] feta(Pedido): Implementa a solicitação de pedidos no balcão do tabelionato

Browse source
This commit is contained in:
Keven 2025-11-15 12:31:00 -03:00
parent 42d76991b0
commit c3b087808e
39 changed files with 1492 additions and 243 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
packages/v1/administrativo/actions/c_caixa_servico/c_caixa_servico_index_action.py
View file

@ -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

12
packages/v1/administrativo/actions/c_caixa_servico/c_caixa_servico_save_action.py
View file

@ -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)

115
packages/v1/administrativo/controllers/c_caixa_servico_controller.py
View file

@ -5,9 +5,10 @@ from packages.v1.administrativo.schemas.c_caixa_servico_schema import (
CCaixaServicoUpdateSchema,
CCaixaServicoIdSchema,
CCaixaServicoDescricaoSchema,
CCaixaServicoSistemaIdSchema
CCaixaServicoSistemaIdSchema,
)
class CCaixaServicoController:
def __init__(self):
@ -23,108 +24,122 @@ class CCaixaServicoController:
# Lista todos os caixa serviço
def index(self):
# Importação da classe desejada
indexService = self.dynamic_import.service("c_caixa_servico_index_service", "IndexService")
indexService = self.dynamic_import.service(
"c_caixa_servico_index_service", "IndexService"
)
# Instânciamento da classe service
self.indexService = indexService()
# Lista todos os caixa serviço
return {
'message': 'caixa serviço localizados com sucesso',
'data': self.indexService.execute()
"message": "caixa serviço localizados com sucesso",
"data": self.indexService.execute(),
}
# Busca um usuário especifico pelo ID
def show(self, caixa_servico_schema : CCaixaServicoIdSchema):
#Importação da classe desejada
show_service = self.dynamic_import.service('c_caixa_servico_show_service', 'ShowService')
# Busca um usuário especifico pelo ID
def show(self, caixa_servico_schema: CCaixaServicoIdSchema):
# Importação da classe desejada
show_service = self.dynamic_import.service(
"c_caixa_servico_show_service", "ShowService"
)
# Instânciamento da classe desejada
self.show_service = show_service()
# Busca e retorna o usuário desejado
return {
'message' : 'Caixa Serviço localizado com sucesso',
'data': self.show_service.execute(caixa_servico_schema)
"message": "Caixa Serviço localizado com sucesso",
"data": self.show_service.execute(caixa_servico_schema),
}
# Busca um caixa serviço pela descrição
def getDescricao(self, caixa_servico_schema : CCaixaServicoDescricaoSchema):
# Busca um caixa serviço pela descrição
def getDescricao(self, caixa_servico_schema: CCaixaServicoDescricaoSchema):
#Importação da classe desejada
show_service = self.dynamic_import.service('c_caixa_servico_get_descricao_service', 'GetDescricaoService')
# Importação da classe desejada
show_service = self.dynamic_import.service(
"c_caixa_servico_get_descricao_service", "GetDescricaoService"
)
# Instânciamento da classe desejada
self.show_service = show_service()
# Busca e retorna o usuário desejado
return {
'message' : 'Caixa Serviço localizado com sucesso',
'data': self.show_service.execute(caixa_servico_schema, True)# True para retornar a mensagem de erro caso não localize o serviço
}
"message": "Caixa Serviço localizado com sucesso",
"data": self.show_service.execute(
caixa_servico_schema, True
), # True para retornar a mensagem de erro caso não localize o serviço
}
# Busca um caixa serviço pelp sistema_id
def getSistemaId(self, caixa_servico_schema: CCaixaServicoSistemaIdSchema):
# Busca um caixa serviço pelp sistema_id
def getSistemaId(self, caixa_servico_schema : CCaixaServicoSistemaIdSchema):
#Importação da classe desejada
show_sistema_id_service = self.dynamic_import.service('c_caixa_servico_get_sistema_id_service', 'GetSistemaIdService')
# Importação da classe desejada
show_sistema_id_service = self.dynamic_import.service(
"c_caixa_servico_get_sistema_id_service", "GetSistemaIdService"
)
# Instânciamento da classe desejada
self.show_sistema_id_service = show_sistema_id_service()
# Busca e retorna o usuário desejado
return {
'message' : 'Caixa Serviços localizados com sucesso',
'data': self.show_sistema_id_service.execute(caixa_servico_schema)
}
"message": "Caixa Serviços localizados com sucesso",
"data": self.show_sistema_id_service.execute(caixa_servico_schema),
}
# Cadastra um novo usuário
def save(self, caixa_servico_schema : CCaixaServicoSaveSchema):
def save(self, caixa_servico_schema: CCaixaServicoSaveSchema):
#Importação da classe desejada
save_service = self.dynamic_import.service('c_caixa_servico_save_service', 'CCaixaServicoSaveService')
# Importação da classe desejada
save_service = self.dynamic_import.service(
"c_caixa_servico_save_service", "CCaixaServicoSaveService"
)
# Instânciamento da classe desejada
self.save_service = save_service()
# Busca e retorna o usuário desejado
return {
'message' : 'Caixa Serviço salvo com sucesso',
'data': self.save_service.execute(caixa_servico_schema)
"message": "Caixa Serviço salvo com sucesso",
"data": self.save_service.execute(caixa_servico_schema),
}
# Atualiza os dados de um usuário
def update(self, caixa_servico_id : int, caixa_servico_schema : CCaixaServicoUpdateSchema):
def update(
self, caixa_servico_id: int, caixa_servico_schema: CCaixaServicoUpdateSchema
):
#Importação da classe desejada
save_service = self.dynamic_import.service('c_caixa_servico_update_service', 'CCaixaServicoUpdateService')
# Importação da classe desejada
save_service = self.dynamic_import.service(
"c_caixa_servico_update_service", "CCaixaServicoUpdateService"
)
# Instânciamento da classe desejada
self.save_service = save_service()
# Busca e retorna o usuário desejado
return {
'message' : 'Caixa Serviço atualizado com sucesso',
'data': self.save_service.execute(caixa_servico_id, caixa_servico_schema)
"message": "Caixa Serviço atualizado com sucesso",
"data": self.save_service.execute(caixa_servico_id, caixa_servico_schema),
}
# Exclui um usuário
def delete(self, caixa_servico_schema : CCaixaServicoIdSchema):
#Importação da classe desejada
delete_service = self.dynamic_import.service('c_caixa_servico_delete_service', 'DeleteService')
# Exclui um usuário
def delete(self, caixa_servico_schema: CCaixaServicoIdSchema):
# Importação da classe desejada
delete_service = self.dynamic_import.service(
"c_caixa_servico_delete_service", "DeleteService"
)
# Instânciamento da classe desejada
self.delete_service = delete_service()
# Busca e retorna o usuário desejado
return {
'message' : 'Caixa Serviço removido com sucesso',
'data': self.delete_service.execute(caixa_servico_schema)
}
"message": "Caixa Serviço removido com sucesso",
"data": self.delete_service.execute(caixa_servico_schema),
}

86
packages/v1/administrativo/repositories/c_caixa_item/c_caixa_item_save.py
View file

@ -1,72 +1,36 @@
# Importação de bibliotecas
from fastapi import HTTPException, status
from actions.data.generate_insert_sql import generate_insert_sql
from packages.v1.administrativo.schemas.c_caixa_item_schema import CaixaItemSchema
from abstracts.repository import BaseRepository
class Save(BaseRepository):
def execute(self, caixa_item : CaixaItemSchema):
def execute(self, caixa_item: CaixaItemSchema):
# SQL para update ou insert
sql = """ UPDATE OR INSERT INTO C_CAIXA_ITEM (
ESPECIE_PAGAMENTO,
CAIXA_ITEM_ID,
CAIXA_SERVICO_ID,
USUARIO_SERVICO_ID,
USUARIO_CAIXA_ID,
DESCRICAO,
DATA_PAGAMENTO,
SITUACAO,
TIPO_DOCUMENTO,
TIPO_TRANSACAO,
VALOR_SERVICO,
VALOR_PAGO,
OBSERVACAO,
HORA_PAGAMENTO,
TIPO_SERVICO,
REGISTRADO
) VALUES (
:especie_pagamento,
:caixa_item_id,
:caixa_servico_id,
:usuario_servico_id,
:usuario_caixa_id,
:descricao,
:data_pagamento,
:situacao,
:tipo_documento,
:tipo_transacao,
:valor_servico,
:valor_pago,
:observacao,
:hora_pagamento,
:tipo_servico,
:registrado
)
MATCHING (CAIXA_ITEM_ID); """
try:
# Preenchimento de Parâmetros
params = {
"especie_pagamento" : caixa_item.especie_pagamento,
"caixa_item_id" : caixa_item.caixa_item_id,
"caixa_servico_id" : caixa_item.caixa_servico_id,
"usuario_servico_id" : caixa_item.usuario_servico_id,
"usuario_caixa_id" : caixa_item.usuario_caixa_id,
"descricao" : caixa_item.descricao,
"data_pagamento" : caixa_item.data_pagamento,
"situacao" : caixa_item.situacao,
"tipo_documento" : caixa_item.tipo_documento,
"tipo_transacao" : caixa_item.tipo_transacao,
"valor_servico" : caixa_item.valor_servico,
"valor_pago" : caixa_item.valor_pago,
"observacao" : caixa_item.observacao,
"hora_pagamento" : caixa_item.hora_pagamento,
"tipo_servico" : caixa_item.tipo_servico,
"registrado" : caixa_item.registrado
}
# ----------------------------------------------------
# Preenchimento dos parâmetros
# ----------------------------------------------------
params = caixa_item.model_dump(exclude_unset=True)
# Execução do sql
response = self.run(sql, params)
# ----------------------------------------------------
# Montagem do SQL dinâmico
# ----------------------------------------------------
sql = generate_insert_sql("C_CAIXA_ITEM", params)
# Retorna os dados registrados
return caixa_item
# ----------------------------------------------------
# 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}",
)

23
packages/v1/administrativo/repositories/c_caixa_servico/c_caixa_servico_delete_repository.py
View file

@ -1,33 +1,32 @@
from packages.v1.administrativo.schemas.c_caixa_servico_schema import \
CCaixaServicoIdSchema
from packages.v1.administrativo.schemas.c_caixa_servico_schema import (
CCaixaServicoIdSchema,
)
from abstracts.repository import BaseRepository
from fastapi import HTTPException, status
class DeleteRepository(BaseRepository):
def execute(self, caixa_servico_schema : CCaixaServicoIdSchema):
def execute(self, caixa_servico_schema: CCaixaServicoIdSchema):
try:
# Montagem do sql
sql = """ DELETE FROM c_caixa_servico ccs WHERE ccs.caixa_servico_id = :caixa_servico_id """
# Preenchimento de parâmetros
params = {
"caixa_servico_id" : caixa_servico_schema.caixa_servico_id
}
params = {"caixa_servico_id": caixa_servico_schema.caixa_servico_id}
#Execução do sql
# Execução do sql
response = self.run(sql, params)
# Retorna o resultado
return response
except Exception as e:
# Informa que houve uma falha na atualização do usuário
raise HTTPException(
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
detail=f"Erro ao excluir caixa serviço: {e}"
)
detail=f"Erro ao excluir caixa serviço: {e}",
)

20
packages/v1/administrativo/schemas/c_caixa_item_schema.py
View file

@ -1,22 +1,24 @@
from datetime import date, datetime
from decimal import Decimal
from typing import Optional
from pydantic import BaseModel
class CaixaItemSchema(BaseModel):
especie_pagamento: Optional[str] = None
caixa_item_id: Optional[int] = None
caixa_servico_id: Optional[int] = None
usuario_servico_id: Optional[int] = None
usuario_caixa_id: Optional[int] = None
chave_servico: Optional[int] = None
chave_servico: Optional[Decimal] = None
descricao: Optional[str] = None
data_pagamento: Optional[date] = None
situacao: Optional[str] = None
situacao: Optional[int] = None
tipo_documento: Optional[str] = None
tipo_transacao: Optional[str] = None
valor_servico: Optional[float] = None
valor_pago: Optional[float] = None
observacao: Optional[str] = None
valor_pago: Optional[Decimal] = None
observacao: Optional[Decimal] = None
caixa_cheque_id: Optional[int] = None
hora_pagamento: Optional[str] = None
caixa_id: Optional[int] = None
@ -27,14 +29,14 @@ class CaixaItemSchema(BaseModel):
mensalista_id: Optional[int] = None
quitado_caixa_id: Optional[int] = None
registrado: Optional[int] = None
emolumento: Optional[float] = None
taxa_judiciaria: Optional[float] = None
emolumento: Optional[Decimal] = None
taxa_judiciaria: Optional[Decimal] = None
fundesp: Optional[float] = None
desconto: Optional[float] = None
valor_documento: Optional[float] = None
outra_taxa1: Optional[float] = None
chave_servico_sec: Optional[str] = None
emolumento_item_id: Optional[int] = None
emolumento_item_id: Optional[Decimal] = None
caixa_registroselo_id: Optional[int] = None
fundo_ri: Optional[float] = None
valor_recibo: Optional[float] = None
@ -51,9 +53,11 @@ class CaixaItemSchema(BaseModel):
class Config:
from_attributes = True
class IntervaloDatas(BaseModel):
date_start: Optional[str] = None
date_end: Optional[str] = None
class CaixaItemSearchSchema(BaseModel):
data_pagamento: Optional[IntervaloDatas] = None
data_pagamento: Optional[IntervaloDatas] = None

171
packages/v1/administrativo/schemas/c_caixa_servico_schema.py
View file

@ -1,10 +1,11 @@
from pydantic import BaseModel, field_validator, model_validator
from pydantic import BaseModel, field_validator, model_validator
from fastapi import HTTPException, status
from typing import Optional
# Funções para sanitização de entradas (evitar XSS, SQLi etc.)
from actions.validations.text import Text
# ----------------------------------------------------
# Schema base
# ----------------------------------------------------
@ -44,16 +45,17 @@ class CCaixaServicoSaveSchema(BaseModel):
tipo_conta_carneleao: Optional[str] = None
centro_de_custa_id: Optional[int] = None
repetir_descricao: Optional[str] = None
# Sanitiza os inputs enviados
@field_validator('tipo_transacao',
'situacao',
'interno_sistema',
'descricao',
'emitir_relatorio',
'tipo_conta_carneleao',
'repetir_descricao')
@field_validator(
"tipo_transacao",
"situacao",
"interno_sistema",
"descricao",
"emitir_relatorio",
"tipo_conta_carneleao",
"repetir_descricao",
)
def validate_required_fields(cls, v):
# Se for string e composta só por dígitos
@ -61,61 +63,81 @@ class CCaixaServicoSaveSchema(BaseModel):
# Não lança exceção aqui, apenas retorna para o model_validator
pass
return Text.sanitize_input(v)
return Text.sanitize_input(v)
# Validador para `sistema_id` e outros campos numéricos, se necessário
@field_validator('sistema_id')
@field_validator("sistema_id")
def validate_sistema_id(cls, v):
if v is not None and v <= 0:
raise ValueError("O sistema precisa ser informado.")
return v
return v
# Verifica se os campos foram enviados
@model_validator(mode='after')
@model_validator(mode="after")
def validate_all_fields(self):
# Variavel responsavel em armaezar os erros
errors = []
# Validação do tipo_transacao
if not self.tipo_transacao or len(self.tipo_transacao.strip()) == 0:
errors.append({'input': 'tipo_transacao', 'message': 'O tipo transação é obrigatório.'})
errors.append(
{
"input": "tipo_transacao",
"message": "O tipo transação é obrigatório.",
}
)
# Validação da sistema_id
if not self.sistema_id or self.sistema_id == 0:
errors.append({'input': 'sistema_id', 'message': 'O sistema precisa ser informado.'})
errors.append(
{"input": "sistema_id", "message": "O sistema precisa ser informado."}
)
# Validação do situacao
if not self.situacao or len(self.situacao.strip()) == 0:
errors.append({'input': 'situacao', 'message': 'A situação é obrigatório.'})
errors.append({"input": "situacao", "message": "A situação é obrigatório."})
# Validação da interno_sistema
if not self.interno_sistema or len(self.interno_sistema.strip()) == 0:
errors.append({'input': 'interno_sistema', 'message': 'O uso interno é obrigatória.'})
errors.append(
{"input": "interno_sistema", "message": "O uso interno é obrigatória."}
)
# Validação do descricao
if not self.descricao or len(self.descricao.strip()) == 0:
errors.append({'input': 'descricao', 'message': 'A descrição é obrigatório.'})
errors.append(
{"input": "descricao", "message": "A descrição é obrigatório."}
)
# Validação do emitir_relatorio
if not self.emitir_relatorio or len(self.emitir_relatorio.strip()) == 0:
errors.append({'input': 'emitir_relatorio', 'message': 'Sair nos relatórios é obrigatório.'})
errors.append(
{
"input": "emitir_relatorio",
"message": "Sair nos relatórios é obrigatório.",
}
)
# Validação do repetir_descricao
if not self.repetir_descricao or len(self.repetir_descricao.strip()) == 0:
errors.append({'input': 'repetir_descricao', 'message': 'Repetir descrição de serviço no caixa é obrigatório.'})
errors.append(
{
"input": "repetir_descricao",
"message": "Repetir descrição de serviço no caixa é obrigatório.",
}
)
# Se houver errors, lança uma única exceção
if errors:
# Lança uma exceção do FastAPI para um tratamento limpo
# O `detail` da exceção será a lista de errors que criamos
raise HTTPException(
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
detail=errors
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=errors
)
return self
# ----------------------------------------------------
# Schema para atualizar caixa serviço (PUT)
@ -131,16 +153,17 @@ class CCaixaServicoUpdateSchema(BaseModel):
tipo_conta_carneleao: Optional[str] = None
centro_de_custa_id: Optional[int] = None
repetir_descricao: Optional[str] = None
# Sanitiza os inputs enviados
@field_validator('tipo_transacao',
'situacao',
'interno_sistema',
'descricao',
'emitir_relatorio',
'tipo_conta_carneleao',
'repetir_descricao')
@field_validator(
"tipo_transacao",
"situacao",
"interno_sistema",
"descricao",
"emitir_relatorio",
"tipo_conta_carneleao",
"repetir_descricao",
)
def validate_required_fields(cls, v):
if not v or len(v.strip()) == 0:
# Não lança exceção aqui. Apenas retorna para o model_validator.
@ -148,72 +171,93 @@ class CCaixaServicoUpdateSchema(BaseModel):
# Este validador individual é mais para sanitização.
pass
return Text.sanitize_input(v)
# Validador para `sistema_id` e outros campos numéricos, se necessário
@field_validator('sistema_id')
@field_validator("sistema_id")
def validate_sistema_id(cls, v):
if v is not None and v <= 0:
raise ValueError("O sistema precisa ser informado.")
return v
return v
# Verifica se os campos foram enviados
@model_validator(mode='after')
@model_validator(mode="after")
def validate_all_fields(self):
# Variavel responsavel em armaezar os erros
errors = []
# Validação do tipo_transacao
if not self.tipo_transacao or len(self.tipo_transacao.strip()) == 0:
errors.append({'input': 'tipo_transacao', 'message': 'O tipo transação é obrigatório.'})
errors.append(
{
"input": "tipo_transacao",
"message": "O tipo transação é obrigatório.",
}
)
# Validação da sistema_id
if not self.sistema_id or self.sistema_id == 0:
errors.append({'input': 'sistema_id', 'message': 'O sistema precisa ser informado.'})
errors.append(
{"input": "sistema_id", "message": "O sistema precisa ser informado."}
)
# Validação do situacao
if not self.situacao or len(self.situacao.strip()) == 0:
errors.append({'input': 'situacao', 'message': 'A situação é obrigatório.'})
errors.append({"input": "situacao", "message": "A situação é obrigatório."})
# Validação da interno_sistema
if not self.interno_sistema or len(self.interno_sistema.strip()) == 0:
errors.append({'input': 'interno_sistema', 'message': 'O uso interno é obrigatória.'})
errors.append(
{"input": "interno_sistema", "message": "O uso interno é obrigatória."}
)
# Validação do descricao
if not self.descricao or len(self.descricao.strip()) == 0:
errors.append({'input': 'descricao', 'message': 'A descrição é obrigatório.'})
errors.append(
{"input": "descricao", "message": "A descrição é obrigatório."}
)
# Validação do emitir_relatorio
if not self.emitir_relatorio or len(self.emitir_relatorio.strip()) == 0:
errors.append({'input': 'emitir_relatorio', 'message': 'Sair nos relatórios é obrigatório.'})
errors.append(
{
"input": "emitir_relatorio",
"message": "Sair nos relatórios é obrigatório.",
}
)
# Validação do repetir_descricao
if not self.repetir_descricao or len(self.repetir_descricao.strip()) == 0:
errors.append({'input': 'repetir_descricao', 'message': 'Repetir descrição de serviço no caixa é obrigatório.'})
errors.append(
{
"input": "repetir_descricao",
"message": "Repetir descrição de serviço no caixa é obrigatório.",
}
)
# Se houver errors, lança uma única exceção
if errors:
# Lança uma exceção do FastAPI para um tratamento limpo
# O `detail` da exceção será a lista de errors que criamos
raise HTTPException(
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
detail=errors
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=errors
)
return self
return self
# ----------------------------------------------------
# Schema para localizar um caixa serviço especifico pelo ID (GET)
# ----------------------------------------------------
class CCaixaServicoIdSchema(BaseModel):
caixa_servico_id: int
caixa_servico_id: int
# ----------------------------------------------------
# Schema para localizar um caixa serviço especifico pelo ID (GET)
# ----------------------------------------------------
class CCaixaServicoSistemaIdSchema(BaseModel):
sistema_id: int
sistema_id: int
# ----------------------------------------------------
@ -225,19 +269,18 @@ class CCaixaServicoDescricaoSchema(BaseModel):
descricao: str # senha_api obrigatório
# Validação e sanitização do login
@field_validator('descricao')
@field_validator("descricao")
def validar_e_sanitizar_descricao(cls, v):
# Verifica se a descrição foi informada
if not v:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail='Informe a descrição'
)
status_code=status.HTTP_400_BAD_REQUEST, detail="Informe a descrição"
)
# Sanitiza a decrição para evitar XSS e SQL Injection
return Text.sanitize_input(v)
class Config:
from_attributes = True
from_attributes = True

2
packages/v1/administrativo/schemas/g_calculo_schema.py
View file

@ -19,7 +19,7 @@ class GCalculoServico(BaseModel):
sistema_id: Optional[float] = None
emolumento_id: Optional[float] = None
valor_documento: Optional[float] = None
valor_documento: Optional[Decimal] = None
quantidade: Optional[Decimal] = None
# valida e coerce em atribuições após criar o objeto

9
packages/v1/administrativo/services/c_caixa_item/go/c_caixa_item_save_service.py
View file

@ -1,8 +1,11 @@
from packages.v1.administrativo.actions.c_caixa_item.c_caixa_item_save_action import SaveAction
from packages.v1.administrativo.actions.c_caixa_item.c_caixa_item_save_action import (
SaveAction,
)
from packages.v1.administrativo.schemas.c_caixa_item_schema import CaixaItemSchema
from packages.v1.sequencia.schemas.g_sequencia import GSequenciaSchema
from packages.v1.sequencia.services.g_sequencia.generate_service import GenerateService
class SaveService:
def execute(self, caixa_item_schema: CaixaItemSchema):
@ -11,7 +14,7 @@ class SaveService:
sequencia_schema = GSequenciaSchema()
# Define os dados para atualizar a sequencia
sequencia_schema.tabela = 'C_CAIXA_ITEM'
sequencia_schema.tabela = "C_CAIXA_ITEM"
# Busco a sequência atualizada
generate = GenerateService()
@ -26,4 +29,4 @@ class SaveService:
saveAction = SaveAction()
# Retorna todos produtos desejados
return saveAction.execute(caixa_item_schema)
return saveAction.execute(caixa_item_schema)

44
packages/v1/administrativo/services/c_caixa_servico/go/c_caixa_servico_save_service.py
View file

@ -1,10 +1,16 @@
from actions.dynamic_import.dynamic_import import DynamicImport
from packages.v1.sequencia.schemas.g_sequencia import GSequenciaSchema
from packages.v1.sequencia.services.g_sequencia.generate_service import GenerateService
from packages.v1.administrativo.schemas.c_caixa_servico_schema import CCaixaServicoSaveSchema, CCaixaServicoDescricaoSchema
from packages.v1.administrativo.actions.c_caixa_servico.c_caixa_servico_save_action import SaveAction
from packages.v1.administrativo.schemas.c_caixa_servico_schema import (
CCaixaServicoSaveSchema,
CCaixaServicoDescricaoSchema,
)
from packages.v1.administrativo.actions.c_caixa_servico.c_caixa_servico_save_action import (
SaveAction,
)
from fastapi import HTTPException, status
class CCaixaServicoSaveService:
def __init__(self):
@ -16,37 +22,41 @@ class CCaixaServicoSaveService:
# Define a tabela que o pacote pertence
self.dynamic_import.set_table("c_caixa_servico")
pass
pass
# Cadastra o novo caixa serviço
def execute(self, caixa_servico_schema: CCaixaServicoSaveSchema):
def execute(self, caixa_servico_schema: CCaixaServicoSaveSchema):
# Armazena possíveis erros
errors = []
# Verifica se o e-mail já esta sendo utilizado
# Importação de service de email
descricao_service = self.dynamic_import.service("c_caixa_servico_get_descricao_service", "GetDescricaoService")
descricao_service = self.dynamic_import.service(
"c_caixa_servico_get_descricao_service", "GetDescricaoService"
)
# Instânciamento da service
self.descricao_service = descricao_service()
self.descricao_service = descricao_service()
# Verifica se o email já esta sendo utilizado
self.response = self.descricao_service.execute(CCaixaServicoDescricaoSchema(descricao=caixa_servico_schema.descricao), False)
self.response = self.descricao_service.execute(
CCaixaServicoDescricaoSchema(descricao=caixa_servico_schema.descricao),
False,
)
# Se houver retorno significa que a descrição já esta sendo utiizada
if self.response:
errors.append({'input': 'descricao', 'message': 'a descrição informada já esta sendo utilizada.'})
errors.append(
{
"input": "descricao",
"message": "a descrição informada já esta sendo utilizada.",
}
)
# Se houver erros, informo
if errors:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail=errors
)
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=errors)
# Verifica se precisa gerar o id de sequencia
if not caixa_servico_schema.caixa_servico_id:
@ -55,7 +65,7 @@ class CCaixaServicoSaveService:
sequencia_schema = GSequenciaSchema()
# Define os dados para atualizar a sequencia
sequencia_schema.tabela = 'C_CAIXA_SERVICO'
sequencia_schema.tabela = "C_CAIXA_SERVICO"
# Busco a sequência atualizada
generate = GenerateService()
@ -70,4 +80,4 @@ class CCaixaServicoSaveService:
saveAction = SaveAction()
# Retorna todos produtos desejados
return saveAction.execute(caixa_servico_schema)
return saveAction.execute(caixa_servico_schema)

12
packages/v1/administrativo/services/g_calculo/go/g_calculo_servico_service.py
View file

@ -9,9 +9,7 @@ from packages.v1.administrativo.actions.g_emolumento_item.g_emolumento_item_get_
GEmolumentoItemGetFaixaValorAction,
)
from packages.v1.administrativo.schemas.g_calculo_schema import (
GCalculoRapidoSchema,
GCalculoServico,
ResponseGCalculoRapidoSchema,
)
from packages.v1.administrativo.schemas.g_emolumento_item_schema import (
GEmolumentoItemIndexSchema,
@ -62,6 +60,8 @@ class GCalculoServicoService:
def execute(self, data: GCalculoServico):
print(data)
# Busca os parâmetros da aplicação
periodo_id = float(
self._config_service.execute(
@ -104,7 +104,7 @@ class GCalculoServicoService:
# Se vier lista, usa o primeiro (ou ajuste a regra aqui, se necessário)
emolumento_item = self._emolumento_item_get_faixa_valor_action.execute(
emolumento_itens, Decimal(data.valor_documento)
emolumento_itens, Decimal(0)
)
# Converter o valor para decimal
@ -136,9 +136,9 @@ class GCalculoServicoService:
# Resposta
return SimpleNamespace(
emolumento_id=float(data.emolumento_id),
emolumento_item_id=float(emolumento_item.emolumento_item_id),
valor_documento=float(data.valor_documento),
emolumento_id=Decimal(data.emolumento_id),
emolumento_item_id=Decimal(emolumento_item.emolumento_item_id),
valor_documento=Decimal(data.valor_documento),
valor_emolumento=emolumento_total,
valor_taxa_judiciaria=taxa_judiciaria_total,
valor_iss=iss_total,

9
packages/v1/api.py
View file

@ -47,6 +47,7 @@ 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_pessoa_cartao_endpoint,
t_servico_itempedido_endpoint,
t_servico_pedido_endpoint,
)
@ -358,3 +359,11 @@ api_router.include_router(
prefix="/servicos/balcao/t_servico_itempedido",
tags=["Itens do Pedido"],
)
# Inclui as rotas de g_emolumento periodo
api_router.include_router(
t_pessoa_cartao_endpoint.router,
prefix="/servicos/balcao/t_pessoa_cartao",
tags=["Pessoa Cartao"],
)

37
packages/v1/servicos/balcao/actions/t_pessoa_cartao/t_pessoa_cartao_delete_action.py Normal file
View file

@ -0,0 +1,37 @@
from abstracts.action import BaseAction
from packages.v1.servicos.balcao.repositories.t_pessoa_cartao.t_pessoa_cartao_delete_repository import (
TPessoaCartaoDeleteRepository,
)
from packages.v1.servicos.balcao.schemas.t_pessoa_cartao_schema import (
TPessoaCartaoIdSchema,
)
class TPessoaCartaoDeleteAction(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_PESSOA_CARTAO.
"""
def execute(self, t_pessoa_cartao_id_schema: TPessoaCartaoIdSchema):
"""
Executa a operação de exclusão no banco de dados.
Args:
t_pessoa_cartao_id_schema (TPessoaCartaoIdSchema):
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_pessoa_cartao_delete_repository = TPessoaCartaoDeleteRepository()
# ----------------------------------------------------
# Execução da exclusão
# ----------------------------------------------------
response = t_pessoa_cartao_delete_repository.execute(t_pessoa_cartao_id_schema)
return response

42
packages/v1/servicos/balcao/actions/t_pessoa_cartao/t_pessoa_cartao_index_action.py Normal file
View file

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

40
packages/v1/servicos/balcao/actions/t_pessoa_cartao/t_pessoa_cartao_save_action.py Normal file
View file

@ -0,0 +1,40 @@
from abstracts.action import BaseAction
from packages.v1.servicos.balcao.repositories.t_pessoa_cartao.t_pessoa_cartao_save_repository import (
TPessoaCartaoSaveRepository,
)
from packages.v1.servicos.balcao.schemas.t_pessoa_cartao_schema import (
TPessoaCartaoSaveSchema,
)
class TPessoaCartaoSaveAction(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_PESSOA_CARTAO.
"""
def execute(self, t_pessoa_cartao_save_schema: TPessoaCartaoSaveSchema):
"""
Executa a operação de salvamento.
Args:
t_pessoa_cartao_schema (TPessoaCartaoSchema):
O esquema com os dados a serem persistidos.
Returns:
O resultado da operação de salvamento.
"""
# ----------------------------------------------------
# Instanciamento do repositório
# ----------------------------------------------------
t_pessoa_cartao_save_repository = TPessoaCartaoSaveRepository()
# ----------------------------------------------------
# Execução do repositório
# ----------------------------------------------------
response = t_pessoa_cartao_save_repository.execute(t_pessoa_cartao_save_schema)
# ----------------------------------------------------
# Retorno da informação
# ----------------------------------------------------
return response

40
packages/v1/servicos/balcao/actions/t_pessoa_cartao/t_pessoa_cartao_show_action.py Normal file
View file

@ -0,0 +1,40 @@
from abstracts.action import BaseAction
from packages.v1.servicos.balcao.repositories.t_pessoa_cartao.t_pessoa_cartao_show_repository import (
TPessoaCartaoShowRepository,
)
from packages.v1.servicos.balcao.schemas.t_pessoa_cartao_schema import (
TPessoaCartaoIdSchema,
)
class TPessoaCartaoShowAction(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_pessoa_cartao_id_schema: TPessoaCartaoIdSchema):
"""
Executa a operação de exibição.
Args:
t_pessoa_cartao_id_schema (TPessoaCartaoIdSchema):
O esquema com o ID do registro a ser exibido.
Returns:
O resultado da operação de exibição.
"""
# ----------------------------------------------------
# Instanciamento do repositório
# ----------------------------------------------------
t_pessoa_cartao_show_repository = TPessoaCartaoShowRepository()
# ----------------------------------------------------
# Execução do repositório
# ----------------------------------------------------
response = t_pessoa_cartao_show_repository.execute(t_pessoa_cartao_id_schema)
# ----------------------------------------------------
# Retorno da informação
# ----------------------------------------------------
return response

42
packages/v1/servicos/balcao/actions/t_pessoa_cartao/t_pessoa_cartao_update_action.py Normal file
View file

@ -0,0 +1,42 @@
from abstracts.action import BaseAction
from packages.v1.servicos.balcao.repositories.t_pessoa_cartao.t_pessoa_cartao_update_repository import (
TPessoaCartaoUpdateRepository,
)
from packages.v1.servicos.balcao.schemas.t_pessoa_cartao_schema import (
TPessoaCartaoUpdateSchema,
)
class TPessoaCartaoUpdateAction(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_pessoa_cartao_update_schema: TPessoaCartaoUpdateSchema):
"""
Executa a operação de atualização.
Args:
t_pessoa_cartao_update_schema (TPessoaCartaoUpdateSchema):
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_pessoa_cartao_update_repository = TPessoaCartaoUpdateRepository()
# ----------------------------------------------------
# Execução do repositório
# ----------------------------------------------------
response = t_pessoa_cartao_update_repository.execute(
t_pessoa_cartao_update_schema
)
# ----------------------------------------------------
# Retorno do resultado
# ----------------------------------------------------
return response

112
packages/v1/servicos/balcao/controllers/t_pessoa_cartao_controller.py Normal file
View file

@ -0,0 +1,112 @@
from actions.dynamic_import.dynamic_import import DynamicImport
from packages.v1.servicos.balcao.schemas.t_pessoa_cartao_schema import (
TPessoaCartaoIndexchema,
TPessoaCartaoSaveSchema,
TPessoaCartaoUpdateSchema,
TPessoaCartaoIdSchema,
)
class TPessoaCartaoController:
"""
Controller responsável por orquestrar as operações CRUD da tabela T_PESSOA_CARTAO,
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_pessoa_cartao")
# ----------------------------------------------------
# Lista todos os registros de T_PESSOA_CARTAO
# ----------------------------------------------------
def index(self, t_pessoa_cartao_index_schema: TPessoaCartaoIndexchema):
# Importação da classe desejada
index_service = self.dynamic_import.service(
"t_pessoa_cartao_index_service", "TPessoaCartaoIndexService"
)
# Instância da classe service
self.index_service = index_service()
# Execução da listagem
return {
"message": "Registros de T_PESSOA_CARTAO localizados com sucesso.",
"data": self.index_service.execute(t_pessoa_cartao_index_schema),
}
# ----------------------------------------------------
# Busca um registro específico de T_PESSOA_CARTAO pelo ID
# ----------------------------------------------------
def show(self, t_pessoa_cartao_id_schema: TPessoaCartaoIdSchema):
# Importação da classe desejada
show_service = self.dynamic_import.service(
"t_pessoa_cartao_show_service", "TPessoaCartaoShowService"
)
# Instância da classe service
self.show_service = show_service()
# Execução da busca
return {
"message": "Registro de T_PESSOA_CARTAO localizado com sucesso.",
"data": self.show_service.execute(t_pessoa_cartao_id_schema),
}
# ----------------------------------------------------
# Cadastra um novo registro em T_PESSOA_CARTAO
# ----------------------------------------------------
def save(self, t_pessoa_cartao_save_schema: TPessoaCartaoSaveSchema):
# Importação da classe desejada
save_service = self.dynamic_import.service(
"t_pessoa_cartao_save_service", "TPessoaCartaoSaveService"
)
# Instância da classe service
self.save_service = save_service()
# Execução do salvamento
return {
"message": "Registro de T_PESSOA_CARTAO salvo com sucesso.",
"data": self.save_service.execute(t_pessoa_cartao_save_schema),
}
# ----------------------------------------------------
# Atualiza um registro existente de T_PESSOA_CARTAO
# ----------------------------------------------------
def update(self, t_pessoa_cartao_update_schema: TPessoaCartaoUpdateSchema):
# Importação da classe desejada
update_service = self.dynamic_import.service(
"t_pessoa_cartao_update_service", "TPessoaCartaoUpdateService"
)
# Instância da classe service
self.update_service = update_service()
# Execução da atualização
return {
"message": "Registro de T_PESSOA_CARTAO atualizado com sucesso.",
"data": self.update_service.execute(t_pessoa_cartao_update_schema),
}
# ----------------------------------------------------
# Exclui um registro de T_PESSOA_CARTAO
# ----------------------------------------------------
def delete(self, t_pessoa_cartao_id_schema: TPessoaCartaoIdSchema):
# Importação da classe desejada
delete_service = self.dynamic_import.service(
"t_pessoa_cartao_delete_service", "TPessoaCartaoDeleteService"
)
# Instância da classe service
self.delete_service = delete_service()
# Execução da exclusão
return {
"message": "Registro de T_PESSOA_CARTAO removido com sucesso.",
"data": self.delete_service.execute(t_pessoa_cartao_id_schema),
}

20
packages/v1/servicos/balcao/controllers/t_servico_pedido_controller.py
View file

@ -109,3 +109,23 @@ class TServicoPedidoController:
"message": "Registro de T_SERVICO_PEDIDO removido com sucesso.",
"data": self.delete_service.execute(t_servico_pedido_id_schema),
}
# ----------------------------------------------------
# Exclui um registro de T_SERVICO_PEDIDO
# ----------------------------------------------------
def load_params(self):
# Importação da classe desejada
load_params_service = self.dynamic_import.service(
"t_servico_pedido_load_params_service", "TServicoPedidoLoadParamsService"
)
# Instância da classe service
self.load_params_service = load_params_service()
# Execução da exclusão
return {
"message": "Parâmetros de T_SERVICO_PEDIDO localizados com sucesso.",
"data": self.load_params_service.execute(),
}

116
packages/v1/servicos/balcao/endpoints/t_pessoa_cartao_endpoint.py Normal file
View file

@ -0,0 +1,116 @@
# 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_pessoa_cartao_controller import (
TPessoaCartaoController,
)
from packages.v1.servicos.balcao.schemas.t_pessoa_cartao_schema import (
TPessoaCartaoIndexchema,
TPessoaCartaoSaveSchema,
TPessoaCartaoUpdateSchema,
TPessoaCartaoIdSchema,
)
# ----------------------------------------------------
# Inicializa o roteador para as rotas da tabela T_PESSOA_CARTAO
# ----------------------------------------------------
router = APIRouter()
# Instanciamento do controller
t_pessoa_cartao_controller = TPessoaCartaoController()
# ----------------------------------------------------
# Lista todos os registros de T_PESSOA_CARTAO
# ----------------------------------------------------
@router.get(
"/pessoa/{pessoa_id}",
status_code=status.HTTP_200_OK,
summary="Lista todos os registros de T_PESSOA_CARTAO cadastrados",
response_description="Lista todos os registros de T_PESSOA_CARTAO cadastrados",
)
async def index(pessoa_id: int, current_user: dict = Depends(get_current_user)):
"""
Retorna todos os registros da tabela T_PESSOA_CARTAO.
"""
t_pessoa_cartao_index_schema = TPessoaCartaoIndexchema(pessoa_id=pessoa_id)
response = t_pessoa_cartao_controller.index(t_pessoa_cartao_index_schema)
return response
# ----------------------------------------------------
# Busca um registro específico de T_PESSOA_CARTAO pelo ID
# ----------------------------------------------------
@router.get(
"/{pessoa_cartao_id}",
status_code=status.HTTP_200_OK,
summary="Busca um registro de T_PESSOA_CARTAO pelo ID",
response_description="Busca um registro de T_PESSOA_CARTAO em específico",
)
async def show(pessoa_cartao_id: int, current_user: dict = Depends(get_current_user)):
"""
Retorna um registro específico de T_PESSOA_CARTAO com base no ID informado.
"""
t_pessoa_cartao_id_schema = TPessoaCartaoIdSchema(pessoa_cartao_id=pessoa_cartao_id)
response = t_pessoa_cartao_controller.show(t_pessoa_cartao_id_schema)
return response
# ----------------------------------------------------
# Cadastra um novo registro em T_PESSOA_CARTAO
# ----------------------------------------------------
@router.post(
"/",
status_code=status.HTTP_201_CREATED,
summary="Cadastra um novo registro em T_PESSOA_CARTAO",
response_description="Cadastra um novo registro em T_PESSOA_CARTAO",
)
async def save(
t_pessoa_cartao_schema: TPessoaCartaoSaveSchema,
current_user: dict = Depends(get_current_user),
):
"""
Cria um novo registro na tabela T_PESSOA_CARTAO.
"""
response = t_pessoa_cartao_controller.save(t_pessoa_cartao_schema)
return response
# ----------------------------------------------------
# Atualiza um registro existente de T_PESSOA_CARTAO
# ----------------------------------------------------
@router.put(
"/{pessoa_cartao_id}",
status_code=status.HTTP_200_OK,
summary="Atualiza um registro existente em T_PESSOA_CARTAO",
response_description="Atualiza um registro existente em T_PESSOA_CARTAO",
)
async def update(
pessoa_cartao_id: int,
t_pessoa_cartao_update_schema: TPessoaCartaoUpdateSchema,
current_user: dict = Depends(get_current_user),
):
"""
Atualiza um registro existente de T_PESSOA_CARTAO com base no ID informado.
"""
t_pessoa_cartao_update_schema.pessoa_cartao_id = pessoa_cartao_id
response = t_pessoa_cartao_controller.update(t_pessoa_cartao_update_schema)
return response
# ----------------------------------------------------
# Exclui um registro de T_PESSOA_CARTAO
# ----------------------------------------------------
@router.delete(
"/{pessoa_cartao_id}",
status_code=status.HTTP_200_OK,
summary="Remove um registro de T_PESSOA_CARTAO",
response_description="Remove um registro de T_PESSOA_CARTAO",
)
async def delete(pessoa_cartao_id: int, current_user: dict = Depends(get_current_user)):
"""
Remove um registro específico de T_PESSOA_CARTAO com base no ID informado.
"""
t_pessoa_cartao_id_schema = TPessoaCartaoIdSchema(pessoa_cartao_id=pessoa_cartao_id)
response = t_pessoa_cartao_controller.delete(t_pessoa_cartao_id_schema)
return response

17
packages/v1/servicos/balcao/endpoints/t_servico_pedido_endpoint.py
View file

@ -37,6 +37,23 @@ async def index(current_user: dict = Depends(get_current_user)):
return response
# ----------------------------------------------------
# Exclui um registro de T_SERVICO_PEDIDO
# ----------------------------------------------------
@router.get(
"/load-params",
status_code=status.HTTP_200_OK,
summary="Localiza os parâmetros de registro de T_SERVICO_PEDIDO",
response_description="Localiza os parâmetros de registro de T_SERVICO_PEDIDO",
)
async def load_params(current_user: dict = Depends(get_current_user)):
"""
Localiza os parâmetros para operar corretamente o T_SERVICO_PEDIDO
"""
response = t_servico_pedido_controller.load_params()
return response
# ----------------------------------------------------
# Busca um registro específico de T_SERVICO_PEDIDO pelo ID
# ----------------------------------------------------

47
packages/v1/servicos/balcao/repositories/t_pessoa_cartao/t_pessoa_cartao_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_pessoa_cartao_schema import (
TPessoaCartaoIdSchema,
)
class TPessoaCartaoDeleteRepository(BaseRepository):
"""
Repositório responsável pela exclusão de registros na tabela
TPessoaCartao.
"""
def execute(self, TPessoaCartao_id_schema: TPessoaCartaoIdSchema):
"""
Executa a exclusão de um registro específico da tabela TPessoaCartao
com base no ID informado.
Args:
TPessoaCartao_id_schema (TPessoaCartaoIdSchema): 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_pessoa_cartao tpc
WHERE tpc.pessoa_cartao_id = :pessoa_cartao_id
"""
# Preenchimento dos parâmetros
params = {"pessoa_cartao_id": TPessoaCartao_id_schema.pessoa_cartao_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 TPessoaCartao: {e}",
)

31
packages/v1/servicos/balcao/repositories/t_pessoa_cartao/t_pessoa_cartao_index_repository.py Normal file
View file

@ -0,0 +1,31 @@
from abstracts.repository import BaseRepository
from packages.v1.servicos.balcao.schemas.t_pessoa_cartao_schema import (
TPessoaCartaoIndexchema,
)
class TPessoaCartaoIndexRepository(BaseRepository):
"""
Repositório para a operação de listagem de todos os registros
na tabela t_censec_qualidade.
"""
def execute(self, t_pessoa_cartao_index_schema: TPessoaCartaoIndexchema):
"""
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 * FROM T_PESSOA_CARTAO
WHERE PESSOA_ID = :pessoa_id
"""
params = {"pessoa_id": t_pessoa_cartao_index_schema.pessoa_id}
# Execução do sql
response = self.fetch_all(sql, params)
# Retorna os dados localizados
return response

52
packages/v1/servicos/balcao/repositories/t_pessoa_cartao/t_pessoa_cartao_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_pessoa_cartao_schema import (
TPessoaCartaoSaveSchema,
)
class TPessoaCartaoSaveRepository(BaseRepository):
"""
Repositório responsável pela operação de salvamento de um novo registro
na tabela T_PESSOA_CARTAO.
"""
def execute(self, t_pessoa_cartao_save_schema: TPessoaCartaoSaveSchema):
"""
Executa a operação de salvamento no banco de dados.
Args:
t_pessoa_cartao_save_schema (TPessoaCartaoSchema): 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_pessoa_cartao_save_schema.model_dump(exclude_unset=True)
# ----------------------------------------------------
# Montagem do SQL dinâmico
# ----------------------------------------------------
sql = generate_insert_sql("T_PESSOA_CARTAO", 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_PESSOA_CARTAO: {e}",
)

69
packages/v1/servicos/balcao/repositories/t_pessoa_cartao/t_pessoa_cartao_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_pessoa_cartao_schema import (
TPessoaCartaoIdSchema,
)
class TPessoaCartaoShowRepository(BaseRepository):
"""
Repositório responsável pela operação de exibição de um registro
na tabela T_PESSOA_CARTAO.
"""
def execute(self, t_pessoa_cartao_id_schema: TPessoaCartaoIdSchema):
"""
Busca um registro específico de T_PESSOA_CARTAO pelo ID.
Args:
t_pessoa_cartao_id_schema (TPessoaCartaoIdSchema):
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_PESSOA_CARTAO GG
WHERE GG.PESSOA_CARTAO_ID = :pessoa_cartao_id
"""
# ----------------------------------------------------
# Preenchimento de parâmetros
# ----------------------------------------------------
params = t_pessoa_cartao_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_PESSOA_CARTAO 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_PESSOA_CARTAO: {e}",
)

63
packages/v1/servicos/balcao/repositories/t_pessoa_cartao/t_pessoa_cartao_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_pessoa_cartao_schema import (
TPessoaCartaoUpdateSchema,
)
class TPessoaCartaoUpdateRepository(BaseRepository):
"""
Repositório responsável pela operação de atualização de registros
na tabela T_PESSOA_CARTAO.
"""
def execute(self, t_pessoa_cartao_update_schema: TPessoaCartaoUpdateSchema):
"""
Atualiza um registro existente na tabela T_PESSOA_CARTAO.
Args:
t_pessoa_cartao_update_schema (TPessoaCartaoUpdateSchema):
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_pessoa_cartao_update_schema,
exclude_fields=["pessoa_cartao_id"],
id_field="pessoa_cartao_id",
)
# ----------------------------------------------------
# Montagem do SQL dinâmico
# ----------------------------------------------------
sql = f"""
UPDATE T_PESSOA_CARTAO
SET {update_columns}
WHERE PESSOA_CARTAO_ID = :pessoa_cartao_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_PESSOA_CARTAO: {str(e)}",
)

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

@ -30,7 +30,10 @@ class TServicoItemPedidoSaveRepository(BaseRepository):
# ----------------------------------------------------
# Preenchimento dos parâmetros
# ----------------------------------------------------
params = t_servico_itempedido_save_schema.model_dump(exclude_unset=True)
params = t_servico_itempedido_save_schema.model_dump(
exclude_unset=True,
exclude=["usuario_id", "cartao_data", "cartao_numero"],
)
# ----------------------------------------------------
# Montagem do SQL dinâmico

88
packages/v1/servicos/balcao/schemas/t_pessoa_cartao_schema.py Normal file
View file

@ -0,0 +1,88 @@
from pydantic import BaseModel
from typing import Optional
from datetime import datetime
# ----------------------------------------------------
# Schema para localizar um registro pelo ID (GET /{id})
# ----------------------------------------------------
class TPessoaCartaoIndexchema(BaseModel):
pessoa_id: int
class Config:
from_attributes = True
# ----------------------------------------------------
# Schema base - representa a tabela PESSOA_CARTAO
# ----------------------------------------------------
class TPessoaCartaoSchema(BaseModel):
pessoa_cartao_id: Optional[int] = None
data_abertura: Optional[datetime] = None
usuario_id: Optional[int] = None
situacao: Optional[str] = None
cartao_impresso: Optional[str] = None
pessoa_id: Optional[int] = None
renovado: Optional[str] = None
numero: Optional[int] = None
chave_importacao: Optional[int] = None
tipo_pessoa_relacionada: Optional[str] = None
id_cartao: Optional[int] = None
data_renovacao: Optional[datetime] = None
class Config:
from_attributes = True
# ----------------------------------------------------
# Schema para localizar um registro pelo ID (GET /{id})
# ----------------------------------------------------
class TPessoaCartaoIdSchema(BaseModel):
pessoa_cartao_id: int
class Config:
from_attributes = True
# ----------------------------------------------------
# Schema para criação (POST)
# - normalmente sem o ID (gerado pelo banco)
# ----------------------------------------------------
class TPessoaCartaoSaveSchema(BaseModel):
pessoa_cartao_id: Optional[int] = None
data_abertura: Optional[datetime] = None
usuario_id: Optional[int] = None
situacao: Optional[str] = None
cartao_impresso: Optional[str] = None
pessoa_id: Optional[int] = None
renovado: Optional[str] = None
numero: Optional[int] = None
chave_importacao: Optional[int] = None
tipo_pessoa_relacionada: Optional[str] = None
id_cartao: Optional[int] = None
data_renovacao: Optional[datetime] = None
class Config:
from_attributes = True
# ----------------------------------------------------
# Schema para atualização (PUT)
# - inclui o ID + campos opcionais para alterar
# ----------------------------------------------------
class TPessoaCartaoUpdateSchema(BaseModel):
pessoa_cartao_id: Optional[int] = None
data_abertura: Optional[datetime] = None
usuario_id: Optional[int] = None
situacao: Optional[str] = None
cartao_impresso: Optional[str] = None
pessoa_id: Optional[int] = None
renovado: Optional[str] = None
numero: Optional[int] = None
chave_importacao: Optional[int] = None
tipo_pessoa_relacionada: Optional[str] = None
id_cartao: Optional[int] = None
data_renovacao: Optional[datetime] = None
class Config:
from_attributes = True

3
packages/v1/servicos/balcao/schemas/t_servico_itempedido_schema.py
View file

@ -73,6 +73,9 @@ class TServicoItemPedidoSchema(BaseModel):
vrcext: Optional[Decimal] = None
valor_fundo_selo: Optional[Decimal] = None
averbacao: Optional[str] = None
usuario_id: Optional[int] = None
cartao_data: Optional[str] = None
cartao_numero: Optional[int] = None
class Config:
from_attributes = True

6
packages/v1/servicos/balcao/schemas/t_servico_pedido_schema.py
View file

@ -3,8 +3,10 @@ from typing import Annotated, Optional, List
from decimal import Decimal
from datetime import datetime
from pydantic.config import ConfigDict
from pydantic.functional_validators import BeforeValidator
from packages.v1.parametros.schemas.g_config_schema import GConfigNomeSchema
from packages.v1.servicos.balcao.schemas.t_servico_itempedido_schema import (
TServicoItemPedidoSchema,
)
@ -109,3 +111,7 @@ class TServicoPedidoUpdateSchema(BaseModel):
class Config:
from_attributes = True
class TServicoPedidoLoadParams(GConfigNomeSchema):
model_config = ConfigDict(from_attributes=True)

39
packages/v1/servicos/balcao/services/t_pessoa_cartao/go/t_pessoa_cartao_delete_service.py Normal file
View file

@ -0,0 +1,39 @@
from packages.v1.servicos.balcao.actions.t_pessoa_cartao.t_pessoa_cartao_delete_action import (
TPessoaCartaoDeleteAction,
)
from packages.v1.servicos.balcao.schemas.t_pessoa_cartao_schema import (
TPessoaCartaoIdSchema,
)
class TPessoaCartaoDeleteService:
"""
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_PESSOA_CARTAO.
"""
def execute(self, t_pessoa_cartao_id_schema: TPessoaCartaoIdSchema):
"""
Executa a operação de exclusão do registro no banco de dados.
Args:
t_pessoa_cartao_id_schema (TPessoaCartaoIdSchema):
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_pessoa_cartao_delete_action = TPessoaCartaoDeleteAction()
# ----------------------------------------------------
# Execução da ação
# ----------------------------------------------------
data = t_pessoa_cartao_delete_action.execute(t_pessoa_cartao_id_schema)
# ----------------------------------------------------
# Retorno da informação
# ----------------------------------------------------
return data

50
packages/v1/servicos/balcao/services/t_pessoa_cartao/go/t_pessoa_cartao_index_service.py Normal file
View file

@ -0,0 +1,50 @@
from packages.v1.servicos.balcao.actions.t_pessoa_cartao.t_pessoa_cartao_index_action import (
TPessoaCartaoIndexAction,
)
from fastapi import HTTPException, status
from packages.v1.servicos.balcao.schemas.t_pessoa_cartao_schema import (
TPessoaCartaoIndexchema,
)
class TPessoaCartaoIndexService:
"""
Serviço responsável por encapsular a lógica de negócio para a operação
de listagem de registros na tabela T_PESSOA_CARTAO.
"""
def execute(self, t_pessoa_cartao_index_schema: TPessoaCartaoIndexchema):
"""
Executa a operação de busca de todos os registros no banco de dados.
Args:
t_pessoa_cartao_index_schema (TPessoaCartaoIndexSchema):
Esquema que pode conter filtros ou parâmetros de busca.
Returns:
A lista de registros encontrados.
"""
# ----------------------------------------------------
# Instanciamento da ação
# ----------------------------------------------------
t_pessoa_cartao_index_action = TPessoaCartaoIndexAction()
# ----------------------------------------------------
# Execução da ação
# ----------------------------------------------------
data = t_pessoa_cartao_index_action.execute(t_pessoa_cartao_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_PESSOA_CARTAO.",
)
# ----------------------------------------------------
# Retorno da informação
# ----------------------------------------------------
return data

51
packages/v1/servicos/balcao/services/t_pessoa_cartao/go/t_pessoa_cartao_save_service.py Normal file
View file

@ -0,0 +1,51 @@
from packages.v1.servicos.balcao.actions.t_pessoa_cartao.t_pessoa_cartao_save_action import (
TPessoaCartaoSaveAction,
)
from packages.v1.sequencia.schemas.g_sequencia import GSequenciaSchema
from packages.v1.servicos.balcao.schemas.t_pessoa_cartao_schema import (
TPessoaCartaoSaveSchema,
)
from packages.v1.sequencia.services.g_sequencia.generate_service import (
GenerateService,
)
class TPessoaCartaoSaveService:
"""
Serviço responsável por encapsular a lógica de negócio para a operação
de criação de registros na tabela T_PESSOA_CARTAO.
"""
def execute(self, t_pessoa_cartao_save_schema: TPessoaCartaoSaveSchema):
"""
Executa a operação de salvamento do registro no banco de dados.
Args:
t_pessoa_cartao_save_schema (TPessoaCartaoSaveSchema):
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_pessoa_cartao_save_schema.pessoa_cartao_id:
# Cria o schema de sequência
sequencia_schema = GSequenciaSchema()
sequencia_schema.tabela = "T_PESSOA_CARTAO"
# Gera a sequência atualizada
generate = GenerateService()
sequencia = generate.execute(sequencia_schema)
# Atualiza o ID no schema
t_pessoa_cartao_save_schema.pessoa_cartao_id = sequencia.sequencia
# ----------------------------------------------------
# Instanciamento e execução da Action de salvamento
# ----------------------------------------------------
t_pessoa_cartao_save_action = TPessoaCartaoSaveAction()
return t_pessoa_cartao_save_action.execute(t_pessoa_cartao_save_schema)

49
packages/v1/servicos/balcao/services/t_pessoa_cartao/go/t_pessoa_cartao_show_service.py Normal file
View file

@ -0,0 +1,49 @@
from packages.v1.servicos.balcao.actions.t_pessoa_cartao.t_pessoa_cartao_show_action import (
TPessoaCartaoShowAction,
)
from packages.v1.servicos.balcao.schemas.t_pessoa_cartao_schema import (
TPessoaCartaoIdSchema,
)
from fastapi import HTTPException, status
class TPessoaCartaoShowService:
"""
Serviço responsável por encapsular a lógica de negócio para a operação
de busca de um registro na tabela T_PESSOA_CARTAO.
"""
def execute(self, t_pessoa_cartao_id_schema: TPessoaCartaoIdSchema):
"""
Executa a operação de busca no banco de dados.
Args:
t_pessoa_cartao_id_schema (TPessoaCartaoIdSchema):
O esquema com o ID do registro a ser buscado.
Returns:
O resultado da busca.
"""
# ----------------------------------------------------
# Instanciamento da ação
# ----------------------------------------------------
t_pessoa_cartao_show_action = TPessoaCartaoShowAction()
# ----------------------------------------------------
# Execução da ação
# ----------------------------------------------------
data = t_pessoa_cartao_show_action.execute(t_pessoa_cartao_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_PESSOA_CARTAO.",
)
# ----------------------------------------------------
# Retorno da informação
# ----------------------------------------------------
return data

34
packages/v1/servicos/balcao/services/t_pessoa_cartao/go/t_pessoa_cartao_update_service.py Normal file
View file

@ -0,0 +1,34 @@
from packages.v1.servicos.balcao.actions.t_pessoa_cartao.t_pessoa_cartao_update_action import (
TPessoaCartaoUpdateAction,
)
from packages.v1.servicos.balcao.schemas.t_pessoa_cartao_schema import (
TPessoaCartaoUpdateSchema,
)
class TPessoaCartaoUpdateService:
"""
Serviço responsável pela operação de atualização de um registro
na tabela T_PESSOA_CARTAO.
"""
def execute(self, t_pessoa_cartao_update_schema: TPessoaCartaoUpdateSchema):
"""
Executa a operação de atualização no banco de dados.
Args:
t_pessoa_cartao_update_schema (TPessoaCartaoUpdateSchema):
O esquema com os dados a serem atualizados.
Returns:
O resultado da operação de atualização.
"""
# ----------------------------------------------------
# Instanciamento da ação
# ----------------------------------------------------
t_pessoa_cartao_update_action = TPessoaCartaoUpdateAction()
# ----------------------------------------------------
# Execução da ação e retorno do resultado
# ----------------------------------------------------
return t_pessoa_cartao_update_action.execute(t_pessoa_cartao_update_schema)

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

@ -1,16 +1,42 @@
from datetime import datetime
from packages.v1.parametros.schemas.g_config_schema import GConfigNomeSchema
from packages.v1.parametros.services.g_config.g_config_show_by_nome_service import (
GConfigShowByNomeService,
)
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.controllers.t_pessoa_cartao_controller import (
TPessoaCartaoSaveSchema,
)
from packages.v1.servicos.balcao.schemas.t_servico_itempedido_schema import (
TServicoItemPedidoSaveSchema,
)
from packages.v1.sequencia.services.g_sequencia.generate_service import (
GenerateService,
)
from packages.v1.servicos.balcao.services.t_pessoa_cartao.go.t_pessoa_cartao_save_service import (
TPessoaCartaoSaveService,
)
class TServicoItemPedidoSaveService:
def __init__(self) -> None:
# Classe de consulta de parâmetro
config_show_by_nome_service = GConfigShowByNomeService()
# Busca os parâmetros da aplicação
self.servico_cartao_id = float(
config_show_by_nome_service.execute(
GConfigNomeSchema(nome="SERVICO_ABERTURA_CARTAO", sistema_id=2)
).valor
)
pass
"""
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.
@ -48,6 +74,44 @@ class TServicoItemPedidoSaveService:
# Instanciamento e execução da Action de salvamento
# ----------------------------------------------------
t_servico_itempedido_save_action = TServicoItemPedidoSaveAction()
return t_servico_itempedido_save_action.execute(
response = t_servico_itempedido_save_action.execute(
t_servico_itempedido_save_schema
)
# Se o serviço foi salvo, gero o cartão, se o serviço for igual ao parâmetro
if response and response.servico_tipo_id == self.servico_cartao_id:
# Classe para gerar cartão
t_pessoa_cartao_save_service = TPessoaCartaoSaveService()
# ----------------------------------------------------
# Geração automática de ID (sequência)
# ----------------------------------------------------
if not t_servico_itempedido_save_schema.cartao_numero:
# Cria o schema de sequência
sequencia_schema = GSequenciaSchema()
sequencia_schema.tabela = "T_CARTAO_NUMERO"
# Gera a sequência atualizada
generate = GenerateService()
sequencia = generate.execute(sequencia_schema)
# Atualiza o ID no schema
t_servico_itempedido_save_schema.cartao_numero = sequencia.sequencia
# Gera o cartão
t_pessoa_cartao_save_service.execute(
TPessoaCartaoSaveSchema(
data_abertura=datetime.now(),
usuario_id=t_servico_itempedido_save_schema.usuario_id,
situacao="A",
cartao_impresso="N",
tipo_pessoa_relacionada="P",
pessoa_id=t_servico_itempedido_save_schema.pessoa_id,
numero=t_servico_itempedido_save_schema.cartao_numero,
id_cartao=t_servico_itempedido_save_schema.cartao_numero,
)
)
return response

25
packages/v1/servicos/balcao/services/t_servico_pedido/go/t_servico_pedido_load_params_service.py Normal file
View file

@ -0,0 +1,25 @@
from packages.v1.parametros.schemas.g_config_schema import GConfigNomeSchema
from packages.v1.parametros.services.g_config.g_config_show_by_nome_service import (
GConfigShowByNomeService,
)
class TServicoPedidoLoadParamsService:
"""
Serviço responsável pela operação de atualização de um registro
na tabela T_SERVICO_PEDIDO.
"""
def execute(self):
response = []
g_config_show_by_nome_service = GConfigShowByNomeService()
response.append(
g_config_show_by_nome_service.execute(
GConfigNomeSchema(nome="SERVICO_ABERTURA_CARTAO", sistema_id=2)
)
)
return response

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

@ -1,4 +1,15 @@
from datetime import datetime
from urllib import response
from packages.v1.administrativo.schemas.c_caixa_item_schema import CaixaItemSchema
from packages.v1.administrativo.schemas.t_servico_tipo_schema import (
TServicoTipoIdSchema,
)
from packages.v1.administrativo.services.c_caixa_servico.go.c_caixa_servico_save_service import (
CCaixaServicoSaveService,
)
from packages.v1.administrativo.services.t_servico_tipo.go.t_servico_tipo_show_service import (
ShowService,
)
from packages.v1.servicos.balcao.actions.t_servico_pedido.t_servico_pedido_save_action import (
TServicoPedidoSaveAction,
)
@ -12,6 +23,9 @@ from packages.v1.sequencia.services.g_sequencia.generate_service import (
from packages.v1.servicos.balcao.services.t_servico_itempedido.go.t_servico_itempedido_save_service import (
TServicoItemPedidoSaveService,
)
from packages.v1.administrativo.services.c_caixa_item.go.c_caixa_item_save_service import (
SaveService,
)
class TServicoPedidoSaveService:
@ -52,17 +66,22 @@ class TServicoPedidoSaveService:
# ----------------------------------------------------
t_servico_pedido_save_action = TServicoPedidoSaveAction()
# Obtenho a resposta da operação
response = t_servico_pedido_save_action.execute(t_servico_pedido_save_schema)
# Verifica se tem a data do pedido
if not t_servico_pedido_save_schema.data_pedido:
if t_servico_pedido_save_schema.data_pedido is None:
# Obtem a data e hora atual
t_servico_pedido_save_schema.data_pedido = datetime.now()
# Obtenho a resposta da operação
response_pedido = t_servico_pedido_save_action.execute(
t_servico_pedido_save_schema
)
response_pedido_itens = []
# Verifica se o pedido foi salvo
if (
response.servico_pedido_id > 0
response_pedido.servico_pedido_id > 0
and len(t_servico_pedido_save_schema.itens) > 0
):
@ -70,12 +89,48 @@ class TServicoPedidoSaveService:
for item in t_servico_pedido_save_schema.itens:
# Define o id do item do serviço
item.servico_pedido_id = response.servico_pedido_id
item.servico_pedido_id = response_pedido.servico_pedido_id
# Define o id do item do usuario
item.usuario_id = response_pedido.usuario_id
# Import a classe de salvar os intes
t_servico_itempedido_service = TServicoItemPedidoSaveService()
# Salva o item do pedido
t_servico_itempedido_service.execute(item)
response_pedido_item = t_servico_itempedido_service.execute(item)
return response
# Guarda o item do pedido
response_pedido_itens.append(response_pedido_item)
if item and response_pedido_item:
# Busca os detalhes do serviço do item
t_servico_tipo_show = ShowService()
response_t_servico_tipo_show = t_servico_tipo_show.execute(
TServicoTipoIdSchema(servico_tipo_id=item.servico_tipo_id)
)
# Controle de pedidos
c_caixa_item_save_service = SaveService()
# Salva o serviço no caixa
c_caixa_item_save_service.execute(
CaixaItemSchema(
apresentante=t_servico_pedido_save_schema.apresentante,
usuario_servico_id=response_pedido.usuario_id,
chave_servico=response_pedido.servico_pedido_id,
descricao=response_t_servico_tipo_show.descricao,
situacao=3,
emolumento_item_id=item.emolumento_item_id,
emolumento=item.emolumento,
taxa_judiciaria=item.taxa_judiciaria,
iss=item.valor_iss,
fundesp=item.fundesp,
valor_servico=1,
valor_pago=1,
)
)
return response_pedido

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

@ -35,16 +35,16 @@ class TServicoPedidoUpdateService:
# ----------------------------------------------------
t_servico_pedido_update_action = TServicoPedidoUpdateAction()
# Verifica se tem a data do pedido
if t_servico_pedido_update_schema.data_pedido is None:
t_servico_pedido_update_schema.data_pedido = datetime.now()
# Obtenho a resposta da operação
response = t_servico_pedido_update_action.execute(
t_servico_pedido_update_schema
)
# Verifica se tem a data do pedido
if not t_servico_pedido_update_schema.data_pedido:
t_servico_pedido_update_schema.data_pedido = datetime.now()
# Verifica se o pedido foi salvo
if (
response.servico_pedido_id > 0