def json_cancelar_solicitud(request):
"""
Un usuario cancela su solicitud de separación de un item
"""
if request.method == "GET":
if 'id_solicitud' in request.GET:
cliente = Cliente.objects.get(usuario=request.user)
solicitud = get_object_or_404(
Solicitud, cliente=cliente, id=request.GET["id_solicitud"])
if solicitud.estado == u"E":
solicitud.estado = u"C"
solicitud.save()
message = u"Su solicitud ha sido cancelada"
cancelado = True
else:
solicitud_c = Solicitud(tipo=u"C", cliente=cliente,
item=solicitud.item,
proyecto=solicitud.proyecto)
solicitud_c.save()
message = u"Se ha enviado una solicitúd de cancelación, será " \
u"informado por medio de un e-mail"
cancelado = False
return json_response({"cancel_response": message,
"status": True,
"cancelado": cancelado})
else:
return json_response({})
else:
return json_response({})
def get_statistics_by_city(request):
"""
statistics item numbers by city
:param request:
:return:
"""
if request.method != 'GET':
json_msg = {'error': 'Wrong HTTP method'}
return json_response(json_msg)
query_type = request.GET.get('t')
if not query_type or query_type not in support_query_types:
query_type = 'host'
if query_type == 'host' or query_type == 'camera':
rows = Device.objects.values('city').annotate(
item_count=Count('ip_address'))
else:
rows = Website.objects.values('city').annotate(
item_count=Count('ip_address'))
total = 0
for row in rows:
total += row.get('item_count')
if total > 0:
for row in rows:
row['percent'] = round(row.get('item_count') / total, 2)
json_msg = {'result': list(rows)}
return json_response(json_msg)
def get_proyecto_json(request):
"""
:return:devuelve un proyecto serializado en json
"""
if request.method == 'GET':
try:
id_ = request.GET["id_"]
except MultiValueDictKeyError:
return json_response({})
try:
proyecto = get_object_or_404(Proyecto, id=id_)
except ValueError:
return json_response({})
fotos = [{"nombre": foto.nombre,
"imagen": foto.imagen.url,
"thumbnail": foto.imagen['gallery'].url}
for foto in proyecto.fotos.all()]
data = {
"nombre": proyecto.nombre,
"descripcion": proyecto.descripcion,
"url": proyecto.url,
"fotos": fotos,
}
return json_response(data)
def search(request):
"""
API for searching
:param request:
:return:
"""
result = ''
if request.method == 'GET':
query_condition = request.GET.get('q')
query_type = request.GET.get('t')
page_num = request.GET.get('p')
logger.info(request.GET)
try:
pn = int(page_num)
except Exception:
pn = 1
if not query_type:
query_type = 'host'
if query_type not in support_query_types:
query_type = 'host'
if not query_condition:
errmsg = {'error': 'Please enter a query condition!'}
return json_response(errmsg)
search_params = {}
query_list = query_condition.split(' ')
for query in query_list:
one_query = query.split(':')
if len(one_query) != 2:
continue
search_params[one_query[0]] = one_query[1]
if query_type == 'host':
result, total_page, curr_page, total_num = _get_devices(
search_params, pn)
elif query_type == 'web':
result, total_page, curr_page, total_num = _get_website(
search_params, pn)
else:
return json_response({'error': 'Invalid query type!'})
json_msg = {
'result': result,
'tp': total_page,
'p': curr_page,
'tn': total_num
}
else:
json_msg = {'error': 'Wrong HTTP method'}
return json_response(json_msg)
def get(self, request, *args, **kwargs):
form = api_forms.Client(request.GET)
if form.is_valid():
response = dict()
return common_utils.json_response(
request, success=True, response=response)
else:
return common_utils.json_response(
request, success=False, errors=form.errors)
def get(self, request, *args, **kwargs):
form = api_forms.MassAddCreditCards(request.POST)
if form.is_valid():
response = dict()
return common_utils.json_response(
request, success=True, response=response)
else:
return common_utils.json_response(
request, success=False, errors=form.errors)
def get(self, request, *args, **kwargs):
form = api_forms.Client(request.GET)
if form.is_valid():
response = dict()
return common_utils.json_response(request,
success=True,
response=response)
else:
return common_utils.json_response(request,
success=False,
errors=form.errors)
def json_get_precio(request):
"""
"""
if "id_tipo_servicio" in request.GET:
tipo_servicio = get_object_or_404(TipoServicio,
id=request.GET["id_tipo_servicio"])
return json_response({"precio": tipo_servicio.precio_base})
else:
return json_response({})
def json_get_precios_producto(request):
"""
"""
if "id_producto" in request.GET:
precios = [{"id": precio.id, "nombre": precio.__unicode__()}
for precio in
PrecioProducto.objects.filter(
producto=request.GET["id_producto"])]
return json_response(precios)
else:
return json_response({})
def json_desafiliar(request):
"""
Desafilia a un cliente de un proyecto en específico
"""
if request.method == 'GET':
if 'id_proyecto' in request.GET:
proyecto = get_object_or_404(Proyecto, id=request.GET['id_proyecto'])
cliente = get_object_or_404(Cliente, usuario=request.user)
proyecto.clientes.remove(cliente)
data = {"status": True}
return json_response(data)
else:
return json_response({})
else:
return json_response({})
def json_desuscribir(request):
"""
Quita la suscripcion a un rubro de un cliente
"""
if request.method == 'GET':
if 'id_rubro' in request.GET:
rubro = get_object_or_404(Rubro, id=request.GET['id_rubro'])
cliente = get_object_or_404(Cliente, usuario=request.user)
cliente.rubros.remove(rubro)
data = {"status": True}
return json_response(data)
else:
return json_response({})
else:
return json_response({})
def json_suscribir(request):
"""
Suscribe un cliente a un rubro mediante ajax
"""
if request.method == 'GET':
if 'rubro' in request.GET:
rubro = get_object_or_404(Rubro, id=request.GET['rubro'])
cliente = get_object_or_404(Cliente, usuario=request.user)
cliente.rubros.add(rubro)
data = {"status": True}
return json_response(data)
else:
return json_response({})
else:
return json_response({})
def get_detalles_json(request, id_proyecto):
"""
Devuelve la estructura de datos con los detalles de construcción serializados
en una respuesta json
"""
detalles_construccion = get_detalles_construccion(id_proyecto)
return json_response(detalles_construccion)
def json_get_panimage(request, index):
"""
Devuelve una imágen panorámica de los servicios
"""
servicios = Servicio.accepted.filter(destacado=True)
if servicios:
servicio = servicios[(int(index) + 1) % len(servicios)]
data = {
"img": servicio.foto_panoramica.generate_url("pano"),
"des": "%s ..." % servicio.descripcion[:74],
"url": servicio.get_absolute_url(),
}
return json_response(data)
else:
return json_response({})
def json_get_photos_by_screen(request):
"""
devuelve las fotos de los items según la resolución
"""
screen = request.GET["screen"]
if request.GET["category"]:
category = get_object_or_404(Category, slug=request.GET["category"])
# items = Item.home_objects.filter(category=category)
items = category.all_home_item_set
else:
# items = Item.home_objects.all()
from teams.models import Item as teams_item
from global_presence.models import Item as global_presence_item
items = list(
chain(
Item.home_objects.all(),
teams_item.home_objects.all(),
global_presence_item.home_objects.all()
)
)
data = [{"name": item.name,
"url": item.get_absolute_url(),
"thumb": item.get_thumbnail_by_screen(screen)} for item in items]
return json_response(data)
def json_valorar_opinion(request, opinion_id):
"""
Una opinión recibe la valoración de un usuario
"""
opinion = get_object_or_404(Opinion, id=opinion_id)
data = {"nuevo": opinion.add_valoracion(request.user)}
return json_response(data)
def json_get_photo_by_screen(request, slug):
"""
devuelve las foto del equipo según la resolución
"""
screen = request.GET["screen"]
item = Team.objects.get(slug=slug)
data = {"name": item.name, "thumb": item.get_photo_by_screen(screen)}
return json_response(data)
def get_protocols(request):
"""
API for get all protocols
:param request:
:return:
"""
protocols = Protocol.objects.values()
detail = {'protocols': list(protocols)}
return json_response(detail)
def json_responder_opinion(request, opinion_id, respuesta):
"""
Una opinión recibe la respuesta del administrador
"""
opinion = get_object_or_404(Opinion, id=opinion_id)
admin = get_object_or_404(AdministradorServicio, user=request.user)
verified = opinion.set_respuesta(admin, respuesta)
data = {"verified": verified}
return json_response(data)
def json_get_mini_by_screen(request):
""" returns flags thumbnails based on the creen resolution """
screen = request.GET["screen"]
qs = tuple(chain(Item.objects.all(), Country.objects.all()))
data = [{"id": obj.id,
"name": obj.name,
"thumb": obj.get_flag_mini_by_screen(screen),
"url": obj.get_absolute_url()} for obj in qs]
return json_response(data)
def json_get_teammember_photos_by_screen(request):
"""
returns the teammember photos based on the resolution
"""
screen = request.GET["screen"]
data = []
for pos, item in enumerate(TeamMember.objects.all()):
data.append({"thumb": item.get_photo_by_screen(screen, pos)})
return json_response(data)
def json_get_horometro(request):
"""
Devuelve el último registro del horómetro final de un parte diario de una
máquina, si no existiera parte diario el horómetro de la máquina en el
sistema
"""
if "id_maquina" in request.GET:
id_maquina = request.GET["id_maquina"]
if id_maquina:
try:
horometro = ParteDiario.objects.filter(maquina__id=id_maquina).order_by("-horometro_final")[:1][0].horometro_final
except IndexError:
horometro = get_object_or_404(Maquina, id=id_maquina).horometro
return json_response({"horometro": horometro})
else:
return json_response({})
else:
return json_response({})
def json_get_aviso(request):
"""
Devuelve un aviso según el indice enviado
"""
if request.method == 'GET' and "index" in request.GET:
total = Aviso.objects.all().count()
min_id = Aviso.objects.aggregate(Min("id"))['id__min']
if total:
aviso = Aviso.objects.get(id=(int(request.GET['index'])%total)+min_id)
data = {
'url': aviso.proyecto.get_absolute_url(),
'aviso': aviso.get_archivo_html(),
'duracion': aviso.duracion,
'status': True,
}
return json_response(data)
else:
return json_response({'status': False,})
else:
return json_response({})
def get_proyecto_json(request, id_proyecto):
"""
Obtener el resumen de un proyecto mediante una respuesta json
"""
proyecto_objeto = Proyecto.objects.get(id = id_proyecto)
proyecto = {'nombre': proyecto_objeto.nombre,
'id': proyecto_objeto.id,
'tipo': proyecto_objeto.tipo_proyecto.nombre,
'descripcion': proyecto_objeto.descripcion,
"imagen": u'%s' % proyecto_objeto.imagen.extra_thumbnails['resumen'], }
return json_response(proyecto)
def json_get_slider_by_screen(request):
"""
:return: devuelve las fotos de un item según la resolución
"""
screen = request.GET["screen"]
item = get_object_or_404(Item, slug=request.GET["item"])
subitems = SubItem.objects.filter(item=item)
data = [{"slider": subitem.get_photo_slider(screen),
"videos": subitem.get_videos(screen),
"slug": subitem.slug} for subitem in subitems]
return json_response(data)
def ajax_edit_video(self, request):
"""
si el id recibido es correcto devuelve el nombre, url y descripcion del
video
"""
if request.method == 'POST':
try:
f = Video.objects.get(id=request.POST['id'])
data = {'nombre': f.nombre, 'url': f.url,
'descripcion': f.descripcion, 'id':f.id,}
except Video.DoesNotExist:
data = {'response' : u'el id no pertenece a ningún video'}
return json_response(data)
return None
def json_get_team_by_screen(request):
""" returns team thumbnails based on the creen resolution """
screen = request.GET["screen"]
try:
country = Country.objects.get(id=int(request.GET["country"]))
except Country.DoesNotExist:
data = []
else:
qs = country.team_set.all()
data = [{"id": obj.id,
"name": obj.name,
"thumb": obj.get_mini_by_screen(screen)} for obj in qs]
return json_response(data)
def json_fastcooper(request, substring):
"""
Búsqueda de una subcadena en la tabla productos
"""
match_products = Producto.objects.filter(nombre__istartswith=substring)
productos = []
for match_producto in match_products:
producto = {'id': match_producto.id,
'nombre': match_producto.nombre,
'descripcion': match_producto.descripcion,
'imagen': u"%s" % match_producto.imagen.thumbnail,}
productos.append(producto)
return json_response(productos)
def json_proyectos_slider(request):
"""
Devuelve un proyecto según el índice enviado
"""
if request.method == 'GET':
if 'proyectos' in request.session:
proyectos = request.session['proyectos']
else:
proyectos = Proyecto.accepted.all().order_by('relevancia')
request.session['proyectos'] = proyectos
if proyectos:
proyecto = proyectos[int(request.GET['index']) % proyectos.count()]
data = {
'nombre': proyecto.nombre,
'rubro': proyecto.rubro.nombre,
'url': proyecto.get_absolute_url(),
'imagen': '%s' % proyecto.foto_principal.extra_thumbnails.get("small_slider").absolute_url,
}
return json_response(data)
else:
raise Http404
else:
return json_response({})
def json_registro(request):
"""
Registra un usuario a traves de la data envíada por ajax, por ejemplo desde
el login por fb
"""
if request.method == 'GET':
if "username" in request.GET and \
User.objects.filter(username=request.GET["username"]).exists():
user = authenticate(username=request.GET["username"], password="******")
data = {"exists": True}
elif "id" in request.GET and \
User.objects.filter(username=request.GET["id"]).exists():
user = authenticate(username=request.GET["id"], password="******")
data = {"exists": True}
else:
if 'username' in request.GET:
user = User.objects.create_user(request.GET["username"],
request.GET["email"], "fb")
else:
if "id" not in request.GET:
return json_response({})
user = User.objects.create_user(request.GET["id"],
request.GET["email"], "fb")
user.is_active = False
user.first_name = request.GET["first_name"]
user.last_name = request.GET["last_name"]
user.save()
cliente = Cliente(usuario=user)
cliente.save()
data = {"exists": False}
user = authenticate(username=user.username, password="******")
login(request, user)
return json_response(data)
else:
return json_response({})
def ajax_edit_foto(self, request):
"""
si el id recibido es correcto devuelve el nombre y descripcion de la
foto
"""
if request.method == 'POST':
try:
foto = Foto.objects.get(id=request.POST['id'])
data = foto.__dict__
data.pop('imagen')
data.pop('_state')
except Foto.DoesNotExist:
data = {'response': 'el id no pertenece a ninguna foto'}
return json_response(data)
def ajax_edit_foto(self, request):
"""
si el id recibido es correcto devuelve el nombre y descripcion de la
foto
"""
if request.method == 'POST':
try:
f = Foto.objects.get(id=request.POST['id'])
data = {'nombre': f.nombre,
'descripcion': f.descripcion,
'id': f.id,}
except Foto.DoesNotExist:
data = {'response' : 'el id no pertenece a ninguna foto'}
return json_response(data)
return None
def json_fast_proyectos(request):
"""
Búsqueda de una subcadena de texto dentro de los nombres de proyectos
"""
if request.method == 'GET':
proyectos = Proyecto.accepted.all()
return json_fastsearch(proyectos, 'nombre', request.GET['substring'],
{"id": "slug",
"name": "nombre",
"subtitle": "rubro",
"description": "resumen",
"image": "foto_principal"})
else:
return json_response({})
def json_get_mini_by_screen(request):
"""
:return: devuelve las fotos de los items según la resolución para las
miniaturas de la galería
"""
screen = request.GET["screen"]
category = get_object_or_404(Category, slug=request.GET["category"])
# items = Item.home_objects.filter(category=category)
items = category.all_home_item_set
data = [{"name": item.name,
"url": item.get_absolute_url(),
"slug": item.slug,
"thumb": item.get_mini_by_screen(screen)} for item in items]
return json_response(data)
def json_get_servicio(request, servicio_id):
"""
Devuelve los datos de un servicio
"""
servicio = get_object_or_404(Servicio, id=servicio_id, estado=u"A")
json_dict = {
"id": servicio.id,
"nombre": servicio.nombre,
"tipo": servicio.tipo_servicio.id,
"direccion": servicio.ubicacion.direccion,
"latitud": servicio.ubicacion.latitud,
"longitud": servicio.ubicacion.longitud
}
return json_response(json_dict)
def entry_ajax(request, app_label, model):
if app_label not in ('shapes', 'photos'):
raise Http404
ids = request.GET['ids'].split('-')
model = get_model(app_label, model)
queryset = model.objects.filter(id__in=ids)
if hasattr(model, 'photo'):
queryset = queryset.select_related('photo')
elif hasattr(model, 'shape'):
queryset = queryset.select_related('shape', 'shape__photo')
return json_response({
'objects': {q.id: q.get_entry_dict() for q in queryset.iterator()}
})
def entry_ajax(request, app_label, model):
if app_label not in ('shapes', 'photos'):
raise Http404
ids = request.GET['ids'].split('-')
model = get_model(app_label, model)
queryset = model.objects.filter(id__in=ids)
if hasattr(model, 'photo'):
queryset = queryset.select_related('photo')
elif hasattr(model, 'shape'):
queryset = queryset.select_related('shape', 'shape__photo')
return json_response(
{'objects': {q.id: q.get_entry_dict()
for q in queryset.iterator()}})
def json_get_mini_by_screen(request):
"""
:return: devuelve las fotos de los items según la resolución para las
miniaturas de la galería
"""
team = Team.objects.latest('id')
if team:
queryset = team.item.category.all_item_set
else:
queryset = []
screen = request.GET["screen"]
data = [{"name": item.name,
"thumb": item.get_mini_by_screen(screen),
"slug": item.slug,
"url": item.get_absolute_url()} for item in queryset]
return json_response(data)
def photo_curate(request, template='photos/curate.html'):
if request.method == 'POST':
if request.POST['action'] == 'button':
photo_id = request.POST['photo_id']
attr = request.POST['attr']
Photo.objects.filter(id=photo_id).update(
**{attr: request.POST['val'].lower() == u'true'}
)
val = Photo.objects.filter(id=photo_id) \
.values_list(attr, flat=True)[0]
return json_response({
'photo_id': photo_id,
'attr': attr,
'val': val
})
elif request.POST['action'] == 'done':
items = json.loads(request.POST['items'])
for item in items:
print item
Photo.objects.filter(id=item['photo_id']).update(
**item['updates']
)
return json_success_response()
else:
raise Http404
else:
entries = Photo.objects \
.filter(scene_category_correct=True) \
.filter(
Q(inappropriate__isnull=True) |
Q(nonperspective__isnull=True) |
Q(stylized__isnull=True) |
Q(rotated__isnull=True)) \
.order_by('-num_vertices', 'scene_category_correct_score')
count = entries.count()
entries = list(entries[:400])
entries.sort(key=lambda x: x.aspect_ratio)
return render(request, template, {
'nav': 'browse/photo',
'count': count,
'entries': entries,
})
def getData():
conn = db.get_connection()
cursor = conn.cursor()
cursor.execute("""
select gene,count(0) total from gene_hsa group by gene
""")
rows = cursor.fetchall()
dict_result = {}
data_arr = []
title_arr = []
for index, row in enumerate(rows):
dict_obj = {}
dict_obj['name'] = row[0]
dict_obj['value'] = row[1]
title_arr.append(row[0])
data_arr.append(dict_obj)
dict_result['data'] = data_arr
dict_result['title'] = title_arr
return json_response(dict_result)
def photo_curate(request, template='photos/curate.html'):
if request.method == 'POST':
if request.POST['action'] == 'button':
photo_id = request.POST['photo_id']
attr = request.POST['attr']
Photo.objects.filter(id=photo_id).update(
**{attr: request.POST['val'].lower() == u'true'})
val = Photo.objects.filter(id=photo_id) \
.values_list(attr, flat=True)[0]
return json_response({
'photo_id': photo_id,
'attr': attr,
'val': val
})
elif request.POST['action'] == 'done':
items = json.loads(request.POST['items'])
for item in items:
print item
Photo.objects.filter(id=item['photo_id']).update(
**item['updates'])
return json_success_response()
else:
raise Http404
else:
entries = Photo.objects \
.filter(scene_category_correct=True) \
.filter(
Q(inappropriate__isnull=True) |
Q(nonperspective__isnull=True) |
Q(stylized__isnull=True) |
Q(rotated__isnull=True)) \
.order_by('-num_vertices', 'scene_category_correct_score')
count = entries.count()
entries = list(entries[:400])
entries.sort(key=lambda x: x.aspect_ratio)
return render(request, template, {
'nav': 'browse/photo',
'count': count,
'entries': entries,
})