def define_carrinho(usr, id_usuario):
"""Esta função busca por compras em aberto do usuário {usr}. Se houver alguma nessa
condição, então a com o MENOR indice contida no identificador sera usada como carrinho,
caso contrário será criado um novo carrinho vazio.
Identificador é dado por'C-{NNNNNNNN}'"""
lista_ids_compras = compra.busca_por_cliente(id_usuario)
# inicializo todos os identificadores com compras em aberto
lista_ids_compras_abertos = []
if not lista_ids_compras:
return compra.cria(usr)
else:
# define a posicao do elemento na lista_ids_compras_abertos comecando da posicao 0
posicao = 0
for id_compra in lista_ids_compras:
obj_compra = compra.busca_por_identificador(id_compra)
# pega a substring NNNNNNNN do identificador C-{NNNNNNNN}'
substring_indice_compra = id_compra[2:10]
if compra.obtem_status(obj_compra) == 'comprando':
lista_ids_compras_abertos.insert(posicao, substring_indice_compra)
posicao = posicao + 1
# seleciono o menor indice
indice_minimo = min(lista_ids_compras_abertos)
# monto o parametro
identificador = "C-" + str(indice_minimo)
# busco a compra em aberto com o menor indice no identificador
obj_compra_identificador_min = compra.busca_por_identificador(identificador)
return obj_compra_identificador_min
return compra.cria(usr)
def cria_testes(verb):
global cache, nome_tb, letra_tb, colunas, diags
inicializa(True)
# Identificador de usuários e cookie de cada sessão:
lista_ucs = \
[
( "U-00000001", "ABCDEFGHIJK", "C-00000001" ), # S-00000001
( "U-00000001", "BCDEFGHIJKL", "C-00000002" ), # S-00000002
( "U-00000002", "CDEFGHIJKLM", "C-00000003" ), # S-00000003
( "U-00000003", "DEFGHIJKLMN", None ), # S-00000004
]
for id_usuario, cookie, id_carrinho in lista_ucs:
usr = usuario.busca_por_identificador(id_usuario)
assert usr != None and type(usr) is usuario.Objeto_Usuario
if id_carrinho == None:
carrinho = None
else:
carrinho = compra.busca_por_identificador(id_carrinho)
assert carrinho != None and type(carrinho) is compra.Objeto_Compra
ses = cria(usr, cookie, carrinho)
assert ses != None and type(ses) is sessao.Objeto_Sessao
id_ses = sessao.obtem_identificador(ses)
usr = sessao.obtem_usuario(ses)
id_usr = usuario.obtem_identificador(usr) if usr != None else "ninguém"
if verb:
sys.stderr.write("sessão %s de %s criada\n" % (id_ses, id_usr))
return
def pode_trocar(usr, pol):
global cache, nome_tb, letra_tb, colunas, diags
if usr == None or pol == None: return False
assert type(usr) is usuario.Objeto_Usuario
assert type(pol) is poltrona.Objeto_Poltrona
# A poltrona {pol} está reservada a alguma compra?
id_cpr = poltrona.obtem_atributo(pol, 'id_compra');
if id_cpr == None: return False
# A compra {cpr} ainda está aberta?
cpr = compra.busca_por_identificador(id_cpr)
assert cpr != None # Paranóia.
if compra.obtem_atributo(cpr, 'status') != 'comprando': return False
# O trecho da poltrona {pol} ainda não foi encerrado?
id_trc_pol = poltrona.obtem_atributo(pol, 'id_trecho');
trc_pol = None if id_trc_pol == None else trecho.busca_por_identificador(id_trc_pol)
assert trc_pol != None # Paranóia.
if trecho.obtem_atributo(trc_pol, 'encerrado'): return False
# O usuário tem direito de excluir e comprar nessa compra?
dono = (compra.obtem_cliente(cpr) == usr)
if not dono: return False
# Pode trocar, parece:
return True
def processa(ses, args):
# Obtém a compra:
id_cpr = args['id_compra']
assert id_cpr is not None # Paranóia (formulário deve incluir).
del args['id_compra']
cpr = compra.busca_por_identificador(id_cpr)
assert cpr != None # Paranóia.
# Obtém dados alterados:
forma_pag = args['metodo']
assert id_cpr is not None # Paranóia (formulário deve obrigar a preencher)
# Aplica a compra:
try:
novos_atrs = {'forma_pag': forma_pag}
compra.muda_atributos(cpr, novos_atrs)
# Atualiza a pagina com os novos valores
pag = html_pag_compra.gera(ses, cpr, None, None)
except ErroAtrib as ex:
# Repete a página da alterar compra com mesmos atributos e mens de erro:
erros = ex[0]
pag = html_pag_compra.gera(ses, cpr, args, erros)
return pag
def processa(ses, args):
# Obtém id da compra a alterar
id_cpr = args['id_compra'] if 'id_compra' in args else None
assert id_cpr != None # Paranóia (formulário deve incluir sempre).
del args['id_compra']
cpr = compra.busca_por_identificador(id_cpr)
assert cpr != None # Paranóia.
# Obtem dados alteráveis dos {args}:
nome_pass = args['nome_pass'] if 'nome_pass' in args else None
doc_pass = args['doc_pass'] if 'doc_pass' in args else None
status = args['status'] if 'status' in args else None
# Monta dicionário com alterações:
novos_atrs = {}.copy()
if nome_pass != None: novos_atrs['nome_pass'] = nome_pass
if doc_pass != None: novos_atrs['doc_pass'] = doc_pass
if status != None: novos_atrs['status'] = status
# Editar passageiro
try:
compra.muda_atributos(cpr, novos_atrs)
# Mostra compra com os novos valores
pag = html_pag_compra.gera(ses, cpr, None, None)
except ErroAtrib as ex:
# Repete o formulário de alteração com valores já alterados e erros
erros = ex[0]
pag = html_pag_compra.gera(ses, cpr, args, erros)
return pag
def testa_novo_passageiro():
# Valores originais
id_cpr = 'C-00000001'
cpr = compra.busca_por_identificador(id_cpr)
status = compra.obtem_atributo(cpr, 'status')
# Novos valores
nome_pass = '******'
args = {'id_compra': id_cpr, 'status': status, 'nome_pass': nome_pass}
testa("NovoPass", ses, args)
# Valores atualizados
cpr_mod = compra.busca_por_identificador('C-00000001')
nome_pass_mod = compra.obtem_atributo(cpr_mod, 'nome_pass')
assert nome_pass_mod == nome_pass, "Compra não atualizada"
def compras_abertas(usr):
id_usr = usuario.obtem_identificador(usr)
ids_compras_usr = compra.busca_por_cliente(
id_usr) # IDs das compras deste usuário.
compras_usr = map(lambda id: compra.busca_por_identificador(id),
ids_compras_usr) # Pega objetos.
# Filtra apenas as compras que não estao finalizadas:
abertas_usr = list(
filter(lambda cpr: compra.obtem_status(cpr) != 'fechado', compras_usr))
return abertas_usr
def testa_nome_passageiro_null():
# Valores originais
id_cpr = 'C-00000001'
cpr = compra.busca_por_identificador(id_cpr)
usr = compra.obtem_cliente(cpr)
id_usr = usuario.obtem_identificador(usr)
status = compra.obtem_atributo(cpr, 'status')
nome_pass_org = compra.obtem_atributo(cpr, 'nome_pass')
# Novos valores
args = {'id_compra': id_cpr, 'id_usr': id_usr, 'status': status}
testa("NoPass", ses, args)
# Valores atualizados
cpr_mod = compra.busca_por_identificador('C-00000001')
nome_pass_mod = compra.obtem_atributo(cpr_mod, 'nome_pass')
assert nome_pass_mod == nome_pass_org, "Compra não atualizada"
def processa(ses, args):
# Verificar se o usuário esta logado
if ses == None:
return html_pag_login.gera(ses, None)
# Buscar a compra no Carrinho
id_compra = args['id_compra']
cpr = compra.busca_por_identificador(id_compra)
# Muda status da compra para "pagando"
compra.fecha(cpr)
# Mostrar a página de pagamento
pag = html_pag_escolher_pagamento.gera(ses, cpr, None)
return pag
def gera(ids_poltronas, usr, carr):
id_trc = None # Identificador do trecho comum, ou None.
admin = False if usr == None else usuario.obtem_atributo(
usr, 'administrador')
fazer_checkin = admin # Por enquanto.
embarcar = admin #Por enquanto
if admin or usr == None:
assert carr == None # Administrador e não-logado não tem carrinho.
id_carr = None if carr == None else compra.obtem_identificador(carr)
# Gera a linha de os cabeçalhos das colunas
linha_cab = html_resumo_de_poltrona_de_trecho.gera_cabecalho(fazer_checkin)
assert type(linha_cab) is list or type(linha_cab) is tuple # Paranóia.
# Gera as linhas da tabela.
linhas = [].copy()
for id_poltrona in ids_poltronas:
pol = poltrona.busca_por_identificador(id_poltrona)
# Obtem dados da poltrona:
assert pol != None
id_trc_pol = poltrona.obtem_atributo(pol, 'id_trecho')
id_cpr_pol = poltrona.obtem_atributo(pol, 'id_compra')
cpr_pol = None if id_cpr_pol == None else compra.busca_por_identificador(
id_cpr_pol)
usr_pol = None if cpr_pol == None else compra.obtem_cliente(cpr_pol)
# Verifica se o trecho é o mesmo para todas as poltronas:
if id_trc != None: assert id_trc_pol == id_trc
id_trc = id_trc_pol
# Decide que botões vai ter:
alterar = admin
comprar = (carr != None) and poltrona.pode_comprar(usr, pol, carr)
excluir = (cpr_pol != None) and (usr_pol
== usr) and poltrona.pode_excluir(
usr, pol)
# Gera os campos da linha:
linha = html_resumo_de_poltrona_de_trecho.gera(pol, alterar, comprar,
excluir, fazer_checkin,
embarcar)
assert type(linha) is list or type(linha) is tuple # Paranóia.
linhas.append(linha)
ht_tabela = html_table.gera(linhas, linha_cab)
ht_legenda = html_resumo_de_poltrona_de_trecho.gera_legenda(fazer_checkin)
ht_res = ht_tabela + ht_legenda
return ht_res
def processa(ses, args):
if ses == None or not sessao.aberta(ses):
return html_pag_mensagem_de_erro.gera(ses,
"Sessão deveria estar aberta")
try:
carrinho = sessao.obtem_carrinho(ses)
id_carrinho = compra.obtem_identificador(
carrinho) if carrinho != None else None
if not sessao.eh_administrador(ses):
# Usuário comum só pode buscar as próprias compras:
usr = sessao.obtem_usuario(ses) # Dono da sessao.
usr_id = usuario.obtem_identificador(usr)
if not (args['cliente'] == None or args['cliente'] == usr_id):
raise ErroAtrib("Você não tem acesso a essa informação")
args['cliente'] = usr_id
# Se recebeu parâmetro genérico "passageiro", converte ele para "doc_pass" ou
# "nome_pass"
if 'passageiro' in args:
matchList = re.findall(
"([0-9]{2}[\.]?[0-9]{3}[\.]?[0-9]{3}[\/]?[0-9]{4}[-]?[0-9]{2})|([0-9]{3}[\.]?[0-9]{3}[\.]?[0-9]{3}[-]?[0-9]{2})",
args['passageiro'])
# É um documento
if len(matchList) > 0:
args['doc_pass'] = args['passageiro']
# É um nome
else:
args['nome_pass'] = args['passageiro']
del args['passageiro']
campos = ['cliente', 'status', 'nome_pass', 'doc_pass']
verifica_campos(args, campos)
cprs_ids = compra.busca_por_campos(args)
cprs = map(lambda id_compra: compra.busca_por_identificador(id_compra),
cprs_ids)
ver = True if sessao.eh_administrador(
ses) or args['cliente'] == sessao.obtem_usuario(ses) else False
bloco = html_lista_de_compras.gera(cprs, ver, id_carrinho)
pag = html_pag_generica.gera(ses, bloco, None)
return pag
except ErroAtrib as ex:
erros = ex.args[0]
# Repete a página com mensagem de erro:
pag = html_pag_buscar_compras.gera(ses, args,
sessao.eh_administrador(ses), erros)
return pag
def processa(ses, args):
usr_ses = None if ses == None else sessao.obtem_usuario(ses)
assert sessao.eh_administrador(
ses) # O dono da sessão deve ser administrador.
try:
if not 'id' in args:
pag = html_pag_mensagem_de_erro.gera(
ses, 'É necessário adicionar um ID para pesquisar.')
return pag
id = args['id']
if len(id) != 10:
raise ErroAtrib("O identificador \"" + id + "\" é inválido")
letra = id[0]
if letra == "U":
usr = usuario.busca_por_identificador(id)
if usr == None:
raise ErroAtrib("Não existe usuário com identificador " + id)
usr_atrs = usuario.obtem_atributos(usr)
usr_atrs['id_usuario'] = usuario.obtem_identificador(usr)
pag = html_pag_usuario.gera(ses, usr, usr_atrs, None)
elif letra == "C":
cpr = compra.busca_por_identificador(id)
if cpr == None:
raise ErroAtrib(
"Não existe pedido de compra com identificador" + id)
pag = html_pag_compra.gera(ses, cpr, None, None)
elif letra == "T":
trc = trecho.busca_por_identificador(id)
if trc == None:
raise ErroAtrib(
"Não existe trecho de viagem com identificador" + id)
pag = html_pag_trecho.gera(ses, trc, None, None)
elif letra == "S":
ses_a_ver = sessao.busca_por_identificador(id)
if ses_a_ver == None:
raise ErroAtrib("Não existe sessão com identificador" + id)
pag = html_pag_sessao.gera(ses, ses_a_ver, None)
elif letra == "A":
pol = poltrona.busca_por_identificador(id)
if pol == None:
raise ErroAtrib("Não existe poltrona com identificador" + id)
pag = html_pag_poltrona.gera(ses, pol, None, None)
else:
raise ErroAtrib("Classe de objeto \"" + letra + "\" inválida")
except ErroAtrib as ex:
erros = ex.args[0]
return html_pag_mensagem_de_erro.gera(ses, erros)
return pag
def id_para_objeto(id):
letra = id[0]
if letra == "U":
obj = usuario.busca_por_identificador(id)
elif letra == "C":
obj = compra.busca_por_identificador(id)
elif letra == "S":
obj = sessao.busca_por_identificador(id)
elif letra == "A":
obj = poltrona.busca_por_identificador(id)
elif letra == "T":
obj = trecho.busca_por_identificador(id)
else:
erro_prog("identificador '" + id + " inválido")
return obj
def processa(ses, args):
assert ses != None
pag = html_pag_mensagem_de_erro.gera(ses, "sessão corrente")
assert sessao.aberta(ses)
ids_compras = compra.busca_por_cliente(args['id'])
ids_poltronas = []
for i in range(len(ids_compras)):
cpr = compra.busca_por_identificador(ids_compras[i])
ids_poltronas += poltrona.busca_por_compra(cpr)
ht_conteudo = html_lista_de_poltronas_de_usuario.gera(ids_poltronas)
pag = html_pag_generica.gera(ses, ht_conteudo, None)
return pag
def processa(ses, args):
# Obtem o dono da sessão {ses}:
usr_ses = None if ses == None else sessao.obtem_usuario(ses)
assert usr_ses != None # Usuário não logado não deveria ter acesso a este comando.
admin = False if usr_ses == None else usuario.obtem_atributo(usr_ses, 'administrador')
carr = None if ses == None else sessao.obtem_carrinho(ses) # Carrinho de compras da sessão.
# Obtem a poltrona a excluir:
id_pol = args['id_poltrona']
pol = None if id_pol == None else poltrona.busca_por_identificador(id_pol)
assert pol != None # A poltrona deve estar identificada em {args}.
del args['id_poltrona']
# Obtem a compra de onde excluir:
id_cpr_pol = poltrona.obtem_atributo(pol, 'id_compra')
cpr_pol = None if id_cpr_pol == None else compra.busca_por_identificador(id_cpr_pol)
assert cpr_pol != None # A poltrona não pode estar livre.
# Obtem o dono da compra:
usr_pol = compra.obtem_cliente(cpr_pol)
assert usr_pol != None # Paranoia.
# Verifica permissão:
assert admin or (usr_pol == usr_ses) # Outro usuário não deveria ter acesso a este comando.
try:
# Ao definir {id_compra} como {None}, estamos excluindo a poltrona
poltrona.muda_atributos(pol, {'id_compra': None})
if (not admin) and (cpr_pol != carr):
# Mudamos o carrinho:
sessao.muda_atributos(ses, {'carrinho': cpr_pol})
aviso = ("Seu carrinho agora é a compra %s" % id_cpr_pol)
else:
aviso = None
# Gera a página de retorno:
pag = html_pag_compra.gera(ses, cpr_pol, None, aviso)
except ErroAtrib as ex:
erros = ex[0]
# Mostra a página da poltrona com mesmos args e erro:
pag = html_pag_compra.gera(ses, cpr_pol, args, aviso)
return pag
def processa(ses, args):
# Validações, por via das dúvidas:
assert ses != None # Deveria acontecer.
assert sessao.aberta(ses) # Deveria acontecer.
assert 'id_compra' in args # Deveria acontecer
# obter compra
id_compra = args['id_compra']
cpr = compra.busca_por_identificador(id_compra)
if cpr == None:
erros = ["compra \"" + id_compra + "\" não existe"]
return html_pag_mensagem_de_erro(ses, erros)
# Trocar o carrinho pela compra
sessao.muda_atributos(ses, {'carrinho': cpr})
# Mostrar carrinho atualizado
return comando_ver_carrinho.processa(ses, args)
def gera(ids_compras, ver, id_carrinho):
linhas = [].copy()
# Linha de cabeçalho:
estilo_cab = "font-size:20px;font-weight:bold; background-color: #60a3bc; color: white; padding:0px 10px 0px 0px"
# Linha de cabeçalho:
cabs_raw = [
'CR', 'Compra', 'Usuário', 'NP', 'Passageiro', 'Documento', 'Preço'
]
cabs_div = [].copy()
for cb in cabs_raw:
cabs_div.append(
html_div.gera(html_estilo_cabecalho_de_tabela.gera(), cb))
# Linhas das compras:
for id_cpr in ids_compras:
# Obtem o objeto correspondente
compra_obj = compra.busca_por_identificador(id_cpr)
# Gera uma lista de fragmentos HTML com as informacoes dessa compra
res_campos = html_resumo_de_compra.gera(compra_obj, ver, id_carrinho)
# sys.stderr.write("res_campos = %s\n" % str(res_campos))
assert type(res_campos) is list or type(res_campos) is tuple
# Adiciona essa lista à lista de linhas para a tabela HTML:
linhas.append(res_campos)
# sys.stderr.write("linhas = %s\n" % str(linhas))
ht_cabe = html_cabecalho.gera("Minhas compras", False)
# Gera a tabela HTML a partir da lista de linhas
ht_itens = html_table.gera(linhas, cabs_div)
ht_legenda = "CR: Seu Carrinho, NP: Número da Poltrona"
ht_conteudo = \
ht_cabe + "<br/>\n" + \
ht_itens + "<br/>\n" + \
ht_legenda
# Devolve a tabela HTML
return ht_conteudo
def poltronas_abertas(usr):
id_usr = usuario.obtem_identificador(usr)
abertas_usr = [].copy()
ids_compras = compra.busca_por_cliente(id_usr)
for id_cpr in ids_compras:
cpr = compra.busca_por_identificador(id_cpr)
assert cpr != None # Paranóia.
# Pega o id das poltronas de cada uma dessas compras
ids_poltronas = compra.obtem_poltronas(cpr)
for id_pol in ids_poltronas:
# Para cada um desses ids pega o objeto da poltrona
pol = poltrona.busca_por_identificador(id_pol)
assert pol != None # Paranóia.
assert poltrona.obtem_atributo(pol,
'id_compra') == id_cpr # Paranóia.
# Verifica se o trecho não foi encerrado
id_trc = poltrona.obtem_atributo(pol, 'id_trecho')
trc = trecho.busca_por_identificador(id_trc)
if not trecho.obtem_atributo(trc, 'encerrado'):
abertas_usr.append(pol)
return abertas_usr
def processa(ses, args):
# Validações, por via das dúvidas:
# Falhas são erros de programação e não do usuário.
assert ses != None # Deveria acontecer.
assert sessao.aberta(ses) # Deveria acontecer.
usr = sessao.obtem_usuario(ses)
assert usr != None # Deveria acontecer.
# Obtém id da compra a ver
id_cpr = args['id_compra'] if 'id_compra' in args else None
assert id_cpr != None # Paranóia (formulário deve incluir sempre).
del args['id_compra']
cpr = compra.busca_por_identificador(id_cpr)
assert cpr != None # Paranóia.
# O dono da sessão pode examinar essa compra?
autorizado = (compra.obtem_cliente(cpr)
== usr) or sessao.eh_administrador(ses)
assert autorizado # Paranóia (cliente não deveria ter acesso a compras de outros).
pag = html_pag_compra.gera(ses, cpr, None, None)
return pag
sys.stderr.write("Criando alguns objetos...\n")
tabelas.cria_todos_os_testes(False)
# ----------------------------------------------------------------------
sys.stderr.write("Testando função...\n")
def testa(rotulo, *args):
"""Testa {funcao(*args)}, grava resultado
em "testes/saida/{modulo}.{funcao}.{rotulo}.html"."""
modulo = html_form_dados_de_compra
funcao = modulo.gera
frag = True # {True} se for apenas um fragmento HTML, {False} se for página completa.
pretty = False # Se {True}, formata HTML para legibilidate (mas introduz brancos nos textos).
utils_testes.testa_gera_html(modulo, funcao, rotulo, frag, pretty, *args)
# pega admin
admin = usuario.busca_por_identificador('U-00000003')
# pega compra
compra1 = compra.busca_por_identificador('C-00000001')
# testa modulo
editavel = True
testa("edT", compra1, editavel, "Alterar", 'alterar_compra')
editavel = False
testa("edF", compra1, editavel, "Alterar", 'alterar_compra')
sys.stderr.write(
"Inicializando módulo {compra}, limpando tabela, criando compras para teste:\n"
)
compra.cria_testes(False)
sys.stderr.write("Inicializando módulo {compra}, limpando tabela:\n")
compra.inicializa(True)
# ----------------------------------------------------------------------
sys.stderr.write("Obtendo dois usuários para teste:\n")
usr1 = usuario.busca_por_identificador("U-00000001")
usr2 = usuario.busca_por_identificador("U-00000002")
cmp1 = compra.busca_por_identificador("C-00000001")
cmp2 = compra.busca_por_identificador("C-00000003")
# ----------------------------------------------------------------------
# Funções de teste:
ok_global = True # Vira {False} se um teste falha.
def verifica_compra(rotulo, cpr, ident, cliente, status, nome_pass, doc_pass):
"""Testes básicos de consistência do objeto {cpr} da classe {Objeto_Compra}, dados
{ident} e {atrs} esperados."""
global ok_global
sys.stderr.write("%s\n" % ("-" * 70))
sys.stderr.write("verificando compra %s\n" % rotulo)
# ----------------------------------------------------------------------
# Dados para testes:
# Um cliente comum:
usrC_id = "U-00000001"
usrC = usuario.busca_por_identificador(usrC_id)
assert not usuario.obtem_atributo(usrC, 'administrador')
# Um administrador:
usrA_id = "U-00000003"
usrA = usuario.busca_por_identificador(usrA_id)
assert usuario.obtem_atributo(usrA, 'administrador')
# Uma compra em aberto do cliente 1:
cprC_id = "C-00000001"
cprC = compra.busca_por_identificador(cprC_id)
assert compra.obtem_status(cprC) == 'comprando'
assert compra.obtem_cliente(cprC) == usrC
# Uma compra fechada:
cprF_id = "C-00000004"
cprF = compra.busca_por_identificador(cprF_id)
assert compra.obtem_status(cprF) != 'comprando'
# Sessão do cliente 1:
sesC = sessao.busca_por_identificador("S-00000001")
assert sessao.obtem_usuario(sesC) == usrC
# Sessão de outro cliente comum:
sesO = sessao.busca_por_identificador("S-00000003")
assert sessao.obtem_usuario(sesO) != None
def gera(pol, alterar, comprar, excluir, fazer_checkin, embarcar):
assert int(alterar) + int(comprar) + int(excluir) <= 1 # No máximo um deve ser "True"
campos = [].copy() # Campos a devolver
estilo = "font-size:20px;font-weight:bold;"
# Obtem atributos da poltrona:
id_pol = poltrona.obtem_identificador(pol)
atrs_pol = poltrona.obtem_atributos(pol)
numero = atrs_pol['numero']
preco = atrs_pol['preco']
oferta = atrs_pol['oferta'] # Se a poltrona está em oferta.
id_cpr = atrs_pol['id_compra'] # Pedido de compra que reservou a poltrona, ou {None}
fez_checkin = atrs_pol['fez_checkin'] # Passageiro já fez checkin?
embarcou = atrs_pol['embarcou'] # Passageiro já embarcou?
if id_cpr != None:
# Poltrona está reservada. Determina a compra:
cpr = compra.busca_por_identificador(id_cpr)
assert cpr != None # Paranóia.
else:
# Poltrona está livre:
cpr = None
args_cmd = { 'íd_poltrona': id_pol } # Argumentos para os comandos.
# Número da poltrona sempre aparece:
ht_numero = html_span.gera(estilo, numero)
campos.append(ht_numero)
# Preço da poltrona senmpre aparece:
ht_preco = html_span.gera(estilo, preco)
campos.append(ht_preco)
# Indicação de oferta sempre aparece:
ht_oferta = html_span.gera(estilo + "color:'#ffbb00';", "★" if oferta else "")
campos.append(ht_oferta)
# Coluna de identificador da compra sempre aparece:
ht_id_cpr = html_span.gera(estilo, id_cpr if cpr != None else "LIVRE")
campos.append(ht_id_cpr);
# Coluna de "fez checkin" sempre aparece:
ht_fez_checkin = html_span.gera(estilo, "CK" if fez_checkin else "")
campos.append(ht_fez_checkin);
# Coluna de "embarcou" sempre aparece:
ht_embarcou = html_span.gera(estilo, "EM" if embarcou else "")
campos.append(ht_embarcou);
# Coluna do botão "Ver" sempre aparece:
ht_bt_ver = html_botao_simples.gera("Ver", "ver_poltrona", {'id_poltrona': id_pol}, "55ee55")
campos.append(ht_bt_ver);
# Coluna do botão de ação:
if alterar:
ht_bt_acao = html_botao_simples.gera("Alterar", "solicitar_pag_alterar_poltrona", args_cmd, '#bca360')
elif comprar:
ht_bt_acao = html_botao_simples.gera("Comprar", 'comprar_poltrona', args_cmd, '#ff0000')
elif excluir:
ht_bt_acao = html_botao_simples.gera("Excluir", 'excluir_poltrona', args_cmd, '#ff0000')
else:
ht_bt_acao = ""
campos.append(ht_bt_acao);
if fazer_checkin:
# Campos para checkin:
if cpr != None:
# Nome e documento do passageiro, e botão de fazer checkin:
nome_pass = compra.obtem_atributo(cpr, 'nome_pass')
doc_pass = compra.obtem_atributo(cpr, 'doc_pass')
ht_nome_pass = html_span.gera(estilo, nome_pass)
campos.append(ht_nome_pass);
ht_doc_pass = html_span.gera(estilo, doc_pass)
campos.append(ht_doc_pass);
if fez_checkin:
ht_bt_checkin = ""
else:
# Apresentando o botão fazer checkin somente quando o status é pago
if compra.obtem_atributo(cpr, 'status') == 'pago':
ht_bt_checkin = html_botao_simples.gera("Checkin", 'fazer_checkin', args_cmd, '#55ee55')
campos.append(ht_bt_checkin);
else:
# Campos em branco:
campos.append("");
campos.append("");
campos.append("");
if embarcar:
ht_bt_embarcar = ""
if fez_checkin:
ht_bt_embarcar = html_botao_simples.gera("Embarcar", 'embarcar', args_cmd, '#55ee55')
campos.append(ht_bt_embarcar);
return campos
def gera(ses, pol, atrs, erros):
# Obtem dados da sessão e seu usuário:
usr_ses = None if ses == None else sessao.obtem_usuario(ses)
admin = sessao.eh_administrador(ses)
carr = None if (ses == None) or admin else sessao.obtem_carrinho(ses)
# Obtem dados correntes da poltrona:
assert pol != None, "poltrona deve ser especificada"
assert type(pol) is poltrona.Objeto_Poltrona
id_pol = poltrona.obtem_identificador(pol)
assert id_pol != None # Paranóia.
# Completa {atrs} com atributos correntes de {pol}:
if atrs == None: atrs = {}.copy() # Por via das dúvidas.
atrs_pol = poltrona.obtem_atributos(pol)
assert atrs_pol != None # Paranóia
for ch, val in atrs_pol.items():
if not ch in atrs: atrs[ch] = val
# Obtem compra {cpr} da poltrona, se houver:
id_cpr = poltrona.obtem_atributo(pol, 'id_compra')
cpr = None if id_cpr == None else compra.busca_por_identificador(id_cpr)
cpr_aberta = False if cpr == None else compra.obtem_status(
cpr) == 'comprando'
usr_cpr = None if cpr == None else compra.obtem_cliente(cpr)
# Obtem trecho {trc} da poltrona:
id_trc = poltrona.obtem_atributo(pol, 'id_trecho')
assert id_trc != None # Paranóia.
trc = trecho.busca_por_identificador(id_trc)
assert trc != None # Paranóia.
encerrado = trecho.obtem_atributo(trc, 'encerrado')
# Gera botões da página:
ht_submit = ""
# Tem botão "Alterar" para alterar dados?
if admin:
ht_submit += html_botao_submit.gera("Alterar", "alterar_poltrona",
None, "#ff0000")
# Tem botão "Excluir" para excluir a poltrona de {cpr}?
if poltrona.pode_excluir(usr_ses, pol):
ht_submit += html_botao_simples.gera("Excluir", "excluir_poltrona",
{'id_poltrona': id_pol},
"#ff4400")
# Tem botão "Comprar" para comprar a poltrona?
if poltrona.pode_comprar(usr_ses, pol, carr):
ht_submit += html_botao_simples.gera("Comprar", "comprar_poltrona",
{'id_poltrona': id_pol},
"#ff4400")
# Tem botão "Trocar" para trocar a poltrona?
if poltrona.pode_trocar(usr_ses, pol):
ht_submit += html_botao_simples.gera("Trocar", "trocar_poltrona",
{'id_poltrona': id_pol},
"#ff4400")
# Botão de cancelar alteração:
if admin:
ht_submit += html_botao_simples.gera("Cancelar", "principal", None,
"#00ff00")
ht_conteudo = html_form_dados_de_poltrona.gera(id_pol, atrs, admin,
ht_submit)
pag = html_pag_generica.gera(ses, ht_conteudo, erros)
return pag
utils_testes.mostra(0, "Conectando com base de dados...")
res = base_sql.conecta("DB", None, None)
assert res == None
utils_testes.mostra(0, "Criando alguns objetos...")
tabelas.cria_todos_os_testes(False)
# Compras teste
lista_ids = ["C-00000001", "C-00000002", "C-00000003"]
def testa(rotulo, *args):
modulo = html_resumo_de_compra
funcao = modulo.gera
# Teste da função {gera} HTML
frag = True # {True} se for apenas um fragmento HTML, {False} se for página completa.
pretty = False # Se {True}, formata HTML para legibilidate (mas introduz brancos nos textos).
utils_testes.testa_gera_html(modulo, funcao, rotulo, frag, pretty, *args)
utils_testes.mostra(0, "Realizando testes com html_resumo_de_compra...")
for id_compra in lista_ids:
cpr = compra.busca_por_identificador(id_compra)
assert cpr != None
testa(id_compra, cpr, False, lista_ids[0])
testa(''.join([id_compra, "_V"]), cpr, True, lista_ids[1])
utils_testes.mostra(2, "Testes realizados com sucesso!")
def processa(ses, args):
# !!! Verificar validade dos argumentos, devolver pag de erro se falhar !!!
id_compra = args['id_compra']
cpr = compra.busca_por_identificador(id_compra)
pag = html_pag_escolher_pagamento.gera(ses, cpr, None)
return pag
# ----------------------------------------------------------------------
sys.stderr.write("Conectando com base de dados...\n")
base_sql.conecta("DB", None, None)
tabelas.inicializa_todas(True)
tabelas.cria_todos_os_testes(False)
usr1_id = "U-00000001"
usr1 = usuario.busca_por_identificador(usr1_id)
usr2_id = "U-00000002"
usr2 = usuario.busca_por_identificador(usr2_id)
cpr1_id = "C-00000001"
cpr1 = compra.busca_por_identificador(cpr1_id)
ses1_id = "S-00000001"
ses1 = sessao.busca_por_identificador(ses1_id)
ok_global = True # Vira {False} se um teste falha.
# ----------------------------------------------------------------------
# TESTES DE CONVERSÃO DE VALORES
def verifica_valor(rotulo, val_mem, tipo_mem, val_SQL, tipo_SQL, nulo_ok):
"""Testa {valor_mem_para_valor_SQL} e {valor_SQL_para_valor_mem}."""
global ok_global
ok = True # Estado deste teste.
import tabelas
import sessao
import sys
sys.stderr.write("Conectando com base de dados...\n")
res = base_sql.conecta("DB", None, None)
assert res == None
sys.stderr.write("Criando alguns objetos...\n")
tabelas.cria_todos_os_testes(False)
# Sessão que será utilizada no teste
ses1 = sessao.busca_por_identificador("S-00000001")
# Compra que será utilizada no teste
cpr1 = compra.busca_por_identificador("C-00000001")
def testa(rotulo, *args):
"""Testa {funcao(*args)}, grava resultado
em "testes/saida/{modulo}.{funcao}.{rotulo}.html"."""
modulo = html_pag_ver_compra
funcao = modulo.gera
frag = False # {True} se for apenas um fragmento HTML, {False} se for página completa.
pretty = False # Se {True}, formata HTML para legibilidate (mas introduz brancos nos textos).
utils_testes.testa_gera_html(modulo, funcao, rotulo, frag, pretty, *args)
# Testa com e sem a opção de excluir habilitada
testes = ( \
def gera(ses, trc, atrs, erros):
# Obtem usuário da sessão, determina privilégios:
usr_ses = None if ses == None else sessao.obtem_usuario(ses)
admin = sessao.eh_administrador(ses)
if atrs == None: atrs = {}.copy() # Por via das dúvidas.
# Botões de acão:
ht_submit = ""
if trc == None:
# Acrescentando novo trecho:
id_trc = None
novo = True
# O submit é "Acrescentar":
ht_submit += html_botao_submit.gera("Acrescentar",
"acrescentar_trecho", None,
"#ff0000")
else:
# Visualização/alteração de trecho existente:
assert type(trc) is trecho.Objeto_Trecho
novo = False
id_trc = trecho.obtem_identificador(trc)
assert id_trc != None # Paranóia.
# Completa {atrs} com atributos de {trc}:
atrs_trc = trecho.obtem_atributos(trc)
assert atrs_trc != None # Paranóia
for ch, val in atrs_trc.items():
if not ch in atrs: atrs[ch] = val
# Botoes de ação:
if admin:
# O submit é "Alterar":
ht_submit += html_botao_submit.gera("Alterar", "alterar_trecho",
None, "#ff0000")
# Tem tamém botão "Clonar":
ht_submit += html_botao_simples.gera("Clonar", "clonar_trecho",
{'id_trecho': id_trc},
"#ff0000")
# Constrói formulário com dados do trecho:
ht_dados_trecho = html_form_dados_de_trecho.gera(id_trc, atrs, admin,
ht_submit)
# Constrói a lista de poltronas do trecho:
if novo:
ht_dados_poltronas = ""
else:
# Formata a lista de poltronas:
ids_pols_todas = poltrona.busca_por_trecho(trc)
if admin:
# Mostra todas as poltronas do trecho:
ids_pols_ver = ids_pols_todas
else:
# Mostra só as poltronas disponíveis ou reservadas para compras do usuário {usr}:
trc_encerrado = atrs_trc['encerrado']
ids_pols_ver = [].copy()
for id_pol in ids_pols_todas:
assert id_pol != None # Paranóia.
pol = poltrona.busca_por_identificador(id_pol)
assert pol != None # Paranóia.
id_cpr_pol = poltrona.obtem_atributo(pol, 'id_compra')
cpr_pol = None if id_cpr_pol == None else compra.busca_por_identificador(
id_cpr_pol)
usr_pol = None if cpr_pol == None else compra.obtem_cliente(
cpr_pol)
# Verifica relevância de {pol} para o usuário:
livre = (cpr_pol == None)
if (livre and (not trc_encerrado)) or ((usr_ses != None) and
(usr_pol == usr_ses)):
ids_pols_ver.append(id_pol)
if len(ids_pols_ver) == 0:
# Não há poltronas a mostrar.
estilo_aviso = "color:red;font-size:20;"
ht_dados_poltronas = "<br/>" + html_span.gera(
estilo_aviso, "Não há poltronas disponíveis")
else:
# Formata a lista de poltronas:
fazer_checkin = admin # Deve ter botão de "Checkin" em cada poltrona?
# sys.stderr.write(" ids_pols = %s\n" % str(ids_pols))
# sys.stderr.write(" id_trc = %s\n" % str(id_trc))
carr = None if ses == None else sessao.obtem_carrinho(ses)
ht_dados_poltronas = html_lista_de_poltronas_de_trecho.gera(
ids_pols_ver, usr_ses, carr)
# Botão "Voltar":
ht_bt_cancel = html_botao_simples.gera("Voltar", 'principal', None,
"#ff2200")
# Monta a página:
ht_conteudo = \
ht_dados_trecho + "<br/>" + \
ht_dados_poltronas + "<br/>" + \
ht_bt_cancel
pagina = html_pag_generica.gera(ses, ht_conteudo, erros)
return pagina
em "testes/saida/{modulo}.{funcao}.{rotulo}.html"."""
modulo = comando_excluir_poltrona
funcao = modulo.processa
frag = False # {True} se for apenas um fragmento HTML, {False} se for página completa.
pretty = False # Se {True}, formata HTML para legibilidate (mas introduz brancos nos textos).
testa_gera_html(modulo, funcao, rotulo, frag, pretty, *args)
# Sessao de usuário comum e poltrona desse usuário:
ses_com1 = sessao.busca_por_identificador("S-00000003")
usr_com1 = sessao.obtem_usuario(ses_com1)
assert not usuario.obtem_atributo(usr_com1, 'administrador')
id_cpr_com1 = "C-00000003"
cpr_com1 = compra.busca_por_identificador(id_cpr_com1)
assert compra.obtem_cliente(cpr_com1) == usr_com1
id_pol_com1 = "A-00000008"
pol_com1 = poltrona.busca_por_identificador(id_pol_com1)
assert poltrona.obtem_atributo(pol_com1, "id_compra") == id_cpr_com1
testa("com1-com1", ses_com1, {'id_poltrona': id_pol_com1})
# Sessao de administrador e poltrona de outro usuário:
ses_adm3 = sessao.busca_por_identificador("S-00000004")
usr_adm3 = sessao.obtem_usuario(ses_adm3)
assert usuario.obtem_atributo(usr_adm3, 'administrador')
id_cpr_com2 = "C-00000001"
cpr_com2 = compra.busca_por_identificador(id_cpr_com2)
usr_com2 = compra.obtem_cliente(cpr_com2)
