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 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 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 processa(ses, args):
# Determina se o usuário corrente {usr_ses} é administrador:
if ses is None:
usr_ses = None
admin = False
else:
usr_ses = sessao.obtem_usuario(ses)
assert usr_ses is not None
admin = usuario.obtem_atributos(usr_ses)['administrador']
id_usr = args["id_usuario"] if "id_usuario" in args else None
assert id_usr is not None, "id_usuario obrigatório para atualizar"
usr = usuario.busca_por_identificador(id_usr)
# Tenta editar o usuário:
try:
if usr == None: raise ErroAtrib("esse usuário não existe")
atrs_muda = args.copy()
del atrs_muda["id_usuario"]
usuario.confere_e_elimina_conf_senha(atrs_muda)
usuario.muda_atributos(usr, atrs_muda)
# Mostra de novo a página de alterar com dados novos:
args_novos = usuario.obtem_atributos(usr)
pag = html_pag_usuario.gera(ses, usr, args_novos, None)
except ErroAtrib as ex:
erros = ex.args[0]
# Repete a página de cadastrar com os mesmos argumentos e mens de erro:
pag = html_pag_usuario.gera(ses, usr, args, erros)
return pag
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):
# Quem está cadastrando é administrador?
if ses != None:
usr_ses = sessao.obtem_usuario(ses)
admin = usuario.obtem_atributo(usr_ses, 'administrador')
else:
admin = False
pag = html_pag_buscar_trechos.gera(ses, {}, admin, None)
return pag
def processa(ses, args):
if ses == None:
return html_pag_mensagem_de_erro.gera(
ses, "Precisa estar logado para usar este comando.")
else:
usr_ses = sessao.obtem_usuario(ses)
admin = usuario.obtem_atributo(usr_ses, 'administrador')
if not admin:
return html_pag_mensagem_de_erro.gera(
ses, "Precisa ser administrador para usar este comando.")
pag = html_pag_buscar_usuarios.gera(ses, {}, admin, None)
return pag
def processa(ses, args):
usr_ses = None if ses == None else sessao.obtem_usuario(ses)
# Tenta criar o usuário:
try:
usuario.confere_e_elimina_conf_senha(args)
usr = usuario.cria(args)
pag = html_pag_login.gera(ses, None)
except ErroAtrib as ex:
erros = ex.args[0]
# Repete a página de cadastrar com os mesmos argumentos e mens de erro:
pag = html_pag_usuario.gera(ses, None, args, erros)
return pag
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 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 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 processa(ses, args):
# Obtem usuário e carrinho de compras:
assert ses != None # Comando não deveria ser acessível a usuário não logado.
usr_ses = sessao.obtem_usuario(ses)
assert usr_ses != None # Paranóia.
admin = usuario.obtem_atributo(usr_ses, 'administrador')
assert not admin # Admnistrador não deveria ter acesso a este cmd.
#Obtem a poltrona a comprar:
id_pol = args['id_poltrona'] if 'id_poltrona' in args else None
assert id_pol != None # Paranóia (formulário ou botão deve fornecer)
pol = poltrona.busca_por_identificador(id_pol)
assert pol != None # Paranóia.
# Obtém carrinho do usuário:
carr = sessao.obtem_carrinho(ses)
assert carr != None # Todo cliente comum deve ter carrinho.
id_carr = compra.obtem_identificador(carr)
try:
if not poltrona.pode_comprar(usr, pol, carr):
# Não deveria acontecer, mas em todo caso:
raise ErroAtrib("Esta poltrona não está disponível")
# Muda a poltrona para comprada
poltrona.muda_atributos(pol, { 'id_compra': id_carr })
# Mostra o carrinho do usuário com a poltrona comprada:
pag = html_pag_compra.gera(ses, cpr, excluir, None)
except ErroAtrib as ex:
erros = ex.args[0]
# Se o trecho da poltrona estiver disponível, mostra o trecho para outra compra:
id_trc = poltrona.obtem_atributo(pol, 'id_trecho')
assert id_trc != None # Paranoia.
trc = trecho.busca_por_identificador(id_trc)
assert trc != None # Paranoia.
if trecho.verificar_disponibilidade(trc) and trecho_eh_compativel(cpr, trc):
# Usuário pode comprar outra poltrona deste trecho:
pag = html_pag_trecho.gera(ses, trc, None, erros)
else:
# Usuário não pode comprar nenuma poltrona neste trecho.
# Volte para a página principal.
# !!! Deveria buscar e mostrar roteiros de mesma origem e destino !!!
pag = html_pag_principal.gera(ses, erros)
return pag
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.
assert not usuario.obtem_atributo(usr,
'administrador') # Deveria acontecer.
cpr = sessao.obtem_carrinho(ses)
assert cpr != None # Deveria acontecer
# Monta página:
pag = html_pag_compra.gera(ses, cpr, None, 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):
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 verifica_sessao(rotulo, ses, ident, usr, abrt, cookie, carrinho):
"""Testes básicos de consistência do objeto {ses} da classe {Objeto_Sessao}, dados
{ident} e {atrs} esperados."""
global ok_global
sys.stderr.write("%s\n" % ("-" * 70))
sys.stderr.write("verificando sessão %s\n" % rotulo)
atrs = { 'usr': usr, 'abrt': abrt, 'cookie': cookie, 'carrinho': carrinho }
ok = sessao.verifica(ses, ident, atrs)
if ses != None and type(ses) is sessao.Objeto_Sessao:
sys.stderr.write("testando {obtem_usuario()}:\n")
usr1 = sessao.obtem_usuario(ses)
if usr1 != usr:
aviso_prog("retornou " + str(usr1) + ", deveria ter retornado " + str(usr),True)
ok = False
sys.stderr.write("testando {aberta()}:\n")
abrt1 = sessao.aberta(ses)
if abrt1 != abrt:
aviso_prog("retornou " + str(abrt1) + ", deveria ter retornado " + str(abrt),True)
ok = False
sys.stderr.write("testando {obtem_cookie()}:\n")
cookie1 = sessao.obtem_cookie(ses)
if cookie1 != cookie:
aviso_prog("retornou " + str(cookie1) + ", deveria ter retornado " + str(cookie),True)
ok = False
sys.stderr.write("testando {obtem_carrinho()}:\n")
carrinho1 = sessao.obtem_carrinho(ses)
if carrinho1 != carrinho:
aviso_prog("retornou " + str(carrinho1) + ", deveria ter retornado " + str(carrinho),True)
ok = False
if not ok:
aviso_prog("teste falhou",True)
ok_global = False
sys.stderr.write("%s\n" % ("-" * 70))
return
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 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 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
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
modulo = html_pag_trecho
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)
assert 'id_usuario' in args
testa(rot, ses, args)
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:
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 testa(rotulo, *args):
"""Testa {comando_solicitar_pag_alterar_usuario.processa(*args)}, grava resultado
em "testes/saida/{modulo}.{funcao}.{rotulo}.html"."""
modulo = comando_solicitar_pag_alterar_usuario
funcao = modulo.processa
frag = False # {True} se for apenas um fragmento HTML, {False} se for página completa.
pretty = True # Se {True}, formata HTML para legibilidate (mas introduz brancos nos textos).
utils_testes.testa_gera_html(modulo, funcao, rotulo, frag, pretty, *args)
# Sessão de cliente comum:
ses1 = sessao.busca_por_identificador("S-00000001")
assert ses1 != None
usr_ses1 = sessao.obtem_usuario(ses1)
assert not usuario.obtem_atributo(usr_ses1, 'administrador')
# Sessão de administrador:
ses4 = sessao.busca_por_identificador("S-00000004")
assert ses4 != None
usr_ses4 = sessao.obtem_usuario(ses4)
assert usuario.obtem_atributo(usr_ses4, 'administrador')
# Usuário comum alterando seus dados:
usr1 = usr_ses1
id_usr1 = usuario.obtem_identificador(usr1)
args_usr1 = {'id_usuario': id_usr1}
testa("sesC_usrC", ses1, args_usr1)
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
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)
# 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)
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 processa(ses, args):
usr_ses = None if ses == None else sessao.obtem_usuario(ses)
pag = html_pag_usuario.gera(ses, None, None, None)
return pag
