def cadastrar_subcategoria(self):
subcategoria = []
c = Categoria()
c.set_nome(str(input("Digite o nome da categoria: ")))
for x in range(len(list_categorias)):
if c.get_nome() == list_categorias[x]['nome']:
subcategoria.append(
str(input("Digite o nome da subcategoria: ")))
op = True
while op:
try:
print('''
Deseja cadastrar outra subcategoria para esta categoria?
[1] - Sim
[2] - Nao
''')
op = int(input('Selecione uma opcao: '))
if op == 1:
subcategoria.append(
str(input("Digite o nome da subcategoria: ")))
elif op == 2:
break
except ValueError:
print('Ops! Opcao indisponivel, tente novamente!')
list_categorias[x]['subcategoria'] = subcategoria
def cadastrar_categoria():
if request.method == 'POST':
if "submit_button" in request.form:
nome = request.form['categoria']
categorias.append(Categoria(nome))
categoria = Categoria(nome)
db.session.add(categoria)
db.session.commit()
return indexCategorias()
else:
return render_template('cadastro-categoria.html')
def put_producto(producto_id):
if 'id' in session:
id = session['id']
try:
producto = Producto.get(Producto.id == producto_id)
categoria = Categoria.get(Categoria.id == producto.categoria)
inventario = Inventario.get((Inventario.id == categoria.inventario)
& (Inventario.usuario == id))
proveedor = Proveedor.get(Proveedor.id == producto.proveedor)
producto.nombre = request.json.get('nombre', producto.nombre)
producto.descripcion = request.json.get('descripcion',
producto.descripcion)
producto.categoria = request.json.get('categoria',
producto.categoria)
producto.proveedor = request.json.get('proveedor',
producto.proveedor)
if producto.save():
return jsonify(
producto.to_json(categoria.add_ok(), proveedor.to_json()))
else:
abort(422)
except Producto.DoesNotExist:
abort(404)
except Inventario.DoesNotExist:
abort(404)
return jsonify({'message': 'KO'})
def put_lote(lote_id):
if 'id' in session:
id = session['id']
try:
lote = Lote.get(Lote.id == lote_id)
producto = Producto.get(Producto.id == lote.producto)
categoria = Categoria.get(Categoria.id == producto.categoria)
inventario = Inventario.get((Inventario.id == categoria.inventario)
& (Inventario.usuario == id))
lote.costo = request.json.get('costo', lote.costo)
lote.precio = request.json.get('precio', lote.precio)
lote.existencia = request.json.get('existencia', lote.existencia)
lote.producto = request.json.get('producto', lote.producto)
if lote.save():
return jsonify(lote.to_json(producto.add_ok()))
else:
abort(422)
except Lote.DoesNotExist:
abort(404)
except Inventario.DoesNotExist:
abort(404)
return jsonify({'message': 'KO'})
def delete(self):
ndb.delete_multi(Comentario.query().fetch(keys_only=True))
ndb.delete_multi(MeGusta.query().fetch(keys_only=True))
ndb.delete_multi(Evento.query().fetch(keys_only=True))
ndb.delete_multi(Usuario.query().fetch(keys_only=True))
ndb.delete_multi(Categoria.query().fetch(keys_only=True))
self.response.unicode_body = u'{"True": "👌🏿"}'
def put_categoria(categoria_id):
if 'id' in session:
id = session['id']
try:
categoria = Categoria.get(Categoria.id == categoria_id)
inventario = Inventario.get((Inventario.id == categoria.inventario)
& (Inventario.usuario == id))
categoria.nombre = request.json.get('nombre', categoria.nombre)
categoria.descripcion = request.json.get('descripcion',
categoria.descripcion)
categoria.inventario = request.json.get('inventario',
categoria.inventario)
if categoria.save():
inventario = Inventario.get(
Inventario.id == categoria.inventario)
return jsonify(categoria.to_json(inventario.add_ok()))
else:
abort(422)
except Categoria.DoesNotExist:
abort(404)
except Inventario.DoesNotExist:
abort(404)
return jsonify({'message': 'KO'})
def newcategoria():
if current_user.is_authenticated and request.method == 'POST':
categoria = Categoria(name=request.form['name'])
session.add(categoria)
session.commit()
return redirect(url_for('categorias'))
return render_template('newcategoria.html', loggeduser=current_user.name)
def enviar_correo_interesados(evento):
categorias = Categoria.query(Categoria.key.IN(evento.categorias)).fetch()
usuarios = usuario.buscar_usuarios_preferencias(categorias)
send_mail([ util.from_json(_usuario.extra)[u'emails'][0][u'value'] for _usuario in usuarios ],
u'Hay un evento que te puede gustar - Agendamlggae',
u'''{} es un evento de tu preferencias. Es nuevo y puede que te interese.
https://agendamlggae-amjm.appspot.com/verEvento/{}
'''.format(evento.nombre, evento.key.urlsafe()))
def cat_id(num):
id_to_name = [
u'Teatro', u'Cine', u'Música', u'Gastronomía', u'Deporte', u'Pintura',
u'Escultura', u'Fotografía', u'Videojuegos', u'eSports',
u'Conferencia', u'Cultural', u'Informática'
]
return Categoria.query(Categoria.nombre == id_to_name[num -
1]).fetch()[0].key
def get(self):
categorias = []
for categoria in Categoria.query().fetch():
categoria_nueva = {
'id': categoria.key.urlsafe(),
'nombre': categoria.nombre
}
categorias.append(categoria_nueva)
self.response.write(to_json(categorias))
def get(self, idSerie):
if not self.checkLogin():
return webapp2.redirect('/')
iden = int(idSerie)
serie = db.get(db.Key.from_path('Serie', iden))
categorias = Categoria.all()
self.render_template('editSerie.html', {'categorias' : categorias, 'serie' : serie })
def do_it():
ndb.delete_multi(Comentario.query().fetch(keys_only=True))
ndb.delete_multi(MeGusta.query().fetch(keys_only=True))
ndb.delete_multi(Evento.query().fetch(keys_only=True))
ndb.delete_multi(Usuario.query().fetch(keys_only=True))
ndb.delete_multi(Categoria.query().fetch(keys_only=True))
add_categories()
add_users()
add_events()
def noticias(categoria_nombre):
categoria = Categoria(
**mongo.db.categorias.find_one_or_404({"nombre": categoria_nombre}))
noticias = mongo.db.noticias.find({
"categoria": categoria._id
}).sort("_id", -1)
categorias = mongo.db.categorias.find()
return render_template('noticias.html',
categorias=categorias,
noticias=noticias,
categoria_nombre=categoria_nombre)
def get_categorias():
if 'id' in session:
id = session['id']
categorias = Categoria.select().join(Inventario).where(
Inventario.usuario == id)
categorias = [
Categoria.to_json(
Inventario.get(Inventario.id == Categoria.inventario).add_ok())
for Categoria in categorias
]
identificador = Categoria.select().join(Inventario).where(
Inventario.usuario == id)
identificador = [Categoria.iden() for Categoria in identificador]
diccionario = {}
for x in range(len(categorias)):
diccionario[identificador[x]] = categorias[x]
return jsonify(diccionario)
return jsonify({'message': 'KO'})
def agregar():
categoria = Categoria()
categoriaForm= CategoriaForm(obj=categoria)
if request.method =='POST':
if categoriaForm.validate_on_submit():
categoriaForm.populate_obj(categoria)
db.session.add(categoria)
db.session.commit()
return redirect(url_for('inicio'))
return render_template('agregar.html',categoriaForm=categoriaForm)
def get_categoria(categoria_id):
if 'id' in session:
id = session['id']
try:
categoria = Categoria.get(Categoria.id == categoria_id)
inventario = Inventario.get((Inventario.id == categoria.inventario)
& (Inventario.usuario == id))
return jsonify(categoria.to_json(inventario.add_ok()))
except Categoria.DoesNotExist:
abort(404)
except Inventario.DoesNotExist:
abort(404)
return jsonify({'message': 'KO'})
def alta_noticia():
if request.method == 'POST':
categoria = Categoria(**mongo.db.categorias.find_one_or_404(
{"nombre": request.form["categoria"]}))
fecha = date.today().isoformat()
noticia = Noticia(request.form["titulo"], request.form["copete"],
request.form["cuerpo"], categoria._id, fecha)
mongo.db.noticias.insert_one(noticia.__dict__)
return redirect(url_for("index"))
else:
abort(404)
class TestCrearPolicial(TestCase):
def setUp(self):
self.policiales = Categoria(nombre='policiales')
self.policiales.save()
def test_noticia_se_crea_correctamente(self):
self.assertEquals(Noticia.objects.count(), 0)
nueva = crear_policial()
cantidad = Noticia.objects.filter(pk=nueva.pk).count()
self.assertEquals(cantidad, 1)
def test_noticia_creada_tiene_categoria_policiales(self):
nueva = crear_policial()
self.assertEquals(nueva.categoria, self.policiales)
def test_fecha_no_es_futura(self):
nueva = crear_policial()
self.assertGreaterEqual(datetime.now(), nueva.fecha)
def test_datos_noticia_aparecen_en_html_resultante(self):
response = self.client.get(reverse('crear_policial'))
nueva = Noticia.objects.get()
self.assertEquals(response.status_code, 200)
self.assertIn(nueva.titulo, response.content)
self.assertIn(nueva.texto, response.content)
def test_la_vista_tiene_que_usar_la_api(self):
from sitio.views import crear_policial as crear_policial_de_views
self.assertEquals(crear_policial, crear_policial_de_views)
with mock.patch('sitio.views.crear_policial') as mock_api_crear:
self.client.get(reverse('crear_policial'))
self.assertTrue(mock_api_crear.called)
def get_lote(lote_id):
if 'id' in session:
id = session['id']
try:
lote = Lote.get(Lote.id == lote_id)
producto = Producto.get(Producto.id == lote.producto)
categoria = Categoria.get(Categoria.id == producto.categoria)
inventario = Inventario.get((Inventario.id == categoria.inventario)
& (Inventario.usuario == id))
return jsonify(lote.to_json(producto.add_ok()))
except Lote.DoesNotExist:
abort(404)
except Inventario.DoesNotExist:
abort(404)
return jsonify({'message': 'KO'})
def get_producto(producto_id):
if 'id' in session:
id = session['id']
try:
producto = Producto.get(Producto.id == producto_id)
categoria = Categoria.get(Categoria.id == producto.categoria)
inventario = Inventario.get((Inventario.id == categoria.inventario)
& (Inventario.usuario == id))
proveedor = Proveedor.get(Proveedor.id == producto.proveedor)
return jsonify(
producto.to_json(categoria.add_ok(), proveedor.to_json()))
except Producto.DoesNotExist:
abort(404)
except Inventario.DoesNotExist:
abort(404)
return jsonify({'message': 'KO'})
def get(self):
if not self.checkLogin():
return webapp2.redirect('/')
user = users.get_current_user()
logoutUrl = self.getLogout();
categoria = None
if self.request.get('categoriaSelected') == '' :
series = Serie.all()
else :
categoriaId = int(self.request.get('categoriaSelected'))
categoria = db.get(db.Key.from_path('Categoria',categoriaId))
print(categoriaId)
series = categoria.series
categorias = Categoria.all()
self.render_template('index.html', {'listaSeries' : series, 'categorias' : categorias, 'categoriaSelected' : categoria, 'nickname' : user.nickname(), 'logoutUrl' : logoutUrl })
def categorias():
alert = ''
if request.method == "POST":
result = db.session.query(Categoria).all()
for i in result:
if request.form.get(
"new_categoria").lower() == i.nombreCategoria.lower():
flash("Esa categoria ya existe")
alert = "alert-warning"
return render_template("categorias.html", alert=alert)
NuevaCateg = Categoria(session["user_id"],
request.form.get("new_categoria"))
db.session.add(NuevaCateg)
db.session.commit()
flash("Categoria creada")
alert = "alert-success"
return render_template("categorias.html", alert=alert)
def loadcat():
categorias = Categoria()
categorias.categoria = "Economia"
db.session.add(categorias)
db.session.commit()
categorias = Categoria()
categorias.categoria = "Tecnologia"
db.session.add(categorias)
db.session.commit()
print("Categorias de prueba creadas")
def post_categoria():
if 'id' in session:
id = session['id']
if not request.json:
abort(400)
nombre = request.json.get('nombre')
descripcion = request.json.get('descripcion')
inventario = request.json.get('inventario')
categoria = Categoria.new(nombre, descripcion, inventario)
if categoria is None:
abort(422)
if categoria == "error":
abort(406)
inventario = Inventario.get(Inventario.id == categoria.inventario)
return jsonify(categoria.to_json(inventario.add_ok()))
return jsonify({'message': 'KO'})
def get_productos():
if 'id' in session:
id = session['id']
productos = Producto.select().join(Categoria).join(Inventario).where(
Inventario.usuario == id)
productos = [
Producto.to_json(
Categoria.get(Categoria.id == Producto.categoria).add_ok(),
Proveedor.get(Proveedor.id == Producto.proveedor).to_json())
for Producto in productos
]
identificador = Producto.select().join(Categoria).join(
Inventario).where(Inventario.usuario == id)
identificador = [Producto.iden() for Producto in identificador]
diccionario = {}
for x in range(len(productos)):
diccionario[identificador[x]] = productos[x]
return jsonify(diccionario)
return jsonify({'message': 'KO'})
def categoria(categoria_id = None):
if request.method == 'GET':
if categoria_id is not None:
categoria = Categoria.query.get(categoria_id)
if categoria:
return jsonify(categoria.serialize()), 200
else:
return jsonify({"msg": " Categoria no encontrada"}), 404
else:
categorias = Categoria.query.all()
categorias = list(map(lambda categoria: categoria.serialize(), categorias))
return jsonify(categorias), 200
if request.method == 'POST':
categoria = request.json.get('categoria', None)
categorias = Categoria()
categorias.categoria = categoria
db.session.add(categorias)
db.session.commit()
return jsonify(categorias.serialize()), 201
if request.method == 'PUT':
categoria = request.json.get('categoria', None)
categorias = Categoria.query.get(categoria_id)
if not categorias:
return jsonify({"msg": "Categoria no encontrada"}), 404
categorias.categoria = categoria
db.session.commit()
return jsonify(categorias.serialize()), 201
if request.method == 'DELETE':
categoria = Categoria.query.get(categoria_id)
if not categoria:
return jsonify({"msg": "Categoria no encontrada"}), 404
db.session.delete(categoria)
db.session.commit()
return jsonify({"msg":"Categoria borrada!"}), 200
def post_producto():
if 'id' in session:
id = session['id']
if not request.json:
abort(400)
nombre = request.json.get('nombre')
descripcion = request.json.get('descripcion')
categoria = request.json.get('categoria')
proveedor = request.json.get('proveedor')
producto = Producto.new(nombre, descripcion, categoria, proveedor)
if producto is None:
abort(422)
if producto == "error":
abort(406)
categoria = Categoria.get(Categoria.id == producto.categoria)
proveedor = Proveedor.get(Proveedor.id == producto.proveedor)
return jsonify(
producto.to_json(categoria.add_ok(), proveedor.to_json()))
return jsonify({'message': 'KO'})
def post(self):
self.response.headers['Content-Type'] = 'text/plain'
try:
batchsize = int(self.request.get('batchsize'))
batchnumber = int(self.request.get('batchnumber'))
if batchsize is None:
batchsize = 10
if batchnumber is None:
batchnumber = 0
except ValueError:
batchsize = 10
batchnumber = 0
offset = batchnumber * batchsize
sucs = Sucursal.all()
for b in MvBlob.all().order ("-FechaHora").run(limit=1):
sucs.filter("FechaHora >", b.FechaHora)
sucs.order("FechaHora")#[offset:offset + batchsize]
logging.info('MvBlob generation, batchsize: ' + str(batchsize) + ',batchnumber: ' + str(batchnumber) + '. [' + str(offset) + ':' + str(offset + batchsize) + ']')
for suc in sucs.run(offset=offset, limit=batchsize):
HasOferta = False
olist = []
OSs = OfertaSucursal.all().filter("IdSuc =", suc.IdSuc)
for OS in OSs:
HasOferta = True
olist.append(OS.IdOft)
if HasOferta:
als = MvBlob.all().filter("IdSuc =", suc.IdSuc)
for al in als:
db.delete(al)
sucdict = {'id': suc.IdSuc, 'nombre': suc.Nombre, 'lat': suc.Geo1, 'long': suc.Geo2, 'fechamod': str(suc.FechaHora)}
ent = None
entidades = Entidad.all().filter("CveEnt =", suc.DirEnt)
for entidad in entidades:
ent = entidad.Entidad
mun = None
municipios = Municipio.all().filter("CveEnt =", suc.DirEnt).filter("CveMun =", suc.DirMun)
for municipio in municipios:
mun = municipio.Municipio
sucdict['direccion'] = {'calle': suc.DirCalle, 'colonia': suc.DirCol, 'cp': suc.DirCp,'entidad_id': suc.DirEnt, 'entidad': ent,'municipio_id': suc.DirMun, 'municipio': mun}
empresas = Empresa.all().filter("IdEmp = ", suc.IdEmp)
for empresa in empresas.run(limit=1):
empresadict = {'id': empresa.IdEmp, 'nombre': empresa.Nombre, 'url': empresa.Url, 'url_logo': ''}
sucdict['empresa'] = empresadict
urllogo = 'http://www.elbuenfin.org/imgs/imageDefault.png'
ofertaslist = []
for o in olist:
ofertas = Oferta.all().filter("IdOft =", o).run()
for oferta in ofertas:
url = 'http://www.elbuenfin.org/imgs/imageDefault.png'
try:
if oferta.Codigo and oferta.Codigo.replace('https://','http://')[0:7] == 'http://':
url = oferta.Codigo
except AttributeError:
err = 'logourl'
try:
if oferta.Codigo is None and oferta.BlobKey and oferta.BlobKey != None and oferta.BlobKey.key() != 'none':
url = 'http://' + APPID + '/ofimg?id=' + str(oferta.BlobKey.key())
except AttributeError:
err = 'logourl'
if url == 'http://www.elbuenfin.org/imgs/imageDefault.png' and oferta.Promocion is not None and oferta.Promocion != '':
url = oferta.Promocion
if oferta.Promocion is not None and oferta.Promocion != '':
urllogo = oferta.Promocion
ofertadict = {'id': oferta.IdOft, 'oferta': oferta.Oferta, 'descripcion': oferta.Descripcion, 'descuento': oferta.Descuento, 'promocion': oferta.Promocion, 'enlinea': oferta.Enlinea, 'precio': oferta.Precio, 'url': oferta.Url, 'url_logo': url, 'fechapub': str(oferta.FechaHoraPub.strftime('%Y-%m-%d'))}
palabraslist = []
palabras = OfertaPalabra.all().filter("IdOft =", oferta.IdOft)
for palabra in palabras:
palabraslist.append(palabra.Palabra)
ofertadict['palabras'] = palabraslist
cat = None
categorias = Categoria.all().filter("IdCat =", oferta.IdCat)
for categoria in categorias:
cat = categoria.Categoria
ofertadict['categoria_id'] = oferta.IdCat
ofertadict['categoria'] = cat
ofertaslist.append(ofertadict)
sucdict['ofertas'] = ofertaslist
sucdict['empresa']['url_logo'] = urllogo
mvblob = MvBlob()
mvblob.FechaHora = suc.FechaHora
mvblob.IdSuc = suc.IdSuc
mvblob.Blob = json.dumps(sucdict)
mvblob.put()
else:
pass
def categorias(id=None):
if request.method == 'GET':
if id is not None:
categoria = Categoria.query.get(id)
if categoria:
return jsonify(categoria.serialize()), 200
else:
return jsonify({"error": "Not found"}), 404
else:
categorias = Categoria.query.all()
categorias = list(
map(lambda categoria: categoria.serialize(), categorias))
return jsonify(categorias), 200
if request.method == 'POST':
if not request.json.get('nombre'):
return jsonify({"nombre": "es requerido"}), 422
data = request.get_json()
categoria = Categoria.query.filter_by(
name=data['nombre'].upper()).first()
print(categoria)
if categoria:
return jsonify(
{"categoria": data['nombre'].upper() + " ya existe"}), 200
else:
categoria = Categoria()
categoria.name = data['nombre'].upper()
db.session.add(categoria)
db.session.commit()
return jsonify(categoria.serialize()), 201
if request.method == 'PUT':
data = request.get_json()
if not request.json.get('descripcion'):
return jsonify({"descripcion": "es requerido"}), 422
categoria = Categoria.query.get(id)
if not categoria:
return jsonify({"error": "not found"}), 404
else:
categoria = Categoria.query.filter_by(
descripcion=data['descripcion'].upper()).first()
if categoria:
return jsonify(
{"categoria":
data['descripcion'].upper() + " ya existe"}), 200
else:
categoria = Categoria.query.get(id)
categoria.descripcion = data['descripcion'].upper()
db.session.commit()
return jsonify(categoria.serialize()), 201
if request.method == 'DELETE':
categoria = Categoria.query.get(id)
if not categoria:
return jsonify({"error": "not found"}), 404
else:
db.session.delete(pais)
db.session.commit()
return jsonify({"message": "delete"}), 200
def get(self):
if not self.checkLogin():
return webapp2.redirect('/')
categorias = Categoria.all()
self.render_template('newSerie.html', {'categorias' : categorias})
def post(self):
cat = Categoria(nombre=self.request.get('inputNewCat'), series=[])
cat.put()
# se necesita un sleep ara que los items se creen en el datastore y los vea
return webapp2.redirect('/index')
def get(self):
timestamp = self.request.get('timestamp')
horas = self.request.get('horas')
self.response.headers['Content-Type'] = 'text/plain'
if not timestamp or not horas or timestamp == None or horas == None or timestamp == '' or horas == '':
errordict = {'error': -1, 'message': 'Must specify variables in GET method (i.e. /db?timestamp=<YYYYMMDDHH24>&horas=<int>)'}
self.response.out.write(json.dumps(errordict))
elif len(timestamp) != 10:
errordict = {'error': -2, 'message': 'timestamp must be 10 chars long: YYYYMMDDHH24'}
self.response.out.write(json.dumps(errordict))
else:
try:
fechastr = timestamp[0:8]
timestamp = datetime.strptime(timestamp,'%Y%m%d%H')
timestampdia = datetime.strptime(fechastr, '%Y%m%d')
horas = int(horas)
timestampend = timestamp + timedelta(hours = horas)
except ValueError:
errordict = {'error': -2, 'message': 'Value Error. Timestamp must be YYYYMMDDHH24 and horas is an integer'}
self.response.out.write(json.dumps(errordict))
if horas > 24:
errordict = {'error': -2, 'message': 'Horas must be <= 24'}
self.response.out.write(json.dumps(errordict))
else:
self.response.headers['Content-Type'] = 'text/plain'
suclist = memcache.get('wssucursales-' + fechastr)
if suclist is None:
outputlist = []
sucursales = Sucursal.all().filter("FechaHora >=", timestampdia).filter("FechaHora <", timestampdia + timedelta(days = 1))
for sucursal in sucursales:
sucdict = {}
sucdict['id'] = sucursal.IdSuc
sucdict['nombre'] = sucursal.Nombre
ent = None
entidades = Entidad.all().filter("CveEnt =", sucursal.DirEnt)
for entidad in entidades:
ent = entidad.Entidad
mun = None
municipios = Municipio.all().filter("CveEnt =", sucursal.DirEnt).filter("CveMun =", sucursal.DirMun)
for municipio in municipios:
mun = municipio.Municipio
sucdict['direccion'] = {'calle': sucursal.DirCalle, 'colonia': sucursal.DirCol, 'cp': sucursal.DirCp,'entidad_id': sucursal.DirEnt, 'entidad': ent,'municipio_id': sucursal.DirMun, 'municipio': mun}
sucdict['logo'] = None
sucdict['lat'] = sucursal.Geo1
sucdict['long'] = sucursal.Geo2
empresaQ = db.GqlQuery("SELECT * FROM Empresa WHERE IdEmp = :1", sucursal.IdEmp)
empresas = empresaQ.fetch(1)
empresadict = {}
for empresa in empresas:
empresadict = {'id': empresa.IdEmp, 'nombre': empresa.Nombre, 'url': empresa.Url, 'url_logo': 'http://' + APPID + '/spic?IdEmp=' + empresa.IdEmp}
sucdict['empresa'] = empresadict
ofertas = OfertaSucursal.all().filter("IdSuc =", sucursal.IdSuc)
ofertaslist = []
for oferta in ofertas.run(batch_size=10000):
ofs = Oferta.all().filter("IdOft =", oferta.IdOft)
of = []
for ofinst in ofs.run(limit=1):
of = ofinst
ofertadict = {}
ofertadict['id'] = oferta.IdOft
ofertadict['oferta'] = oferta.Oferta
ofertadict['descripcion'] = oferta.Descripcion
ofertadict['descuento'] = oferta.Descuento
ofertadict['promocion'] = oferta.Promocion
ofertadict['enlinea'] = oferta.Enlinea
#ofertadict['categoria'] = oferta.IdCat
ofertadict['precio'] = oferta.Precio
ofertadict['url'] = oferta.Url
if of.BlobKey and of.BlobKey is not None:
url = 'http://' + APPID + '/ofimg?id=' + str(of.BlobKey.key())
else:
url = ''
ofertadict['url_logo'] = url
palabraslist = []
palabras = OfertaPalabra.all().filter("IdOft =", oferta.IdOft)
for palabra in palabras:
palabraslist.append(palabra.Palabra)
ofertadict['palabras'] = palabraslist
cat = None
# CATEGORIA -temporal-
idcat = None
ofts = Oferta.all().filter("IdOft =", oferta.IdOft)
for oft in ofts:
idcat = oft.IdCat
categorias = Categoria.all().filter("IdCat =", idcat)
for categoria in categorias:
cat = categoria.Categoria
ofertadict['categoria_id'] = idcat
ofertadict['categoria'] = cat
ofertaslist.append(ofertadict)
sucdict['ofertas'] = ofertaslist
sucdict['timestamp'] = str(sucursal.FechaHora)
outputlist.append(sucdict)
memcache.add('wssucursales-' + fechastr, outputlist, 3600)
suclist = outputlist
if suclist is None:
self.response.out.write(json.dumps([]))
else:
outputlist = []
for suc in suclist:
valid = False
suctimestamp = datetime.strptime(suc['timestamp'].split('.')[0], '%Y-%m-%d %H:%M:%S')
if timestamp <= suctimestamp and suctimestamp <= timestampend:
valid = True
if valid == True:
outputlist.append(suc)
self.response.out.write(json.dumps(outputlist))
