def filtra_por_datas(trcs_ids, data_min, data_max): """A partir e um conjunto de ids de trechos, devolve os ids daqueles que possuem o atributo {data_partida} + {hora_partida} superior à {data_min} e o atributo {data_chegada} + {hora_chegada} inferior à {data_max}.""" if data_min == data_max == None: # Não há o que filtrar return trcs_ids trcs = map(lambda id_trecho: trecho.busca_por_identificador(id_trecho), trcs_ids) lista_retorno = [] for trc in trcs: atrs_trc = trecho.obtem_atributos(trc) data_min_trc = atrs_trc['dia_partida'] + " " + atrs_trc['hora_partida'] data_max_trc = atrs_trc['dia_chegada'] + " " + atrs_trc['hora_chegada'] if data_min is not None and data_max is not None: if data_min <= data_min_trc and data_max_trc <= data_max: lista_retorno.append(trecho.obtem_identificador(trc)) else: if data_min is not None: if data_min <= data_min_trc: lista_retorno.append(trecho.obtem_identificador(trc)) if data_max is not None: if data_max_trc <= data_max: lista_retorno.append(trecho.obtem_identificador(trc)) return lista_retorno
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): assert ses != None, "Este comando só pode ser usado após login" assert sessao.eh_administrador( ses), "Este comando é reservado para administradores" args = args.copy() # Por via das dúvidas. # Trecho a alterar: id_trc = args["id_trecho"] if 'id_trecho' in args else None assert id_trc != None # Paranoia (formulario deve incluir). args.pop("id_trecho") trc = trecho.busca_por_identificador(id_trc) assert trc != None try: atrs_muda = {'encerrado': True} trecho.muda_atributos(trc, atrs_muda) # Repete a página de ver trecho com valores correntes (alterados): pag = html_pag_trecho.gera(ses, trc, None, "Trecho encerrado") except ErroAtrib as ex: erros = ex.args[0] # Repete a página de ver trecho com os mesmos argumentos e mens de erro: pag = html_pag_trecho.gera(ses, trc, args, erros) return pag
def processa(ses, args): admin = False if ses == None else sessao.eh_administrador(ses) assert admin # Paranóia (cliente comum e deslogado não deeveria ter acesso a este cmd) # Obtem o trecho a clonar e seus atributos: id_trc = args['id_trecho'] if 'id_trecho' in args else None assert id_trc != None # Paranóia (formulário/botão deveria especificar). del args['id_trecho'] trc = trecho.busca_por_identificador(id_trc) assert id_trc != None # Paranóia. # Obtem os atributos correntes do trecho: atrs_clone = trecho.obtem_atributos(trc) # Elimina atributos que não podem ser mantidos: del atrs_clone['dia_partida'] del atrs_clone['hora_partida'] del atrs_clone['dia_chegada'] del atrs_clone['hora_chegada'] # Acrescenta especificação de poltronas: ids_pols = poltrona.busca_por_trecho(trc) nums_precos = poltrona.obtem_numeros_e_precos(ids_pols) esp_poltronas = resume_numeros_e_precos(nums_precos) atrs_clone['poltronas'] = esp_poltronas # Mostra página de novo trecho com esses atributos: pag = html_pag_trecho.gera(ses, None, atrs_clone, None) return pag
def gera(ses, rot, erros): ver_roteiro = False # Já estamos vendo o roteiro. campos_resumo = html_resumo_de_roteiro.gera(rot, ver_roteiro) ht_resumo = "".join(str(campos_resumo)) # ??? EXPANDIR COMO {html_pag_ver_compra} alterar_trcs = False # Não deve ter botões de "Alterar". ht_trechos = html_lista_de_trechos.gera(rot, alterar_trcs) ht_conteudo = ht_resumo + "<br/>" + ht_trechos ids_trechos = roteiro.obtem_identificadores_de_trechos(rot) ids_trechos_txt = ",".join(ids_trechos) # verifica se todos os trechos estao disponivels roteiro_disponivel = True for id_trc in ids_trechos: trc = trecho.busca_por_identificador(id_trc) roteiro_disponivel = roteiro_disponivel and not trecho.obtem_atributo(trc, 'encerrado') if roteiro_disponivel: atrs_comprar = {'ids_trechos': ids_trechos_txt} ht_comprar = html_botao_simples.gera("Comprar", "comprar_roteiro", atrs_comprar, "#22ff22") ht_conteudo += "<br/>" + ht_comprar pag = html_pag_generica.gera(ses, ht_conteudo, erros) return pag
def pode_comprar(usr, pol, cpr): global cache, nome_tb, letra_tb, colunas, diags if cpr == None or pol == None or cpr == None: return False assert type(usr) is usuario.Objeto_Usuario assert type(pol) is poltrona.Objeto_Poltrona assert type(cpr) is compra.Objeto_Compra # A compra {cpr} ainda está aberta? if compra.obtem_atributo(cpr, 'status') != 'comprando': return False # A poltrona {pol} está livre? id_cpr_pol = poltrona.obtem_atributo(pol, 'id_compra'); if id_cpr_pol != None: return False # O trecho da poltrona {pol} ainda está disponível? 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 # Há incompatibilidade de horários com as poltronas já em {cpr}? if not compra.trecho_eh_compativel(cpr, trc_pol): return False # Pode comprar, parece: return True
def testa_acrescenta_trecho_invalido(id_trecho_ult, id_trecho_prox): """Testa a criação de um novo trecho com falha, dados o maior identificador válido {id_trecho_ult} e o menor inválido {id_trecho_prox}.""" assert trecho.busca_por_identificador(id_trecho_ult) != None assert trecho.busca_por_identificador(id_trecho_prox) == None args = { 'codigo': "AZ 2345", 'origem': "SDU", 'dia_partida': "2020-05-25", 'hora_partida': "13:40", 'dia_chegada': "2020-05-26", 'hora_chegada': "06:23", } testa("Inv", ses, args) trc_novo = trecho.busca_por_identificador(id_trecho_prox) assert trc_novo == None
def processa(ses, args): id_poltronas = poltrona.busca_ofertas() poltronas = [poltrona.busca_por_identificador(id) for id in id_poltronas] id_trechos = list( set([poltrona.obtem_atributo(pol, 'id_trecho') for pol in poltronas])) trechos = [trecho.busca_por_identificador(id) for id in id_trechos] pag = html_pag_ofertas.gera(ses, trechos, None) return pag
def testa_atualiza_atributo_com_sucesso(): args = {'id_trecho': "T-00000001", 'destino': 'POA'} testa("Suc", ses, args) updated_trecho = trecho.busca_por_identificador("T-00000001") assert trecho.obtem_atributo(updated_trecho, "destino") == 'POA', "Trecho não atualizado"
def testa_encerra_trecho(): args = {'id_trecho': "T-00000001"} # Executa comando de teste testa("Suc", ses, args) # Valida se teste funcionou trc = trecho.busca_por_identificador("T-00000001") # Verifica se alterou: assert trecho.obtem_atributo(trc, 'encerrado'), "Não encerrou o trecho"
def processa(ses, args): admin = False if ses == None else sessao.eh_administrador(ses) assert admin # Paranóia (cliente comum e deslogado não deveria ter acesso a este cmd). # Obtem o trecho a alterar: id_trc = args['id_trecho'] if 'id_trecho' in args else None assert id_trc != None # Paranóia (formulário deveria especificar). trc = trecho.busca_por_identificador(id_trc) assert trc != None # Paranóia. pag = html_pag_trecho.gera(ses, trc, None, None) return pag
def trecho_eh_compativel(cpr, trc): global cache, nome_tb, letra_tb, colunas, diags assert cpr != None and type(cpr) is compra.Objeto_Compra for id_pol in obtem_poltronas(cpr): pol = poltrona.busca_por_identificador(id_pol) id_trc_pol = poltrona.obtem_atributo(pol, 'id_trecho') # Verifca se {trc} é compatível com o trecho da polrona {pol}: trc_pol = None if id_trc_pol == None else trecho.busca_por_identificador( id_trc_pol) assert trc_pol != None # Paranóia. if not trecho.horarios_sao_compativeis(trc, trc_pol): return False # Todos compatíveis return preco
def processa(ses, args): # Validações, por via das dúvidas: assert 'id_trecho' in args # Deveria acontecer # Monta página: id_trecho = args['id_trecho'] trc = trecho.busca_por_identificador(id_trecho) if trc == None: erros = ["trecho \"" + id_trecho + "\" não existe"] pag = html_pag_mensagem_de_erro(ses, erros) else: pag = html_pag_trecho.gera(ses, trc, None, None) return pag
def processa(ses, args): # Usuário deve estar logado para iniciar um pedido de compra if ses == None: pag = html_pag_mensagem_de_erro.gera( ses, ["Voce deve estar logado para comprar um roteiro!"]) return pag cpr = sessao.obtem_carrinho(ses) if cpr == None: # Novo carrinho associada ao usuario compra.cria(ses.cliente, ses.cliente.nome_pass, ses.cliente.doc_pass) # Recupera os objetos trechos para verificar poltronas ids_trechos = args['ids_trechos'].split(',') obj_trechos = [] for id in ids_trechos: obj_trechos.append(trecho.busca_por_identificador(id)) # Verifica e inclui poltronas na compra for trc in obj_trechos: # Verifica se o trecho possui pelo menos uma poltrona livre if trecho.numero_de_poltronas_livres(trc) < 1: pag = html_pag_mensagem_de_erro.gera(ses, [ "Nao tem mais poltronas livres no trecho {} :(".format( trecho.obtem_atributo(trc, "codigo")) ]) return pag # Obtem lista de poltronas livres para comparacao do melhor preco id_pol_livres = poltrona.lista_livres(trc) melhor_preco = math.inf id_melhor_preco = None for id_pol in id_pol_livres: pol = poltrona.busca_por_identificador(id_pol) preco_pol = poltrona.obtem_atributo(pol, "preco") # Atualiza melhor preco, assim como seu id if preco_pol < melhor_preco: melhor_preco = preco_pol id_melhor_preco = id_pol # Adiciona a poltrona ao carrinho comando_comprar_poltrona.processa(ses, {'id_poltrona': id_melhor_preco}) pag = comando_ver_carrinho.processa(ses, None) 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 processa(ses, args): try: # Por via das dúvidas: if args == None: args = {}.copy() erros = [].copy() # Obtem os campos sem defaults: origem = args['origem'] if 'origem' in args else None dia_partida = args['dia_partida'] if 'dia_partida' in args else None destino = args['destino'] if 'destino' in args else None dia_chegada = args['dia_chegada'] if 'dia_chegada' in args else None # Verifica campos obrigatórios: if origem == None and destino == None: erros.append( "um dos campos 'origem' e 'destino' deve ser especificado") if dia_partida == None: erros.append("o campo 'dia_partida' deve ser especificado") if dia_chegada == None: erros.append("o campo 'dia_chegada' deve ser especificado") # Obtem horas e providencia defaults: hora_partida = args[ 'hora_partida'] if 'hora_partida' in args else "00:00" hora_chegada = args[ 'hora_chegada'] if 'hora_chegada' in args else "00:00" if len(erros) > 0: raise ErroAtrib(erros) # Monta datas completas: data_min = dia_partida + " " + hora_partida + " UTC" data_max = dia_chegada + " " + hora_chegada + " UTC" # Busca trechos: trcs_ids = trecho.busca_por_origem_e_destino(origem, destino, data_min, data_max) trcs = map(lambda id_trecho: trecho.busca_por_identificador(id_trecho), trcs_ids) alterar_trcs = sessao.eh_administrador(ses) bloco = html_lista_de_trechos.gera(trcs, alterar_trcs) pag = html_pag_generica.gera(ses, bloco, None) return pag except ErroAtrib as ex: erros = ex.args[0] # Repete a página com mensagens de erro: admin = sessao.eh_administrador(ses) pag = html_pag_buscar_trechos.gera(ses, args, admin, 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 testa_acrescenta_trecho_com_sucesso(id_trecho_ult, id_trecho_prox): """Testa a criação de um novo trecho com sucesso, dados o maior identificador válido {id_trecho_ult} e o menor inválido {id_trecho_prox}.""" assert trecho.busca_por_identificador(id_trecho_ult) != None assert trecho.busca_por_identificador(id_trecho_prox) == None args = { 'codigo': "AZ 2345", 'origem': "SDU", 'destino': "GRU", 'dia_partida': "2020-05-25", 'hora_partida': "13:40", 'dia_chegada': "2020-05-26", 'hora_chegada': "06:23", 'veiculo': "jegue003", 'poltronas': "1A-12D: 90.00", 'encerrado': False } testa("Suc", ses, args) trc_novo = trecho.busca_por_identificador(id_trecho_prox) assert trc_novo != None atrs_novo = trecho.obtem_atributos(trc_novo) assert atrs_novo == args
def gera(pol, id_compra, ver, excluir): # Atributos da poltrona: id_pol = poltrona.obtem_identificador(pol) atrs_pol = poltrona.obtem_atributos(pol) assert atrs_pol['id_compra'] == id_compra preco_pol = atrs_pol['preco'] numero_pol = atrs_pol['numero'] # Atributos do trecho da poltrona id_trecho = atrs_pol['id_trecho'] trc = trecho.busca_por_identificador(id_trecho) atrs_trc = trecho.obtem_atributos(trc) origem_trc = atrs_trc['origem'] dt_partida_trc = atrs_trc['dia_partida'] + ' ' + atrs_trc['hora_partida'] destino_trc = atrs_trc['destino'] dt_chegada_trc = atrs_trc['dia_chegada'] + ' ' + atrs_trc['hora_chegada'] # Campos da linha para {html_table.gera}: ht_trecho = html_span.gera(None, id_trecho) ht_origem = html_span.gera(None, origem_trc) ht_dt_partida = html_span.gera(None, dt_partida_trc) ht_destino = html_span.gera(None, destino_trc) ht_dt_chegada = html_span.gera(None, dt_chegada_trc) ht_numero = html_span.gera(None, numero_pol) ht_preco = html_span.gera(None, preco_pol) linha = [ \ ht_trecho, ht_origem, ht_dt_partida, ht_destino, ht_dt_chegada, ht_numero, ht_preco ] ver = True # Por enquanto. if ver: args_ver = {'id_poltrona': id_pol} ht_ver = html_botao_simples.gera("Ver", 'ver_poltrona', args_ver, '#60a3bc') linha.append(ht_ver) linha.append("</form>") if excluir: args_excluir = {'id_poltrona': id_pol, 'id_compra': id_compra} ht_excluir = html_botao_simples.gera("Excluir", 'excluir_poltrona', args_excluir, '#ff4422') linha.append(ht_excluir) return linha
def processa(ses, args): # Obtem os identificadores dos trechos do roteiro a mostrar: ids_trcs_str = args['ids_trechos'] if 'ids_trechos' in args else None assert ids_trcs_str != None and type(ids_trcs_str) is str # Paranóia (formulário deveria fornecer). ids_trcs = ids_trcs_str.split(",") # Obtem o roteiro (lista de trechos): rot = [].copy() for id_trc in ids_trcs: trc = trecho.busca_por_identificador(id_trc) rot.append(trc) if len(rot) == 0: erros = ["Roteiro vazio!"] pag = html_pag_mensagem_de_erro.gera(ses, erros) else: pag = html_pag_ver_roteiro.gera(ses, rot, None) return pag
def processa(ses, args): args = args.copy() # Por via das dúvidas. id_trc = args["id_trecho"] assert id_trc != None # Paranóia (formulário deve incluir). args.pop("id_trecho") trc = trecho.busca_por_identificador(id_trc) assert trc != None # Paranóia. # Tenta editar o trecho: try: trecho.muda_atributos(trc, args) # Repete a página de alterar trecho com valores correntes (alterados): pag = html_pag_trecho.gera(ses, trc, None, None) except ErroAtrib as ex: erros = ex.args[0] # Repete a página de alterar trecho com os mesmos argumentos e mens de erro: pag = html_pag_trecho.gera(ses, trc, args, erros) return pag
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 livre_mais_proxima(pol, preco_max): global cache, nome_tb, letra_tb, colunas, diags dist_pol_desejada = -1 id_trc = poltrona.obtem_atributo(pol, 'id_trecho') trc = trecho.busca_por_identificador(id_trc) ids_livres = lista_livres(trc) id_pol = poltrona.obtem_identificador(pol) pol_desejada = None if len(ids_livres) != 0: for id in ids_livres: if (id != id_pol): pol_aux = poltrona.busca_por_identificador(id) dist_aux = distancia(pol, pol_aux) preco_aux = obtem_atributo(pol_aux, 'preco') if (dist_pol_desejada == -1 and preco_aux <= preco_max): pol_desejada = pol_aux dist_pol_desejada = dist_aux else: if (dist_aux < dist_pol_desejada and preco_aux <= preco_max): pol_desejada = pol_aux dist_pol_desejada = dist_aux return pol_desejada
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) # Trechos de teste (somente id): trc1_id = "T-00000001" # Não encerrado. trc1 = trecho.busca_por_identificador(trc1_id) assert not trecho.obtem_atributo(trc1, 'encerrado') trc6_id = "T-00000006" # Encerrado. trc6 = trecho.busca_por_identificador(trc6_id) assert trecho.obtem_atributo(trc6, 'encerrado') # ---------------------------------------------------------------------- # Atributos para criação de novo trecho: atrs_nov = { 'codigo': 'AZ 3344', 'origem': 'GRU', 'destino': 'RAO', 'dia_partida': '2020-05-02', 'dia_chegada': '2020-05-02' }
pretty = False # Se {True}, formata HTML para legibilidate (mas introduz brancos nos textos). utils_testes.testa_gera_html(modulo, funcao, rotulo, frag, pretty, *args) testes = ( \ ( "U-00000001", "T-00000001", ), # Cliente comum. ( "U-00000001", "T-00000002", ), # Cliente comum. ( "U-00000003", "T-00000003" ), # Admin. ( "U-00000003", "T-00000004", ), # Admin. ( None, "T-00000005", ), # Usuario deslogado. ) for usr_id, trc_id in testes: usr = None if usr_id == None else usuario.busca_por_identificador(usr_id) admin = False if usr == None else usuario.obtem_atributo( usr, 'administrador') usr_cprs = [] if usr == None else usuario.compras_abertas(usr) carr = None if len(usr_cprs) == 0 else usr_cprs[ 0] # Faz de conta que a primeira compra é o carrinho. id_carr = None if carr == None else compra.obtem_identificador(carr) trc = None if trc_id == None else trecho.busca_por_identificador(trc_id) assert trc != None ids_pols = trecho.obtem_poltronas(trc) fazer_checkin = admin #por enquanto rot = trc_id + "-" + str(usr_id) + "-" + str(id_carr) rot += "-admin" + str(admin)[0] rot += "-fzck" + str(fazer_checkin)[0] testa(rot, ids_pols, usr, carr)
sys.stderr.write("Resumo retornado:" + str(resumo) + '\n') except: aviso_prog('Teste da função {obtem_resumo} falhou',True) return False return True sys.stderr.write("Conectando com base de dados...\n") res = base_sql.conecta("DB",None,None) trecho.inicializa(False) trecho.cria_testes(False) sys.stderr.write("----------" * 7 + "\n") sys.stderr.write("Testando {roteiro.obtem_resumo}\n") trc_VCP_SDU_1 = trecho.busca_por_identificador("T-00000001") trc_VCP_SDU_2 = trecho.busca_por_identificador("T-00000002") trc_SDU_POA_1 = trecho.busca_por_identificador("T-00000004") trc_POA_MAO_1 = trecho.busca_por_identificador("T-00000005") trc_SDU_MAO_1 = trecho.busca_por_identificador("T-00000006") rot1 = [ trc_VCP_SDU_1, trc_SDU_POA_1, trc_POA_MAO_1] rot2 = [ trc_VCP_SDU_1, trc_SDU_MAO_1 ] rot3 = [ trc_VCP_SDU_2, trc_SDU_MAO_1 ] ok = True ok = ok and testa_obtem_resumo(rot1) ok = ok and testa_obtem_resumo(rot2) ok = ok and testa_obtem_resumo(rot3) sys.stderr.write("----------" * 7 + "\n") sys.stderr.write("Testando {roteiro.descobre_todos}\n")
def descobre_todos_rec(origem, data_min, prefixo, destino, data_max, soh_disponiveis): """Função auxiliar da função {descobre_todos}. O parâmetro {prefixo} é o roteiro parcial que atualmente esta sendo montado. Se não for uma lista vazia, deve ser um roteiro válido que começa em {origem}, não antes de {data_min}. A função calcula recursivamente todos as extensões válidas do {prefixo} que saem do aeroporto onde este termina e terminam em {destino}, e devolve uma lista de todos esses roteiros. Para ser válido, um roteiro não pode terminar depois de {data_max}, e cada trecho além do primeiro deve sair do mesmo aeroporto onde o trecho anterior chegou, com intervalo de tempo suficiente para a baldeação. As datas devem ter o formato "aaaa-mm-dd HH:MM UTC". """ debug = True # Pega o último trecho do prefixo: trc_prev = None if len(prefixo) == 0 else prefixo[-1]; if debug: sys.stderr.write(" " * len(prefixo)) sys.stderr.write("trc_prev = %s\n" % trecho.mostra(trc_prev)) assert (trc_prev == None) or (type(trc_prev) is trecho.Objeto_Trecho) # Pega o aeroporto final do {prefixo} etapa = origem if trc_prev == None else trecho.obtem_atributo(trc_prev, 'destino') if etapa == destino: # Este prefixo é uma slução e não adianta tentar estendê-lo: return [ prefixo ] rots = [].copy() # Os roteiros encontrados que começam com {prefixo}. # Pega todos os trechos que saem de {etapa}: for id_trc_prox in trecho.busca_por_origem(etapa): trc_prox = trecho.busca_por_identificador(id_trc_prox) assert trc_prox != None # Paranóia. # Verifica tempo. Este é o teste que impede recursão infinita. if trc_prev != None: # Verifica se há tempo suficiente para a baldeação: dt_sai_ok = trecho.horarios_sao_compativeis(trc_prev, trc_prox) else: # Verifica se {trc_prox} não sai antes da data mínima de partide: data_sai = trecho.obtem_dia_e_hora_de_chegada(trc_prox) dt_sai_ok = (data_sai >= data_min) if not dt_sai_ok: continue if soh_disponiveis: # Verifica se este trecho está não encerrado para compra: disp = trecho.verificar_disponibilidade(trc_prox) if not disp: continue # Verifica se este trecho termina antes da data limite: data_chg = trecho.obtem_dia_e_hora_de_partida(trc_prox) data_chg_ok = (data_chg <= data_max) if not data_chg_ok: continue # Emenda este trecho no prefixo e busca recursivamente: prefixo1 = prefixo + [ trc_prox ] rots1 = descobre_todos_rec(origem, data_min, prefixo1, destino, data_max, soh_disponiveis) rots += rots1 # Esgotou todas as possiveis extensoes do {prefixo}: return rots
def obtem_origem_destino(pol): id_trc = obtem_atributo(pol, 'id_trecho'); trc = trecho.busca_por_identificador(id_trc); origem = trecho.obtem_atributo(trc, 'origem') destino = trecho.obtem_atributo(trc, 'destino') return origem, destino
def obtem_dia_e_hora_de_chegada(pol): global cache, nome_tb, letra_tb, colunas, diags assert pol != None and type(pol) is poltrona.Objeto_Poltrona id_trc = obtem_atributo(pol, 'id_trecho'); trc = trecho.busca_por_identificador(id_trc); return trecho.obtem_dia_e_hora_de_chegada(trc)
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