def gera(cpr, ver, id_carrinho):
id_cpr = compra.obtem_identificador(cpr)
usr = compra.obtem_cliente(cpr)
id_usr = usuario.obtem_identificador(usr)
atrs_compra = compra.obtem_atributos(cpr)
preco_tot = compra.calcula_preco(cpr)
nome_pass = atrs_compra['nome_pass']
doc_pass = atrs_compra['doc_pass']
ids_poltronas = poltrona.busca_por_compra(cpr)
num_poltronas = len(ids_poltronas)
icone_carrinho = "<b>🛒</b>" if id_cpr == id_carrinho else ""
# !!! Definir um estilo decente para os campos? Ou definir fora do {html_table}? !!!
ht_carrinho = icone_carrinho
ht_cpr = id_cpr
ht_usr = id_usr
ht_num_poltronas = str(num_poltronas)
ht_preco_tot = str(preco_tot)
ht_nome_pass = nome_pass
ht_doc_pass = doc_pass
campos = [
ht_carrinho, ht_cpr, ht_usr, ht_num_poltronas, ht_nome_pass,
ht_doc_pass, ht_preco_tot
]
if ver:
ht_ver = html_botao_simples.gera("Ver", "ver_compra",
{'id_compra': id_cpr}, "#22ff22")
campos.append(ht_ver)
return campos
def gera(ses):
id_ses = sessao.obtem_identificador(ses)
usr = sessao.obtem_usuario(ses)
admin = usuario.obtem_atributo(usr, 'administrador')
id_usr = usuario.obtem_identificador(usr)
carr = sessao.obtem_carrinho(ses)
id_cpr = compra.obtem_identificador(carr)
abrt = sessao.aberta(ses)
data_login = sessao.obtem_data_de_criacao(ses)
atrs = {
'id_ses': id_ses,
'data_login': data_login,
'id_usr': id_usr,
'id_cpr': id_cpr,
'abrt': "Sim" if abrt else "Não",
}
# Dados para {html_form_table.gera}
# {(rotulo,tipo,chave,dica,visivel,editavel,obrigatorio)}
dados_linhas = \
(
( "ID sessão", "text", "id_ses", None, True, False, False, ),
( "Criada em", "text", "data_login", None, True, False, False, ),
( "ID usuário", "text", "id_usr", None, True, False, False, ),
( "ID carrinho", "text", "id_cpr", None, True, False, False, ),
( "Status da sessão", "text", "abrt", None, True, admin, False, ),
)
ht_table = html_form_table.gera(dados_linhas, atrs)
return ht_table
def processa(ses, args):
assert ses != None
assert sessao.aberta(ses)
usr_ses = sessao.obtem_usuario(ses)
id_usr_ses = usuario.obtem_identificador(usr_ses)
assert usr_ses != None
if 'id' in args:
# Alguém quer ver sessões de usuário específico:
id_usr = args['id']
assert (id_usr == id_usr_ses) or sessao.eh_administrador(
ses) # Deveria ser o caso.
bt_ver = True
bt_fechar = True
else:
# Usuário da sessão {ses} uer ver as próprias sessões:
usr = usr_ses
id_usr = id_usr_ses
bt_ver = True
bt_fechar = True
# Com o id do usuário, podemos buscar suas sessões no banco:
ids_sessoes = sessao.busca_por_campo('usr', id_usr)
ht_conteudo = html_lista_de_sessoes.gera(ids_sessoes, bt_ver, bt_fechar)
pag = html_pag_generica.gera(ses, ht_conteudo, None)
return pag
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 cria_testes(verb):
global cache, nome_tb, letra_tb, colunas, diags
inicializa(True)
# Identificador de usuários e lista de poltronas de cada pedido de compra:
lista_cupsf = \
[
( "C-00000001", "U-00000001", "Amanda Almeida", "45.246.235-2", True, ),
( "C-00000002", "U-00000001", "Basílio Barros", "234.764.987-23", True, ),
( "C-00000003", "U-00000002", "Carlos Costa", "76.863.987-5", True, ),
( "C-00000004", "U-00000002", "Diego Dias", "654.987.098-09", False,),
( "C-00000005", "U-00000002", "Romario Silva", "122.787.038-05", False,),
( "C-00000006", "U-00000001", "Fabio Santos", "555.957.058-05", True, ),
( "C-00000007", "U-00000001", "Renato Augusto", "111.227.338-03", False,),
( "C-00000008", "U-00000001", "Carlos Tevez", "666.967.698-06", True, ),
( "C-00000009", "U-00000002", "André Santos", "554.181.018-01", False,),
( "C-00000010", "U-00000002", "Victor Cantillo", "444.955.085-08", True, ),
]
for id_cpr_esp, id_cliente, nome_pass, doc_pass, comprando in lista_cupsf:
cliente = usuario.busca_por_identificador(id_cliente)
cpr = cria(cliente, nome_pass, doc_pass)
assert cpr != None and type(cpr) is compra.Objeto_Compra
id_cpr = compra.obtem_identificador(cpr)
if not comprando: compra.fecha(cpr)
# Paranóia:
assert id_cpr == id_cpr_esp
cliente_1 = compra.obtem_cliente(cpr)
id_cliente_1 = usuario.obtem_identificador(cliente_1)
assert id_cliente_1 == id_cliente
if verb:
sys.stderr.write("compra %s de %s criada\n" % (id_cpr, id_cliente))
return
def sessoes_abertas(usr):
id_usr = usuario.obtem_identificador(usr)
ids_sessoes_usr = sessao.busca_por_usuario(
id_usr) # IDs das sessões deste usuário.
sessoes_usr = map(lambda id: sessao.busca_por_identificador(id),
ids_sessoes_usr) # Pega objetos.
# Filtra apenas as Sessoes que estao abertas
abertas_usr = list(filter(lambda ses: sessao.aberta(ses), sessoes_usr))
return abertas_usr
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 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 gera(ses, bt_ver, bt_fechar):
sessao_id = sessao.obtem_identificador(ses)
# Pega/monta atributos a mostrar:
sessao_usuario = sessao.obtem_atributo(ses, 'usr')
sessao_aberta = sessao.obtem_atributo(ses, 'abrt')
sessao_cookie = sessao.obtem_atributo(ses, 'cookie')
sessao_carrinho = sessao.obtem_atributo(ses, 'carrinho')
sessao_data = sessao.obtem_atributo(ses, 'criacao')
# Formata informações em HTML:
ht_sessao_id = formata_texto(sessao_id)
ht_codigo_usuario = formata_texto(
usuario.obtem_identificador(sessao_usuario))
ht_estado = formata_texto(sessao_esta_aberta(sessao_aberta))
ht_cookie = formata_texto(sessao_cookie)
ht_data = formata_texto(sessao_data)
if sessao_carrinho == None:
tx_carrinho = ""
else:
tx_carrinho = compra.obtem_identificador(sessao_carrinho)
ht_carrinho = formata_texto(tx_carrinho)
ht_campos = [
ht_sessao_id, ht_codigo_usuario, ht_estado, ht_cookie, ht_carrinho,
ht_data
]
args_bt = {'id_sessao': sessao_id} # Argumentos para os botões.
cor_bt_admin = '#FFA700' # Cor para botões de adminstrador.
# O comando para tratar a url "ver_detalhes_sessao" ainda não existe, e deverá ser implementado
# no futuro.
if bt_ver:
ht_bt_fechar = html_botao_simples.gera("Ver", 'ver_sessao', args_bt,
cor_bt_admin)
ht_campos.append(ht_bt_fechar)
if bt_fechar and sessao_aberta:
ht_bt_fechar = html_botao_simples.gera("Fechar", 'fechar_sessao',
args_bt, cor_bt_admin)
ht_campos.append(ht_bt_fechar)
if sessao_carrinho != None:
tx_carrinho = compra.obtem_identificador(sessao_carrinho)
if tx_carrinho[-1] == "1":
ht_bt_fechar = html_label.gera("Sessão Atual", None)
ht_campos.append(ht_bt_fechar)
return ht_campos
def devolve_pagina(self, ses, pag):
"""Manda para o usuário a {pag} dada, que deve ser um string
com o conteúdo da página em HTML 5.0., com os preâmulos adequados
segundo o protocolo HTTP.
Se {pag} é {None}, sinaliza no preâmbulo o código 404 com conteúdo 'text/plain',
mensagem 'Não encontrado'. Caso contrário, devolve a página com código 200 e
'content-type' 'text/html'.
Se {ses} não é {None}, deve ser um objeto da classe {ObjSession}.
Nesse caso, a função inclui no preâmbulo cookies que identificam a
sessão e o o usuário."""
if pag == None:
aviso_prog("Página a devolver é {None}", True)
codigo = 404 # Error - Not found.
msg = "Pagina nao encontrada - Page not found"
tipo = 'text/plain'
pag = html_pag_mensagem_de_erro.gera(ses, msg)
if pag == None:
aviso_prog(
"Função {html_pag_mensagem_de_erro.gera} devolveu {None}",
True)
# Na marra:
pag = "<!doctype html>\n<html>\n<body>\n" + msg + "\n</body>\n</head>"
else:
codigo = 200 # No error.
tipo = 'text/html'
self.send_response(codigo)
self.send_header('Content-type', tipo)
# Manda cookies que identificam usuário e sessão:
if ses != None:
id_sessao = sessao.obtem_identificador(ses)
cookie = sessao.obtem_cookie(ses)
usr = sessao.obtem_usuario(ses)
id_usuario = usuario.obtem_identificador(usr)
else:
id_sessao = ""
cookie = ""
usr = None
id_usuario = ""
self.send_header('Set-Cookie', 'id_usuario=' + id_usuario)
self.send_header('Set-Cookie', 'id_sessao=' + id_sessao)
self.send_header('Set-Cookie', 'cookie_sessao=' + cookie)
self.end_headers()
self.wfile.write(pag.encode('utf-8'))
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):
assert ses != None
pag = html_pag_mensagem_de_erro.gera(ses, "sessão corrente")
assert sessao.aberta(ses)
usr = sessao.obtem_usuario(ses)
assert usr != None
id_usr = usuario.obtem_identificador(usr)
ids_compras = compra.busca_por_cliente(id_usr)
ver_compra = True # Queremos botão "Ver" em cada compra.
carrinho = sessao.obtem_carrinho(ses)
assert not (
(carrinho != None) and sessao.eh_administrador(ses)) # Paranóia.
id_carrinho = compra.obtem_identificador(
carrinho) if carrinho != None else None
ht_conteudo = html_lista_de_compras.gera(ids_compras, ver_compra,
id_carrinho)
pag = html_pag_generica.gera(ses, ht_conteudo, None)
return pag
def processa(ses, args):
if ses == None or not sessao.aberta(ses):
erro_prog("sessão deveria estar aberta")
else:
usr_ses = sessao.obtem_usuario(ses)
admin = usuario.obtem_atributo(usr_ses, 'administrador')
if args == {} or args['id_usuario'] == None:
# O 'id_usuario' nao foi especificado; supõe que é o dono da sessao:
usr = usr_ses
id_usr = usuario.obtem_identificador(usr)
elif args['id_usuario'] != None:
# O 'id_usuario' foi especificado; obtém dados do do dito cujo.
id_usr = args['id_usuario']
usr = usuario.busca_por_identificador(id_usr)
else:
erro_prog("usuário não identificado")
atrs = usuario.obtem_atributos(usr)
pag = html_pag_usuario.gera(ses, usr, atrs, None)
return pag
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):
assert ses != None
pag = html_pag_mensagem_de_erro.gera(ses, "sessão corrente")
assert sessao.aberta(ses)
usr_ses = sessao.obtem_usuario(ses)
assert usr_ses != None
id_usr_ses = usuario.obtem_identificador(usr_ses)
admin = sessao.eh_administrador(ses)
# Usuário a examinar:
if 'id' in args:
id_usr = args['id']
usr = usuario.busca_por_identificador(id_usr)
else:
usr = usr_ses
id_usr = id_usr_ses
if (id_usr != id_usr_ses) and not admin:
pag = html_pag_mensagem_de_erro.gera(ses, ["Apenas administradores podem ver sessões por este comando"])
return pag
# Compra a identificar como "Seu carrinho":
if id_usr == id_usr_ses:
carrinho = sessao.obtem_carrinho(ses)
id_carrinho = compra.obtem_identificador(carrinho) if carrinho != None else None
else:
carrinho = None # Usuário pode ter várias sessões, não vale a pena marcar carrinho(s).
id_carrinho = None
ids_compras = compra.busca_por_cliente(id_usr)
ver_compra = True # Queremos botão "Ver" em cada compra.
ht_conteudo = html_lista_de_compras.gera(ids_compras, ver_compra, id_carrinho)
pag = html_pag_generica.gera(ses, ht_conteudo, None)
return pag
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)
# ----------------------------------------------------------------------
# Sessao de teste de usuário comum:
ses_com = sessao.busca_por_identificador("S-00000001")
assert ses_com != None
assert not sessao.eh_administrador(ses_com)
# Usuario comum de teste:
usr_com = sessao.obtem_usuario(ses_com)
assert usr_com != None
usr_com_id = usuario.obtem_identificador(usr_com)
usr_com_atrs = usuario.obtem_atributos(usr_com)
# Sessao de teste de administrador:
ses_adm = sessao.busca_por_identificador("S-00000004")
assert ses_adm != None
assert sessao.eh_administrador(ses_adm)
# Usuario administrador de teste:
usr_adm = sessao.obtem_usuario(ses_adm)
assert usr_adm != None
usr_adm_id = usuario.obtem_identificador(usr_adm)
usr_adm_atrs = usuario.obtem_atributos(usr_adm)
# Trechos de teste (somente id):
trc1_id = "T-00000001" # Não encerrado.
pretty = False # Se {True}, formata HTML para legibilidate (mas introduz brancos nos textos).
utils_testes.testa_gera_html(modulo, funcao, rotulo, frag, pretty, *args)
# fixtures
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)
# Testes das funções de {gera_html_form}:
usr1 = usuario.busca_por_identificador("U-00000001")
assert usr1 != None
id_usr1 = usuario.obtem_identificador(usr1)
atrs_usr1 = usuario.obtem_atributos(usr1)
assert not usuario.obtem_atributo(usr1, 'administrador')
usr3 = usuario.busca_por_identificador("U-00000003")
assert usr3 != None
id_usr3 = usuario.obtem_identificador(usr3)
atrs_usr3 = usuario.obtem_atributos(usr3)
assert usuario.obtem_atributo(usr3, 'administrador')
atrs_usr0 = atrs_usr1
del atrs_usr0['nome']
del atrs_usr0['telefone']
ht_bt_coisar = html_botao_submit.gera("Coisar", "coisar", {'coisa': "568"},
"#ffaa00")
def gera(cpr, editavel, texto_bt, comando_bt):
# Obtem atributos a mostrar:
valores = {}.copy()
id_cpr = compra.obtem_identificador(cpr)
atrs_cpr = compra.obtem_atributos(cpr)
# Atributos da compra em si
valores['id_cpr'] = id_cpr
valores['status'] = atrs_cpr['status']
valores['nome_pass'] = atrs_cpr['nome_pass']
valores['doc_pass'] = atrs_cpr['doc_pass']
valores['preco_tot'] = ("%.2f" % compra.calcula_preco(cpr))
# valores['pagamento'] = atrs_cpr['pagamento']
# Cliente que está montando ou montou a compra:
usr = compra.obtem_cliente(cpr)
valores['id_usr'] = usuario.obtem_identificador(usr)
atrs_usr = usuario.obtem_atributos(usr)
valores['nome_usr'] = atrs_usr['nome']
# Bilhetes da compra:
ids_pols = compra.obtem_poltronas(cpr)
num_trechos = len(ids_pols)
valores['n_trechos'] = str(num_trechos)
if (num_trechos >= 1):
# Obtém origem, data, e hora de partida do primeiro trecho:
pol_ini = poltrona.busca_por_identificador(ids_pols[0])
id_trc_ini = poltrona.obtem_atributo(pol_ini, 'id_trecho')
trc_ini = trecho.busca_por_identificador(id_trc_ini)
origem = trecho.obtem_atributo(trc_ini, 'origem')
dh_partida = trecho.obtem_dia_e_hora_de_partida(trc_ini)
valores['partida'] = origem + " " + dh_partida
# Obtém destino, data, e hora de chegada do último trecho:
pol_fin = poltrona.busca_por_identificador(ids_pols[-1])
id_trc_fin = poltrona.obtem_atributo(pol_fin, 'id_trecho')
trc_fin = trecho.busca_por_identificador(id_trc_fin)
destino = trecho.obtem_atributo(trc_fin, 'destino')
dh_chegada = trecho.obtem_dia_e_hora_de_chegada(trc_fin)
valores['chegada'] = destino + " " + dh_chegada
# Linhas para {html_table.gera}:
linhas = (
html_cpr_campo("Compra", 'id_cpr', valores, 'text', None, False),
html_cpr_campo("Cliente", 'id_usr', valores, 'text', None, False),
html_cpr_campo("Nome do cliente", 'nome_usr', valores, 'text', None,
False),
html_cpr_campo("Nome do passageiro", 'nome_pass', valores, 'text',
"Fulano da Silva", editavel),
html_cpr_campo("Documento do passageiro", 'doc_pass', valores, 'text',
"123.456.789-10", editavel),
html_cpr_campo("Número de trechos", 'n_trechos', valores, 'text', None,
False),
html_cpr_campo("Preço total", 'preco_tot', valores, 'text', None,
False),
html_cpr_campo("Estado", 'status', valores, 'text', None, False),
html_cpr_campo("Partida", 'partida', valores, 'text', None, False),
html_cpr_campo("Chegada", 'chegada', valores, 'text', None, False),
)
ht_campos = html_table.gera(linhas, ["", ""])
# Botões:
if editavel:
args_submit = {
'id_compra': id_cpr
} # Argumentos adicionais para submissão.
ht_submit = html_botao_submit.gera(texto_bt, comando_bt, args_submit,
"#44ff44")
ht_campos += "<br/>" + ht_submit
return html_form.gera(ht_campos)
def cria_testes(verb):
global cache, nome_tb, letra_tb, colunas, diags
inicializa(True)
lista_atrs = \
[
{ # U-00000001
'nome': "José Primeiro",
'senha': "123456789",
'email': "*****@*****.**",
'CPF': "123.456.789-00",
'telefone': "+55(19)9 9876-5432",
'documento': "1.234.567-9 SSP-SP",
'milhagem': 100,
'administrador': False,
},
{ # U-00000002
'nome': "João Segundo",
'senha': "987654321",
'email': "*****@*****.**",
'CPF': "987.654.321-99",
'telefone': "+55(19)9 9898-1212",
'documento': 'CD98765-43 PF',
'milhagem': 200,
'administrador' : False,
},
{ # U-00000003
'nome': "Juca Terceiro",
'senha': "333333333",
'email': "*****@*****.**",
'CPF': "111.111.111-11",
'telefone': "+55(19)9 9999-9999",
'documento': None,
'milhagem': None,
'administrador' : True,
},
{ # U-00000004
'nome': "Jurandir Quarto",
'senha': "111111111",
'email': "*****@*****.**",
'CPF': "222.222.222-22",
'telefone': "+55(19)9 9898-1211",
'documento': '1.234.567-8 SSP-SP',
'milhagem': 400,
'administrador' : False,
},
{ # U-00000005
'nome': "Josenildo Quinto",
'senha': "222222222",
'email': "*****@*****.**",
'CPF': "333.333.333-33",
'telefone': "+55(19)9 9898-1213",
'documento': '1.234.567-7 SSP-SP',
'milhagem': 500,
'administrador' : False,
},
{ # U-00000006
'nome': "Julio Sexto",
'senha': "444444444",
'email': "*****@*****.**",
'CPF': "444.444.444-44",
'telefone': "+55(19)9 9898-1214",
'documento': '1.234.567-6 SSP-SP',
'milhagem': 600,
'administrador' : False,
},
{ # U-00000007
'nome': "Jeferson Setimo",
'senha': "555555555",
'email': "*****@*****.**",
'CPF': "555.555.555-55",
'telefone': "+55(19)9 9898-1215",
'documento': '1.234.567-5 SSP-SP',
'milhagem': 700,
'administrador' : False,
},
{ # U-00000008
'nome': "Joaquim Oitavo",
'senha': "666666666",
'email': "*****@*****.**",
'CPF': "666.666.666-66",
'telefone': "+55(19)9 9898-1216",
'documento': '1.234.567-4 SSP-SP',
'milhagem': None,
'administrador' : True,
},
{ # U-00000009
'nome': "Jonas Nono",
'senha': "777777777",
'email': "*****@*****.**",
'CPF': "777.777.777-77",
'telefone': "+55(19)9 9898-1217",
'documento': '1.234.567-3 SSP-SP',
'milhagem': None,
'administrador' : True,
},
]
for atrs in lista_atrs:
usr = cria(atrs)
assert usr != None and type(usr) is usuario.Objeto_Usuario
id_usr = usuario.obtem_identificador(usr)
nome = usuario.obtem_atributo(usr, 'nome')
if verb:
sys.stderr.write("usuário %s = \"%s\" criado\n" % (id_usr, nome))
return
def gera(ses, usr, atrs, erros):
# Obtem usuário da sessão, determina privilégios:
usr_ses = None if ses == None else sessao.obtem_usuario(ses)
if usr_ses == None:
# Usuário que pediu não está logado:
admin = False
mesmo = False
else:
assert type(usr_ses) is usuario.Objeto_Usuario
admin = usuario.obtem_atributo(usr_ses, "administrador")
mesmo = (usr_ses == usr)
if atrs == None: atrs = {}.copy() # Por via das dúvidas.
ht_submit = ""
ht_bt_cancel = ""
if usr == None:
# Cadastramento de novo usuário:
id_usr = None
ht_submit += html_botao_submit.gera("Cadastrar", "cadastrar_usuario",
None, "#ff0000")
titulo = "Novo usuário"
else:
# Visualização/alteração de usuário existente:
assert usr_ses != None, "operação não autorizada sem login"
assert admin or mesmo, "usuário não está autorizado a efetuar esta operação"
assert type(usr) is usuario.Objeto_Usuario
id_usr = usuario.obtem_identificador(usr)
assert id_usr != None # Paranóia.
if mesmo:
titulo = f"Sua conta"
else:
titulo = f"Usuário {id_usr}"
# Completa {atrs} com atributos de {usr}:
atrs_usr = usuario.obtem_atributos(usr)
assert atrs_usr != None # Paranóia
for ch, val in atrs_usr.items():
if not ch in atrs: atrs[ch] = val
# Botoes de ação:
ht_submit += html_botao_submit.gera("Alterar", "alterar_usuario", None,
"#ff0000")
ht_bt_cancel = html_botao_simples.gera("Voltar", 'principal', None,
"#ff2200")
ht_titulo = "<h2>" + titulo + "</h2>"
# Cria formulário:
ht_form = html_form_dados_de_usuario.gera(id_usr, atrs, admin, ht_submit)
# Botoes adicionais:
ht_bt_linhas = [].copy()
if usr != None and not mesmo:
# Botões para administrador ver objetos associados a usuário:
args_bt = {'id': id_usr}
estilo_n = "font-family:\"Courier\";font-size:20;"
n_compras = len(usuario.compras_abertas(usr))
ht_n_compras = html_span.gera(estilo_n, str(n_compras))
ht_bt_compras = html_botao_simples.gera("Ver compras",
"ver_compras_de_usuario",
args_bt, '#eeee55')
ht_bt_linhas.append((
html_label.gera("Compras abertas", ":"),
ht_n_compras,
ht_bt_compras,
))
n_sessoes = len(usuario.sessoes_abertas(usr))
ht_n_sessoes = html_span.gera(estilo_n, str(n_sessoes))
ht_bt_sessoes = html_botao_simples.gera("Ver sessões",
"ver_sessoes_de_usuario",
args_bt, '#eeee55')
ht_bt_linhas.append((
html_label.gera("Sessoes abertas", ":"),
ht_n_sessoes,
ht_bt_sessoes,
))
n_poltronas = len(usuario.poltronas_abertas(usr))
ht_n_poltronas = html_span.gera(estilo_n, str(n_poltronas))
ht_bt_poltronas = html_botao_simples.gera("Ver poltronas",
"ver_poltronas_de_usuario",
args_bt, '#eeee55')
ht_bt_linhas.append((
html_label.gera("Poltronas abertas", ":"),
ht_n_poltronas,
ht_bt_poltronas,
))
ht_bts_ver_coisas = html_table.gera(ht_bt_linhas, (
"",
"",
))
ht_conteudo = \
ht_titulo + \
ht_form + "<br/>\n" + \
ht_bts_ver_coisas + "<br/>" + \
ht_bt_cancel
pag = html_pag_generica.gera(ses, ht_conteudo, erros)
return pag
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)
# Sessao de teste:
ses = sessao.busca_por_identificador("S-00000001")
assert ses != None
# Usuario teste:
usr1 = sessao.obtem_usuario(ses)
assert usr1 != None
usr1_id = usuario.obtem_identificador(usr1)
usr1_atrs = usuario.obtem_atributos(usr1)
def testa(rotulo, *args):
"""Testa {funcao(*args)}, grava resultado
em "testes/saida/{modulo}.{funcao}.{rotulo}.html"."""
modulo = html_pag_buscar_compras
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)
for admin in (False, True):
id_usr = args['id_usuario']
usr = usuario.busca_por_identificador(id_usr)
atrs_usr = usuario.obtem_atributos(usr)
for ch, val in atrs_usr.items():
if ch in args:
assert val == args[ch], (
"campo '%s' = '%s' não foi alterado para '%s'\n" %
(ch, val, args[ch]))
# ----------------------------------------------------------------------
# Usuário comum alterando seus próprios dados:
ses_com1 = sessao.busca_por_identificador("S-00000001")
usr_com1 = sessao.obtem_usuario(ses_com1)
assert not usuario.obtem_atributo(usr_com1, 'administrador')
id_usr_com1 = usuario.obtem_identificador(usr_com1)
args_alt1_com1 = args = {
'id_usuario': id_usr_com1,
'nome': "John First",
'telefone': "007",
'senha': "111",
'conf_senha': "111",
}
testa_atualiza_atributo("sesC-usrC", ses_com1, args_alt1_com1)
# ----------------------------------------------------------------------
# Administrador alterando usuário comum e promovendo a administrador:
ses_adm3 = sessao.busca_por_identificador("S-00000004")
usr_adm3 = sessao.obtem_usuario(ses_adm3)
