def salvar(pedido_id, email, descricao, arquivo):
pedido = Drawing.get_by_id(int(pedido_id))
pedido.email = email
pedido.descricao = descricao
pedido.arquivo = arquivo
pedido.put()
return RedirectResponse(pedido)
def delete(_resp, _logged_user, id):
key = ndb.Key(Game, int(id))
key.delete()
query = ArcGen.find_origins(key)
arc_keys = query.fetch(keys_only=True)
ndb.delete_multi(arc_keys)
return RedirectResponse("/admin/games-management")
def index(_resp):
facade.logout(_resp).execute()
redirect_url = '/'
google_user = get_current_user()
if google_user:
redirect_url = create_logout_url(redirect_url)
return RedirectResponse(redirect_url)
def delete(filme_id):
chave = ndb.Key(Filme,int(filme_id))
chave.delete()
query = AutorArco.find_origins(chave)
chaves_dos_arcos = query.fetch(keys_only=True)
ndb.delete_multi(chaves_dos_arcos)
return RedirectResponse(router.to_path(index))
def salvar(**propriedades):
form = ProdutoForm(**propriedades)
erros = form.validate()
if not erros:
produto = form.fill_model()
produto.put()
return RedirectResponse(index)
def atualizar(lesson_id, titulo, descricao, tema):
lesson = Licao.get_by_id(int(lesson_id))
lesson.titulo = titulo
lesson.descricao = descricao
lesson.tema = ndb.Key(Tema, int(tema))
lesson.put()
return RedirectResponse(lessons)
def atualizar(**propriedades):
propriedades['categoria'] = ndb.Key(Categoria,
int(propriedades['categoria']))
produto_form = validation.ProdutoForm(**propriedades)
erros = produto_form.validate()
if erros:
contexto = {
'acao': 'atualizar',
'erros': erros,
'produto': produto_form,
'categorias': Categoria.query_ordenada_por_nome(),
'validacao_id': Produto.get_by_id(int(propriedades['produto_id']))
}
return TemplateResponse(contexto,
template_path='produtos/admin/cadastro.html')
else:
produto_id = propriedades['produto_id']
produto = Produto.get_by_id(int(produto_id))
produto.nome = propriedades['nome']
produto.categoria = propriedades['categoria']
produto.preco = float(propriedades['preco'])
produto.descricao = propriedades['descricao']
produto.novidade = propriedades['novidade']
produto.put()
return RedirectResponse('/produtos/admin')
def edit(_logged_user, name, user_locale, timezone):
if name:
_logged_user.name = name
_logged_user.locale = user_locale
_logged_user.timezone = timezone
_logged_user.put()
return RedirectResponse('/')
def delete(funcionario_id):
chave = ndb.Key(Funcionario, int(funcionario_id))
chave.delete()
query = UsuarioArco.find_origins(chave)
chaves_dos_arcos = query.fetch(keys_only=True)
ndb.delete_multi(chaves_dos_arcos)
sleep(1)
return RedirectResponse(router.to_path(index))
def save(membro_id, **membro_properties):
cmd = membro_facade.update_membro_cmd(membro_id, **membro_properties)
try:
cmd()
except CommandExecutionException:
context = {'errors': cmd.errors, 'membro': membro_properties}
return TemplateResponse(context, 'membros/membro_form.html')
return RedirectResponse(router.to_path(membros))
def save(pessoa_id, **pessoa_properties):
cmd = pessoa_facade.update_pessoa_cmd(pessoa_id, **pessoa_properties)
try:
cmd()
except CommandExecutionException:
context = {'errors': cmd.errors, 'pessoa': pessoa_properties}
return TemplateResponse(context, 'pessoas/pessoa_form.html')
return RedirectResponse(router.to_path(pessoas))
def salvar(**propriedades):
propriedades['tema'] = ndb.Key(Tema, int(propriedades['tema']))
form = LicaoForm(**propriedades)
erros = form.validate()
if erros:
return
licao = form.fill_model()
licao.put()
return RedirectResponse(lessons)
def save(item_id, **item_properties):
cmd = itens_facade.update_item_cmd(item_id, **item_properties)
try:
cmd()
except CommandExecutionException:
context = {'errors': cmd.errors, 'item': item_properties}
return TemplateResponse(context, 'itenss/itens_form.html')
return RedirectResponse(router.to_path(itenss))
def salvar(pedido_id, **kwargs):
#pedido = Pedido.get_by_id(pedido_id)
form = PedidoForm(**kwargs)
erros = form.validate()
if not erros:
pedido = form.fill_model()
pedido.put()
return RedirectResponse(pedidos)
def save(venda_id, **venda_properties):
cmd = venda_facade.update_venda_cmd(venda_id, **venda_properties)
try:
cmd()
except CommandExecutionException:
context = {'errors': cmd.errors, 'venda': venda_properties}
return TemplateResponse(context, 'vendas/venda_form.html')
return RedirectResponse(router.to_path(vendas))
def save(course_id, **course_properties):
cmd = course_facade.update_course_cmd(course_id, **course_properties)
try:
cmd()
except CommandExecutionException:
context = {'errors': cmd.errors, 'course': course_properties}
return TemplateResponse(context, 'courses/course_form.html')
return RedirectResponse(router.to_path(courses))
def save(**book_properties):
cmd = book_facade.save_book_cmd(**book_properties)
try:
cmd()
except CommandExecutionException:
context = {'errors': cmd.errors, 'book': book_properties}
return TemplateResponse(context, 'books/book_form.html')
return RedirectResponse(router.to_path(books))
def save(**categoria_properties):
cmd = categoria_facade.save_categoria_cmd(**categoria_properties)
try:
cmd()
except CommandExecutionException:
context = {'errors': cmd.errors, 'categoria': categoria_properties}
return TemplateResponse(context, 'categorias/categoria_form.html')
return RedirectResponse(router.to_path(categorias))
def save(**peca_properties):
cmd = pecas_facade.save_peca_cmd(**peca_properties)
try:
cmd()
except CommandExecutionException:
context = {'errors': cmd.errors,
'peca': peca_properties}
return TemplateResponse(context, 'rests/rest_form.html')
return RedirectResponse(router.to_path(rests))
def salvar(**propriedades):
propriedades['categoria'] = ndb.Key(Categoria,
int(propriedades['categoria']))
form = ProdutoForm(**propriedades)
erros = form.validate()
if erros:
return
produto = form.fill_model()
produto.put()
return RedirectResponse(produtos)
def salvar(**kwargs):
form = TemaForm(**kwargs)
erros = form.validate()
if not erros:
propriedades = form.normalize()
tema = Tema(**propriedades)
tema.put()
return RedirectResponse(temas)
else:
ctx = {'tema':kwargs, 'erros':erros}
return TemplateResponse(ctx, 'temas/form.html')
def salvar(**kwargs):
form = CategoriaForm(**kwargs)
erros = form.validate()
if not erros:
valores_normalizados = form.normalize()
categoria = Categoria(**valores_normalizados)
categoria.put()
return RedirectResponse(categorias)
else:
ctx = {'categoria': kwargs, 'erros': erros}
return TemplateResponse(ctx, 'categorias/categoria_form.html')
def salvar(**kwargs):
form = CategoriaForm(**kwargs)
erros = form.validate()
if not erros:
propriedades = form.normalize()
categoria = Categoria(**propriedades)
categoria.put()
from routes.andris import admin
return RedirectResponse(admin)
else:
ctx = {'categoria': kwargs, 'erros': erros}
return TemplateResponse(ctx, 'categorias/categorias_form.html')
def salvar(** propriedades):
imovel_form = ImovelForm(**propriedades)
errors = imovel_form.validate()
if errors:
contexto = {'save_path':router.to_path(salvar),
'errors':errors,
'imovel':imovel_form}
return TemplateResponse(contexto, '/imoveis/form.html')
else:
imovel = imovel_form.fill_model()
imovel.put()
return RedirectResponse(router.to_path(index))
def salvar(**kwargs):
form = DesenhoForm(**kwargs)
erros=form.validate()
if not erros:
valores_normalizados = form.normalize()
desenho = Desenho(**valores_normalizados)
desenho.put()
return RedirectResponse(desenhos)
else:
ctx={'desenhos':kwargs,'erros':erros}
return TemplateResponse(ctx,'desenhos/desenhos_form.html')
def salvar(**kwargs):
form = PedidoForm(**kwargs)
erros = form.validate()
if not erros:
valores_normalizados = form.normalize()
pedido = Pedido(**valores_normalizados)
pedido.put()
return RedirectResponse(pedidos)
else:
ctx = {'pedido': kwargs, 'erros': erros}
return TemplateResponse(ctx, 'pedidos/pedido_form.html')
def index(_resp, token, ret_path='/'):
cmd = facade.login_facebook(token, _resp)
cmd()
if cmd.pending_link:
pending_path = router.to_path(pending.index, cmd.pending_link.key.id())
user_email = cmd.main_user_from_email.email
facade.send_passwordless_login_link(user_email, settings.APP_URL +
pending_path).execute()
return TemplateResponse({
'provider': 'Facebook',
'email': user_email
}, 'login/pending.html')
return RedirectResponse(ret_path)
def index(_resp, id=None, context={}):
if id:
game = Game.get_by_id(int(id))
if not game: return RedirectResponse(router.to_path(index))
game_form = GameFormTable()
game_form.fill_with_model(game)
query = ArcGen.query(ArcGen.destination == game.key)
arc = query.fetch()
query = MainUser.query(MainUser.key == arc[0].origin)
autor = query.fetch()
context = {'properties': game_form, 'edit': True, 'id' : id, 'autor' : autor[0]}
return TemplateResponse(context, template_path="/admin/games-management-form-dialog.html")
return TemplateResponse(context, template_path="admin/games-management-form-dialog.html")
def salvar(_resp, **propriedades):
propriedades['categoria']=ndb.Key(Categoria,int(propriedades['categoria']))
produto_form = validation.ProdutoForm(**propriedades)
erros = produto_form.validate()
if erros:
contexto = {'salvar_path': to_path(salvar), 'erros': erros, 'produto': produto_form , 'categorias' : Categoria.query_ordenada_por_nome()}
return TemplateResponse(contexto, template_path='produtos/admin/cadastro.html')
else:
# produto = Produto(nome=propriedades['nome'], preco=propriedades['preco'], categoria=propriedades['categoria'], descricao = propriedades['descricao'], novidade = int(propriedades['novidade']))
produto = produto_form.fill_model()
produto.put()
return RedirectResponse('/produtos/admin')
def index(_resp, ret_path='/'):
user = users.get_current_user()
if user:
cmd = facade.login_google(user, _resp).execute()
if cmd.pending_link:
pending_path = router.to_path(pending.index, cmd.pending_link.key.id())
facade.send_passwordless_login_link(user.email(),
settings.APP_URL + pending_path).execute()
TemplateResponse({'provider': 'Google', 'email': user.email()}, 'login/pending.html')
else:
main_user=cmd.main_user_from_external
user_document=get_or_create_user_document(main_user)
return RedirectResponse(ret_path)
