def gera_botoes_linha_1_logado(nome_usuario, admin):
"""Gera uma lista de fragmentos HTML com os botões da linha 1 do menu
geral, para um usuário que está logado."""
botoes_sempre = (html_botao_simples.gera("Minha Conta",
'solicitar_pag_alterar_usuario',
None, '#eeeeee'),
html_botao_simples.gera("Minhas Sessões",
'ver_minhas_sessoes', None,
'#eeeeee'),
html_botao_simples.gera("Contato",
'solicitar_pag_contato', None,
'#eeeeee'),
html_botao_simples.gera("Sair", 'fazer_logout', None,
'#eeeeee'),
gera_nome_usuario(nome_usuario))
if admin:
html_botao_simples.gera("Buscar usuários", 'buscar_usuarios', None,
'#eeeeee'),
html_botao_simples.gera("Buscar compras", 'buscar_compras', None,
'#eeeeee'),
botoes_compras = ()
else:
botoes_compras = (
html_botao_simples.gera("Meu Carrinho", 'ver_carrinho', None,
'#eeeeee'),
html_botao_simples.gera("Minhas Compras", 'ver_minhas_compras',
None, '#eeeeee'),
)
return botoes_sempre + botoes_compras
def gera(rot, ver):
# Obtem resumo do roteiro (dicionário):
resumo = roteiro.obtem_resumo(rot)
# Formata campos:
# Porto, dia, e hora de partida do primeiro trecho:
ht_origem = resumo['origem']
ht_dt_partida = resumo['dia_partida'] + " " + resumo[
'hora_partida'] + " UTC"
# Porto, dia, e hora de chegada do último trecho:
ht_destino = resumo['destino']
ht_dt_chegada = resumo['dia_chegada'] + " " + resumo[
'hora_chegada'] + " UTC"
ht_num_escalas = "%2d" % resumo['num_escalas']
ht_preco_min = "%7.2f" % resumo['preco_min']
campos = [
ht_origem, ht_dt_partida, ht_destino, ht_dt_chegada, ht_num_escalas,
ht_preco_min
]
if ver:
ids_trechos = roteiro.obtem_identificadores_de_trechos(rot)
ids_trechos_txt = ",".join(ids_trechos)
ht_ver = html_botao_simples.gera("Ver", "ver_roteiro",
{'ids_trechos': ids_trechos_txt},
"#22ff22")
campos.append(ht_ver)
ht_comprar = html_botao_simples.gera("Comprar", "comprar_roteiro",
{'ids_trechos': ids_trechos_txt},
"#ffff22")
campos.append(ht_comprar)
return campos
def gera_botoes_linha_1(logado, nome_usuario, admin):
"""Gera uma lista de fragmentos de HTML que descrevem os botões da linha 1 do menu
geral. Estes botões são mostrados para todos os usuários, mas
dependem do tipo de usuário (normal ou administrador) e se o
usuário está logado."""
# Botões da primeira linha que sempre aparecem:
ht_bt_principal = html_botao_simples.gera("Principal", 'principal', None,
'#60a3bc')
ht_bt_ofertas = html_botao_simples.gera("Ofertas", 'solicitar_pag_ofertas',
None, '#ffdd22')
ht_bt_trechos = html_botao_simples.gera("Buscar Trechos",
'solicitar_pag_buscar_trechos',
None, '#eeeeee')
ht_bt_roteiros = html_botao_simples.gera("Sugerir Roteiros",
'solicitar_pag_sugerir_roteiros',
None, '#eeeeee')
botoes = (ht_bt_principal, ht_bt_ofertas, ht_bt_trechos, ht_bt_roteiros)
if logado:
# Gera outros botões de usuario normal logado
botoes += gera_botoes_linha_1_logado(nome_usuario, admin)
else:
# Gera outros botões de usuário deslogado:
botoes += gera_botoes_linha_1_deslogado()
return botoes
def gera_botoes_linha_2():
"""Gera uma lista de fragmentos de HTML com os botões da linha 2 do menu
geral. Estes botões são mostrados apenas se o usuário está logado
e é um administrador."""
ht_input = html_input.gera(None, "text", "id", None, None, True, True,
"Id do objeto", None)
ht_bt_submit = html_botao_submit.gera("Checar Objeto", "ver_objeto", None,
'#ffdd22')
form_content = \
ht_input + \
ht_bt_submit
ht_input2 = html_input.gera(None, "text", "passageiro", None, None, True,
True, "Nome ou documento", None)
ht_bt_submit2 = html_botao_submit.gera("Buscar passageiro",
"buscar_compras", None, '#ffdd22')
form_content2 = \
ht_input2 + \
ht_bt_submit2
botoes = (
html_botao_simples.gera("Acrescentar trecho",
"solicitar_pag_acrescentar_trecho", None,
'#ffdd22'),
html_botao_simples.gera("Trafego", "comando_relatorio_de_trafego",
None, '#FF00FF'), html_form.gera(form_content),
html_form.gera(form_content2)
# html_botao_simples.gera("Alterar trecho", "solicitar_pag_alterar_trecho", None, '#ffdd22'),
# html_form_passageiros.gera(),
# html_form_buscar_objeto.gera(),
)
return botoes
def gera_botoes_linha_1_deslogado():
"""Gera uma lista de fragmentos HTML com os botões da linha 1 do menu
geral, para um usuário que não está logado."""
botoes = (
html_botao_simples.gera("Entrar", 'solicitar_pag_login', None,
'#55ee55'),
html_botao_simples.gera("Cadastrar", 'solicitar_pag_cadastrar_usuario',
None, '#eeeeee'),
)
return botoes
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 gera(pol, id_compra, ver, excluir):
# Atributos da poltrona:
id_pol = poltrona.obtem_identificador(pol)
atrs_pol = poltrona.obtem_atributos(pol)
assert atrs_pol['id_compra'] == id_compra
preco_pol = atrs_pol['preco']
numero_pol = atrs_pol['numero']
# Atributos do trecho da poltrona
id_trecho = atrs_pol['id_trecho']
trc = trecho.busca_por_identificador(id_trecho)
atrs_trc = trecho.obtem_atributos(trc)
origem_trc = atrs_trc['origem']
dt_partida_trc = atrs_trc['dia_partida'] + ' ' + atrs_trc['hora_partida']
destino_trc = atrs_trc['destino']
dt_chegada_trc = atrs_trc['dia_chegada'] + ' ' + atrs_trc['hora_chegada']
# Campos da linha para {html_table.gera}:
ht_trecho = html_span.gera(None, id_trecho)
ht_origem = html_span.gera(None, origem_trc)
ht_dt_partida = html_span.gera(None, dt_partida_trc)
ht_destino = html_span.gera(None, destino_trc)
ht_dt_chegada = html_span.gera(None, dt_chegada_trc)
ht_numero = html_span.gera(None, numero_pol)
ht_preco = html_span.gera(None, preco_pol)
linha = [ \
ht_trecho, ht_origem, ht_dt_partida, ht_destino, ht_dt_chegada,
ht_numero, ht_preco
]
ver = True # Por enquanto.
if ver:
args_ver = {'id_poltrona': id_pol}
ht_ver = html_botao_simples.gera("Ver", 'ver_poltrona', args_ver,
'#60a3bc')
linha.append(ht_ver)
linha.append("</form>")
if excluir:
args_excluir = {'id_poltrona': id_pol, 'id_compra': id_compra}
ht_excluir = html_botao_simples.gera("Excluir", 'excluir_poltrona',
args_excluir, '#ff4422')
linha.append(ht_excluir)
return linha
def gera(ses, rot, erros):
ver_roteiro = False # Já estamos vendo o roteiro.
campos_resumo = html_resumo_de_roteiro.gera(rot, ver_roteiro)
ht_resumo = "".join(str(campos_resumo))
# ??? EXPANDIR COMO {html_pag_ver_compra}
alterar_trcs = False # Não deve ter botões de "Alterar".
ht_trechos = html_lista_de_trechos.gera(rot, alterar_trcs)
ht_conteudo = ht_resumo + "<br/>" + ht_trechos
ids_trechos = roteiro.obtem_identificadores_de_trechos(rot)
ids_trechos_txt = ",".join(ids_trechos)
# verifica se todos os trechos estao disponivels
roteiro_disponivel = True
for id_trc in ids_trechos:
trc = trecho.busca_por_identificador(id_trc)
roteiro_disponivel = roteiro_disponivel and not trecho.obtem_atributo(trc, 'encerrado')
if roteiro_disponivel:
atrs_comprar = {'ids_trechos': ids_trechos_txt}
ht_comprar = html_botao_simples.gera("Comprar", "comprar_roteiro", atrs_comprar, "#22ff22")
ht_conteudo += "<br/>" + ht_comprar
pag = html_pag_generica.gera(ses, ht_conteudo, erros)
return pag
def gera(ses, cpr, erros):
id_compra = compra.obtem_identificador(cpr);
ht_form = html_form_escolher_pagamento.gera(cpr)
ht_cancelar = html_botao_simples.gera("Cancelar", "principal", None, "#ffff00")
ht_conteudo = html_form.gera(ht_form + " " + ht_cancelar)
pag = html_pag_generica.gera(ses, ht_conteudo, erros)
return pag
def gera(atrs, admin):
# Dados para {html_form_table.gera}
# {(rotulo,tipo,chave,dica,visivel,editavel,obrigatorio)}
dados_linhas = ((
"Usuário",
"text",
"id_usuario",
"U-xxxxxxxx",
True,
True,
True,
), )
ht_table = html_form_table.gera(dados_linhas, atrs)
ht_submit = html_botao_submit.gera("Buscar", "buscar_compras", None,
'#55ee55')
ht_cancel = html_botao_simples.gera("Cancelar", "principal", None,
'#ff2200')
ht_conteudo = \
ht_table + \
ht_submit + \
ht_cancel
return html_form.gera(ht_conteudo)
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(atrs, admin):
# Dados para {html_form_table.gera}
# {(rotulo,tipo,chave,dica,visivel,editavel,obrigatorio)}
dados_linhas = (
( "Nome", "text", "nome", "Fulano de tal", True, True, False, ),
( "documento", "text", "documento", "RG 4.444.444-4 SSP SP", True, True, False, ),
( "email", "email", "email", "*****@*****.**", True, True, False, ),
( "telefone", "text", "telefone", "(XX) XXXX-XXXX", True, True, False, ),
( "CPF", "text", "cpf", "XXX.XXX.XXX-XX", True, True, False, ),
)
ht_table = html_form_table.gera(dados_linhas, atrs)
ht_submit = html_botao_submit.gera("Buscar", "buscar_usuarios", None, '#55ee55')
ht_cancel = html_botao_simples.gera("Cancelar", "principal", None, '#ff2200')
ht_conteudo = \
ht_table + \
ht_submit + \
ht_cancel
return html_form.gera(ht_conteudo)
def processa(ses, args):
assert ses != None
assert sessao.aberta(ses)
usr_ses = sessao.obtem_usuario(ses)
if 'id_sessao' in args:
id_sessao = args['id_sessao']
sesaux = sessao.busca_por_identificador(id_sessao)
if sesaux == None or sessao.obtem_usuario(sesaux) != usr_ses:
pag = html_erro.gera('id de sessão inválido')
else:
ht_conteudo = html_form_dados_de_sessao.gera(sesaux)
args_bt = {'id_sessao': id_sessao}
ht_conteudo += html_botao_simples.gera("Fechar sessão",
'fechar_sessao', args_bt,
'#FFA700')
pag = html_pag_generica.gera(ses, ht_conteudo, None)
else:
pag = html_erro.gera('Chamada sem argumentos')
return pag
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
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
def gera(id_usr, atrs, admin, ht_bt_submit):
# Para simplificar:
if atrs == None: atrs = {}.copy()
novo = (id_usr == None)
if novo:
# Não deve haver 'id_usr' no formulário:
if 'id_usuario' in atrs:
del atrs['id_usuario'] # Por via das dúvidas.
else:
# Inclui campo 'id_usr' no formulário:
atrs['id_usuario'] = id_usr
# Limpa 'senha' e 'conf_senha':
if 'senha' in atrs: del atrs['senha']
if 'conf_senha' in atrs: del atrs['conf_senha']
# Dados para {html_form_table.gera}
# {(rotulo,tipo,chave,dica,visivel,editavel,obrigatorio)}
cps = [].copy()
if not novo:
id_edit = False
id_vis = admin
cps.append((
"ID",
"text",
"id_usuario",
None,
id_vis,
id_edit,
True,
))
cps.append((
"Nome",
"text",
"nome",
None,
True,
True,
True,
))
ec_edit = novo # Email e CPF editáveis apenas na criação.
cps.append((
"E-mail",
"email",
"email",
"*****@*****.**",
True,
ec_edit,
True,
))
cps.append((
"CPF",
"text",
"CPF",
"xxx.xxx.xxx-xx",
True,
ec_edit,
True,
))
cps.append((
"Telefone",
"text",
"telefone",
"+xx(xx)x-xxxx-xxxx",
True,
True,
True,
))
cps.append((
"Documento",
"text",
"documento",
"Número, tipo, órgão",
True,
True,
True,
))
cps.append((
"Milhagem",
"text",
"milhagem",
"Número não-negativo",
True,
id_vis,
True,
))
cps.append((
"Senha",
"password",
"senha",
None,
True,
True,
True,
))
cps.append((
"Confirmar senha",
"password",
"conf_senha",
None,
True,
True,
True,
))
if admin:
# Checkbox não pode ser obrigatório porque significa "Obrig. True".
cps.append((
"Administrador",
"checkbox",
"administrador",
None,
True,
True,
False,
))
ht_table = html_form_table.gera(cps, atrs)
ht_bt_cancel = html_botao_simples.gera("Cancelar", 'principal', None,
'#ee5555')
ht_campos = \
ht_table + \
ht_bt_submit + \
ht_bt_cancel
return html_form.gera(ht_campos)
def gera(atrs, admin):
# Dados para {html_form_table.gera}
# {(rotulo,tipo,chave,dica,visivel,editavel,obrigatorio)}
dados_linhas = (
(
"Nome",
"text",
"nome",
"Nome",
True,
True,
True,
),
(
"Email",
"text",
"email",
"Email",
True,
True,
True,
),
(
"Telefone",
"text",
"telefone",
"Telefone",
True,
True,
True,
),
(
"Assunto",
"text",
"assunto",
"Assunto",
True,
True,
True,
),
(
"Mensagem",
"textarea",
"mensagem",
"Digite sua mensagem aqui",
True,
True,
True,
),
)
ht_table = html_form_table.gera(dados_linhas, atrs)
ht_submit = html_botao_submit.gera("Enviar", "enviar_msg_contato", None,
'#55ee55')
ht_cancel = html_botao_simples.gera("Cancelar", "principal", None,
'#ff2200')
ht_conteudo = \
ht_table + \
ht_submit + \
ht_cancel
return html_form.gera(ht_conteudo)
def gera(ses, cpr, atrs, erros):
# Validação dos parâmetros:
assert ses != None # Paranóia (cliente deslogado não deve poder ver compra nenhuma).
assert sessao.aberta(ses) # Paranóia.
usr_ses = sessao.obtem_usuario(ses)
assert usr_ses != None # Paranóia.
admin = usuario.obtem_atributo(usr_ses, 'administrador')
carr = None if admin or ses == None else sessao.obtem_carrinho(ses)
if atrs == None: atrs = {}.copy() # Por via das dúvidas.
# Botões de acão:
ht_submit = ""
ht_bt_def_carr = ""
ht_bt_cancel = ""
args_bt = {'id_compra': id_cpr}
if cpr == None:
# Nova compra:
assert not admin # Paranóia (administrador não deve poder criar novas compras).
id_cpr = None
novo = True
titulo = "Nova compra"
else:
assert type(cpr) is compra.Objeto_Compra
usr_cpr = compra.obtem_cliente(cpr)
assert usr_cpr != None # Paranóia.
assert admin or (
usr_ses == usr_cpr
) # Paranóia (cliente comum só pode ver compras suas).
id_cpr = compra.obtem_identificador(cpr)
assert id_cpr != None # Paranóia.
# Título da página:
if admin:
titulo = f"Compra {id_compra}"
elif cpr == carr:
titulo = "Seu carrinho de compras"
else:
titulo = f"Sua compra {id_compra}"
ht_bt_def_carr = html_botao_simples.gera("Definir como carrinho",
"definir_carrinho",
args_bt, "#44ff00")
# Completa {atrs} com atributos de {cpr}:
atrs_cpr = compra.obtem_atributos(cpr)
assert atrs_cpr != None # Paranóia
for ch, val in atrs_cpr.items():
if not ch in atrs: atrs[ch] = val
# Botoes de ação:
# O submit é "Alterar":
ht_submit += html_botao_submit.gera("Alterar", "alterar_compra", None,
"#ff0000")
if not admin and (compra.obtem_status(cpr) == 'comprando'):
# Tem botão submit de "Finalizar compra" que aplica alterações:
ht_submit += html_botao_submit.gera("Finalizar",
"finalizar_compra", None,
"#55ff00")
ht_bt_cancel = html_botao_simples.gera("Continuar comprando",
'principal', None,
"#ff2200")
else:
ht_bt_cancel = html_botao_simples.gera("Voltar", 'principal', None,
"#ff2200")
ht_titulo = "<h2>" + titulo + "</h2>"
# Constrói formulário com dados da compra:
ht_dados_da_compra = html_form_dados_de_compra.gera(
id_cpr, atrs, admin, ht_submit)
# Constrói a lista de poltronas da compra:
if novo:
ht_dados_das_poltronas = ""
else:
ids_pols = poltrona.busca_por_compra(cpr)
if len(ids_pols) == 0:
# Não há poltronas a mostrar.
estilo_aviso = "color:red;font-size:20;"
ht_dados_das_poltronas = "<br/>" + html_span.gera(
estilo_aviso, "Não há poltronas disponíveis")
else:
ht_dados_das_poltronas = html_lista_de_poltronas_de_compra.gera(
ids_pols, usr_ses, carr)
# Verifica tempos de baldeação:
poltronas_invalidas = compra.verificar_baldeacao(cpr)
if erros is None: erros = [].copy()
for id_poltrona in poltronas_invalidas:
erros.append(f'Poltrona sem tempo para baldeação: {id_poltrona}')
ht_conteudo = \
ht_titulo + "\n" + \
ht_dados_da_compra + "<br/>\n" + \
ht_bt_def_carr + "\n" + \
ht_bt_cancel + "<br/>\n" + \
ht_dados_das_poltronas
pag = html_pag_generica.gera(ses, ht_conteudo, erros)
return pag
import utils_testes
def testa(rotulo, *args):
"""Testa {funcao(*args)}, grava resultado
em "testes/saida/{modulo}.{funcao}.{rotulo}.html"."""
modulo = html_table
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)
linhas = [].copy()
label_de_teste_input = html_label.gera("Teste das funcionalidades de html_table, coloque um input aqui embaixo", ":")
input_de_teste = html_input.gera(None, "text", "input", None, None, True, False, "Me edite!", None)
label_de_teste_botao = html_label.gera("Aperte o botão para ser redirecionado à URL principal", "!")
botao_de_teste = html_botao_simples.gera("OK", 'principal', None, '#55ee55')
erro_de_teste_html = html_erro.gera("Houston, we've got a problem. Nevermind, this is just a Test!")
cabecalho=("Coluna 1", "Coluna 2")
linhas.append((label_de_teste_input, input_de_teste))
linhas.append((label_de_teste_botao, botao_de_teste))
linhas.append((erro_de_teste_html, botao_de_teste))
testa("Teste", linhas, cabecalho)
def gera(ses, erros):
ht_botao = html_botao_simples.gera("OK", 'principal', None, '#55ee55')
pagina = html_pag_generica.gera(ses, ht_botao, erros)
return pagina
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 testa(rotulo, *args):
"""Testa {funcao(*args)}, grava resultado
em "testes/saida/{modulo}.{funcao}.{rotulo}.html"."""
modulo = html_form_dados_de_poltrona
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)
ht_submit = ""
ht_submit += html_botao_submit.gera("Escovar", "escovar_poltrona", None,
"#ffff00")
ht_submit += html_botao_simples.gera("Repensar", "repensar_a_vida",
{'coisa': "418"}, "#00cc00")
pol1_id = "A-00000001"
pol1 = poltrona.busca_por_identificador(pol1_id)
pol1_atrs = {}
pol1_id_cpr = None
testa("pol1_alterar_vazio", pol1_id, pol1_atrs, True, ht_submit)
pol2_id = "A-00000007"
pol2 = poltrona.busca_por_identificador(pol2_id)
pol2_atrs = {'preco': 23.45, 'id_trecho': "T-00000231", 'numero': "99F"}
assert poltrona.obtem_atributo(pol2, 'id_compra') == None
pol2_id_cpr = None
testa("pol2_alterar_alguns", pol2_id, pol2_atrs, True, ht_submit)
pol3_id = "A-00000003"
def gera(atrs, admin):
ht_cabe = html_cabecalho.gera("Busca de trechos", False)
# Dados para {html_form_table.gera}
# {(rotulo,tipo,chave,dica,visivel,editavel,obrigatorio)}
dados_linhas = ((
"Origem",
"text",
"origem",
"Código do aeroporto",
True,
True,
False,
), (
"Data mínima de partida",
"text",
"dia_partida",
"aaaa-mm-dd",
True,
True,
False,
), (
None,
"text",
"hora_partida",
"hh:mm",
True,
True,
False,
), (
"Destino",
"text",
"destino",
"Código do aeroporto",
True,
True,
False,
), (
"Data máxima de chegada",
"text",
"dia_chegada",
"aaaa-mm-dd",
True,
True,
False,
), (
None,
"text",
"hora_chegada",
"hh:mm",
True,
True,
False,
), ("Veiculo", "text", "veiculo", "Código do veiculo", admin, True, False))
ht_table = html_form_table.gera(dados_linhas, atrs)
ht_submit = html_botao_submit.gera("Buscar", "buscar_trechos", None,
'#55ee55')
ht_cancel = html_botao_simples.gera("Cancelar", "principal", None,
'#ff2200')
ht_conteudo = \
ht_cabe + "<br/>\n" + \
ht_table + \
ht_submit + \
ht_cancel
return html_form.gera(ht_conteudo)
def gera(ses, ses_ver, erros):
# Validação dos parâmetros:
assert ses != None # Paranóia (cliente deslogado não deve poder ver compra nenhuma).
assert sessao.aberta(ses) # Paranóia.
usr_ses = sessao.obtem_usuario(ses)
assert usr_ses != None # Paranóia.
admin = usuario.obtem_atributo(usr_ses, 'administrador')
assert ses_ver != None # Paranóia.
assert type(ses_ver) is sessao.Objeto_Sessao
usr_ses_ver = sessao.obtem_usuario(ses_ver)
assert admin or (usr_ses_ver == usr_ses
) # Usuário comum só pode ver sessões suas.
# Botões de acão:
ht_submit = ""
ht_bt_cancel = ""
ht_dados_da_sessao = ""
id_ses_ver = sessao.obtem_identificador(ses_ver)
assert id_ses_ver != None # Paranóia.
# Título da página:
if ses_ver == ses:
titulo = f"Sua sessao corrente {id_sessao}"
elif usr_ses_ver == usr_ses:
titulo = f"Sua sessao {id_sessao}"
else:
titulo = f"Sessao {id_sessao}"
# Botoes de ação:
# O submit por enquanto é só "Fechar":
args_bt = {'id_sessao': id_ses_ver}
ht_submit += html_botao_submit.gera("Fechar", "fechar_sessao", None,
"#ff0000")
ht_bt_cancel = html_botao_simples.gera("Voltar", 'principal', None,
"#ff2200")
ht_titulo = "<h2>" + titlulo + "</h2>"
# Completa {atrs} com atributos de {ses_ver}:
atrs = {}
args_ses_ver = sessao.obtem_atributos(ses_ver)
assert atrs_ses_ver != None # Paranóia
for ch, val in atrs_ses_ver.items():
if not ch in atrs: atrs[ch] = val
# Constrói formulário com dados do trecho:
ht_dados_da_sessao = html_form_dados_de_sessao.gera(
id_ses_ver, atrs, admin, ht_submit)
ht_conteudo = \
ht_titulo + "\n" + \
ht_dados_da_sessao + "<br/>" + \
ht_bt_cancel
pag = html_pag_generica.gera(ses, ht_conteudo, erros)
return pag
ht_bloco_ses = html_form_dados_de_sessao.gera(ses_ver)
# Somente gera botão caso o usuário da sessao atual seja administrador e a sessão selecionada esteja aberta
if (sessao.eh_administrador(ses) and sessao.aberta(ses_ver)):
args = {}
args['id_sessao'] = sessao.obtem_identificador(ses_ver)
# TODO: escolher cores melhores para os botões
fecha_btn = html_botao_simples.gera('Fechar sessão', 'fechar_sessao',
args, 'green')
ht_bloco_ses += fecha_btn
pag = html_pag_generica.gera(ses, ht_bloco_ses, erros)
return pag
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