def define_carrinho(usr, id_usuario): """Esta função busca por compras em aberto do usuário {usr}. Se houver alguma nessa condição, então a com o MENOR indice contida no identificador sera usada como carrinho, caso contrário será criado um novo carrinho vazio. Identificador é dado por'C-{NNNNNNNN}'""" lista_ids_compras = compra.busca_por_cliente(id_usuario) # inicializo todos os identificadores com compras em aberto lista_ids_compras_abertos = [] if not lista_ids_compras: return compra.cria(usr) else: # define a posicao do elemento na lista_ids_compras_abertos comecando da posicao 0 posicao = 0 for id_compra in lista_ids_compras: obj_compra = compra.busca_por_identificador(id_compra) # pega a substring NNNNNNNN do identificador C-{NNNNNNNN}' substring_indice_compra = id_compra[2:10] if compra.obtem_status(obj_compra) == 'comprando': lista_ids_compras_abertos.insert(posicao, substring_indice_compra) posicao = posicao + 1 # seleciono o menor indice indice_minimo = min(lista_ids_compras_abertos) # monto o parametro identificador = "C-" + str(indice_minimo) # busco a compra em aberto com o menor indice no identificador obj_compra_identificador_min = compra.busca_por_identificador(identificador) return obj_compra_identificador_min return compra.cria(usr)
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 pode_trocar(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 e comprar nessa compra? dono = (compra.obtem_cliente(cpr) == usr) if not dono: return False # Pode trocar, parece: return True
def processa(ses, args): # Obtém a compra: id_cpr = args['id_compra'] assert id_cpr is not None # Paranóia (formulário deve incluir). del args['id_compra'] cpr = compra.busca_por_identificador(id_cpr) assert cpr != None # Paranóia. # Obtém dados alterados: forma_pag = args['metodo'] assert id_cpr is not None # Paranóia (formulário deve obrigar a preencher) # Aplica a compra: try: novos_atrs = {'forma_pag': forma_pag} compra.muda_atributos(cpr, novos_atrs) # Atualiza a pagina com os novos valores pag = html_pag_compra.gera(ses, cpr, None, None) except ErroAtrib as ex: # Repete a página da alterar compra com mesmos atributos e mens de erro: erros = ex[0] pag = html_pag_compra.gera(ses, cpr, args, erros) return pag
def processa(ses, args): # Obtém id da compra a alterar 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. # Obtem dados alteráveis dos {args}: nome_pass = args['nome_pass'] if 'nome_pass' in args else None doc_pass = args['doc_pass'] if 'doc_pass' in args else None status = args['status'] if 'status' in args else None # Monta dicionário com alterações: novos_atrs = {}.copy() if nome_pass != None: novos_atrs['nome_pass'] = nome_pass if doc_pass != None: novos_atrs['doc_pass'] = doc_pass if status != None: novos_atrs['status'] = status # Editar passageiro try: compra.muda_atributos(cpr, novos_atrs) # Mostra compra com os novos valores pag = html_pag_compra.gera(ses, cpr, None, None) except ErroAtrib as ex: # Repete o formulário de alteração com valores já alterados e erros erros = ex[0] pag = html_pag_compra.gera(ses, cpr, args, erros) return pag
def testa_novo_passageiro(): # Valores originais id_cpr = 'C-00000001' cpr = compra.busca_por_identificador(id_cpr) status = compra.obtem_atributo(cpr, 'status') # Novos valores nome_pass = '******' args = {'id_compra': id_cpr, 'status': status, 'nome_pass': nome_pass} testa("NovoPass", ses, args) # Valores atualizados cpr_mod = compra.busca_por_identificador('C-00000001') nome_pass_mod = compra.obtem_atributo(cpr_mod, 'nome_pass') assert nome_pass_mod == nome_pass, "Compra não atualizada"
def compras_abertas(usr): id_usr = usuario.obtem_identificador(usr) ids_compras_usr = compra.busca_por_cliente( id_usr) # IDs das compras deste usuário. compras_usr = map(lambda id: compra.busca_por_identificador(id), ids_compras_usr) # Pega objetos. # Filtra apenas as compras que não estao finalizadas: abertas_usr = list( filter(lambda cpr: compra.obtem_status(cpr) != 'fechado', compras_usr)) return abertas_usr
def testa_nome_passageiro_null(): # Valores originais id_cpr = 'C-00000001' cpr = compra.busca_por_identificador(id_cpr) usr = compra.obtem_cliente(cpr) id_usr = usuario.obtem_identificador(usr) status = compra.obtem_atributo(cpr, 'status') nome_pass_org = compra.obtem_atributo(cpr, 'nome_pass') # Novos valores args = {'id_compra': id_cpr, 'id_usr': id_usr, 'status': status} testa("NoPass", ses, args) # Valores atualizados cpr_mod = compra.busca_por_identificador('C-00000001') nome_pass_mod = compra.obtem_atributo(cpr_mod, 'nome_pass') assert nome_pass_mod == nome_pass_org, "Compra não atualizada"
def processa(ses, args): # Verificar se o usuário esta logado if ses == None: return html_pag_login.gera(ses, None) # Buscar a compra no Carrinho id_compra = args['id_compra'] cpr = compra.busca_por_identificador(id_compra) # Muda status da compra para "pagando" compra.fecha(cpr) # Mostrar a página de pagamento pag = html_pag_escolher_pagamento.gera(ses, cpr, 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): 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 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 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 pag = html_pag_mensagem_de_erro.gera(ses, "sessão corrente") assert sessao.aberta(ses) ids_compras = compra.busca_por_cliente(args['id']) ids_poltronas = [] for i in range(len(ids_compras)): cpr = compra.busca_por_identificador(ids_compras[i]) ids_poltronas += poltrona.busca_por_compra(cpr) ht_conteudo = html_lista_de_poltronas_de_usuario.gera(ids_poltronas) pag = html_pag_generica.gera(ses, ht_conteudo, 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): # Validações, por via das dúvidas: assert ses != None # Deveria acontecer. assert sessao.aberta(ses) # Deveria acontecer. assert 'id_compra' in args # Deveria acontecer # obter compra id_compra = args['id_compra'] cpr = compra.busca_por_identificador(id_compra) if cpr == None: erros = ["compra \"" + id_compra + "\" não existe"] return html_pag_mensagem_de_erro(ses, erros) # Trocar o carrinho pela compra sessao.muda_atributos(ses, {'carrinho': cpr}) # Mostrar carrinho atualizado return comando_ver_carrinho.processa(ses, args)
def gera(ids_compras, ver, id_carrinho): linhas = [].copy() # Linha de cabeçalho: estilo_cab = "font-size:20px;font-weight:bold; background-color: #60a3bc; color: white; padding:0px 10px 0px 0px" # Linha de cabeçalho: cabs_raw = [ 'CR', 'Compra', 'Usuário', 'NP', 'Passageiro', 'Documento', 'Preço' ] cabs_div = [].copy() for cb in cabs_raw: cabs_div.append( html_div.gera(html_estilo_cabecalho_de_tabela.gera(), cb)) # Linhas das compras: for id_cpr in ids_compras: # Obtem o objeto correspondente compra_obj = compra.busca_por_identificador(id_cpr) # Gera uma lista de fragmentos HTML com as informacoes dessa compra res_campos = html_resumo_de_compra.gera(compra_obj, ver, id_carrinho) # sys.stderr.write("res_campos = %s\n" % str(res_campos)) assert type(res_campos) is list or type(res_campos) is tuple # Adiciona essa lista à lista de linhas para a tabela HTML: linhas.append(res_campos) # sys.stderr.write("linhas = %s\n" % str(linhas)) ht_cabe = html_cabecalho.gera("Minhas compras", False) # Gera a tabela HTML a partir da lista de linhas ht_itens = html_table.gera(linhas, cabs_div) ht_legenda = "CR: Seu Carrinho, NP: Número da Poltrona" ht_conteudo = \ ht_cabe + "<br/>\n" + \ ht_itens + "<br/>\n" + \ ht_legenda # Devolve a tabela HTML return ht_conteudo
def poltronas_abertas(usr): id_usr = usuario.obtem_identificador(usr) abertas_usr = [].copy() ids_compras = compra.busca_por_cliente(id_usr) for id_cpr in ids_compras: cpr = compra.busca_por_identificador(id_cpr) assert cpr != None # Paranóia. # Pega o id das poltronas de cada uma dessas compras ids_poltronas = compra.obtem_poltronas(cpr) for id_pol in ids_poltronas: # Para cada um desses ids pega o objeto da poltrona pol = poltrona.busca_por_identificador(id_pol) assert pol != None # Paranóia. assert poltrona.obtem_atributo(pol, 'id_compra') == id_cpr # Paranóia. # Verifica se o trecho não foi encerrado id_trc = poltrona.obtem_atributo(pol, 'id_trecho') trc = trecho.busca_por_identificador(id_trc) if not trecho.obtem_atributo(trc, 'encerrado'): abertas_usr.append(pol) return abertas_usr
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
sys.stderr.write("Criando alguns objetos...\n") tabelas.cria_todos_os_testes(False) # ---------------------------------------------------------------------- sys.stderr.write("Testando função...\n") def testa(rotulo, *args): """Testa {funcao(*args)}, grava resultado em "testes/saida/{modulo}.{funcao}.{rotulo}.html".""" modulo = html_form_dados_de_compra 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) # pega admin admin = usuario.busca_por_identificador('U-00000003') # pega compra compra1 = compra.busca_por_identificador('C-00000001') # testa modulo editavel = True testa("edT", compra1, editavel, "Alterar", 'alterar_compra') editavel = False testa("edF", compra1, editavel, "Alterar", 'alterar_compra')
sys.stderr.write( "Inicializando módulo {compra}, limpando tabela, criando compras para teste:\n" ) compra.cria_testes(False) sys.stderr.write("Inicializando módulo {compra}, limpando tabela:\n") compra.inicializa(True) # ---------------------------------------------------------------------- sys.stderr.write("Obtendo dois usuários para teste:\n") usr1 = usuario.busca_por_identificador("U-00000001") usr2 = usuario.busca_por_identificador("U-00000002") cmp1 = compra.busca_por_identificador("C-00000001") cmp2 = compra.busca_por_identificador("C-00000003") # ---------------------------------------------------------------------- # Funções de teste: ok_global = True # Vira {False} se um teste falha. def verifica_compra(rotulo, cpr, ident, cliente, status, nome_pass, doc_pass): """Testes básicos de consistência do objeto {cpr} da classe {Objeto_Compra}, dados {ident} e {atrs} esperados.""" global ok_global sys.stderr.write("%s\n" % ("-" * 70)) sys.stderr.write("verificando compra %s\n" % rotulo)
# ---------------------------------------------------------------------- # Dados para testes: # Um cliente comum: usrC_id = "U-00000001" usrC = usuario.busca_por_identificador(usrC_id) assert not usuario.obtem_atributo(usrC, 'administrador') # Um administrador: usrA_id = "U-00000003" 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
def gera(pol, alterar, comprar, excluir, fazer_checkin, embarcar): assert int(alterar) + int(comprar) + int(excluir) <= 1 # No máximo um deve ser "True" campos = [].copy() # Campos a devolver estilo = "font-size:20px;font-weight:bold;" # Obtem atributos da poltrona: id_pol = poltrona.obtem_identificador(pol) atrs_pol = poltrona.obtem_atributos(pol) numero = atrs_pol['numero'] preco = atrs_pol['preco'] oferta = atrs_pol['oferta'] # Se a poltrona está em oferta. id_cpr = atrs_pol['id_compra'] # Pedido de compra que reservou a poltrona, ou {None} fez_checkin = atrs_pol['fez_checkin'] # Passageiro já fez checkin? embarcou = atrs_pol['embarcou'] # Passageiro já embarcou? if id_cpr != None: # Poltrona está reservada. Determina a compra: cpr = compra.busca_por_identificador(id_cpr) assert cpr != None # Paranóia. else: # Poltrona está livre: cpr = None args_cmd = { 'íd_poltrona': id_pol } # Argumentos para os comandos. # Número da poltrona sempre aparece: ht_numero = html_span.gera(estilo, numero) campos.append(ht_numero) # Preço da poltrona senmpre aparece: ht_preco = html_span.gera(estilo, preco) campos.append(ht_preco) # Indicação de oferta sempre aparece: ht_oferta = html_span.gera(estilo + "color:'#ffbb00';", "★" if oferta else "") campos.append(ht_oferta) # Coluna de identificador da compra sempre aparece: ht_id_cpr = html_span.gera(estilo, id_cpr if cpr != None else "LIVRE") campos.append(ht_id_cpr); # Coluna de "fez checkin" sempre aparece: ht_fez_checkin = html_span.gera(estilo, "CK" if fez_checkin else "") campos.append(ht_fez_checkin); # Coluna de "embarcou" sempre aparece: ht_embarcou = html_span.gera(estilo, "EM" if embarcou else "") campos.append(ht_embarcou); # Coluna do botão "Ver" sempre aparece: ht_bt_ver = html_botao_simples.gera("Ver", "ver_poltrona", {'id_poltrona': id_pol}, "55ee55") campos.append(ht_bt_ver); # Coluna do botão de ação: if alterar: ht_bt_acao = html_botao_simples.gera("Alterar", "solicitar_pag_alterar_poltrona", args_cmd, '#bca360') elif comprar: ht_bt_acao = html_botao_simples.gera("Comprar", 'comprar_poltrona', args_cmd, '#ff0000') elif excluir: ht_bt_acao = html_botao_simples.gera("Excluir", 'excluir_poltrona', args_cmd, '#ff0000') else: ht_bt_acao = "" campos.append(ht_bt_acao); if fazer_checkin: # Campos para checkin: if cpr != None: # Nome e documento do passageiro, e botão de fazer checkin: nome_pass = compra.obtem_atributo(cpr, 'nome_pass') doc_pass = compra.obtem_atributo(cpr, 'doc_pass') ht_nome_pass = html_span.gera(estilo, nome_pass) campos.append(ht_nome_pass); ht_doc_pass = html_span.gera(estilo, doc_pass) campos.append(ht_doc_pass); if fez_checkin: ht_bt_checkin = "" else: # Apresentando o botão fazer checkin somente quando o status é pago if compra.obtem_atributo(cpr, 'status') == 'pago': ht_bt_checkin = html_botao_simples.gera("Checkin", 'fazer_checkin', args_cmd, '#55ee55') campos.append(ht_bt_checkin); else: # Campos em branco: campos.append(""); campos.append(""); campos.append(""); if embarcar: ht_bt_embarcar = "" if fez_checkin: ht_bt_embarcar = html_botao_simples.gera("Embarcar", 'embarcar', args_cmd, '#55ee55') campos.append(ht_bt_embarcar); return campos
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
utils_testes.mostra(0, "Conectando com base de dados...") res = base_sql.conecta("DB", None, None) assert res == None utils_testes.mostra(0, "Criando alguns objetos...") tabelas.cria_todos_os_testes(False) # Compras teste lista_ids = ["C-00000001", "C-00000002", "C-00000003"] def testa(rotulo, *args): modulo = html_resumo_de_compra funcao = modulo.gera # Teste da função {gera} HTML 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) utils_testes.mostra(0, "Realizando testes com html_resumo_de_compra...") for id_compra in lista_ids: cpr = compra.busca_por_identificador(id_compra) assert cpr != None testa(id_compra, cpr, False, lista_ids[0]) testa(''.join([id_compra, "_V"]), cpr, True, lista_ids[1]) utils_testes.mostra(2, "Testes realizados com sucesso!")
def processa(ses, args): # !!! Verificar validade dos argumentos, devolver pag de erro se falhar !!! id_compra = args['id_compra'] cpr = compra.busca_por_identificador(id_compra) pag = html_pag_escolher_pagamento.gera(ses, cpr, None) return pag
# ---------------------------------------------------------------------- sys.stderr.write("Conectando com base de dados...\n") 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.
import tabelas import sessao 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) # Sessão que será utilizada no teste ses1 = sessao.busca_por_identificador("S-00000001") # Compra que será utilizada no teste cpr1 = compra.busca_por_identificador("C-00000001") def testa(rotulo, *args): """Testa {funcao(*args)}, grava resultado em "testes/saida/{modulo}.{funcao}.{rotulo}.html".""" modulo = html_pag_ver_compra 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) # Testa com e sem a opção de excluir habilitada testes = ( \
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
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) assert usuario.obtem_atributo(usr_adm3, 'administrador') id_cpr_com2 = "C-00000001" cpr_com2 = compra.busca_por_identificador(id_cpr_com2) usr_com2 = compra.obtem_cliente(cpr_com2)