def remover_produto_carrinho(carrinho):
"""
Funcao para remover produtos do carrinho
:param carrinho: lista de carrinho de compras
:return: lista de carrinho de compras sem os produtos removidos
"""
repetir = True
while repetir:
if not aux.checa_vazio(carrinho):
aux.ver_estoque_ou_carrinho(carrinho, 'Carrinho')
num_produto_remover = input(
'Digite o numero do produto a ser '
'removido do carrinho (0 (zero) para cancelar): ')
produto_valido, num_produto = aux.valida_produto(
num_produto_remover, carrinho)
if produto_valido:
if num_produto == 0: # Cancelar operacao
print('Operacao cancelada')
return carrinho
else:
# Tem que remover 1 de num_produto pois o indice de lista comeca em zero
produto_removido = carrinho.pop(num_produto - 1)
# Pergunta se o usuario deseja repetir a operacao
print(f'O produto {produto_removido["Produto"]} foi removido.')
print('\nDeseja repetir a operacao?')
repetir = aux.confirmacao()
else:
print('O carrinho estah vazio')
break
return carrinho
def fechar_compra(carrinho, estoque, arquivo_com_estoque):
"""
Funcao para remover a quantidade de cada produto comprada do estoque e salvar o novo estoque
:param carrinho: lista com os produtos a serem comprados
:param estoque: lista com os produtos em estoque
:param arquivo_com_estoque: arquivo ".txt" contendo o estoque
:return: None
"""
print('Compras finalizadas!')
if not aux.checa_vazio(carrinho):
aux.ver_estoque_ou_carrinho(carrinho, 'Carrinho')
# Loop para remover os produtos comprados do estoque
indice_inicial = 0
for item_carrinho in carrinho:
for indice in range(indice_inicial, len(estoque)):
if estoque[indice]['Produto'] == item_carrinho['Produto']:
estoque[indice]['Em estoque'] -= item_carrinho['Carrinho']
# No proximo item do carrinho, pode procurar a partir de onde parou no estoque
# para economizar alguns loops (porque as listas estao em ordem alfabetica)
indice_inicial = indice + 1
break
# Salvando o estado atual do estoque
aux.atualiza_arquivo(arquivo_com_estoque, estoque)
def remover_produto(arquivo_estoque):
"""
Essa funcao remove produtos do estoque e salva o arquivo atualizado
:param arquivo_estoque: string com o nome do arquivo ".txt" com os cadastros do usuario.
O arquivo deve conter uma lista de dicionarios com chaves = Produto, Preco, Em estoque
:return: estoque atualizado
"""
# Sequencia para cadastrar produtos
while True:
# Recupera o estoque mais atualizado
print()
estoque = recupera_estoque(arquivo_estoque)
# Se o estoque esta vazio volta para o menu anterior
if len(estoque) == 0:
return estoque
# Imprime o estoque na tela
aux.ver_estoque_ou_carrinho(estoque)
num_produto = input(
'\nDigite o numero do produto a ser removido: (0 (zero) para cancelar) '
)
produto_valido, num_produto = aux.valida_produto(num_produto, estoque)
if produto_valido:
# Zero para cancelar a remocao
if num_produto == 0:
return estoque
else:
print(
f'\nConfirma a remocao de {estoque[num_produto - 1]["Produto"]} do estoque?'
)
if aux.confirmacao():
# Removendo o produto. (Como o indice comeca em zero, tem que retirar um de "produto")
dic_produto = estoque.pop(num_produto - 1)
print(
f'\nO produto ({dic_produto["Produto"]}) foi removido com sucesso.'
)
# Atualizando o arquivo de estoque
aux.atualiza_arquivo(arquivo_estoque, estoque)
# Pergunta se o usuario deseja repetir a operacao
print('\nDeseja repetir a operacao?')
if not aux.confirmacao():
break
return estoque
def cliente_acesso(lista_comandos, arquivo_com_estoque):
# Recuperando o estoque
estoque = adm.recupera_estoque(arquivo_com_estoque)
# Se o estoque estah vazio, retorna None para voltar ao menu principal
# Eh necessario ter itens no estoque para que o cliente possa comprar
if aux.checa_vazio(estoque):
print(
'O estoque estah vazio. Eh necessario adicionar itens ao estoque primeiro.'
)
return None
# Criando o carrinho
carrinho = []
# Loop de rotina de cliente
while True:
# Print para separar os comandos
aux.separar_comandos_print()
# Imprime os comandos para administradores
print(f'Acessado como cliente.')
aux.imprimir_comandos(lista_comandos)
# Pede que o usuario escolha uma opcao ate ser dado um comando valido
comando = aux.checa_comando(lista_comandos)
print()
# Chama a funcao que o usuario pediu
if comando == 1: # Ver carrinho
aux.ver_estoque_ou_carrinho(carrinho, 'Carrinho')
elif comando == 2: # Adicionar um produto ao carrinho
carrinho = cli.adicionar_produto_carrinho(estoque, carrinho)
elif comando == 3: # Remover um produto do carrinho
carrinho = cli.remover_produto_carrinho(carrinho)
elif comando == 4: # Alterar quantidade de um produto
if not aux.checa_vazio(carrinho):
carrinho = cli.alterar_quantidade_carrinho(estoque, carrinho)
else:
print('O carrinho estah vazio')
elif comando == 5: # Fechar a compra
cli.fechar_compra(carrinho, estoque, arquivo_com_estoque)
break
elif comando == 0: # Sair
break
def adicionar_produto_carrinho(estoque, carrinho):
"""
Adiciona um produto do estoque ao carrinho (se nao estiver adicionado ainda)
:param estoque: lista com o estoque mais atualizado
:param carrinho: lista com carrinho de compras mais atualizado
:return: carrinho
"""
repetir = True
while repetir:
aux.ver_estoque_ou_carrinho(estoque)
if not aux.checa_vazio(carrinho):
print()
aux.ver_estoque_ou_carrinho(carrinho, 'Carrinho')
produtos_no_carrinho = [produto['Produto'] for produto in carrinho]
num_produto_para_add = input(
'Digite o numero do produto a ser '
'adicionado ao carrinho (0 (zero) para cancelar): ')
produto_valido, num_produto = aux.valida_produto(
num_produto_para_add, estoque)
if produto_valido:
if num_produto == 0: # Cancelar operacao
print('Operacao cancelada')
return carrinho
else:
# Tem que remover 1 de num_produto pois o indice de lista comeca em zero
if estoque[num_produto - 1]["Produto"] in produtos_no_carrinho:
print('Este produto ja estah no carrinho.')
else:
carrinho.append(estoque[num_produto - 1].copy())
carrinho = alterar_quantidade_carrinho(
estoque, carrinho, True)
carrinho.sort(
key=lambda dict_produto: dict_produto['Produto'])
# Pergunta se o usuario deseja repetir a operacao
print('\nDeseja repetir a operacao?')
repetir = aux.confirmacao()
return carrinho
def adm_acesso(lista_comandos, arquivo_adms, arquivo_estoque):
"""
Funcao com o fluxo de um adm
:param lista_comandos: lista com os comandos possiveis para os adms
:param arquivo_adms: string com o nome do arquivo ".txt" com os cadastros do usuario.
O arquivo deve conter um dicionario com chave = nome do usuario
e valor = senha criptografada
:param arquivo_estoque: string com o nome do arquivo ".txt" com os cadastros do usuario.
O arquivo deve conter uma lista de dicionarios com chaves = Produto, Preco, Em estoque
:return:
"""
# Print para separar os comandos
aux.separar_comandos_print()
# Primeira coisa a ser feita eh recuperar os adms cadastrados
adms = adm.dados_registrados(arquivo_adms)
# Se nao tiver nenhum cadastrado, pedir para cadastrar o primeiro
if len(adms) == 0:
print(
'Ainda nao ha administradores cadastrados. Eh necessario cadastrar o primeiro administrador.'
)
# Cadastrando
adms, usuario_cadastrado = adm.cadastrar_adm(arquivo_adms)
logado, usuario_ativo = True, usuario_cadastrado
else:
logado, usuario_ativo = adm.login(adms)
# Se nao logou, eh pra sair e voltar pro menu principal
if not logado:
# Retornando None pra sair da funcao
return None
# Se logou, entra no menu dos administradores
while True:
# Se o usuario remover todos os adms (possivel), deve sair da area de adm
if len(adms) == 0:
# Retornando None pra sair da funcao
return None
# Print para separar os comandos
aux.separar_comandos_print()
# Imprime os comandos para administradores
print(f'Acessado como administrador ({usuario_ativo})')
aux.imprimir_comandos(lista_comandos)
# Pede que o usuario escolha uma opcao ate ser dado um comando valido
comando = aux.checa_comando(lista_comandos)
print()
# Chama a funcao que o usuario pediu
if comando == 1: # Ver estoque
estoque = adm.recupera_estoque(arquivo_estoque)
aux.ver_estoque_ou_carrinho(estoque)
elif comando == 2: # Cadastrar novo produto
adm.cadastrar_produto(arquivo_estoque)
elif comando == 3: # Remover um produto da lista
adm.remover_produto(arquivo_estoque)
elif comando == 4: # Alterar preco de um produto
adm.alterar_preco_ou_quantidade('loja_estoque.txt', 'preco')
elif comando == 5: # Atualizar estoque de um produto
adm.alterar_preco_ou_quantidade('loja_estoque.txt', 'quantidade')
elif comando == 6: # Adicionar novo administrador
adms, usuario_cadastrado = adm.cadastrar_adm(arquivo_adms)
elif comando == 7: # Remover administrador
adms, usuario_removido = adm.remover_adm(arquivo_adms)
# Se o adm se removeu do cadastro, deve voltar para a funcao principal e pedir novo login
if usuario_ativo == usuario_removido:
print()
print(
'O usuario ativo foi removido do cadastro. Eh necessaria nova autenticacao.'
)
break
elif comando == 0: # Sair
break
def alterar_quantidade_carrinho(estoque, carrinho, adicionando=False):
# Se o produto estah sendo adicionado ao carrinho, nao eh necessario pedir o numero do produto
# O numero sera -1 (ultimo da lista, que depois sera ordenada) e sera um produto valido
indice_produto = -1
produto_valido = True
repetir = True
while repetir:
# Se nao estah adicionando (estah so alterando) um produto, eh preciso pedir o numero do produto e validar
if not adicionando:
aux.ver_estoque_ou_carrinho(estoque)
aux.ver_estoque_ou_carrinho(carrinho, 'Carrinho')
num_produto_para_alterar = input(
'Digite o numero do produto a ser '
'alterado no carrinho (0 (zero) para cancelar): ')
produto_valido, indice_produto = aux.valida_produto(
num_produto_para_alterar, carrinho)
# Se zero, o usuario deseja cancelar
if indice_produto == 0:
print('Operacao cancelada.')
return carrinho
indice_produto -= 1 # O indice da lista comeca em zero
if produto_valido:
while True:
quantidade = input(
f'Digite a quantidade de {carrinho[indice_produto]["Produto"]} '
f'que deseja manter no carrinho: ')
try:
# Transforma em float para conseguir validar se a informacao do usuario eh int ou float
quantidade = float(quantidade)
if quantidade < 0 or quantidade > carrinho[indice_produto][
"Em estoque"]:
raise ValueError
elif int(quantidade) != float(quantidade):
raise ValueError
except ValueError:
print(
f'Digite um numero valido (inteiro entre 0 e {carrinho[indice_produto]["Em estoque"]}).'
)
else:
quantidade = int(quantidade)
carrinho[indice_produto]['Carrinho'] = quantidade
carrinho[indice_produto]['Total'] = carrinho[indice_produto]['Preco'] * \
carrinho[indice_produto]['Carrinho']
break
# Se o produto esta sendo adicionado ao carrinho, o loop deve ser executado so uma vez
if adicionando:
break
else:
# Pergunta se o usuario deseja repetir a operacao
print('\nDeseja repetir a operacao?')
repetir = aux.confirmacao()
# Loop para retirar produtos com quantidade = 0
carrinho = [item for item in carrinho if item['Carrinho'] != 0]
return carrinho
}, {
'Produto': 'Leite',
'Preco': 3.5,
'Em estoque': 10
}, {
'Produto': 'Suco',
'Preco': 4.5,
'Em estoque': 10
}]
aux.atualiza_arquivo('teste_loja_estoque.txt', estoque_teste)
estoque = recupera_estoque(arquivo_teste_estoque)
carrinho = []
carrinho = adicionar_produto_carrinho(estoque, carrinho)
print('\n' * 3, 'RESULTADO:', sep='\n')
aux.ver_estoque_ou_carrinho(carrinho, 'carrinho')
aux.separar_comandos_print()
######################################################################
print('TESTANDO A FUNCAO PARA REMOVER PRODUTOS DO CARRINHO')
# Um carrinho generico para testar
carrinho = [{
'Produto': 'Cafe',
'Preco': 6.0,
'Em estoque': 20,
'Carrinho': 10,
'Total': 60
}, {
'Produto': 'Cerveja',
def alterar_preco_ou_quantidade(arquivo_estoque,
preco_ou_quantidade='quantidade'):
"""
Essa funcao altera o preco ou a quantidade em estoque de um produto e salva o arquivo atualizado
:param arquivo_estoque: string com o nome do arquivo ".txt" com os cadastros do usuario.
O arquivo deve conter uma lista de dicionarios com chaves = Produto, Preco, Em estoque
:param preco_ou_quantidade: String 'quantidade' ou 'preco' para indical qual variavel sera alterada
:return: estoque atualizado
"""
repetir = True
while repetir:
# Recupera o estoque mais atualizado
print()
estoque = recupera_estoque(arquivo_estoque)
aux.ver_estoque_ou_carrinho(estoque)
# Se o estoque esta vazio volta para o menu anterior
if len(estoque) == 0:
return estoque
if preco_ou_quantidade == 'quantidade':
num_produto = input(
'\nDigite o numero do produto para alterar a quantidade (0 (zero) para cancelar): '
)
else: # Preco
num_produto = input(
'\nDigite o numero do produto para alterar o preco (0 (zero) para cancelar): '
)
produto_valido, num_produto = aux.valida_produto(num_produto, estoque)
if produto_valido:
# Zero para cancelar a remocao
if num_produto == 0:
return estoque
# Pedindo o novo preco ou nova quantidade
else:
while True:
if preco_ou_quantidade == 'quantidade':
nova_variavel = input(
f'Digite a nova quantidade do produto '
f'({estoque[num_produto - 1]["Produto"]}): ')
else:
nova_variavel = input(
f'Digite o novo preco '
f'do produto ({estoque[num_produto - 1]["Produto"]}): '
)
try:
if preco_ou_quantidade == 'quantidade':
nova_variavel = float(nova_variavel)
# A quantidade deve ser um numero inteiro
if not float(nova_variavel) == int(nova_variavel):
raise ValueError
else:
nova_variavel = int(nova_variavel)
else: # Preco
nova_variavel = float(nova_variavel)
# Zero deixado intencionalmente
if nova_variavel < 0:
raise ValueError
except ValueError:
if preco_ou_quantidade == 'quantidade':
print(
f'Digite um numero valido (inteiro nao-negativo).'
)
else:
print(f'Digite um numero valido (nao-negativo).')
else:
break
# Alterando o preco (tem que remover 1 pois o indice de lista comeca em zero)
if preco_ou_quantidade == 'quantidade':
estoque[num_produto - 1]['Em estoque'] = nova_variavel
else:
estoque[num_produto - 1]['Preco'] = nova_variavel
# Salvando as alteracoes no arquivo
aux.atualiza_arquivo(arquivo_estoque, estoque)
# Pergunta se o usuario deseja repetir a operacao
print('\nDeseja repetir a operacao?')
repetir = aux.confirmacao()
return estoque
def cadastrar_produto(arquivo_estoque):
"""
Essa funcao cadastra novos produtos no estoque e salva o arquivo atualizado
:param arquivo_estoque: string com o nome do arquivo ".txt" com os cadastros do usuario.
O arquivo deve conter uma lista de dicionarios com chaves = Produto, Preco, Em estoque
:return: estoque atualizado
"""
# Recupera o estoque mais atualizado
estoque = recupera_estoque(arquivo_estoque)
aux.ver_estoque_ou_carrinho(estoque)
# Produtos ja cadastrados para evitar repeticao
produtos_cadastrados = [
dic_produto['Produto'].capitalize() for dic_produto in estoque
]
# Sequencia para cadastrar produtos
repetir = True
while repetir:
produto = input(
'\nDigite o produto a ser adicionado (0 (zero) para cancelar): ')
# Se usuario digitou para sair, volta ao menu
if produto == "0":
return estoque
else:
produto = produto.capitalize()
# Se o produto ja esta cadastrado, nao cadastra de novo
if produto in produtos_cadastrados:
print('Esse produto ja esta cadastrado.')
print(
f'Os produtos cadastrados sao: {", ".join(produtos_cadastrados)}'
)
else:
# Se nao tem esse produto, pede preco e quantidade para adicionar
while True:
preco = input('Digite o preco, em reais, do produto: ')
# Checa se o preco passado eh numero
try:
preco = float(preco)
# O preco nao deve ser negativo (zero foi deixado intencionalmente)
if preco < 0:
raise ValueError
except ValueError:
print('O preco informado deve ser um numero positivo.')
# Se deu tudo certo, sai do loop do preco
else:
break
# Adicionando a quantidade
while True:
quantidade = input(
f'Digite a quantidade de {produto} em estoque: ')
# Checa se a quantidade passada eh numero inteiro
try:
quantidade = float(quantidade)
# A quantidade nao deve ser negativa
if quantidade < 0:
raise ValueError
elif int(quantidade) != float(quantidade):
raise ValueError
except ValueError:
print(
'A quantidade informada deve ser um numero inteiro igual ou maior que zero.'
)
# Se deu tudo certo, sai do loop da quantidade
else:
quantidade = int(quantidade)
break
# Adicionando ao estoque
dic_produto = {
'Produto': produto,
'Preco': preco,
'Em estoque': quantidade
}
estoque.append(dic_produto)
estoque.sort(key=lambda dic_produto: dic_produto['Produto'])
# Salvando no arquivo
aux.atualiza_arquivo(arquivo_estoque, estoque)
# Pergunta se o usuario deseja repetir a operacao
print('\nDeseja repetir a operacao?')
repetir = aux.confirmacao()
# Quando o usuario nao quiser mais adicionar produtos, deve retornar o estoque final
return estoque
'Preco': 5,
'Em estoque': 10
}, {
'Produto': 'Biscoito',
'Preco': 5,
'Em estoque': 10
}]
# Salvando no estoque de teste
aux.atualiza_arquivo(arquivo_teste_estoque, estoque_teste)
# Cadastrando novo produto
estoque_teste = cadastrar_produto(arquivo_teste_estoque)
print('\n' * 1, 'RESULTADO:', sep='\n')
aux.ver_estoque_ou_carrinho(estoque_teste)
aux.separar_comandos_print()
######################################################################
print('TESTANDO A FUNCAO PARA REMOVER PRODUTOS')
# Um estoque generico para testar
estoque_teste = [{
'Produto': 'Arroz',
'Preco': 5,
'Em estoque': 10
}, {
'Produto': 'Biscoito',
'Preco': 5,
'Em estoque': 10
}, {