NeoAnd/evo-ai
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

translate to english

Browse Source
This commit is contained in:
Davidson Gomes
2025-04-28 20:04:51 -03:00
parent c3baa54215
commit 215e76012e
54 changed files with 3269 additions and 3460 deletions
Download Patch File Download Diff File Expand all files Collapse all files

74
src/services/client_service.py
View File

@@ -12,50 +12,50 @@ import logging
logger = logging.getLogger(__name__)
def get_client(db: Session, client_id: uuid.UUID) -> Optional[Client]:
"""Busca um cliente pelo ID"""
"""Search for a client by ID"""
try:
client = db.query(Client).filter(Client.id == client_id).first()
if not client:
logger.warning(f"Cliente não encontrado: {client_id}")
logger.warning(f"Client not found: {client_id}")
return None
return client
except SQLAlchemyError as e:
logger.error(f"Erro ao buscar cliente {client_id}: {str(e)}")
logger.error(f"Error searching for client {client_id}: {str(e)}")
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
detail="Erro ao buscar cliente"
detail="Error searching for client"
)
def get_clients(db: Session, skip: int = 0, limit: int = 100) -> List[Client]:
"""Busca todos os clientes com paginação"""
"""Search for all clients with pagination"""
try:
return db.query(Client).offset(skip).limit(limit).all()
except SQLAlchemyError as e:
logger.error(f"Erro ao buscar clientes: {str(e)}")
logger.error(f"Error searching for clients: {str(e)}")
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
detail="Erro ao buscar clientes"
detail="Error searching for clients"
)
def create_client(db: Session, client: ClientCreate) -> Client:
"""Cria um novo cliente"""
"""Create a new client"""
try:
db_client = Client(**client.model_dump())
db.add(db_client)
db.commit()
db.refresh(db_client)
logger.info(f"Cliente criado com sucesso: {db_client.id}")
logger.info(f"Client created successfully: {db_client.id}")
return db_client
except SQLAlchemyError as e:
db.rollback()
logger.error(f"Erro ao criar cliente: {str(e)}")
logger.error(f"Error creating client: {str(e)}")
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
detail="Erro ao criar cliente"
detail="Error creating client"
)
def update_client(db: Session, client_id: uuid.UUID, client: ClientCreate) -> Optional[Client]:
"""Atualiza um cliente existente"""
"""Updates an existing client"""
try:
db_client = get_client(db, client_id)
if not db_client:
@@ -66,18 +66,18 @@ def update_client(db: Session, client_id: uuid.UUID, client: ClientCreate) -> Op
db.commit()
db.refresh(db_client)
logger.info(f"Cliente atualizado com sucesso: {client_id}")
logger.info(f"Client updated successfully: {client_id}")
return db_client
except SQLAlchemyError as e:
db.rollback()
logger.error(f"Erro ao atualizar cliente {client_id}: {str(e)}")
logger.error(f"Error updating client {client_id}: {str(e)}")
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
detail="Erro ao atualizar cliente"
detail="Error updating client"
)
def delete_client(db: Session, client_id: uuid.UUID) -> bool:
"""Remove um cliente"""
"""Removes a client"""
try:
db_client = get_client(db, client_id)
if not db_client:
@@ -85,54 +85,54 @@ def delete_client(db: Session, client_id: uuid.UUID) -> bool:
db.delete(db_client)
db.commit()
logger.info(f"Cliente removido com sucesso: {client_id}")
logger.info(f"Client removed successfully: {client_id}")
return True
except SQLAlchemyError as e:
db.rollback()
logger.error(f"Erro ao remover cliente {client_id}: {str(e)}")
logger.error(f"Error removing client {client_id}: {str(e)}")
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
detail="Erro ao remover cliente"
detail="Error removing client"
)
def create_client_with_user(db: Session, client_data: ClientCreate, user_data: UserCreate) -> Tuple[Optional[Client], str]:
"""
Cria um novo cliente com um usuário associado
Creates a new client with an associated user
Args:
db: Sessão do banco de dados
client_data: Dados do cliente a ser criado
user_data: Dados do usuário a ser criado
db: Database session
client_data: Client data to be created
user_data: User data to be created
Returns:
Tuple[Optional[Client], str]: Tupla com o cliente criado (ou None em caso de erro) e mensagem de status
Tuple[Optional[Client], str]: Tuple with the created client (or None in case of error) and status message
"""
try:
# Iniciar transação - primeiro cria o cliente
# Start transaction - first create the client
client = Client(**client_data.model_dump())
db.add(client)
db.flush() # Obter o ID do cliente sem confirmar a transação
db.flush() # Get client ID without committing the transaction
# Usar o ID do cliente para criar o usuário associado
# Use client ID to create the associated user
user, message = create_user(db, user_data, is_admin=False, client_id=client.id)
if not user:
# Se houve erro na criação do usuário, fazer rollback
# If there was an error creating the user, rollback
db.rollback()
logger.error(f"Erro ao criar usuário para o cliente: {message}")
return None, f"Erro ao criar usuário: {message}"
logger.error(f"Error creating user for client: {message}")
return None, f"Error creating user: {message}"
# Se tudo correu bem, confirmar a transação
# If everything went well, commit the transaction
db.commit()
logger.info(f"Cliente e usuário criados com sucesso: {client.id}")
return client, "Cliente e usuário criados com sucesso"
logger.info(f"Client and user created successfully: {client.id}")
return client, "Client and user created successfully"
except SQLAlchemyError as e:
db.rollback()
logger.error(f"Erro ao criar cliente com usuário: {str(e)}")
return None, f"Erro ao criar cliente com usuário: {str(e)}"
logger.error(f"Error creating client with user: {str(e)}")
return None, f"Error creating client with user: {str(e)}"
except Exception as e:
db.rollback()
logger.error(f"Erro inesperado ao criar cliente com usuário: {str(e)}")
return None, f"Erro inesperado: {str(e)}"
logger.error(f"Unexpected error creating client with user: {str(e)}")
return None, f"Unexpected error: {str(e)}"