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 index(_resp, **kwargs):
# Se for via Ajax
if kwargs:
# Procurar o recado com o ID passado pelo POST - AJAX
recado_id = kwargs['id']
cmd = recado_facade.get_recado_cmd(recado_id)
try:
recado = cmd()
except CommandExecutionException:
_resp.status_code = 500
return JsonResponse(cmd.errors)
recado_form = recado_facade.recado_form()
dados = {'neto': recado.neto}
return JsonResponse(
recado_form.fill_with_model(recado)
) # Json só aceita objetos simples, não podendo passar uma instância de Recado
# Listagem de todos os recados
cmd = recado_facade.list_recados_cmd()
recado_list = cmd()
recado_form = recado_facade.recado_form()
context = {'recados': recado_list, 'form': recado_form}
return TemplateResponse(context)
def index():
return TemplateResponse({
'passwordless_admin_path':
router.to_path(passwordless.form),
'facebook_admin_path':
router.to_path(facebook.form)
})
def index(_resp, categoria_selecionada=""):
editar_path_base = to_path(editar)
deletar_path_base = to_path(deletar)
produtos = Produto.query().fetch()
for prod in produtos:
prod.editar_path = to_path(editar_path_base, prod.key.id())
prod.deletar_path = to_path(deletar_path_base, prod.key.id())
contexto = {'categorias': Categoria.query()}
if categoria_selecionada == "":
contexto['produtos'] = Produto.query_ordenada_por_nome().fetch()
contexto['categoria_selecionada'] = None
else:
# sql = ndb.Key(Categoria, int(categoria_selecionada))
# contexto['produtos']=Produto.query(Produto.categoria==sql).fetch()
contexto['produtos'] = Produto.query_por_categoria_ordenada_por_nome(
categoria_selecionada).fetch()
contexto['categoria_selecionada'] = Categoria.get_by_id(
int(categoria_selecionada))
contexto['resultados'] = len(contexto['produtos'])
return TemplateResponse(contexto)
def index(_resp, criatura_id):
criatura_id = int(criatura_id)
criatura = Criatura.get_by_id(criatura_id)
contexto = {'criatura': criatura}
return TemplateResponse(contexto)
def index():
cmd = facade.list_courses_cmd()
courses = cmd()
public_form = facade.course_public_form()
course_public_dcts = [public_form.fill_with_model(course) for course in courses]
context = {'trailers': course_public_dcts,'admin_path':router.to_path(admin)}
return TemplateResponse(context)
def index(_logged_user):
"""
This is a example of file upload using
Google Cloud Storage
:return:
"""
success_url = router.to_path(upload)
bucket = get_default_gcs_bucket_name()
logging.info(bucket)
url = blobstore.create_upload_url(success_url, gs_bucket_name=bucket)
cmd = blob_facade.list_blob_files_cmd(_logged_user)
blob_form = blob_facade.blob_file_form()
deletar_path_base = router.to_path(delete)
download_path_base = router.to_path(download)
def localizar_blob(blob):
dct = blob_form.fill_with_model(blob, 64)
dct['delete_path'] = router.to_path(deletar_path_base, dct['id'])
dct['download_path'] = router.to_path(download_path_base,
blob_key=blob.blob_key,
filename=dct['filename'])
return dct
blob_files = [localizar_blob(b) for b in cmd()]
context = {'upload_url': url, 'blob_files': blob_files}
return TemplateResponse(context, 'updown/home.html')
def index(_logged_user):
cmd = facade.list_observacoes_cmd()
observacoes = cmd()
get_dono_cmd_lista = [GetDonoObs(o) for o in observacoes]
paralelo = CommandParallel(*get_dono_cmd_lista)
paralelo()
edit_path = router.to_path(edit)
delete_path = router.to_path(delete)
short_form = facade.observacoe_short_form()
def short_observacoe_dict(observacoe):
observacoe_dct = short_form.fill_with_model(observacoe)
observacoe_dct['edit_path'] = router.to_path(edit_path,
observacoe_dct['id'])
observacoe_dct['delete_path'] = router.to_path(delete_path,
observacoe_dct['id'])
return observacoe_dct
short_observacoes = [
short_observacoe_dict(observacoe) for observacoe in observacoes
]
for observacao, dono_comando in zip(short_observacoes, get_dono_cmd_lista):
observacao['dono_flag'] = (dono_comando.result == _logged_user)
context = {
'observacoes': short_observacoes,
'new_path': router.to_path(new)
}
return TemplateResponse(context)
def index(_handler):
upload_path = to_path(upload)
bucket = get_default_gcs_bucket_name()
url = blobstore.create_upload_url(upload_path, gs_bucket_name=bucket)
contexto = {'upload_url': url}
return TemplateResponse(contexto)
def index():
cmd = book_facade.list_books_cmd()
books = cmd()
public_form = book_facade.book_public_form()
book_public_dcts = [public_form.fill_with_model(book) for book in books]
context = {'books': book_public_dcts, 'admin_path': router.to_path(admin)}
return TemplateResponse(context)
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 save(_resp,**props):
solicitacaoForm=SolicitaForm(**props)
erros=solicitacaoForm.validate()
if erros:
contexto = {'salvar_path': router.to_path(save),
'erros': erros}
return TemplateResponse(contexto, 'scomp/home.html')
def index():
query = Cliente.query().order(Cliente.nome)
clientes = query.fetch()
for cliente in clientes:
cliente.exibir_path = router.to_path(exibir, cliente.key.id())
contexto = {'clientes': clientes}
return TemplateResponse(contexto)
def index():
context = {
'salvar_path': router.to_path(rest.save),
'deletar_path': router.to_path(rest.delete),
'editar_path': router.to_path(rest.update),
'listar_path': router.to_path(rest.index)}
return TemplateResponse(context)
def index():
contexto = {
'salvar_path': router.to_path(salvar),
'categoria': '',
'acao': 'adicionar'
}
return TemplateResponse(contexto, template_path='categorias/cadastro.html')
def index():
path = router.to_path(salvar)
ctx = {
'usuarios': ['Renzo', 'Jão', 'Paulo', 'Fabiana'],
'usuario_path': path
}
return TemplateResponse(ctx, template_path='/usuario/usuario_form.html')
def index(ret_path='/'):
g_path = router.to_path(google.index, ret_path=ret_path)
dct = {'login_google_path': users.create_login_url(g_path),
'login_passwordless_path': router.to_path(send_email, ret_path=ret_path),
'login_facebook_path': router.to_path(facebook.index, ret_path=ret_path),
'faceapp': facade.get_facebook_app_data().execute().result}
return TemplateResponse(dct, 'login/home.html')
def editar_form(filme_id):
filme_id = int(filme_id)
filme = Filme.get_by_id(filme_id)
filme_form = FilmeForm()
filme_form.fill_with_model(filme)
contexto={'salvar_path': router.to_path(editar,filme_id),'filme':filme_form}
return TemplateResponse(contexto, 'filmes/form.html')
def index():
### FIXME ENQUANTO NÃO TEM BD CRIAR CLASSE CENTRALIZADA PARA EVITAR REPLIUCAÇÃO DE CODIGO ###
class Produto(object):
def __init__(self, codigo, nome, descricao, preco, categoria,
novidades):
self.codigo = codigo
self.descricao = descricao
self.nome = nome
self.preco = preco
self.categoria = categoria
self.novidades = novidades
produtos = [
Produto(1, 'Roupa Sapinho', 'Roupa para Cachorro', 59.99, 'roupas', 1),
Produto(2, 'Cama Onça', 'Cama para Cães e Gatos', 89.99, 'camas', 0),
Produto(3, 'Coleira de Couro', 'Coleira para Cães', 59.99, 'coleiras',
0),
Produto(4, 'Roupa Jard', 'Roupa para Cachorro', 79.99, 'roupas', 1),
Produto(5, 'Camiseta Pug', 'Camiseta Unissex', 39.99, 'camisetas', 0),
Produto(6, 'Camiseta Labrador', 'Camiseta Unissex', 39.99, 'camisetas',
0),
Produto(7, 'Pedigree (Petisco)', 'Diversos Sabores', 9.99,
'alimentacao', 1),
Produto(8, 'Ração Pedigree', 'Cachorros até 8kg', 19.99, 'alimentacao',
0),
Produto(9, 'Caneca', 'Mosaico', 7.99, 'canecas', 1),
Produto(10, 'Caneca', 'Chaplin', 7.99, 'canecas', 0)
]
## somente as novidades aparecem na homepage | verificação por flag
destaques = [x for x in produtos if x.novidades == 1]
contexto = {'produtos': destaques}
return TemplateResponse(contexto)
def index():
# cmd = facade.list_observacoes_cmd()
# observacoes = cmd()
# get_dono_cmd_lista=[GetDonoObs(o) for o in observacoes]
# paralelo=CommandParallel(*get_dono_cmd_lista)
# paralelo()
#
# edit_path = router.to_path(edit)
# delete_path = router.to_path(delete)
# short_form = facade.observacoe_short_form()
#
# def short_observacoe_dict(observacoe):
# observacoe_dct = short_form.fill_with_model(observacoe)
# observacoe_dct['edit_path'] = router.to_path(edit_path, observacoe_dct['id'])
# observacoe_dct['delete_path'] = router.to_path(delete_path, observacoe_dct['id'])
# return observacoe_dct
#
#
# short_observacoes = [short_observacoe_dict(observacoe) for observacoe in observacoes]
# for observacao,dono_comando in zip(short_observacoes,get_dono_cmd_lista):
# observacao['dono_flag']=(dono_comando.result ==_logged_user)
# context = {'observacoes': short_observacoes,
# 'new_path': router.to_path(new),
# 'busca_produtos':router.to_path(busca_produtos)
# }
return TemplateResponse()
def busca_produtos(_logged_user, busca):
cmd = facade.list_observacoes_cmd()
observacoes = cmd()
busca = slugify(busca)
pesquisa = Observacoe.query(Observacoe.busca >= busca).order(Observacoe.busca)
get_dono_cmd_lista=[GetDonoObs(o) for o in observacoes]
paralelo=CommandParallel(*get_dono_cmd_lista)
paralelo()
edit_path = router.to_path(edit)
delete_path = router.to_path(delete)
short_form = facade.observacoe_short_form()
def short_observacoe_dict(observacoe):
observacoe_dct = short_form.fill_with_model(observacoe)
observacoe_dct['edit_path'] = router.to_path(edit_path, observacoe_dct['id'])
observacoe_dct['delete_path'] = router.to_path(delete_path, observacoe_dct['id'])
return observacoe_dct
short_observacoes = [short_observacoe_dict(observacoe) for observacoe in observacoes]
for observacao,dono_comando in zip(short_observacoes,get_dono_cmd_lista):
observacao['dono_flag']=(dono_comando.result ==_logged_user)
context = {'observacoe': short_observacoes,
'new_path': router.to_path(new),
'observacoes': pesquisa.fetch()
}
return TemplateResponse(context, router.to_path('observacoes/admin/home.html'))
def index():
query = Membro.query()
membro_lista = query.fetch()
form = MembroFormTable()
membro_lista = [form.fill_with_model(membro) for membro in membro_lista]
contexto = {'membro_lista':membro_lista}
return TemplateResponse(contexto)
def index(lancamento_id):
lancamento = facade.get_lancamento_cmd(lancamento_id)()
detail_form = facade.lancamento_detail_form()
context = {
'save_path': router.to_path(save, lancamento_id),
'lancamento': detail_form.fill_with_model(lancamento)
}
return TemplateResponse(context, 'lancamentos/admin/form.html')
def index():
context = {
'rest_list_path': router.to_path(rest.index),
'rest_new_path': router.to_path(rest.new),
'rest_edit_path': router.to_path(rest.edit),
'rest_delete_path': router.to_path(rest.delete)
}
return TemplateResponse(context, 'itenss/itens_home.html')
def index():
return TemplateResponse(
{
'security_table_path': router.to_path(permission_home.index),
'permission_admin_path': router.to_path(admin),
'passwordless_admin_path': router.to_path(passwordless.form),
'facebook_admin_path': router.to_path(facebook.form)
}, 'admin/home.html')
def index(course_id):
course = course_facade.get_course_cmd(course_id)()
course_form = course_facade.course_form()
context = {
'save_path': router.to_path(save, course_id),
'course': course_form.fill_with_model(course)
}
return TemplateResponse(context, 'courses/course_form.html')
def index(venda_id):
venda = venda_facade.get_venda_cmd(venda_id)()
venda_form = venda_facade.venda_form()
context = {
'save_path': router.to_path(save, venda_id),
'venda': venda_form.fill_with_model(venda)
}
return TemplateResponse(context, 'vendas/venda_form.html')
def index(cliente_id):
cliente = facade.get_cliente_cmd(cliente_id)()
detail_form = facade.cliente_detail_form()
context = {
'save_path': router.to_path(save, cliente_id),
'cliente': detail_form.fill_with_model(cliente)
}
return TemplateResponse(context, 'clientes/admin/form.html')
def index(observacoe_id):
observacoe = facade.get_observacoe_cmd(observacoe_id)()
detail_form = facade.observacoe_detail_form()
context = {
'save_path': router.to_path(save, observacoe_id),
'observacoe': detail_form.fill_with_model(observacoe)
}
return TemplateResponse(context, 'observacoes/admin/form.html')
def index(_logged_user):
contexto = {
'rest_new_path': router.to_path(rest.new),
'rest_list_path': router.to_path(rest.index),
'rest_delete_path': router.to_path(rest.delete),
'rest_edit_path': router.to_path(rest.edit)
}
return TemplateResponse(contexto)
