def gera(ids_sessoes, bt_ver, bt_fechar):
# Linha de cabeçalho:
cabs_raw = [
'Sessão', 'Usuário', 'Aberta?', 'Cookie', 'Carrinho', 'Data de Criação'
]
cabs_div = [].copy()
for cb in cabs_raw:
cabs_div.append(
html_div.gera(html_estilo_cabecalho_de_tabela.gera(), cb))
linhas = [].copy()
for id_ses in ids_sessoes:
# busca por id da sessao no banco
ses = sessao.busca_por_identificador(id_ses)
# Gera uma lista de fragmentos HTML com as informacoes dessa compra
res_campos = html_resumo_de_sessao.gera(ses, bt_ver, bt_fechar)
# Adiciona essa lista à lista de linhas para a tabela HTML:
linhas.append(res_campos)
# Gera a tabela HTML a partir da lista de linhas
ht_itens = html_table.gera(linhas, cabs_div)
ht_cabe = html_cabecalho.gera("Minhas Sessões", False)
ht_conteudo = \
ht_cabe + "<br/>\n" + \
ht_itens
# Devolve a tabela HTML
return ht_conteudo
def fecha_sessoes(id_usr):
sessoes = list(
map(lambda id_ses: sessao.busca_por_identificador(id_ses),
sessao.busca_por_usuario(id_usr)))
for sessao_usr in sessoes:
if sessao.aberta(sessao_usr):
sessao.fecha(sessao_usr)
def sessoes_abertas(usr):
id_usr = usuario.obtem_identificador(usr)
ids_sessoes_usr = sessao.busca_por_usuario(
id_usr) # IDs das sessões deste usuário.
sessoes_usr = map(lambda id: sessao.busca_por_identificador(id),
ids_sessoes_usr) # Pega objetos.
# Filtra apenas as Sessoes que estao abertas
abertas_usr = list(filter(lambda ses: sessao.aberta(ses), sessoes_usr))
return abertas_usr
def 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 obtem_sessao(self, dados):
"""Determina a sessão à qual o comando HTTP se refere, ou {None}
se o usuário não está logado, a partir do dicionário de cookies
contidos em {dados}."""
if not 'cookies' in dados:
# Não temos cookies?
return None
cookies = dados['cookies']
if 'id_sessao' in cookies:
id_sessao = cookies['id_sessao']
ses = sessao.busca_por_identificador(id_sessao)
else:
ses = None
return ses
def id_para_objeto(id):
letra = id[0]
if letra == "U":
obj = usuario.busca_por_identificador(id)
elif letra == "C":
obj = compra.busca_por_identificador(id)
elif letra == "S":
obj = sessao.busca_por_identificador(id)
elif letra == "A":
obj = poltrona.busca_por_identificador(id)
elif letra == "T":
obj = trecho.busca_por_identificador(id)
else:
erro_prog("identificador '" + id + " inválido")
return obj
def processa(ses, args):
assert ses != None and sessao.aberta(ses)
id_ses = args['id_sessao']
ses_exit = sessao.busca_por_identificador(id_ses)
# Se for fechar a sessao ativa, feito logout
if ses == ses_exit:
sessao.fecha(ses)
ses_nova = None
pag = html_pag_principal.gera(ses_nova, None)
# caso nao seja a sessao ativa, somente fecha e retorna para pagina de sessoes
else:
sessao.fecha(ses)
ses_nova = None
pag = html_pag_principal.gera(ses_nova, None)
return pag, ses_nova
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
base_sql.conecta("DB", None, None)
tabelas.inicializa_todas(True)
tabelas.cria_todos_os_testes(False)
usr1_id = "U-00000001"
usr1 = usuario.busca_por_identificador(usr1_id)
usr2_id = "U-00000002"
usr2 = usuario.busca_por_identificador(usr2_id)
cpr1_id = "C-00000001"
cpr1 = compra.busca_por_identificador(cpr1_id)
ses1_id = "S-00000001"
ses1 = sessao.busca_por_identificador(ses1_id)
ok_global = True # Vira {False} se um teste falha.
# ----------------------------------------------------------------------
# TESTES DE CONVERSÃO DE VALORES
def verifica_valor(rotulo, val_mem, tipo_mem, val_SQL, tipo_SQL, nulo_ok):
"""Testa {valor_mem_para_valor_SQL} e {valor_SQL_para_valor_mem}."""
global ok_global
ok = True # Estado deste teste.
# Mostra parâmetros:
sys.stderr.write("%s\n" % ("-" * 70))
sys.stderr.write(rotulo + "\n")
sys.stderr.write("Conectando com base de dados...\n")
res = base_sql.conecta("DB", None, None)
assert res == None
sys.stderr.write("Criando objetos...\n")
tabelas.cria_todos_os_testes(False)
def testa(rotulo, *args):
"""Testa {funcao(*args)}, grava resultado em "testes/saida/{modulo}.{funcao}.{rotulo}.html"."""
modulo = comando_fechar_sessao
funcao = modulo.processa
frag = False
pretty = False
utils_testes.testa_gera_html(modulo, funcao, rotulo, frag, pretty, *args)
id_ses1 = "S-00000001" # Sessao do usuário fechador.
ses1 = sessao.busca_por_identificador(id_ses1)
assert ses1 != None
assert sessao.aberta(ses1)
for rotulo, ses, args in [ \
# ('inexistente', ses1, {'id_sessao' : ''}) Não está implementado um tratamento para sessão inexistente
('existente', ses1, {'id_sessao' : 'S-00000002'}),
('proprio', ses1, {'id_sessao' : 'S-00000001'}),
('fechada', ses1, {'id_sessao' : 'S-00000003'})
]:
testa(rotulo, ses, args)
def testa(rotulo, *args):
"""Testa {funcao(*args)}, grava resultado
em "testes/saida/{modulo}.{funcao}.{rotulo}.html"."""
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:
import sessao
import base_sql
import utils_testes
import sys
# Conecta ao banco de dados
sys.stderr.write("Conectando com base de dados...\n")
res = base_sql.conecta("DB", None, None)
assert res is None
sys.stderr.write("Criando alguns objetos...\n")
tabelas.cria_todos_os_testes(False)
# Sessao para teste
ses = sessao.busca_por_identificador("S-00000004")
def testa(rotulo, *args):
"""Testa {funcao(*args)}, grava resultado
em "testes/saida/{modulo}.{funcao}.{rotulo}.html"."""
modulo = comando_acrescentar_trecho
funcao = modulo.processa
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 testa_acrescenta_trecho_com_sucesso(id_trecho_ult, id_trecho_prox):
"""Testa a criação de um novo trecho com sucesso, dados
import base_sql
import tabelas
import usuario
import sessao
import compra
import utils_testes
sys.stderr.write("Conectando com base de dados...\n")
res = base_sql.conecta("DB", None, None)
assert res == None
sys.stderr.write("Criando objetos...\n")
tabelas.cria_todos_os_testes(False)
# Dados de teste
ses3 = sessao.busca_por_identificador("S-00000003")
usr1_id = 'U-00000001'
def testa(rotulo, *args):
"""Testa {funcao(*args)}, grava resultado
em "testes/saida/{modulo}.{funcao}.{rotulo}.html"."""
modulo = comando_ver_minhas_sessoes
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)
testa("s3", ses3, {'id': usr1_id})
tabelas.cria_todos_os_testes(False)
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}
import base_sql
import utils_testes
import sys
# Conecta no banco e alimenta com as informações para o teste
sys.stderr.write("Conectando com base de dados...\n")
res = base_sql.conecta("DB", None, None)
assert res is None
sys.stderr.write("Criando alguns objetos...\n")
tabelas.cria_todos_os_testes(False)
# Sessões de teste
ses_nao_admin = sessao.busca_por_identificador("S-00000001")
admin = usuario.busca_por_identificador("U-00000003")
ses_admin = sessao.cria(admin, "NOPQRSTUVWX", None)
def testa(rotulo, *args):
"""Testa {funcao(*args)}, grava resultado
em "testes/saida/{modulo}.{funcao}.{rotulo}.html"."""
modulo = comando_solicitar_pag_buscar_usuarios
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)
tabelas.cria_todos_os_testes(False)
def testa(rotulo, *args):
"""Testa {funcao(*args)}, grava resultado
em "testes/saida/{modulo}.{funcao}.{rotulo}.html"."""
modulo = comando_excluir_poltrona
funcao = modulo.processa
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).
testa_gera_html(modulo, funcao, rotulo, frag, pretty, *args)
# Sessao de usuário comum e poltrona desse usuário:
ses_com1 = sessao.busca_por_identificador("S-00000003")
usr_com1 = sessao.obtem_usuario(ses_com1)
assert not usuario.obtem_atributo(usr_com1, 'administrador')
id_cpr_com1 = "C-00000003"
cpr_com1 = compra.busca_por_identificador(id_cpr_com1)
assert compra.obtem_cliente(cpr_com1) == usr_com1
id_pol_com1 = "A-00000008"
pol_com1 = poltrona.busca_por_identificador(id_pol_com1)
assert poltrona.obtem_atributo(pol_com1, "id_compra") == id_cpr_com1
testa("com1-com1", ses_com1, {'id_poltrona': id_pol_com1})
# Sessao de administrador e poltrona de outro usuário:
ses_adm3 = sessao.busca_por_identificador("S-00000004")
usr_adm3 = sessao.obtem_usuario(ses_adm3)
sys.stderr.write("Criando objetos...\n")
tabelas.cria_todos_os_testes(False)
def testa(rotulo, *args):
"""Testa {funcao(*args)}, grava resultado
em "testes/saida/{modulo}.{funcao}.{rotulo}.html"."""
modulo = comando_comprar_roteiro
funcao = modulo.processa
frag = False
pretty = True
utils_testes.testa_gera_html(modulo, funcao, rotulo, frag, pretty, *args)
ses1 = sessao.busca_por_identificador("S-00000001")
assert ses1 != None
roteiro = ["T-00000003", "T-00000004"]
roteiro_txt = ",".join(roteiro)
args = {'ids_trechos': roteiro_txt}
testa("comprar_roteiro_usr_logado", ses1, args)
ses2 = sessao.busca_por_identificador("S-00000002")
assert ses2 != None
testa("comprar_roteiro_lotado", ses2, args)
ses3 = None
testa("comprar_roteiro_deslogado", ses3, args)
import sessao
import base_sql
import utils_testes
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:
sessoes = [
sessao.busca_por_identificador("S-00000001"),
sessao.busca_por_identificador("S-00000002"),
sessao.busca_por_identificador("S-00000003")
]
assert sessoes != None
def testa(rotulo, *args):
"""Testa {funcao(*args)}, grava resultado
em "testes/saida/{modulo}.{funcao}.{rotulo}.html"."""
modulo = comando_solicitar_pag_cadastrar_usuario
funcao = modulo.processa
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)
import usuario
import sessao
import compra
import utils_testes
sys.stderr.write("Conectando com base de dados...\n")
res = base_sql.conecta("DB", None, None)
assert res == None
sys.stderr.write("Criando objetos...\n")
tabelas.cria_todos_os_testes(False)
# Sessão de usuário cliente
# Sessão de usuário administrador
ses4 = sessao.busca_por_identificador("S-00000003")
# Usuário a examinar:
def testa(rotulo, *args):
"""Testa {funcao(*args)}, grava resultado
em "testes/saida/{modulo}.{funcao}.{rotulo}.html"."""
modulo = comando_ver_sessoes
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)
import base_sql
import tabelas
import usuario
import sessao
import utils_testes
import utils_testes
import sys
sys.stderr.write("Conectando com a base de dados...\n")
res = base_sql.conecta("DB", None, None)
assert res == None # Verifica que a conexão teve sucesso
sys.stderr.write("Criando alguns objetos...\n")
tabelas.cria_todos_os_testes(False)
# Sessão usada no teste
sessao1 = sessao.busca_por_identificador("S-00000001")
assert sessao1 != None
# Usuário usado no teste
usuario1 = usuario.busca_por_identificador("U-00000001")
assert usuario1 != None
def testa(rotulo, *args):
"""Testa {funcao(*args)}, grava resultado
em "testes/saida/{modulo}.{funcao}.{rotulo}.html"."""
modulo = comando_solicitar_pag_buscar_trechos
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).
usrA = usuario.busca_por_identificador(usrA_id)
assert usuario.obtem_atributo(usrA, 'administrador')
# Uma compra em aberto do cliente 1:
cprC_id = "C-00000001"
cprC = compra.busca_por_identificador(cprC_id)
assert compra.obtem_status(cprC) == 'comprando'
assert compra.obtem_cliente(cprC) == usrC
# Uma compra fechada:
cprF_id = "C-00000004"
cprF = compra.busca_por_identificador(cprF_id)
assert compra.obtem_status(cprF) != 'comprando'
# Sessão do cliente 1:
sesC = sessao.busca_por_identificador("S-00000001")
assert sessao.obtem_usuario(sesC) == usrC
# Sessão de outro cliente comum:
sesO = sessao.busca_por_identificador("S-00000003")
assert sessao.obtem_usuario(sesO) != None
assert sessao.obtem_usuario(sesO) != usrC
# Sessão de administrador:
sesA = sessao.busca_por_identificador("S-00000004")
assert sessao.eh_administrador(sesA)
# Poltrona reservada pelo usuario 1:
polR_id = "A-00000001"
polR = poltrona.busca_por_identificador(polR_id)
assert poltrona.obtem_atributo(polR, 'id_compra') == "C-00000001"