def UserHandler(request, ident):
response = HttpResponse("", content_type='application/json')
try:
usuario = users.GetCurrentUser()
if not usuario:
response.write('{}')
return response
llavetexto = usuario.email() + '/' + ident
llave = ndb.Key(Usuario, llavetexto)
tmp = {}
if (request.raw_post_data):
tmp = simplejson.loads(request.raw_post_data)
def post():
logging.info('post ' + llavetexto)
viejo = llave.get()
if not viejo:
logging.info('No hay viejo')
viejo = Usuario(id=llavetexto)
else:
logging.info('Si hay viejo')
for key, value in tmp.iteritems():
attributo = getattr(Usuario, key, None)
if attributo != None and attributo.__class__ == ndb.model.DateTimeProperty:
value = datetime.datetime.fromtimestamp(value)
setattr(viejo, key, value)
viejo.put()
response.write(simplejson.dumps({'error': 0}))
if request.method == 'GET':
logging.info('get ' + llavetexto)
viejo = llave.get()
todos = simplejson.dumps(to_dict(viejo))
response.write(todos)
if request.method == 'PUT':
logging.info('put ' + llavetexto)
post()
if request.method == 'DELETE':
logging.info('delete ' + llavetexto)
llave.delete()
response.write('{"error":0, "msg": "' + llavetexto + ' borrado"}')
except Exception, e:
response.write(
simplejson.dumps({
'error': 1,
'msg': 'Error de servidor: ' + str(e)
}))
def CarritoHandler(request, ident):
response = HttpResponse("", content_type='application/json')
try:
usuario = users.GetCurrentUser()
if not usuario:
return HttpResponse(status=401)
tmp = {}
if (request.raw_post_data):
tmp = simplejson.loads(request.raw_post_data)
#se busca el carrito actual
actual = ndb.gql(
'SELECT * FROM Carrito WHERE estado = 0 AND correo=\'' +
usuario.email() + '\'')
lista = actual.fetch(1)
if (len(lista) == 1):
carrito = lista[0]
else:
carrito = Carrito(estado=0, correo=usuario.email())
def post():
logging.info('post')
carrito.json = simplejson.dumps(tmp)
carrito.put()
response.write(simplejson.dumps({'error': 0}))
if request.method == 'GET':
logging.info('get carrito')
todos = simplejson.dumps(to_dict(carrito))
response.write(todos)
if request.method == 'PUT':
logging.info('put')
post()
except Exception, e:
response.write(
simplejson.dumps({
'error': 1,
'msg': 'Error de servidor: ' + str(e)
}))
def RESTpaginar(request, ident):
response = HttpResponse("", content_type='application/json')
if request.method == 'PUT':
objeto = simplejson.loads(request.raw_post_data)
if (objeto['cursor'] and len(objeto['cursor']) > 0):
objeto['busqueda']['next'] = objeto['cursor']
rta = comun.buscarGQL(objeto['busqueda'])
ans = {'datos': comun.to_dict(rta['datos'])}
if (rta.has_key('next')):
ans['next'] = rta['next']
todo = simplejson.dumps(ans)
response.write(todo)
return response
else:
return HttpResponse(status=403)
def AsistenciaHandler(request, ident):
fechaAhora = datetime.datetime.now() - datetime.timedelta(hours=5)
response = HttpResponse("", content_type='application/json')
def corregirFecha(nombre, payload):
if (payload.has_key(nombre) and not (payload[nombre] is None)):
payload[nombre] = payload[nombre] / 1000
def corregirFechasPersona(rta):
if (rta.has_key('nacimiento') and not (rta['nacimiento'] is None)):
rta['nacimiento'] = rta['nacimiento'] * 1000
if (rta.has_key('aniversario') and not (rta['aniversario'] is None)):
rta['aniversario'] = rta['aniversario'] * 1000
if (rta.has_key('primiparo') and not (rta['primiparo'] is None)):
rta['primiparo'] = rta['primiparo'] * 1000
def buscarPersona(payload):
if (payload.has_key('id')):
return buscarPersonaConId(payload['id'])
if (payload.has_key('cedula')):
return buscarPersonaConCedula(payload['cedula'])
return None
def buscarPersonaConId(idLocal):
llave = ndb.Key(Asistente, idLocal)
viejo = llave.get()
return viejo
def buscarPersonaConCedula(numero):
#busco por correo
busqueda = "SELECT * FROM Asistente "
busqueda += "WHERE "
busqueda += "cedula = '" + str(numero) + "'"
objeto = comun.buscarGQL({"q": busqueda, "n": long(1)})
if (len(objeto['datos']) == 0):
return None
return objeto['datos'][0]
def buscarMonitores(payload, tampagina):
busqueda = "SELECT * FROM Asistente WHERE rol = 2"
nextPoint = None
if not payload is None and payload.has_key('next'):
nextPoint = payload['next']
objeto = comun.buscarGQL({
"q": busqueda,
"n": long(tampagina),
"next": nextPoint
})
return objeto
def verAsistencia(payload, tampagina):
fecha = payload['fecha']
nextPoint = None
if payload.has_key('next'):
nextPoint = payload['next']
fechaAntes = datetime.datetime.fromtimestamp(float(fecha))
fechaDespues = datetime.datetime.fromtimestamp(
float(fecha)) + datetime.timedelta(hours=24)
formato = "%Y, %m, %d, %H, %M, %S"
busqueda = "SELECT * FROM Asistencia "
busqueda += "WHERE "
busqueda += "fecha > DATETIME(" + fechaAntes.strftime(
formato) + ") AND "
busqueda += "fecha < DATETIME(" + fechaDespues.strftime(formato) + ") "
busqueda += "ORDER BY fecha ASC "
objeto = comun.buscarGQL({
"q": busqueda,
"n": long(tampagina),
"next": nextPoint
})
return objeto
def verTodos(payload, tampagina):
busqueda = "SELECT * FROM Asistente ORDER BY apellidos ASC"
nextPoint = None
if payload.has_key('next'):
nextPoint = payload['next']
objeto = comun.buscarGQL({
"q": busqueda,
"n": long(tampagina),
"next": nextPoint
})
return objeto
def verNuevos(payload, tampagina):
fecha = payload['fecha']
nextPoint = None
if payload.has_key('next'):
nextPoint = payload['next']
fechaAntes = datetime.datetime.fromtimestamp(float(fecha))
fechaDespues = datetime.datetime.fromtimestamp(
float(fecha)) + datetime.timedelta(hours=24)
formato = "%Y, %m, %d, %H, %M, %S"
busqueda = "SELECT * FROM Asistente "
busqueda += "WHERE "
busqueda += "primiparo > DATETIME(" + fechaAntes.strftime(
formato) + ") AND "
busqueda += "primiparo < DATETIME(" + fechaDespues.strftime(
formato) + ") "
busqueda += "ORDER BY primiparo ASC "
objeto = comun.buscarGQL({
"q": busqueda,
"n": long(tampagina),
"next": nextPoint
})
return objeto
def checkearTamanioToken(x, tam):
return len(x) >= tam
def tokenizar(texto, mimSize):
#texto = texto.decode('utf-8')
texto = ''.join((c for c in unicodedata.normalize('NFD', texto)
if unicodedata.category(c) != 'Mn'))
texto = texto.lower()
ans = []
tokens = texto.split()
tokens = [x for x in tokens if checkearTamanioToken(x, mimSize)]
for untoken in tokens:
for i in range(mimSize, len(untoken) + 1):
parte = untoken[:i]
if not parte in ans:
ans.append(parte)
return ans
def verPersonasQ(payload, tampagina):
monitor = None
token = None
if payload.has_key('q'):
token = payload['q']
if payload.has_key('monitor'):
monitor = payload['monitor']
if (token is None):
token = ""
tokens = token.split()
#limpio los tokens de menos de 3
tokens = [x for x in tokens if checkearTamanioToken(x, 3)]
if (len(tokens) > 0):
busqueda = "SELECT * FROM Asistente WHERE "
for untoken in tokens:
busqueda += "busqueda IN ('" + untoken.lower() + "') AND "
if not monitor is None:
busqueda += "monitor = " + str(monitor) + " AND"
busqueda = busqueda[:-4]
else:
busqueda = "SELECT * FROM Asistente "
if not monitor is None:
busqueda += "WHERE monitor = " + str(monitor) + " "
busqueda += "ORDER BY apellidos ASC"
nextPoint = None
if payload.has_key('next'):
nextPoint = payload['next']
objeto = comun.buscarGQL({
"q": busqueda,
"n": long(tampagina),
"next": nextPoint
})
return objeto
def buscarPersonaConCorreo(correo):
#busco por correo
busqueda = "SELECT * FROM Asistente "
busqueda += "WHERE "
busqueda += "correo = '" + correo.upper() + "'"
objeto = comun.buscarGQL({"q": busqueda, "n": long(1)})
if (len(objeto['datos']) == 0):
return None
return objeto['datos'][0]
def enriquecerEntidad(payload, clase):
attributos = clase._buscables
texto = ''
for atributo in attributos:
contenido = payload[atributo]
if not contenido is None:
texto += contenido + ' '
payload['busqueda'] = tokenizar(texto, 3)
def crearPersona(payload):
nuevo = Asistente()
nuevo.primiparo = fechaAhora
enriquecerEntidad(payload, Asistente)
if not payload.has_key('monitor'):
payload['monitor'] = 0 #significa que esta por asignar
rta = comun.llenarYpersistir(Asistente, nuevo, payload, None)
return rta
def crearAsistencia(asistente):
nuevo = Asistencia()
nuevo.asistente = asistente.key.id()
nuevo.fecha = fechaAhora
nuevo.put()
def actualizarPersona(payload, viejo):
llave = ndb.Key(Asistente, payload['id'])
viejo2 = llave.get()
if (viejo2):
enriquecerEntidad(payload, Asistente)
logging.info(payload)
#existe el que voy a actualizar
if (viejo is None or viejo.key.id() == viejo2.key.id()):
rta = comun.llenarYpersistir(Asistente, viejo2, payload, None)
return {'error': 0, 'rta': rta}
else:
return {
'error': 4,
'msg': 'La cédula ' + str(payload['cedula']) + ' ya existe'
}
try:
if request.method == 'PUT':
payload = None
if (request.raw_post_data):
payload = simplejson.loads(request.raw_post_data)
accion = request.GET.get('accion', None)
#A partir de aca se evalua la accion
if (accion == 'leer-usuario'):
usuario = users.get_current_user()
if (usuario is None):
response.write(
simplejson.dumps({
'error': 1,
'msg': 'Debe ingresar antes'
}))
else:
#busco por correo
respuesta = buscarPersonaConCorreo(usuario.email())
entidades = comun.to_dict(respuesta)
if (entidades is None):
response.write(
simplejson.dumps({
'error':
1,
'msg':
'El usuario no se encuentra registrado'
}))
else:
response.write(
simplejson.dumps({
'error': 0,
'data': entidades
}))
elif (accion == 'leer-grupo'):
response.write(simplejson.dumps({'error': 0}))
elif (accion == 'crear-persona' or accion == 'actualizar-persona'
or accion == 'crear-actualizar-persona'):
corregirFecha('nacimiento', payload)
corregirFecha('aniversario', payload)
#busco si ya existe con la cedula dada
viejo = buscarPersonaConCedula(payload['cedula'])
if (not payload.has_key('id') or payload['id'] is None):
if (accion != 'crear-persona'
and accion != 'crear-actualizar-persona'):
response.write(
simplejson.dumps({
'error':
5,
'msg':
'Sin id solo se debe crear la persona'
}))
else:
#Aca es crear la persona
if viejo:
response.write(
simplejson.dumps({
'error':
2,
'msg':
'La cédula ' + str(payload['cedula']) +
' ya existe'
}))
else:
rta = crearPersona(payload)
response.write(
simplejson.dumps({
'error': 0,
'rta': rta
}))
else:
if (accion == 'crear-persona'):
response.write(
simplejson.dumps({
'error':
3,
'msg':
'Con id no se debe crear la persona'
}))
else:
rta = actualizarPersona(payload, viejo)
response.write(simplejson.dumps(rta))
elif (accion == 'leer-persona'):
viejo = buscarPersona(payload)
if viejo:
rta = comun.to_dict(viejo)
corregirFechasPersona(rta)
response.write(simplejson.dumps({'error': 0, 'rta': rta}))
else:
response.write(
simplejson.dumps({
'error': 1,
'msg': 'La persona no esta registrada'
}))
elif (accion == 'buscar-personas'):
objeto = verPersonasQ(payload, 10)
entidades = comun.to_dict(objeto['datos'])
for rta in entidades:
corregirFechasPersona(rta)
cursor = None
if (objeto.has_key('next')):
cursor = objeto['next']
response.write(
simplejson.dumps({
'error': 0,
'entidades': entidades,
'next': cursor
}))
elif (accion == 'borrar-persona'):
if (users.is_current_user_admin()):
llave = ndb.Key(Asistente, long(payload['id']))
llave.delete()
response.write(
simplejson.dumps({
'error': 0,
'borradas': 1
}))
else:
response.write(
simplejson.dumps({
'error': 2,
'msg': 'No tiene los privilegios'
}))
elif (accion == 'tomar-asistencia'):
viejo = buscarPersona(payload)
if (viejo):
#Debo crear una instancia de asistencia
crearAsistencia(viejo)
response.write(
simplejson.dumps({
'error':
0,
'msg':
'Gracias por asistir ' + viejo.nombres + ' ' +
viejo.apellidos
}))
else:
response.write(
simplejson.dumps({
'error': 1,
'msg': 'Debe ingresar como nuevo'
}))
elif (accion == 'verasistencia'):
corregirFecha('fecha', payload)
objeto = verAsistencia(payload, 10)
entidades = comun.to_dict(objeto['datos'])
for rta in entidades:
corregirFechasPersona(rta)
cursor = None
if (objeto.has_key('next')):
cursor = objeto['next']
response.write(
simplejson.dumps({
'error': 0,
'entidades': entidades,
'next': cursor
}))
elif (accion == 'vernuevos'):
corregirFecha('fecha', payload)
objeto = verNuevos(payload, 10)
entidades = comun.to_dict(objeto['datos'])
for rta in entidades:
corregirFechasPersona(rta)
cursor = None
if (objeto.has_key('next')):
cursor = objeto['next']
response.write(
simplejson.dumps({
'error': 0,
'entidades': entidades,
'next': cursor
}))
elif (accion == 'vertodos'):
if (users.is_current_user_admin()):
corregirFecha('fecha', payload)
objeto = verTodos(payload, 10)
entidades = comun.to_dict(objeto['datos'])
for rta in entidades:
corregirFechasPersona(rta)
cursor = None
if (objeto.has_key('next')):
cursor = objeto['next']
response.write(
simplejson.dumps({
'error': 0,
'entidades': entidades,
'next': cursor
}))
else:
response.write(
simplejson.dumps({
'error': 2,
'msg': 'No tiene los privilegios'
}))
elif (accion == 'enviarreporte'):
destinatario = payload['email']
contenido = payload['contenido']
asunto = payload['subject']
try:
message = mail.EmailMessage()
message.sender = "*****@*****.**"
message.to = destinatario
message.html = contenido
message.body = contenido
message.subject = "Reporte de grupo de conexión - ".decode(
'utf-8') + asunto
message.send()
response.write(simplejson.dumps({'error': 0}))
except:
logging.exception("message")
response.write(
simplejson.dumps({
'error': 1,
'msg': 'No se logró enviar el correo'
}))
elif (accion == 'vermonitores'):
if (users.is_current_user_admin()):
objeto = buscarMonitores(payload, 10)
entidades = comun.to_dict(objeto['datos'])
for rta in entidades:
corregirFechasPersona(rta)
cursor = None
if (objeto.has_key('next')):
cursor = objeto['next']
response.write(
simplejson.dumps({
'error': 0,
'entidades': entidades,
'next': cursor
}))
else:
response.write(
simplejson.dumps({
'error': 2,
'msg': 'No tiene los privilegios'
}))
else:
response.write(simplejson.dumps({'error': 0}))
except Exception, e:
logging.exception("message")
response.write(
simplejson.dumps({
'error': 100,
'msg': 'Error de servidor: ' + str(e)
}))
def RESTfulHandler(request, ident):
response = HttpResponse("", content_type='application/json')
tokens = re.findall('(/?)(\w+)/(.*)$', ident)
if len(tokens) > 0:
nombre = tokens[0][1]
ident = tokens[0][2]
else:
nombre = 'Documento'
if ident.isnumeric():
ident = long(ident)
if not users.is_current_user_admin() and request.method in [
'POST', 'PUT', 'DELETE'
]:
return HttpResponse(status=401)
module = __import__('models')
class_ = getattr(module, nombre)
def post():
logging.info('post ' + str(ident) + ' with ')
completo = simplejson.loads(request.raw_post_data)
todo = completo['payload']
leng = completo['leng']
nuevo = class_(id=ident)
otro = comun.llenarYpersistir(class_, nuevo, todo, leng)
ans = {}
ans['error'] = 0
ans['payload'] = otro
response.write(simplejson.dumps(ans))
if request.method == 'GET':
logging.info('get')
if ident:
llave = ndb.Key(nombre, ident)
greetings = llave.get()
else:
greetings = buscarTodos(nombre)
todos = simplejson.dumps(comun.to_dict(greetings))
response.write(todos)
if request.method == 'POST':
post()
if request.method == 'PUT':
logging.info('put ' + str(ident) +
' with ') #tiene problemas con el unicode
completo = simplejson.loads(request.raw_post_data)
tmp = completo['payload']
leng = completo['leng']
viejo = None
if ident:
llave = ndb.Key(nombre, ident)
else:
if (tmp.has_key('id')):
llave = ndb.Key(nombre, tmp['id'])
else:
llave = None
if (llave):
viejo = llave.get()
if viejo:
otro = comun.llenarYpersistir(class_, viejo, tmp, leng)
ans = {}
ans['error'] = 0
ans['payload'] = otro
response.write(simplejson.dumps(ans))
else:
post()
if request.method == 'DELETE':
logging.info('delete ' + str(ident))
if ident:
llave = ndb.Key(nombre, ident)
llave.delete()
response.write('{"error":0, "msg": "' + nombre + ' (' +
str(ident) + ') borrado"}')
else:
return HttpResponse(status=403)
return response
def principal(request, data):
if request.method == 'GET':
#incluye los parametros del get no va a ignorar el lenguaje (solo se usa para memcache)
var_full_path = request.get_full_path()
#incluye hasta la ? y va a ignorar el lenguaje
var_path = request.path
leng = re.findall('^(\/leng-)([a-zA-Z]{3})(\/)', var_path)
if (len(leng) > 0):
leng = leng[0][1].lower()
var_path = var_path[9:]
data = data[9:]
else:
leng = LENGUAJE_PRED
user = users.get_current_user()
#El usuario no administrativo pasa por memcache
if not users.is_current_user_admin():
anterior = memcache.get(var_full_path)
if (anterior):
anterior = anterior.replace(
'__USER__', generarVariablesUsuario(var_full_path, leng),
1)
return HttpResponse(anterior, content_type='text/html')
#Buscar un template valido para la url
partes = data.split('/')
archivo = None
directorio = None
archivoExistente = None
if (not data in COMMON_TEMPLATES.keys()):
for parte in partes:
#Se elimina la extension
parte = parte.split('.')[0]
if (archivo == None):
archivo = os.path.join(TEMPLATE_DIRS[0], parte + '.html')
directorio = os.path.join(TEMPLATE_DIRS[0], parte)
else:
archivo = os.path.join(directorio, parte + '.html')
directorio = os.path.join(directorio, parte)
if (os.path.isfile(archivo)):
archivoExistente = archivo
break
#se valida la direccion
if (archivoExistente == None):
archivoExistente = 'index.html'
tmpl = os.path.join(TEMPLATE_DIRS[0], archivoExistente)
else:
if ((COMMON_TEMPLATES[data]['admin']
and users.is_current_user_admin())
or not COMMON_TEMPLATES[data]['admin']):
archivo = os.path.join(ROOT_PATH, 'templates/' + data)
archivoExistente = archivo
tmpl = archivo
else:
archivo = os.path.join(ROOT_PATH, 'templates/403.html')
archivoExistente = archivo
tmpl = archivo
#Se lee el template para saber cuales ids se deben buscar de la base de datos
llavesEntidades = []
identificadores = []
module = __import__('models')
todo = procesarTemplate(tmpl, var_path, TEMPLATE_DIRS[0])
for parte in todo['nodos']:
class_ = getattr(module, parte['tipo'])
identificadores.append(ndb.Key(class_, parte['id']))
llavesEntidades = todo['busquedas']
#Se leen las entidades
list_of_entities = ndb.get_multi(identificadores)
dicci = {}
for entidad in list_of_entities:
if entidad is not None:
nombreClase = entidad.__class__.__name__
if not dicci.has_key(nombreClase):
dicci[nombreClase] = {}
dicci[nombreClase][entidad.key.id()] = entidad.to_dict()
entidades = {}
cursores = {}
data_q = request.GET.get('data-q', None)
data_next = request.GET.get('data-next', None)
for llaveEntidad in llavesEntidades:
objeto_busqueda = simplejson.loads(llaveEntidad)
if (data_q == llaveEntidad and not data_next == None):
objeto_busqueda['next'] = data_next
objeto = comun.buscarGQL(objeto_busqueda)
entidades[llaveEntidad] = comun.to_dict(objeto['datos'])
if (objeto.has_key('next')):
cursores[llaveEntidad] = objeto['next']
valAnalytics = ''
if (dicci.has_key('Configuracion')):
millave = 'analytics_' + leng
if (dicci['Configuracion'].has_key('/general')
and dicci['Configuracion']['/general'].has_key(millave)):
valor = dicci['Configuracion']['/general'][millave]
if (not valor is None and len(valor) > 0):
valAnalytics = ANALYTICS.replace('$1', valor)
context = {
'ANALYTICS': valAnalytics,
'admin': users.is_current_user_admin(),
'path': var_path,
'dicci': dicci,
'leng': leng,
'leng_pred': LENGUAJE_PRED,
'user': user,
'entidades': entidades,
'cursores': cursores,
'JS_COMUNES0': JS_COMUNES0,
'JS_COMUNES1': JS_COMUNES1,
'JS_COMUNES2': JS_COMUNES2,
'JS_COMUNES3': JS_COMUNES3,
'DATETIME_NOW': comun.DATETIME_NOW,
'DATETIME_NOW_LAST': comun.DATETIME_NOW_LAST,
'DATETIME_NOW_FIRST': comun.DATETIME_NOW_FIRST,
'DATE_NOW': comun.DATE_NOW
}
respuesta = direct_to_template(request, archivoExistente, context)
if not users.is_current_user_admin():
memcache.set(var_full_path, respuesta.content)
respuesta.content = respuesta.content.decode('utf-8').replace(
'__USER__', generarVariablesUsuario(var_full_path, leng), 1)
return respuesta
def CitasHandler(request, ident):
to = comun.fechaAhora.__format__("%Y-%m-%d")
cursor = None
response = HttpResponse("", content_type='application/json')
try:
if request.method == 'PUT':
#{"title": "edelgado", "start": 1460691726, "end": 1460691726, "maxper": 2}
tmp = {}
if (request.raw_post_data):
tmp = simplejson.loads(request.raw_post_data)
rta = {}
if (tmp.has_key('id')):
llave = ndb.Key(Cita, tmp['id'])
viejo = llave.get()
if viejo:
rta = comun.llenarYpersistir(Cita, viejo, tmp, None)
else:
nuevo = Cita()
rta = comun.llenarYpersistir(Cita, nuevo, tmp, None)
response.write(simplejson.dumps({'error': 0, 'rta': rta}))
def buscar(request):
ti = request.GET.get('start', to)
tf = request.GET.get('end', to)
persona = request.GET.get('persona', None)
varn = request.GET.get('n', 100)
varnext = request.GET.get('next', '')
varti = datetime.datetime.strptime(ti, "%Y-%m-%d")
vartf = datetime.datetime.strptime(tf, "%Y-%m-%d")
varttitext = varti.strftime("%Y, %m, %d, %H, %M, %S")
varttftext = vartf.strftime("%Y, %m, %d, %H, %M, %S")
#Recordar que GQL no tiene OR! Ademas no puedo usar dos variables para start <= X and end <=
busqueda = "SELECT * FROM Cita "
busqueda += "WHERE "
busqueda += "start >= DATETIME(" + varttitext + ") AND start <= DATETIME(" + varttftext + ") "
if persona != None:
busqueda += "and persona=" + persona + " "
busqueda += "ORDER BY start ASC"
objeto = comun.buscarGQL({
"q": busqueda,
"n": long(varn),
"next": varnext
})
return objeto
if request.method == 'GET':
objeto = buscar(request)
entidades = comun.to_dict(objeto['datos'], 'to_dict2')
#if (objeto.has_key('next')):
# cursor = objeto['next']
#response.write(simplejson.dumps({'error':0, 'entidades': entidades, 'next': cursor}))
response.write(simplejson.dumps(entidades))
if request.method == 'DELETE':
miid = request.GET.get('id', None)
llave = ndb.Key(Cita, long(miid))
llave.delete()
response.write(simplejson.dumps({'error': 0, 'borradas': 1}))
except Exception, e:
logging.error(str(e))
response.write(
simplejson.dumps({
'error': 1,
'msg': 'Error de servidor: ' + str(e)
}))
def ApiRestHandler(request, ident, val2):
response = HttpResponse("", content_type='application/json')
ahora = datetime.datetime.now()
cursor = None
TOKEN_VERSION = 1;
TOKEN_SEPARADOR = ":"
def generarToken():
return base64.b64encode(str(TOKEN_VERSION)+TOKEN_SEPARADOR+str(time.mktime(ahora.timetuple())))
def decodificarToken(token):
try:
texto = base64.b64decode(token)
partes = texto.split(TOKEN_SEPARADOR)
versionToken = int(partes[0])
ultimaModificacion = float(partes[1])
if versionToken < TOKEN_VERSION:
return None
return datetime.datetime.fromtimestamp(ultimaModificacion)
except:
raise Exception('Token no se puede decodificar')
try:
def buscar(request, fechaToken):
#Para paginacion
varn = request.GET.get('n', 100)
varnext = request.GET.get('next', '')
argumentos = {}
if fechaToken == None:
argumentos = {"borrado":None}
busqueda = "SELECT * FROM Evento WHERE borrado = :borrado"
else:
argumentos = {"modificado":fechaToken}
busqueda = "SELECT * FROM Evento WHERE modificado >= :modificado"
objeto = comun.buscarGQL2({"q":busqueda, "n":long(varn), "next": varnext, "argumentos": argumentos})
return objeto
def limpiarModelo(dato, tipo):
#metadata interna
if (tipo == 'PUT'):
if dato.has_key('borrado'):
del dato['borrado']
if dato.has_key('id'):
del dato['id']
if (tipo == 'GET'):
if not dato.has_key('borrado') or dato['borrado'] == None:
dato['borrado'] = False
if dato.has_key('modificado'):
del dato['modificado']
return dato
def predeterminados(dato, tipo):
if not dato.has_key('fecha'):
dato['fecha'] = time.mktime(ahora.timetuple())
if not dato.has_key('titulo'):
dato['titulo'] = 'Evento en '+ahora.strftime("%Y, %m, %d, %H, %M, %S")
if not dato.has_key('descripcion'):
dato['descripcion'] = 'Descripcion de evento en '+ahora.strftime("%Y, %m, %d, %H, %M, %S")
return limpiarModelo(dato, tipo)
if request.method == 'GET':
#Para sincronizacion
token = request.GET.get('token', None)
fechaToken = None
if token != None:
fechaToken = decodificarToken(token)
token = generarToken()
else:
token = generarToken()
objeto = buscar(request, fechaToken)
entidades = comun.to_dict(objeto['datos'])
if (objeto.has_key('next')):
cursor = objeto['next']
entidades2 = []
for val in entidades:
entidades2.append(limpiarModelo(val, 'GET'))
response.write(simplejson.dumps({'error':0, 'entidades': entidades2, 'next': cursor, 'token': token}))
if request.method == 'PUT':
#Crea o actualiza
tmp = {}
if (request.raw_post_data):
tmp = simplejson.loads(request.raw_post_data)
dato = predeterminados(tmp, 'PUT')
rta = {}
if (ident != None and len(ident) > 0):
llave = ndb.Key(Evento, long(ident))
viejo = llave.get()
if viejo:
rta = comun.llenarYpersistir(Evento, viejo, dato, None)
else:
raise Exception('Modelo no encontrado')
else:
nuevo = Evento()
rta = comun.llenarYpersistir(Evento, nuevo, dato, None)
response.write(simplejson.dumps({'error':0, 'rta':rta}))
if request.method == 'DELETE':
if (ident != None):
llave = ndb.Key(Evento, long(ident))
viejo = llave.get()
if viejo:
viejo.borrado = True
viejo.put()
response.write(simplejson.dumps({'error':0}))
else:
raise Exception('Modelo no encontrado')
else:
raise Exception('Debe proveer id')
except Exception, e:
response.write(simplejson.dumps({'error':1, 'mensaje': 'Error de servidor: '+str(e)}))
def LVHandler(request, ident):
to = time.mktime(comun.fechaAhora.timetuple())
cursor = None
response = HttpResponse("", content_type='application/json')
try:
if request.method == 'PUT':
#{"camara": "1", "epoch": 1460691726, "url": "algo"}
tmp = {}
if (request.raw_post_data):
tmp = simplejson.loads(request.raw_post_data)
if tmp.has_key('camara'):
varcamara = tmp['camara']
else:
varcamara = '1'
if tmp.has_key('epoch'):
varepoch = tmp['epoch']
else:
varepoch = to
if tmp.has_key('url'):
varurl = tmp['url']
else:
varurl = '/'+varcamara+'_'+str(long(varepoch))+'.jpg'
nuevo = Foto()
nuevo.camara = varcamara
nuevo.epoch = datetime.datetime.fromtimestamp(varepoch)
nuevo.fecha = nuevo.epoch.strftime("%Y-%m-%d %H:%M:%S")
nuevo.url = varurl
nuevo.put()
response.write(simplejson.dumps({'error':0}))
def buscar(request):
camara = request.GET.get('camara', "1")
ti = request.GET.get('ti', to)
tf = request.GET.get('tf', to)
varn = request.GET.get('n', 100)
varnext = request.GET.get('next', '')
varti = datetime.datetime.fromtimestamp(float(ti))
vartf = datetime.datetime.fromtimestamp(float(tf))
varttitext = varti.strftime("%Y, %m, %d, %H, %M, %S")
varttftext = vartf.strftime("%Y, %m, %d, %H, %M, %S")
busqueda = "SELECT * FROM Foto WHERE camara='"+camara+"' AND epoch >= DATETIME("+varttitext+") AND epoch <= DATETIME("+varttftext+") ORDER BY epoch ASC"
logging.info(busqueda)
objeto = comun.buscarGQL({"q":busqueda, "n":long(varn), "next": varnext})
return objeto
if request.method == 'GET':
objeto = buscar(request)
entidades = comun.to_dict(objeto['datos'])
if (objeto.has_key('next')):
cursor = objeto['next']
response.write(simplejson.dumps({'error':0, 'entidades': entidades, 'next': cursor}))
if request.method == 'DELETE':
objeto = buscar(request)
llaves = []
for entidad in objeto['datos']:
llaves.append(entidad.key)
ndb.delete_multi(llaves)
if (objeto.has_key('next')):
cursor = objeto['next']
response.write(simplejson.dumps({'error':0, 'borradas': len(llaves), 'next': cursor}))
except Exception, e:
response.write(simplejson.dumps({'error':1, 'msg': 'Error de servidor: '+str(e)}))