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