def pode_excluir(usr, pol):
global cache, nome_tb, letra_tb, colunas, diags
if usr == None or pol == None: return False
assert type(usr) is usuario.Objeto_Usuario
assert type(pol) is poltrona.Objeto_Poltrona
# A poltrona {pol} está reservada a alguma compra?
id_cpr = poltrona.obtem_atributo(pol, 'id_compra');
if id_cpr == None: return False
# A compra {cpr} ainda está aberta?
cpr = compra.busca_por_identificador(id_cpr)
assert cpr != None # Paranóia.
if compra.obtem_atributo(cpr, 'status') != 'comprando': return False
# O trecho da poltrona {pol} ainda não foi encerrado?
id_trc_pol = poltrona.obtem_atributo(pol, 'id_trecho');
trc_pol = None if id_trc_pol == None else trecho.busca_por_identificador(id_trc_pol)
assert trc_pol != None # Paranóia.
if trecho.obtem_atributo(trc_pol, 'encerrado'): return False
# O usuário tem direito de excluir?
admin = usuario.obtem_atributo(usr, 'administrador')
dono = (compra.obtem_cliente(cpr) == usr)
if not (admin or dono): return False
# Pode excluir, parece:
return True
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 gera(ids_poltronas, usr, carr):
id_trc = None # Identificador do trecho comum, ou None.
admin = False if usr == None else usuario.obtem_atributo(
usr, 'administrador')
fazer_checkin = admin # Por enquanto.
embarcar = admin #Por enquanto
if admin or usr == None:
assert carr == None # Administrador e não-logado não tem carrinho.
id_carr = None if carr == None else compra.obtem_identificador(carr)
# Gera a linha de os cabeçalhos das colunas
linha_cab = html_resumo_de_poltrona_de_trecho.gera_cabecalho(fazer_checkin)
assert type(linha_cab) is list or type(linha_cab) is tuple # Paranóia.
# Gera as linhas da tabela.
linhas = [].copy()
for id_poltrona in ids_poltronas:
pol = poltrona.busca_por_identificador(id_poltrona)
# Obtem dados da poltrona:
assert pol != None
id_trc_pol = poltrona.obtem_atributo(pol, 'id_trecho')
id_cpr_pol = poltrona.obtem_atributo(pol, 'id_compra')
cpr_pol = None if id_cpr_pol == None else compra.busca_por_identificador(
id_cpr_pol)
usr_pol = None if cpr_pol == None else compra.obtem_cliente(cpr_pol)
# Verifica se o trecho é o mesmo para todas as poltronas:
if id_trc != None: assert id_trc_pol == id_trc
id_trc = id_trc_pol
# Decide que botões vai ter:
alterar = admin
comprar = (carr != None) and poltrona.pode_comprar(usr, pol, carr)
excluir = (cpr_pol != None) and (usr_pol
== usr) and poltrona.pode_excluir(
usr, pol)
# Gera os campos da linha:
linha = html_resumo_de_poltrona_de_trecho.gera(pol, alterar, comprar,
excluir, fazer_checkin,
embarcar)
assert type(linha) is list or type(linha) is tuple # Paranóia.
linhas.append(linha)
ht_tabela = html_table.gera(linhas, linha_cab)
ht_legenda = html_resumo_de_poltrona_de_trecho.gera_legenda(fazer_checkin)
ht_res = ht_tabela + ht_legenda
return ht_res
def processa(ses, args):
# 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):
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
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:
ses_adm3 = sessao.busca_por_identificador("S-00000004")
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)
testes = ( \
( "U-00000001", "T-00000001", ), # Cliente comum.
( "U-00000001", "T-00000002", ), # Cliente comum.
( "U-00000003", "T-00000003" ), # Admin.
( "U-00000003", "T-00000004", ), # Admin.
( None, "T-00000005", ), # Usuario deslogado.
)
for usr_id, trc_id in testes:
usr = None if usr_id == None else usuario.busca_por_identificador(usr_id)
admin = False if usr == None else usuario.obtem_atributo(
usr, 'administrador')
usr_cprs = [] if usr == None else usuario.compras_abertas(usr)
carr = None if len(usr_cprs) == 0 else usr_cprs[
0] # Faz de conta que a primeira compra é o carrinho.
id_carr = None if carr == None else compra.obtem_identificador(carr)
trc = None if trc_id == None else trecho.busca_por_identificador(trc_id)
assert trc != None
ids_pols = trecho.obtem_poltronas(trc)
fazer_checkin = admin #por enquanto
rot = trc_id + "-" + str(usr_id) + "-" + str(id_carr)
rot += "-admin" + str(admin)[0]
rot += "-fzck" + str(fazer_checkin)[0]
testa(rot, ids_pols, usr, carr)
# fixtures
sys.stderr.write("Conectando com base de dados...\n")
res = base_sql.conecta("DB", None, None)
assert res == None
sys.stderr.write("Criando alguns objetos...\n")
tabelas.cria_todos_os_testes(False)
# Testes das funções de {gera_html_form}:
usr1 = usuario.busca_por_identificador("U-00000001")
assert usr1 != None
id_usr1 = usuario.obtem_identificador(usr1)
atrs_usr1 = usuario.obtem_atributos(usr1)
assert not usuario.obtem_atributo(usr1, 'administrador')
usr3 = usuario.busca_por_identificador("U-00000003")
assert usr3 != None
id_usr3 = usuario.obtem_identificador(usr3)
atrs_usr3 = usuario.obtem_atributos(usr3)
assert usuario.obtem_atributo(usr3, 'administrador')
atrs_usr0 = atrs_usr1
del atrs_usr0['nome']
del atrs_usr0['telefone']
ht_bt_coisar = html_botao_submit.gera("Coisar", "coisar", {'coisa': "568"},
"#ffaa00")
testa("admF_usrN", None, atrs_usr0, False, ht_bt_coisar)
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 eh_administrador(ses):
global cache, nome_tb, letra_tb, colunas, diags
if ses == None or not aberta(ses): return False
usr = obtem_usuario(ses)
return usuario.obtem_atributo(usr, 'administrador')
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)
# Administrador alterando dados de outro usuário:
def cria_testes(verb):
global cache, nome_tb, letra_tb, colunas, diags
inicializa(True)
lista_atrs = \
[
{ # U-00000001
'nome': "José Primeiro",
'senha': "123456789",
'email': "*****@*****.**",
'CPF': "123.456.789-00",
'telefone': "+55(19)9 9876-5432",
'documento': "1.234.567-9 SSP-SP",
'milhagem': 100,
'administrador': False,
},
{ # U-00000002
'nome': "João Segundo",
'senha': "987654321",
'email': "*****@*****.**",
'CPF': "987.654.321-99",
'telefone': "+55(19)9 9898-1212",
'documento': 'CD98765-43 PF',
'milhagem': 200,
'administrador' : False,
},
{ # U-00000003
'nome': "Juca Terceiro",
'senha': "333333333",
'email': "*****@*****.**",
'CPF': "111.111.111-11",
'telefone': "+55(19)9 9999-9999",
'documento': None,
'milhagem': None,
'administrador' : True,
},
{ # U-00000004
'nome': "Jurandir Quarto",
'senha': "111111111",
'email': "*****@*****.**",
'CPF': "222.222.222-22",
'telefone': "+55(19)9 9898-1211",
'documento': '1.234.567-8 SSP-SP',
'milhagem': 400,
'administrador' : False,
},
{ # U-00000005
'nome': "Josenildo Quinto",
'senha': "222222222",
'email': "*****@*****.**",
'CPF': "333.333.333-33",
'telefone': "+55(19)9 9898-1213",
'documento': '1.234.567-7 SSP-SP',
'milhagem': 500,
'administrador' : False,
},
{ # U-00000006
'nome': "Julio Sexto",
'senha': "444444444",
'email': "*****@*****.**",
'CPF': "444.444.444-44",
'telefone': "+55(19)9 9898-1214",
'documento': '1.234.567-6 SSP-SP',
'milhagem': 600,
'administrador' : False,
},
{ # U-00000007
'nome': "Jeferson Setimo",
'senha': "555555555",
'email': "*****@*****.**",
'CPF': "555.555.555-55",
'telefone': "+55(19)9 9898-1215",
'documento': '1.234.567-5 SSP-SP',
'milhagem': 700,
'administrador' : False,
},
{ # U-00000008
'nome': "Joaquim Oitavo",
'senha': "666666666",
'email': "*****@*****.**",
'CPF': "666.666.666-66",
'telefone': "+55(19)9 9898-1216",
'documento': '1.234.567-4 SSP-SP',
'milhagem': None,
'administrador' : True,
},
{ # U-00000009
'nome': "Jonas Nono",
'senha': "777777777",
'email': "*****@*****.**",
'CPF': "777.777.777-77",
'telefone': "+55(19)9 9898-1217",
'documento': '1.234.567-3 SSP-SP',
'milhagem': None,
'administrador' : True,
},
]
for atrs in lista_atrs:
usr = cria(atrs)
assert usr != None and type(usr) is usuario.Objeto_Usuario
id_usr = usuario.obtem_identificador(usr)
nome = usuario.obtem_atributo(usr, 'nome')
if verb:
sys.stderr.write("usuário %s = \"%s\" criado\n" % (id_usr, nome))
return
def gera(ses, 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
