def test_home_index(self):
self.assertEqual("/first_handler/1",
router.to_path(first_handler.index, "1"))
self.assertEqual("/pack/1/2/3", router.to_path(pack_home.index, 1, 2,
3))
self.assertEqual("/1/2/3", router.to_path(home.index, 1, 2, 3))
self.assertEqual("/", router.to_path(home.index))
def index(write_tmpl):
query=Materia.query().order(Materia.nome)
materias=query.fetch(100)
values={"nome":"adm",
"materias":materias,
"save_url":router.to_path(salvar),
"list_url":router.to_path(listar_ajax)}
write_tmpl("/template/adm/materia.html", values)
def listar(write_tmpl):
query=Produto.query(Produto.ddd>0).order(Produto.ddd)
# query=query.filter(Produto.ddd>0)
# query=query.order(Produto.ddd)
produto=query.fetch(100)
values={"produto":produto,
"apagar_url":router.to_path(apagar),
"editar_url":router.to_path(editar)}
write_tmpl("/geo/templates/produto_list.html",values)
def test_listar_ajax(self):
resp = WriterMock()
tirinha.listar_ajax(resp)
jsonCompara = json.loads(resp.json)
self.assertDictEqual({"tirinha":[],
"nextPageUrl":router.to_path(tirinha.listar_ajax,2),
"editar_url":router.to_path(tirinha.editar),
"apagar_url":router.to_path(tirinha.apagar)},
jsonCompara)
def index(_write_tmpl):
query = Curso.query_cursos_ordenados_asc()
lista_de_cursos = query.fetch()
url = router.to_path(form)
values = {'curso_form_url': url,
'lista_de_cursos': lista_de_cursos,
'matricula_url': router.to_path(matriculas),
'matricula_rest_url': router.to_path(rest.matriculas)}
_write_tmpl('templates/curso_home.html', values)
def listar(write_tmpl):
query=Estado.query(Estado.ddd>0).order(Estado.ddd)
# query=query.filter(Estado.ddd>0)
# query=query.order(Estado.ddd)
estados=query.fetch(100)
values={"estados":estados,
"apagar_url":router.to_path(apagar),
"editar_url":router.to_path(editar)}
write_tmpl("/geo/templates/state_list.html",values)
def adminlist(write_tmpl):
#REALIZA A CONSULTA PELOS ID MAIORES QUE 0 E ORDENA POR ID
query = Memes.query().order(Memes.key)
#TRAZ SOMENTE 10 LINHAS DA CONSULTA
memes = query.fetch(10)
#VALORES QUE SERÃO PASSADOS NA URL
values = {"memes":memes,
"apagar_url":router.to_path(apagar),
"editar_url":router.to_path(editar)}
#MONTA A PAGINA
write_tmpl("/historia/templates/memes_listadmin.html",values)
def listar(write_tmpl):
#REALIZA A CONSULTA PELOS ID MAIORES QUE 0 E ORDENA POR ID
query = Usuario.query().order(Usuario.key)
#TRAZ SOMENTE 10 LINHAS DA CONSULTA
usuario = query.fetch(10)
#VALORES QUE SERÃO PASSADOS NA URL
values = {"usuario":usuario,
"apagar_url":router.to_path(apagar),
"editar_url":router.to_path(editar)}
#MONTA A PAGINA
write_tmpl("/usuarios/templates/usuario_list.html",values)
def index(write_tmpl):
query=Usuario.query()
usuarios=query.fetch(100)
query2=Materia.query()
materias=query2.fetch(100)
values={"nome":"adm",
"usuarios":usuarios,
"materias":materias,
"save_url":router.to_path(salvar),
"apagar_url":router.to_path(apagar)}
write_tmpl("/template/adm/usuario.html",values)
def test_listar(self):
def write_tmpl(tmpl_name, dct):
self.tmpl_name = tmpl_name
self.values = dct
tmpl.render(tmpl_name, dct)
estado.listar(write_tmpl)
self.assertEqual("/geo/templates/state_list.html", self.tmpl_name)
self.assertDictEqual({"estados": [],
"apagar_url": router.to_path(estado.apagar),
"editar_url": router.to_path(estado.editar)},
self.values)
def test_listar(self):
def write_tmpl(tmpl_name, dct):
self.tmpl_name = tmpl_name
self.values = dct
tmpl.render(tmpl_name, dct)
materia.index(write_tmpl)
self.assertEquals("/template/adm/materia.html",self.tmpl_name)
self.assertDictEqual({"nome":"adm",
"materias":[],
"save_url":router.to_path(materia.salvar),
"list_url":router.to_path(materia.listar_ajax)},self.values)
def wrapper(_dependencias,handler,*args,**kwargs):
usuario=Usuario.current_user()
if usuario:
novos_argumentos = decorator_util.find_dependencies(_dependencias,fcn)
novos_argumentos.extend(args)
return fcn(*novos_argumentos,**kwargs)
google_user=users.get_current_user()
if google_user:
handler.redirect(router.to_path(red))
else:
url=router.to_path(fcn,*args)
login_url=users.create_login_url(url)
handler.redirect(login_url)
def save(_handler, _resp, name):
save_user = user_business.SaveUser(name)
business.execute(save_user)
if save_user.errors:
_resp.write(save_user.errors)
else:
_handler.redirect(router.to_path(list))
def apagar(handler, id):
#RECEBE O OBJETO MAIS O ID DELE
key = ndb.Key(Memes,long(id))
#DELETA O REGISTRO
key.delete()
#REDIRECIONA PARA A PAGINA LISTAR
handler.redirect(router.to_path(listar))
def listar(write_tmpl,tmpl,estado_id):
estado_id=long(estado_id)
estado=Estado.get_by_id(estado_id)
values={"estado":estado,
"list_url":router.to_path(listar_ajax,estado_id)}
write_tmpl("/geo/templates/cidade_list.html",values)
def test_listar_ajax(self):
resp = WriterMock()
materia.listar_ajax(resp)
jsonComp = json.loads(resp.json)
self.assertDictEqual({"nextPageUrl":router.to_path(materia.listar_ajax,2),
"materias":[]},
jsonComp)
def salvar_matricula(_handler, curso_id, aluno_id):
curso_key = ndb.Key(Curso, int(curso_id))
aluno_key = ndb.Key(Aluno, int(aluno_id))
Matricula(curso=curso_key, aluno=aluno_key).put()
url = router.to_path(matriculas, curso_id)
_handler.redirect(url)
def salvar(handler,nome,id=None):
if id:
materia=Materia(id=long(id),nome=nome)
else:
materia=Materia(nome=nome)
materia.put()
handler.redirect(router.to_path(index))
def matriculas(_write_tmpl, curso_id):
# Lista de todos alunos do BD
alunos = Aluno.query_alunos_ordenados_asc().fetch()
#Construção da chave baseado no id do curso
curso_key = ndb.Key(Curso, int(curso_id))
lista_de_matriculas = Matricula.query_matriculas_do_curso(curso_key).fetch()
# Filtrando apenas chaves dos alunos matriculados
chaves_alunos_matriculados = [m.aluno for m in lista_de_matriculas]
#montando lista de alunos matriculados e disponiveis
alunos_matriculados = []
alunos_disponiveis = []
for aluno in alunos:
if aluno.key in chaves_alunos_matriculados:
alunos_matriculados.append(aluno)
else:
alunos_disponiveis.append(aluno)
# buscando curso do BD. Usa memcache (NDB)
curso = curso_key.get()
#Montagem dos parametros do template
values = {'curso': curso,
'matricula_salvar_url': router.to_path(salvar_matricula),
'lista_de_alunos_matriculados': alunos_matriculados,
'lista_de_alunos_disponiveis': alunos_disponiveis}
_write_tmpl('templates/matricula.html', values)
def test_salvar(self):
handdler = HandlerMock()
materia.salvar(handdler,'TesteMateria')
salvo = Materia.query().get()
self.assertEqual('TesteMateria',salvo.nome)
url = router.to_path(materia.index)
self.assertEqual(url,handdler.url)
def editar(write_tmpl,urlsafe):
key = ndb.Key(urlsafe=urlsafe)
#PEGA A CHAVE PRIMARIA E ARMAZENA NA HISTORIA
tirinha = key.get()
#CARREGA O VALORES DA PK E MANDA PARA O SALVAR
values = {"save_url":router.to_path(salvar),
"tirinha":tirinha}
write_tmpl("/leitura/templates/tirinha_form.html",values)
def form(write_tmpl, handler):
google_user = users.get_current_user()
usuario = Usuario.current_user()
if usuario:
handler.redirect("/")
else:
values = {"url_salvar": router.to_path(salvar), "email": google_user.email()}
write_tmpl("/templates/cadastro_usuario.html", values)
def salvar(handler,nome,cpf,email,tipo,matLista=None,id=None):
google_user=users.get_current_user()
if id:
usuario=Usuario(id=long(id),nome=nome,cpf=cpf,email=email,tipo=tipo,google_id=google_user.user_id())
else:
usuario=Usuario(nome=nome,cpf=cpf,email=email,tipo=tipo,google_id=google_user.user_id())
usuario.put()
handler.redirect(router.to_path(index))
def salvar(handler,nome, sigla, ddd,id=None):
ddd=long(ddd)
if id:
estado=Estado(id=long(id),nome=nome,sigla=sigla,ddd=ddd)
else:
estado=Estado(nome=nome,sigla=sigla,ddd=ddd)
estado.put()
handler.redirect(router.to_path(listar))
def listar(write_tmpl,usuario_id=None):
if usuario_id is None:
usuario_id = Usuario.current_user().key.id()
usuario_id = long(usuario_id)
usuario = Usuario.get_by_id(usuario_id)
#VALORES QUE SERÃO PASSADOS NA URL
values = {"list_url":router.to_path(listar_ajax,usuario_id)}
#MONTA A PAGINA
write_tmpl("/leitura/templates/tirinha_list.html",values)
def editar(write_tmpl,urlsafe):
#
key = ndb.Key(urlsafe=urlsafe)
#PEGA A CHAVE PRIMARIA E ARMAZENA NA HISTORIA
usuario = key.get()
#CARREGA O VALORES DA PK E MANDA PARA O SALVAR
values = {"save_url":router.to_path(salvar),
"usuario":usuario}
write_tmpl("/usuarios/templates/usuario_form.html")
def test_listar(self):
def write_tmpl(tmpl_name, dct):
self.tmpl_name = tmpl_name
self.values = dct
tmpl.render(tmpl_name, dct)
tirinha.listar(write_tmpl)
self.assertEquals("/leitura/templates/tirinha_list.html",self.tmpl_name)
self.assertDictEqual({"list_url":router.to_path(tirinha.listar_ajax)},self.values)
def salvar(handler,nome, sigla, categ, preco,ddd,id=None):
ddd=long(ddd)
if id:
produto=Produto(id=long(id),nome=nome,sigla=sigla, categ=categ,preco=preco,ddd=ddd)
else:
produto=Produto(nome=nome,sigla=sigla,preco=preco, categ=categ, ddd=ddd)
produto.put()
handler.redirect(router.to_path(listar))
def editar(write_tmpl,urlsafe):
#
key = ndb.Key(urlsafe=urlsafe)
#PEGA A CHAVE PRIMARIA E ARMAZENA NA HISTORIA
memes = key.get()
#CARREGA O VALORES DA PK E MANDA PARA O SALVAR
values = {"save_url":router.to_path(salvar),
"memes":memes}
write_tmpl("/historia/templates/memes_form.html")
def test_salvar(self):
handler = HandlerMock()
estado.salvar(handler, "Sao Paulo", "SP", "11")
salvo = Estado.query().get()
self.assertEqual("Sao Paulo", salvo.nome)
self.assertEqual("SP", salvo.sigla)
self.assertEqual(11, salvo.ddd)
url = router.to_path(estado.listar)
self.assertEqual(url, handler.url)
def index(_write_tmpl, name=None):
url = router.to_path(index)
users = User.query_all().fetch()
if name:
cmds = log_facade.save_user_log(name)+facade.save_user(name)
user=cmds.execute().result
if not cmds.errors:
users.insert(0, user)
values = {'form_url': url, 'users': users}
_write_tmpl('templates/form.html', values)
def test_package(self):
self.assertEqual("/", router.to_path(web_test))
self.assertEqual("/pack", router.to_path(pack))
def test_module(self):
self.assertEqual("/first_handler", router.to_path(first_handler))
self.assertEqual("/pack/pack_handler", router.to_path(pack_handler))
def test_function(self):
self.assertEqual("/first_handler/fcn_resp_handler",
router.to_path(first_handler.fcn_resp_handler))
self.assertEqual("/pack/pack_handler/with_kwargs",
router.to_path(pack_handler.with_kwargs))
def test_function_with_params(self):
self.assertEqual("/first_handler/fcn_resp_handler/1",
router.to_path(first_handler.fcn_resp_handler, "1"))
self.assertEqual("/pack/pack_handler/with_kwargs/1/2/3",
router.to_path(pack_handler.with_kwargs, 1, 2, 3))
def index(_write_tmpl):
url = router.to_path(my_form)
_write_tmpl('templates/home.html', {'form_url': url})
def index(_handler):
path = router.to_path(form,"Silvio","Lima")
_handler.redirect(path)
def salvar(_handler,nome,preco):
preco = float(preco)
curso = Curso(nome=nome, preco=preco)
curso.put()
path = router.to_path(index)
_handler.redirect(path)
def form(_write_tmpl):
path = router.to_path(salvar)
dct = {'salvar_curso':path}
_write_tmpl('/templates/curso_form.html', dct)