def extrai_dados_de_formulario(self):
"""Se o comando é 'POST', extrai os dados do formulário, dos
campos {self.rfile} e {self, headers}, na forma de um dicionário Python."""
ffs = {}.copy() # Novo dicionário.
if self.command == 'POST':
formulario = cgi.FieldStorage(fp=self.rfile,
headers=self.headers,
environ={
'REQUEST_METHOD':
'POST',
'CONTENT_TYPE':
self.headers['Content-Type']
})
# Enumera os nomes dos campos presentes no formulário:
for chave in formulario.keys():
# Pega a lista de todos os campos com nome {chave}:
item_list = formulario.getlist(chave)
# Enumera os campos com esse nome:
for val in item_list:
# Armazena no dicionário:
if chave in ffs:
erro_prog(
"o formulário tem mais de um campo com nome '" +
chave + "'")
ffs[chave] = val
return ffs
def cria_tabela(nome_tb, cols):
colunas = constroi_colunas_SQL(cols)
res = base_sql.executa_comando_CREATE_TABLE(nome_tb, colunas)
if res != None:
sys.stderr.write("CREATE TABLE = \"%s\"\n" % str(res))
assert type(res) is str
erro_prog("CREATE_TABLE falhou " + str(res))
return
def limpa_tabela(nome_tb, cols):
res = base_sql.executa_comando_DROP_TABLE(nome_tb)
if res != None:
assert type(res) is str
erro_prog("DROP_TABLE de " + nome_tb + " falhou, res = '" + str(res) +
"' falhou")
cria_tabela(nome_tb, cols)
return
def verifica_resultado(rotulo, res_cmp, res_esp):
"""Verifica se o resultado {res_cmp} de uma chamada é o resultado esperado {res_esp}."""
sys.stderr.write(rotulo + ": ")
sys.stderr.write("tipo resultado = \"" + str(type(res_cmp)) + "\"")
assert type(res_cmp) is list or type(res_cmp) is tuple
if res_cmp != res_esp:
erro_prog("resultado = \"" + str(res_cmp) + "\" não é o esperado = \"" + str(res_esp) + "\"")
else:
sys.stderr.write(" CONFERE\n")
def busca_por_campos(args, unico, cache, nome_tb, letra_tb, colunas):
global diags
res = tabela_generica.busca_por_campos(nome_tb, letra_tb, colunas, args, None)
if res == None: res = [].copy() # Just in case.
if type(res) is list or type(res) is tuple:
return res
elif type(res) is str:
erro_prog("busca na tabela falhou, res = " + res)
else:
erro_prog("busca na tabela devolveu resultado inválido, res = \"" + str(res) + "\"")
def busca_por_semelhanca(nome_tb, let, cols, chaves, valores):
cond = ""
for key in chaves:
for value in valores:
cond += (key + " LIKE '%" + value + "%' OR ")
cond = cond[:-4]
res = base_sql.executa_comando_SELECT(nome_tb, cond, ['indice'])
if res != None and type(res) is str:
erro_prog("SELECT falhou " + str(res))
sys.stderr.write("busca_por_semelhanca: res = " + str(res) + "\n")
res = identificador.de_lista_de_indices(let, res)
return res
def gera_input(tipo, chave, val, vmin, dica, editavel, obrigatorio):
"""Retorna o HTML de um elemento <input> ou <textarea>...</textarea>.
O elemento terá o dado {tipo} ("text", "password", etc.), nome {chave},
valor inicial {val}, valor mínimo {vmin}, e a {dica} especificada
(se {val} for {None}). Se {tipo} for "textarea", gera um
<textarea> em vez de <input>.
O valor inicial {val} é convertido para string de maneira adequada ao
seu tipo python. Em particular, valor {float} é formatado com 2 casas
depois do ponto decimal.
Se a chave for 'senha', não mostra o {val}. Se {tipo}
não for "number", ignora {vmin}. """
if chave == 'senha': val = None
if chave == 'conf_senha': val = None
# Converte val para HTML:
if val == None:
ht_valor = None
elif type(val) is str:
ht_valor = val
elif type(val) is bool:
ht_valor = ('on' if val else 'off')
elif type(val) is float:
ht_valor = ("%.2f" % val)
elif type(val) is int:
ht_valor = ("%d" % val)
else:
erro_prog("valor inválido = \"" + str(val) + "\"")
# Converte o valor mínimo para HTML:
if tipo == 'number':
ht_vmin = str(vmin)
else:
ht_vmin = None
# Dica e valor inicial são mutuamente exclusivos:
if ht_valor == None:
ht_dica = dica
else:
ht_dica = None
# Cozinhada: tipo "textarea" é um elemento diferente.
if tipo != "textarea":
ht_campo = html_input.gera(None, tipo, chave, ht_valor, ht_vmin,
editavel, obrigatorio, ht_dica, None)
else:
ht_campo = html_textarea.gera(None, chave, ht_valor, editavel,
obrigatorio, ht_dica, None)
return ht_campo
def unico_elemento(ids):
if ids == None:
return None
elif type(ids) is list or type(ids) is tuple:
if len(ids) == 0:
return None
elif len(ids) == 1:
id = ids[0]
return id
else:
erro_prog("elemento não é único")
else:
erro_prog("argumento não é {None} ou lista")
def de_lista_de_indices(let, indices):
ids = [].copy()
if indices != None:
assert type(indices) is tuple or type(indices) is list
# Resultado deve ser uma lista de tuplas, cada uma contendo apenas um índice:
for el in indices:
if type(el) is int:
ids.append(de_indice(let, el))
elif type(el) is tuple or type(el) is list:
assert len(el) == 1
ids.append(de_indice(let, el[0]))
return ids
else:
erro_prog("tipo de " + str(indices) + " inválido")
def valor_mem_para_valor_SQL(nome, val_mem, tipo_mem, tipo_SQL, nulo_ok):
if val_mem == None:
if nulo_ok:
return None
else:
erro_prog("atributo '" + nome + "' não pode ser {None}")
if type(val_mem) != tipo_mem:
erro_prog("atributo " + str(val_mem) + " com tipo incorreto")
elif type(val_mem) is str:
assert tipo_SQL == 'TEXT'
val_SQL = val_mem
elif type(val_mem) is int:
assert tipo_SQL == 'INTEGER'
val_SQL = val_mem
elif type(val_mem) is float:
assert tipo_SQL == 'FLOAT'
val_SQL = val_mem
elif type(val_mem) is bool:
assert tipo_SQL == 'INTEGER'
val_SQL = (1 if val_mem else 0)
elif type(val_mem) is list or type(val_mem) is tuple or type(
val_mem) is dict:
erro_prog("valor " + str(val_mem) + " não pode ser convertido")
else:
# Supõe que é objeto. Obtem o id:
if tipo_SQL != 'TEXT':
erro_prog("tipo SQL do atributo '" + nome +
"' deveria ser 'TEXT' mas é '" + tipo_SQL + "'")
val_SQL = objeto.obtem_identificador(val_mem)
return val_SQL
def acrescenta(nome_tb, cache, let, cols, def_obj, atrs_SQL):
# Descobre o indice da última entrada na tabela:
num_ents = base_sql.num_entradas(nome_tb, 'indice')
if not type(num_ents) is int:
erro_prog("base_sql.num_entradas: result = '" + str(num_ents) + "'")
# Tenta criar o objeto:
ind = num_ents + 1 # Indice esperado do objeto na tabela.
ident = identificador.de_indice(let, ind)
obj = def_obj(None, ident, atrs_SQL)
# Insere na base de dados e obtém o índice na mesma:
ind_insert = base_sql.executa_comando_INSERT(nome_tb, atrs_SQL)
if (not type(ind_insert) is int) or (ind_insert != ind):
erro_prog("indice de inserção inválido " + str(ind))
cache[ident] = obj
return obj
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 atualiza(nome_tb, cache, let, cols, def_obj, ident, mods_SQL):
# Obtém o objeto com esse identificador e garante que está em {cache}:
obj = busca_por_identificador(nome_tb, cache, let, cols, def_obj, ident)
if obj == None:
# Objeto não existe:
erro_prog("identificador '" + ident + "' nao encontrado")
# Atualiza os atributos do objeto na memória:
res = def_obj(obj, ident, mods_SQL)
assert res == obj
# Atualiza a base de dados:
ind = identificador.para_indice(let, ident)
cond = "indice = " + str(ind)
res = base_sql.executa_comando_UPDATE(nome_tb, cond, mods_SQL)
if res != None:
erro_prog("UPDATE da tabela '" + nome_tb + "' falhou")
return obj
def mostra_obj(rotulo, obj, id, atrs):
"""Imprime usuário {obj} e compara seus atributos com {id,atrs}."""
sys.stderr.write(rotulo + " = \n")
if obj == None:
sys.stderr.write(" None\n")
elif type(obj) is str:
sys.stderr.write(" " + obj + "\n")
assert False
elif type(obj) is ObjBobo:
sys.stderr.write(" id = " + str(obj.id) + "\n")
sys.stderr.write(" atrs = " + str(obj.atrs) + "\n")
if atrs != None:
id_confere = (obj.id == id)
atrs_conferem = (obj.atrs == atrs)
sys.stderr.write(" CONFERE: " + str(id_confere) + ", " + str(atrs_conferem) + "\n")
else:
erro_prog("resultado " + str(obj) + " não é objeto do tipo correto")
def cria_obj_mem(id, atrs_SQL):
"""Cria um novo objeto da classe {Objeto_Poltrona} com
identificador {id} e atributos {atrs_SQL}, tais como extraidos
da tabela de sessoes. O objeto *NÃO* é inserido na base de dados.
Os valores em {atr_SQL} são convertidos para valores
equivalentes na memória."""
global cache, nome_tb, letra_tb, colunas, diags
# Converte atributos para formato na memória. Todos devem estar presentes:
atrs_mem = conversao_sql.dict_SQL_para_dict_mem(atrs_SQL, colunas, False, tabelas.id_para_objeto)
if diags: mostra(2,"criando objeto, atrs_mem = " + str(atrs_mem))
assert type(atrs_mem) is dict
if len(atrs_mem) != len(colunas):
erro_prog("numero de atributos = " + str(len(atrs_mem)) + " devia ser " + str(len(colunas)))
obj = poltrona.Objeto_Poltrona(id, atrs_mem)
return obj
def busca_por_campo(nome_tb, let, cols, chave, valor, res_cols):
# Converte {valor} para string na linguagem SQL:
valor = base_sql.codifica_valor(valor)
# Supõe que o cache é um subconjuto da base em disco, então procura só na última:
cond = chave + " = " + valor
if res_cols == None:
cols = ['indice']
else:
cols = res_cols
res = base_sql.executa_comando_SELECT(nome_tb, cond, cols)
if res == None:
res = [].copy()
elif type(res) is str:
erro_prog("SELECT falhou " + str(res))
else:
if res_cols == None:
# Converte lista de índices para lista de identificadores:
res = identificador.de_lista_de_indices(let, res)
return res
def codifica_valor(val):
# !!! (MAIS TARDE) Deveria proteger caracteres especiais em {val}, como ';'. !!!
global conexao, diags
if val == None:
return "NULL"
elif type(val) is int:
return str(val)
elif type(val) is str:
return "'" + val + "'"
elif type(val) is float:
return ("%.2f" % val)
elif type(val) is bool:
if val:
return "1"
else:
return "0"
else:
erro_prog("valor " + str(val) + " tipo = " + str(type(val)) +
" invalido")
return None
def verifica_poltrona(rotulo, pol, ident, atrs):
"""Testes básicos de consistência do objeto {pol} da classe {Objeto_Poltrona}, dados
{ident} e {atrs} esperados."""
global ok_global
sys.stderr.write("%s\n" % ("-" * 70))
sys.stderr.write("verificando poltrona %s\n" % rotulo)
ok = poltrona.verifica(pol, ident, atrs)
if pol != None and type(pol) is poltrona.Objeto_Poltrona:
pass # Objeto não está com problemas, poltrona é válido
else:
ok = False
erro_prog("algo falhou")
if not ok:
aviso_prog("teste falhou", True)
ok_global = False
sys.stderr.write("%s\n" % ("-" * 70))
return
def cria_obj_mem(id, atrs_SQL):
"""Cria um novo objeto da classe {Objeto_Usuario} com
identificador {id} e atributos {atrs_SQL}, tais como extraidos
da tabela de sessoes. O objeto *NÃO* é inserido na base de dados.
Os valores em {atr_SQL} são convertidos para valores
equivalentes na memória."""
global cache, nome_tb, letra_tb, colunas, diags
# Converte atributos para formato na memória. Todos devem estar presentes:
atrs_mem = conversao_sql.dict_SQL_para_dict_mem(atrs_SQL, colunas, False,
tabelas.id_para_objeto)
if diags: mostra(2, "criando objeto, atrs_mem = " + str(atrs_mem))
assert type(atrs_mem) is dict
if len(atrs_mem) != len(colunas):
erro_prog("numero de atributos = " + str(len(atrs_mem)) +
" devia ser " + str(len(colunas)))
# Paranóia: verifica de novo a unicidade de CPF e email:
for chave in ('CPF', 'email'):
if chave not in atrs_mem:
erro_prog("falta atributo '" + chave + "'")
else:
val = atrs_mem[chave]
unico = True
id_bus = objeto.busca_por_campo(chave, val, unico, cache, nome_tb,
letra_tb, colunas)
if id_bus != None:
erro_prog("usuário com '" + chave + "' = '" + val +
"' já existe: " + id + " " + id_bus)
obj = usuario.Objeto_Usuario(id, atrs_mem)
return obj
def busca_por_identificador_e_indice(nome_tb, cache, let, cols, def_obj, ident,
ind):
"""Função interna: mesmo que {busca_por identificador}, mas exige o índice inteiro {ind}
da linha da tabela, além do identificador {ident}."""
cond = "indice = " + str(ind)
col_nomes = extrai_nomes_de_colunas_SQL(cols)
res = base_sql.executa_comando_SELECT(nome_tb, cond, col_nomes)
sys.stderr.write("busca_por_identificador_e_indice: res = " + str(res) +
"\n")
if res == None:
return None
res = list(res)
if len(res) == 0:
return None
elif len(res) > 1:
erro_prog("SELECT com índice em '" + nome_tb +
"' não é único, res = " + str(res))
col_vals = list(res[0])
assert len(col_vals) == len(col_nomes)
atrs_SQL = dict(zip(col_nomes, col_vals))
obj = def_obj(None, ident, atrs_SQL)
cache[ident] = obj
return obj
def valor_SQL_para_valor_mem(nome, val_SQL, tipo_SQL, tipo_mem, nulo_ok,
id_para_objeto):
if val_SQL == None:
if nulo_ok:
return None
else:
erro_prog("atributo '" + nome + "' não pode ser {None}")
if tipo_mem is list or tipo_mem is tuple or tipo_mem is dict:
erro_prog("valor " + str(val_SQL) +
" não pode ser convertido para tipo " + str(tipo_mem))
if tipo_SQL == 'TEXT':
if issubclass(tipo_mem, objeto.Objeto):
val_mem = id_para_objeto(val_SQL)
else:
assert type(val_SQL) is str
val_mem = val_SQL
elif tipo_SQL == 'FLOAT':
assert type(val_SQL) is float
val_mem = val_SQL
elif tipo_SQL == 'INTEGER':
assert type(val_SQL) is int
# Tipo na memória pode ser {int}, {bool}, ou objeto
if tipo_mem is int:
val_mem = val_SQL
elif tipo_mem is bool:
if val_SQL < 0 or val_SQL > 1:
erro_prog("valor booleano '" + nome + "' = " + str(val_SQL) +
" inválido")
val_mem = (val_SQL == 1)
else:
erro_prog("tipo_SQL INTEGER nao pode ser convertido para " +
str(tipo_mem) + "")
else:
erro_prog("tipo SQL '" + str(tipo_SQL) + "' inválido")
assert type(val_mem) is tipo_mem
return val_mem
def gera(rotulo, nome, val_ini, editavel, obrigatorio, dica, cmd):
ht_rotulo = html_label.gera(rotulo, ": ")
ht_linhas = " rows=\"" + "10" + "\""
ht_colunas = " cols=\"" + "60" + "\""
ht_tamanho = " maxlength=\"" + "6000" + "\""
ht_nome = " name=\"" + nome + "\""
ht_id = " id=\"" + nome + "\""
if val_ini != None and dica != None:
erro_prog("{val_ini} e {dica} são mutuamente exclusivos")
ht_obrigatorio = (" required" if obrigatorio else "")
if not editavel:
ht_readonly = " readonly"
ht_estilo = "style=\"background-color:#bcbcbc;\""
else:
ht_readonly = ""
ht_estilo = " style=\"background-color:#ffffff\""
ht_dica = (" placeholder=\"" + dica + "\"" if dica != None else "")
ht_cmd = (" onchange=\"window.location.href=" + cmd +
"\"" if cmd != None else "")
ht_textarea = ht_rotulo + \
"<textarea" + \
ht_linhas + \
ht_colunas + \
ht_tamanho + \
ht_nome + \
ht_id + \
ht_readonly + \
ht_dica + \
ht_cmd + \
ht_obrigatorio + \
ht_estilo + \
">" + (val_ini if val_ini != None else "") + "</textarea>"
return ht_textarea
def busca_por_campos(nome_tb, let, cols, args, res_cols):
# Supõe que o cache é um subconjuto da base em disco, então procura só na última.
# Converte {args} para condição na linguagem SQL:
cond = ""
sep = ""
for ch, val in args.items():
compador = " = " if val is not None else " IS "
val_sql = base_sql.codifica_valor(val)
cond = cond + sep + ch + compador + val_sql
sep = " AND "
if res_cols == None:
cols = ['indice']
else:
cols = res_cols
res = base_sql.executa_comando_SELECT(nome_tb, cond, cols)
if res == None:
res = [].copy()
elif type(res) is str:
erro_prog("SELECT falhou " + str(res))
else:
if res_cols == None:
# Converte lista de índices para lista de identificadores:
res = identificador.de_lista_de_indices(let, res)
return res
def def_obj_mem(obj, id, atrs_SQL):
"""Se {obj} for {None}, cria um novo objeto da classe {Objeto_Compra} com
identificador {id} e atributos {atrs_SQL}, tais como extraidos
da tabela de compras. Extrai a lista de itens da tabela
correspondente, se houver. O objeto *NÃO* é inserido na base de dados.
Se {obj} não é {None}, deve ser um objeto da classe {Objeto_Compra}; nesse
caso a função altera os atributos de {obj}, exceto a lista de itens,
conforme especificado em {atrs_SQL}. A entrada correspondente na
base de dados *NÃO* é alterada.
Em qualquer caso, os valores em {atr_SQL} são convertidos para valores
equivalentes na memória. Se os parâmetros forem inválidos ou incompletos,
retorna uma ou mais mensagens de erro, na forma de uma lista de strings."""
global cache, nome_tb, letra_tb, colunas, diags
if diags:
mostra(
0, "compra_IMP.def_obj_mem(" + str(obj) + ", " + id + ", " +
str(atrs_SQL) + ") ...")
if obj == None:
atrs_mem = conversao_sql.dict_SQL_para_dict_mem(
atrs_SQL, colunas, False, tabelas.id_para_objeto)
if diags: mostra(2, "criando objeto, atrs_mem = " + str(atrs_mem))
obj = compra.Objeto_Compra(id, atrs_mem, [].copy())
else:
assert obj.id == id
mods_mem = conversao_sql.dict_SQL_para_dict_mem(
atrs_SQL, colunas, True, tabelas.id_para_objeto)
if diags: mostra(2, "modificando objeto, mods_mem = " + str(mods_mem))
assert type(mods_mem) is dict
if len(mods_mem) > len(obj.atrs):
erro_prog("numero excessivo de atributos a alterar")
for chave, val in mods_mem.items():
if not chave in obj.atrs:
erro_prog("chave '" + chave + "' inválida")
val_velho = obj.atrs[chave]
if not type(val_velho) is type(val):
erro_prog("tipo do campo '" + chave + "' incorreto")
if chave == 'cliente' and val != val_velho:
erro_prog("campo '" + chave + "' não pode ser alterado")
obj.atrs[chave] = val
if diags: mostra(2, "obj = " + str(obj))
return obj
def dict_mem_para_dict_SQL(dic_mem, cols, falta_ok):
if len(dic_mem) > len(cols):
erro_prog("numero excessivo de atributos em " + str(dic_mem))
dic_SQL = {}.copy()
for chave, tipo_mem, tipo_SQL, nulo_ok in cols:
if chave in dic_mem:
val_mem = dic_mem[chave]
if val_mem != None and not type(val_mem) is tipo_mem:
erro_prog("valor " + str(val_mem) + " deveria ter tipo " +
str(tipo_mem))
val_SQL = valor_mem_para_valor_SQL(chave, val_mem, tipo_mem,
tipo_SQL, nulo_ok)
dic_SQL[chave] = val_SQL
elif not falta_ok:
erro_prog("atributo '" + chave + "' faltando")
if len(dic_mem) > len(dic_SQL):
erro_prog("atributos espúrios em " + str(dic_mem))
return dic_SQL
def modifica_obj_mem(obj, atrs_SQL):
"""O parâmetro {obj} deve ser um objeto da classe {Objeto_Usuario}; nesse
caso a função altera os atributos de {obj} conforme especificado em
{atrs_SQL}. A entrada correspondente da base de dados *NÃO* é alterada.
Os valores em {atr_SQL} são convertidos para valores
equivalentes na memória."""
global cache, nome_tb, letra_tb, colunas, diags
# Converte atributos para formato na memória. Pode ser subconjunto:
mods_mem = conversao_sql.dict_SQL_para_dict_mem(atrs_SQL, colunas, True,
tabelas.id_para_objeto)
if diags: mostra(2, "modificando objeto, mods_mem = " + str(mods_mem))
assert type(mods_mem) is dict
if len(mods_mem) > len(colunas):
erro_prog("numero de atributos a alterar = " + str(len(mods_mem)) +
" excessivo")
# Paranóia: verifica de novo a unicidade de CPF e email:
for chave in ('CPF', 'email'):
if chave in mods_mem:
val = mods_mem[chave]
unico = True
id_bus = objeto.busca_por_campo(chave, val, unico, cache, nome_tb,
letra_tb, colunas)
if id_bus != None and id_bus != obj.id:
erro_prog("usuário com '" + chave + "' = '" + val +
"' já existe: " + id + " " + id_bus)
# Modifica os atributos:
for chave, val in mods_mem.items():
if not chave in obj.atrs:
erro_prog("chave '" + chave + "' inválida")
val_velho = obj.atrs[chave]
if val != None and val_velho != None and (
not type(val_velho) is type(val)):
erro_prog("tipo do campo '" + chave + "' incorreto")
obj.atrs[chave] = val
return obj
def dict_SQL_para_dict_mem(dic_SQL, cols, falta_ok, id_para_objeto):
if len(dic_SQL) > len(cols):
erro_prog("numero excessivo de atributos em " + str(dic_SQL))
dic_mem = {}.copy()
for chave, tipo_mem, tipo_SQL, nulo_ok in cols:
if chave in dic_SQL:
val_SQL = dic_SQL[chave]
val_mem = valor_SQL_para_valor_mem(chave, val_SQL, tipo_SQL,
tipo_mem, nulo_ok,
id_para_objeto)
dic_mem[chave] = val_mem
elif not falta_ok:
erro_prog("atributo '" + chave + "' faltando")
if len(dic_SQL) > len(dic_mem):
erro_prog("atributos espúrios em " + str(dic_SQL))
return dic_mem
def modifica_obj_mem(obj, atrs_SQL):
"""O parâmetro {obj} deve ser um objeto da classe {Objeto_Poltrona}; nesse
caso a função altera os atributos de {obj} conforme especificado em
{atrs_SQL}. A entrada correspondente da base de dados *NÃO* é alterada.
Os valores em {atr_SQL} são convertidos para valores
equivalentes na memória."""
global cache, nome_tb, letra_tb, colunas, diags
# Converte atributos para formato na memória. Pode ser subconjunto:
mods_mem = conversao_sql.dict_SQL_para_dict_mem(atrs_SQL, colunas, True, tabelas.id_para_objeto)
if diags: mostra(2,"modificando objeto, mods_mem = " + str(mods_mem))
assert type(mods_mem) is dict
if len(mods_mem) > len(colunas):
erro_prog("numero de atributos a alterar = " + str(len(mods_mem)) + " excessivo")
# Modifica os atributos:
for chave, val in mods_mem.items():
if not chave in obj.atrs:
erro_prog("chave '" + chave + "' inválida")
val_velho = obj.atrs[chave]
if val != None and val_velho != None and (not type(val_velho) is type(val)):
erro_prog("tipo do campo '" + chave + "' incorreto")
obj.atrs[chave] = val
return obj
indice = indel
verifica(" ----------------------------------", let, indice,
ident)
if ok:
sys.stderr.write("verifica_lista: ok\n")
ok_global = ok_global and ok
let1 = "X"
indice1 = 123456
ident1 = identificador.de_indice(let1, indice1)
verifica("identificador.de_indice", let1, indice1, ident1)
let2 = "Y"
ident2 = "Y-00654321"
indice2 = identificador.para_indice(let2, ident2)
verifica("identificador.para_indice", let2, indice2, ident2)
let3 = "Z"
indices3 = [111, 222, [333], 444]
idents3 = identificador.de_lista_de_indices(let3, indices3)
verifica_lista("identificador.de_lista_de_indices", let3, indices3, idents3)
# ----------------------------------------------------------------------
# Veredito final:
if ok_global:
sys.stderr.write("Teste terminou sem detectar erro\n")
else:
erro_prog("- teste falhou")
sys.stderr.write("Testando {roteiro.descobre_todos}\n")
def testa_descobre_todos(origem, destino, data_min, data_max, soh_disponiveis):
"""
Testa função {descobre_todos} do módulo {roteiros}.
"""
tx_args = "'%s', '%s', '%s', '%s', %s" % (origem, destino, data_min, data_max, str(soh_disponiveis))
sys.stderr.write("Testando {descobre_todos}(%s)\n" % tx_args)
roteiros = roteiro.descobre_todos(origem, destino, data_min, data_max, soh_disponiveis)
sys.stderr.write("Roteiros retornados:\n")
ok_local = True
for rot in roteiros:
sys.stderr.write(" " + str(roteiros) + "\n")
if not verifica_roteiro(rot):
aviso_prog('** roteiro inválido', True)
ok_local = False
return ok_local
origem = "VCP"
data_min = "2020-05-08 08:00 UTC"
destino = "MAO"
data_max = "2020-05-23 18:00 UTC"
soh_disponiveis = False
ok = ok and testa_descobre_todos(origem, data_min, destino, data_max, soh_disponiveis)
if ok:
sys.stderr.write("Teste terminou sem detectar erro\n")
else:
erro_prog("Há erros no módulo {roteiro}")
