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
