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 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 gera(ses, bt_ver, bt_fechar):
sessao_id = sessao.obtem_identificador(ses)
# Pega/monta atributos a mostrar:
sessao_usuario = sessao.obtem_atributo(ses, 'usr')
sessao_aberta = sessao.obtem_atributo(ses, 'abrt')
sessao_cookie = sessao.obtem_atributo(ses, 'cookie')
sessao_carrinho = sessao.obtem_atributo(ses, 'carrinho')
sessao_data = sessao.obtem_atributo(ses, 'criacao')
# Formata informações em HTML:
ht_sessao_id = formata_texto(sessao_id)
ht_codigo_usuario = formata_texto(
usuario.obtem_identificador(sessao_usuario))
ht_estado = formata_texto(sessao_esta_aberta(sessao_aberta))
ht_cookie = formata_texto(sessao_cookie)
ht_data = formata_texto(sessao_data)
if sessao_carrinho == None:
tx_carrinho = ""
else:
tx_carrinho = compra.obtem_identificador(sessao_carrinho)
ht_carrinho = formata_texto(tx_carrinho)
ht_campos = [
ht_sessao_id, ht_codigo_usuario, ht_estado, ht_cookie, ht_carrinho,
ht_data
]
args_bt = {'id_sessao': sessao_id} # Argumentos para os botões.
cor_bt_admin = '#FFA700' # Cor para botões de adminstrador.
# O comando para tratar a url "ver_detalhes_sessao" ainda não existe, e deverá ser implementado
# no futuro.
if bt_ver:
ht_bt_fechar = html_botao_simples.gera("Ver", 'ver_sessao', args_bt,
cor_bt_admin)
ht_campos.append(ht_bt_fechar)
if bt_fechar and sessao_aberta:
ht_bt_fechar = html_botao_simples.gera("Fechar", 'fechar_sessao',
args_bt, cor_bt_admin)
ht_campos.append(ht_bt_fechar)
if sessao_carrinho != None:
tx_carrinho = compra.obtem_identificador(sessao_carrinho)
if tx_carrinho[-1] == "1":
ht_bt_fechar = html_label.gera("Sessão Atual", None)
ht_campos.append(ht_bt_fechar)
return ht_campos
def 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):
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 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
sys.stderr.write("Criando alguns objetos...\n")
tabelas.cria_todos_os_testes(False)
sessions = [
sessao.busca_por_identificador("S-00000001"),
sessao.busca_por_identificador("S-00000002"),
sessao.busca_por_identificador("S-00000003"), None
]
args = [
"Lista de ofertas para a sessão S-00000001",
"Lista de ofertas para a sessão S-00000002",
"Lista de ofertas para a sessão S-00000003",
"Lista de ofertas para a sessão Anônima",
]
def testa(rotulo, *args):
"""Testa {funcao(*args)}, grava resultado
em "testes/saida/{modulo}.{funcao}.{rotulo}.html"."""
modulo = comando_solicitar_pag_ofertas
funcao = modulo.processa
frag = False
pretty = False
utils_testes.testa_gera_html(modulo, funcao, rotulo, frag, pretty, *args)
for ses, msg in zip(sessions, args):
test_id = sessao.obtem_identificador(ses)[-1] if ses != None else '0'
testa("T-" + test_id, ses, msg)
def processa_comando(tipo, ses, dados):
"""Esta função processa um comando HTTP 'GET', 'POST', ou 'HEAD' recebido pelo
servidor, com as informações convertidas em um dicionario {dados}.
A sessão {ses} deve ser a sessão deduzida a partir dos cookies que
viram com o comando HTTP.
Esta função devolve a página {pag} a ser enviada ao usuário. Devolve também
a sessão {ses_nova} corrente. Esta sessão pode ser diferente de {ses}, se o
comando for login ou logout."""
mostra(0, "dados = " + str(dados) + "")
mostra_cmd = True # Deve mostrar os dados do comando no final da página?
cmd = dados['real_path']
del dados['real_path']
# Define página a retornar {pag} e a sessão {ses_nova} para futuros comandos:
ses_nova = ses # Geralmente a sessão não muda
if tipo == 'GET' or tipo == 'POST':
# Obtem os argumentos do comando:
if tipo == 'GET':
# Comando causado por acesso inicial ou botão simples:
args = dados['query_data']
del dados[
'query_data'] # Argumentos do comando "GET", no próprio URL "cmd?n1=v1&n2=v2...".
elif tipo == 'POST':
# Comando causado por botão do tipo "submit" dentro de um <form>...</form>:
args = dados['form_data']
del dados['form_data'] # Campos do formulário.
else:
assert False
# Remove parenteses e colchetes supérfluos em {args}:
args = descasca_argumentos(args)
# Despacha o comando:
# !!! Completar a lista abaixo com todos os módulos {comando_*.py} que existem. !!!
sys.stderr.write("!! processa_comando: cmd = %s\n" % cmd)
sys.stderr.write("!! processa_comando: ses = %s\n" % \
(sessao.obtem_identificador(ses) if ses != None else "None"))
# --- comandos gerais ------------------------------------------------
if cmd == '' or cmd == '/' or cmd == '/principal':
# Acesso sem comando, ou usuário apertou "Principal" no menu geral.
pag = html_pag_principal.gera(ses, [])
elif cmd == '/ver_objeto':
# Quer ver os atributos de um objeto:
pag = comando_ver_objeto.processa(ses, args)
elif cmd == '/solicitar_pag_contato':
# Quer formulário para mandar mensagens aos administradores:
pag = comando_solicitar_pag_contato.processa(ses, args)
elif cmd == '/comando_relatorio_de_trafego':
# Quer relatório de tráfego nos aeroportos:
pag = comando_relatorio_de_trafego.processa(ses, args)
# --- comandos referentes a {Objeto_Usuario} ------------------------
elif cmd == '/solicitar_pag_cadastrar_usuario':
# Quer formumlário para cadastrar novo usuário:
pag = comando_solicitar_pag_cadastrar_usuario.processa(ses, args)
elif cmd == '/cadastrar_usuario':
# Preencheu atributos de novo usuário e quer executar a criação:
pag = comando_cadastrar_usuario.processa(ses, args)
elif cmd == '/solicitar_pag_alterar_usuario':
# Quer formulário formulário para alterar atributos de algum usuário:
pag = comando_solicitar_pag_alterar_usuario.processa(ses, args)
elif cmd == '/alterar_usuario':
# Alterou atributos de um usuário e quer executar as alterações:
pag = comando_alterar_usuario.processa(ses, args)
elif cmd == '/solicitar_pag_buscar_usuarios':
# Quer formulário para especificar uma busca na tabela de usuários:
pag = comando_solicitar_pag_buscar_usuarios.processa(ses, args)
elif cmd == '/buscar_usuarios':
# Preencheu formulário de busca de usuários, quer executar a busca:
pag = comando_buscar_usuarios.processa(ses, args)
# --- comandos referentes a {Objeto_Trecho} -----------------------
elif cmd == '/ver_trecho':
# Quer ver atributos de um trecho:
pag = comando_ver_trecho.processa(ses, args)
elif cmd == '/solicitar_pag_acrescentar_trecho':
# Quer formulário para acrescentar novo trecho:
pag = comando_solicitar_pag_acrescentar_trecho.processa(ses, args)
elif cmd == '/solicitar_pag_clonar_trecho':
# Quer formulário para acreacentar novo trecho, copiando atributos de outro:
pag = comando_solicitar_pag_clonar_trecho.processa(ses, args)
elif cmd == '/acrescentar_trecho':
# Preencheu atributos de um novo trecho e quer criar o mesmo:
pag = comando_acrescentar_trecho.processa(ses, args)
elif cmd == '/solicitar_pag_alterar_trecho':
# Quer formulário para alterar atributos de trecho existente:
pag = comando_solicitar_pag_alterar_trecho.processa(ses, args)
elif cmd == '/alterar_trecho':
# Alterou atributos de um trecho e quer executar as alterações:
pag = comando_alterar_trecho.processa(ses, args)
elif cmd == '/encerrar_trecho':
# Quer marcar um trecho como "encerrado":
pag = comando_encerrar_trecho.processa(ses, args)
elif cmd == '/solicitar_pag_buscar_trechos':
# Quer formulário para especificar uma busca na tabela de trechos:
pag = comando_solicitar_pag_buscar_trechos.processa(ses, args)
elif cmd == '/buscar_trechos':
# Preencheu parâmetros de busca de trechos e quer resultado:
pag = comando_buscar_trechos.processa(ses, args)
elif cmd == '/solicitar_pag_ofertas':
# Quer lista dos trechos que tem poltronas em oferta:
pag = comando_solicitar_pag_ofertas.processa(ses, args)
# --- comandos referentes a {Objeto_Poltrona} -----------------------
elif cmd == '/ver_poltrona':
# Quer ver atributos de uma poltrona:
pag = comando_ver_poltrona.processa(ses, args)
elif cmd == '/solicitar_pag_alterar_poltrona':
# Quer formulário para alterar atributos de uma poltrona:
pag = comando_solicitar_pag_alterar_poltrona.processa(ses, args)
elif cmd == '/alterar_poltrona':
# Alterou atributos de uma poltrona, quer executar as alterações:
pag = comando_alterar_poltrona.processa(ses, args)
elif cmd == '/comprar_poltrona':
# Quer comprar uma poltrona (um bilhete):
pag = comando_comprar_poltrona.processa(ses, args)
elif cmd == '/excluir_poltrona':
# Quer excluir uma potrona de um pedido de compra:
pag = comando_excluir_poltrona.processa(ses, args)
elif cmd == '/ver_poltronas_de_usuario':
# Quer ver todas as poltronas compradas por um usuário:
pag = comando_ver_poltronas_de_usuario.processa(ses, args)
# --- comandos referentes a {Objeto_Compra} -----------------------
elif cmd == '/ver_compra':
# Quer ver os atributos de um pedido de compra:
pag = comando_ver_compra.processa(ses, args)
elif cmd == '/alterar_compra':
# Quer formulário para alterar atributos de um pedido de compra
pag = comando_alterar_compra.processa(ses, args)
elif cmd == '/alterar_pagamento':
# Quer formulário para alterar atributos de um pedido de compra
## Descomentar linha apos implementar
#pag = comando_alterar_pagamento.processa(ses, args)
pag = html_pag_mensagem_de_erro.gera(ses, (
"** Adicionar atributo forma_pag a compra.py e descomentar implementacao do comando alterar_pagamento"
))
elif cmd == '/solicitar_pag_escolher_pagamento':
# Quer formulário para escolher a forma de pagamento de uma compra:
pag = comando_solicitar_pag_escolher_pagamento.processa(ses, args)
elif cmd == '/ver_carrinho':
# Quer ver seu carrinho de compras:
pag = comando_ver_carrinho.processa(ses, args)
elif cmd == '/definir_carrinho':
# Quer definir uma outra compra em aberto como carrinho da sessao:
pag = comando_definir_carrinho.processa(ses, args)
elif cmd == '/finalizar_compra':
# Quer finalizar uma compra:
pag = comando_finalizar_compra.processa(ses, args)
elif cmd == '/ver_minhas_compras':
# Quer ver a lista de todas as suas compras:
pag = comando_ver_minhas_compras.processa(ses, args)
elif cmd == '/solicitar_pag_buscar_compras':
# Quer formulário para especificar uma busca na tabela de compras:
pag = comando_solicitar_pag_buscar_compras.processa(ses, args)
elif cmd == '/buscar_compras':
# Preencheu dados de uma busca de compras, quer exxecutar a busca:
pag = comando_buscar_compras.processa(ses, args)
# --- comandos referentes a {Objeto_Sessao} -----------------------
elif cmd == '/solicitar_pag_login':
# Qer formulário para fazer "login":
# ATENÇÃO: Este comando só mostra o formulário de login, não muda a sessão ainda.
pag = comando_solicitar_pag_login.processa(ses, args)
elif cmd == '/fazer_login':
# Preencheu o formulário de login e quer entrar (criar nova sessão):
# ATENÇÃO: devolve também a nova sessão (que pode ser {None} se o login não deu certo).
pag, ses_nova = comando_fazer_login.processa(ses, args)
elif cmd == '/fazer_logout':
# Quer fazer "logout" (fechar a sessão corrente):
# ATENÇÃO: devolve também a nova sessão (que geralmente vai ser {None}).
pag, ses_nova = comando_fazer_logout.processa(ses, args)
elif cmd == '/fechar_sessao':
# Quer encerrar uma sessão dada:
pag, ses_nova = comando_fechar_sessao.processa(ses, args)
elif cmd == '/ver_sessoes':
# !!! ESCLARECER !!!
# Quer ver sessões:
pag = comando_ver_sessoes.processa(ses, args)
elif cmd == '/ver_sessao':
pag = comando_ver_sessao.processa(ses, args)
elif cmd == '/ver_minhas_sessoes':
# Quer ver sessões:
pag = comando_ver_minhas_sessoes.processa(ses, args)
elif cmd == '/enviar_msg_contato':
# Envia mensagem de contato
pag = comando_enviar_msg_contato.processa(ses, args)
# --- comandos referentes a roteiros -----------------------
elif cmd == '/solicitar_pag_sugerir_roteiros':
# Quer formulário para especificar uma busca de roteiros:
pag = comando_solicitar_pag_sugerir_roteiros.processa(ses, args)
elif cmd == '/sugerir_roteiros':
# Preencheu formulário de busca e quer fazer a busca:
pag = comando_sugerir_roteiros.processa(ses, args)
elif cmd == '/ver_roteiro':
# Quer ver um roteiro específico:
pag = comando_ver_roteiro.processa(ses, args)
elif cmd == '/ver_compras_de_usuario':
pag = comando_ver_compras_de_usuario.processa(ses, args)
elif cmd == '/comprar_roteiro':
# Quer comprar um roteiro específico:
pag = comando_comprar_roteiro.processa(ses, args)
# --------------------------------------------------------------
else:
# Comando não identificado
pag = html_pag_mensagem_de_erro.gera(
ses, ("** comando POST \"%s\" inválido" % cmd))
elif tipo == 'HEAD':
# Comando emitido por proxy server:
# !!! (MAIS TARDE) Tratar este caso !!!
args = {}.copy()
pag = html_pag_mensagem_de_erro.gera(
ses, ("** comando HEAD \"%s\" não implementado" % cmd))
else:
# Tipo de comando inválido:
args = {}.copy()
pag = html_pag_mensagem_de_erro.gera(
ses, ("** comando \"%s\" não implementado" % tipo))
sys.stderr.write("!! processa_comando: pag = %s\n" % pag)
if mostra_cmd:
# Acrescenta os dados para depuração:
pag = re.sub(r'</body>', ("<br/>%s<br/><br/></body>" %
formata_dados_http(cmd, args, dados)), pag)
return pag, ses_nova