def processa(ses, args):
try:
if not sessao.eh_administrador(ses):
raise ErroAtrib("Precisa ser administrador para executar esse comando.")
campos = ['email', 'CPF']
if not verifica_pelo_menos_um_campo(campos, args):
raise ErroAtrib("Pelo menos ou o CPF ou o email precisa estar preenchido")
# Em virtude da função {verifica_pelo_menos_um_campo}, temos a garantia de haver pelos menos o CPF ou o email
if 'email' in args:
id_usuario = usuario.busca_por_email(args['email'])
else:
id_usuario = usuario.busca_por_CPF(args['CPF'])
if id_usuario is None:
raise ErroAtrib("Não foi encontrado um usuário com os dados fornecidos")
bloco = html_lista_de_usuarios.gera([id_usuario])
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_usuarios.gera(ses, args, sessao.eh_administrador(ses), erros)
return pag
def gera(ses, atrs, admin, erros): # Constrói formulário com dados: ht_dados = html_form_buscar_trechos.gera(atrs, admin) conteudo = ht_dados # Monta a página: pagina = html_pag_generica.gera(ses, conteudo, erros) return pagina
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 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(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, trcs, erros):
ht_cabe = html_cabecalho.gera("Ofertas", False)
ht_trechos = html_lista_de_trechos.gera(trcs, alterar=False)
ht_conteudo = \
ht_cabe + "<br/>\n" + \
ht_trechos
pag = html_pag_generica.gera(ses, ht_conteudo, erros)
return pag
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 gera(ses, erros):
#conteudo = html_form_contato.gera()
#texto1 = "Entre em contato no telefone (11)99999-9999"
#cor_texto = "#000488"
#cor_fundo = "#eeeeee"
#bloco_texto1 = html_span.gera(None, texto1)
# Constrói formulário com dados:
admin = False
ht_dados = html_form_contato.gera({}, admin)
conteudo = ht_dados
pagina = html_pag_generica.gera(ses, conteudo, erros)
return pagina
def processa(ses, args):
try:
# Por via das dúvidas:
if args == None: args = {}.copy()
erros = [].copy()
# Obtem os campos sem defaults:
origem = args['origem'] if 'origem' in args else None
dia_partida = args['dia_partida'] if 'dia_partida' in args else None
destino = args['destino'] if 'destino' in args else None
dia_chegada = args['dia_chegada'] if 'dia_chegada' in args else None
# Verifica campos obrigatórios:
if origem == None and destino == None:
erros.append(
"um dos campos 'origem' e 'destino' deve ser especificado")
if dia_partida == None:
erros.append("o campo 'dia_partida' deve ser especificado")
if dia_chegada == None:
erros.append("o campo 'dia_chegada' deve ser especificado")
# Obtem horas e providencia defaults:
hora_partida = args[
'hora_partida'] if 'hora_partida' in args else "00:00"
hora_chegada = args[
'hora_chegada'] if 'hora_chegada' in args else "00:00"
if len(erros) > 0: raise ErroAtrib(erros)
# Monta datas completas:
data_min = dia_partida + " " + hora_partida + " UTC"
data_max = dia_chegada + " " + hora_chegada + " UTC"
# Busca trechos:
trcs_ids = trecho.busca_por_origem_e_destino(origem, destino, data_min,
data_max)
trcs = map(lambda id_trecho: trecho.busca_por_identificador(id_trecho),
trcs_ids)
alterar_trcs = sessao.eh_administrador(ses)
bloco = html_lista_de_trechos.gera(trcs, alterar_trcs)
pag = html_pag_generica.gera(ses, bloco, None)
return pag
except ErroAtrib as ex:
erros = ex.args[0]
# Repete a página com mensagens de erro:
admin = sessao.eh_administrador(ses)
pag = html_pag_buscar_trechos.gera(ses, args, admin, erros)
return pag
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):
try:
# Por via das dúvidas:
if args == None: args = {}.copy()
erros = [].copy()
# Verifica e obtem campos obrigatórios:
for ch in ('origem', 'dia_min', 'destino', 'dia_max'):
if not ch in args:
erros.append("O campo '%s' deve ser preenchido" % ch)
# Obtem parâmetros obrigatórios da busca:
origem = args['origem'] if 'origem' in args else None;
dia_min = args['dia_min'] if 'dia_min' in args else None;
destino = args['destino'] if 'destino' in args else None;
dia_max = args['dia_max'] if 'dia_max' in args else None;
# Obtem parãmetros opcionais, com defaults:
hora_min = args['hora_min'] if 'hora_min' in args else "00:00";
hora_max = args['hora_max'] if 'hora_max' in args else "23:59";
# Monta as datas para busca:
data_min = dia_min + " " + hora_min + " UTC"
data_max = dia_max + " " + hora_max + " UTC"
# Verifica se intervalo é razoável: !!! Deveria exigir mais que 1 minuto !!!
if data_min >= data_max:
erros.append("Intervalo de datas inválido")
if len(erros) > 0: raise ErroAtrib(erros)
# Chamando a busca recursiva:
soh_disponiveis = True
roteiros = roteiro.descobre_todos(origem, data_min, destino, data_max, soh_disponiveis)
# Monta página com resposta:
roteiros_html = html_lista_de_roteiros.gera(roteiros)
pag = html_pag_generica.gera(ses, roteiros_html, None)
return pag
except ErroAtrib as ex:
erros = ex.args[0]
# Repete a página com mensagens de erro:
pag = html_pag_sugerir_roteiros.gera(ses, erros)
return pag
def processa(ses, args):
assert ses != None
assert sessao.aberta(ses)
# request para ver sessões do próprio user
usr = sessao.obtem_usuario(ses)
assert usr != None
# com o id do usuário da sessao, podemos buscar suas sessões no banco
sessoes = usuario.sessoes_abertas(usr)
ids_sessoes = []
for i in sessoes:
if (i != ses):
ids_sessoes.append(sessao.obtem_identificador(i))
ht_conteudo = html_lista_de_sessoes.gera(ids_sessoes, True, True)
pag = html_pag_generica.gera(ses, ht_conteudo, None)
return pag
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 gera(ses, dados):
# Converte dados no formato gerado por {trecho.resumo_de_trafego} para
# formato aceito por {html_table}
estilo_item = "font-family:Courier;font-size:20;"
ht_linhas_dados = [].copy()
for dado in dados:
linha_porto = [].copy()
# Codigo do aeroporto
linha_porto.append(html_span.gera(estilo_item, str(dado[0])))
# Infos de chegada
for ch_item in dado[1]:
linha_porto.append(html_span.gera(estilo_item, str(ch_item)))
# Infos de saida
for sa_item in dado[2]:
linha_porto.append(html_span.gera(estilo_item, str(sa_item)))
ht_linha_porto = [html_span.gera(estilo_item, x) for x in linha_porto]
ht_linhas_dados.append(ht_linha_porto)
linha_cab = [].copy()
linha_cab.append("Aeroporto")
for lado in ("chegada", "saida"):
for tt in ( \
"# de trechos", \
"# total de poltronas", \
"# de poltronas reservadas", \
"Total dos preços das poltronas reservadas", \
"# de passageiros que fizeram checkin" \
):
linha_cab.append(tt + " (" + lado + ")")
estilo_cab = html_estilo_cabecalho_de_tabela.gera()
ht_linha_cab = map(lambda x: html_span.gera(estilo_cab, x), linha_cab)
ht_table = html_table.gera(ht_linhas_dados, ht_linha_cab)
return html_pag_generica.gera(ses, ht_table, None)
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, erros):
if ses !=None:
usr = sessao.obtem_usuario(ses)
atrs = usuario.obtem_atributos(usr)
nome = atrs['nome']
texto1 = "Olá <b>"+nome+"</b>!"
else:
texto1 = None
texto2 = "Bem vindo(a) ao nosso site de viagens!"
now = datetime.now(timezone.utc)
data = now.strftime("%Y-%m-%d %H:%M:%S %z")
texto3 = "<hr/><i>DATA CORRENTE </i><b>" + data + "</b><br/>TUDO EM ORDEM NESTE SERVIDOR<hr/>"
cor_texto = "#000488"
cor_fundo = "#eeeeee"
estilo = f"font-family: Courier; font-size: 16px; font-weight: normal; padding: "\
f"5px; text-align: center; color: {cor_texto}; background-color: {cor_fundo}"
bloco_texto1 = html_span.gera(estilo, texto1)
bloco_texto2 = html_span.gera(estilo, texto2)
bloco_texto3 = html_span.gera(estilo, texto3)
conteudo = bloco_texto1 + bloco_texto2 + bloco_texto3
pagina = html_pag_generica.gera(ses, conteudo, erros)
return pagina
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
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
def gera(ses, erros):
conteudo = html_form_sugerir_roteiros.gera()
pag = html_pag_generica.gera(ses, conteudo, erros)
return pag
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(ses, atrs, admin, erros):
ht_form = html_form_buscar_usuarios.gera(atrs, admin)
pag = html_pag_generica.gera(ses, ht_form, erros)
return pag
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
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, erros): conteudo = html_form_login.gera() pagina = html_pag_generica.gera(ses, conteudo, erros) return pagina
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
