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):
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 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
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
id_compra = "C-00000001"
ses = sessao.busca_por_identificador("S-00000001")
usr = usuario.busca_por_identificador("U-00000001")
compra = compra.busca_por_identificador(id_compra)
args = {}
if compra: # Se há compra, coleta dados
sys.stderr.write("Compra encontrada\n")
args = {"id_compra": compra.id}
else: # Não há compra com o id proposto
erro_prog(
"comando_finalizar_compra_TST : teste falhou : compra nao encontrada")
# Pagina de erro gerada pelo modulo {comando_ver_compra} caso algo de errado
erros = ["compra \"" + id_compra + "\" não existe"]
pag_erro = html_pag_mensagem_de_erro.gera(ses, erros)
def testa(rotulo, *args):
"""Testa {funcao(*args)}, grava resultado em "testes/saida/{modulo}.{funcao}.{rotulo}.html"."""
modulo = comando_finalizar_compra
funcao = modulo.processa
frag = False
pretty = False
utils_testes.testa_gera_html(modulo, funcao, rotulo, frag, pretty, *args)
ses = sessao.busca_por_identificador("S-00000001")
assert ses != None
assert sessao.aberta(ses)
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
