def crearPlantilla(request):
try:
with transaction.atomic():
user = usuarioAutenticado(request)
descripcion = request.POST.get('descripcion')
plantilla = PlantillaEquipo(descripcion=descripcion, userid=user.userid)
plantilla.full_clean()
plantilla.save()
response = {
'code': 201,
'data': model_to_dict(plantilla),
'status': 'success'
}
except ValidationError as e:
response = {
'code': 400,
'errors': dict(e),
'status': 'success'
}
return JsonResponse(response, safe=False, status=response['code'])
def crearEquipo(request):
try:
with transaction.atomic():
user = usuarioAutenticado(request)
person = models.Person.objects.get(user__userid=user.userid)
plantilla = models.Team(
team_name=request.POST.get('team_name'),
team_leader=person,
team_description=request.POST.get('team_description'))
plantilla.full_clean()
plantilla.save()
response = {
'code': 201,
'data': model_to_dict(plantilla),
'status': 'success'
}
except ValidationError as e:
response = {'code': 400, 'errors': dict(e), 'status': 'success'}
return JsonResponse(response, safe=False, status=response['code'])
def getPersonNotifications(request):
user = usuarioAutenticado(request)
person = models.Person.objects.get(user__userid__exact=user.userid)
notifications = models.Notification.objects.filter(
person__pers_id__exact=person.pers_id).order_by('-notification_date')
notifications = list(notifications.values())
response = {'code': 200, 'data': notifications, 'status': 'success'}
return JsonResponse(response, safe=False, status=response['code'])
def logout(request):
try:
user = usuarioAutenticado(request)
device = FCMDevice.objects.filter(user_id__exact=user.userid).first()
if device is not None:
device = FCMDevice.objects.get(user_id__exact=user.userid)
device.registration_id = ''
device.save()
data = {'code': 200, 'status': 'success'}
return JsonResponse(data, status=data['code'], safe=False)
except Error as e:
data = {'code': 500, 'errors': str(e), 'status': 'error'}
return JsonResponse(data, status=data['code'], safe=False)
def almacenarSurvery(request):
KOBO_INSTR = 1
tareaid = request.POST.get('tareaid')
try:
with transaction.atomic():
tarea = models.Task.objects.get(pk=tareaid)
#instrumento = models.Instrument.objects.get(pk=tarea.instrument.instrument_id)
instrumento = tarea.instrument
if instrumento.instrument_type == KOBO_INSTR:
informacion = informacionFormularioKoboToolbox(
instrumento.external_id)
if (isinstance(informacion, dict)):
user = usuarioAutenticado(request)
person = models.Person.objects.get(
user__userid__exact=user.userid)
#encuestaview.almacenarEncuestas(
# instrumento, informacion['info'], person, tarea)
index_info = len(informacion['info'])
info = informacion['info'][index_info - 1]
encuesta = models.Survery(
instrument=instrumento,
koboid=info['_uuid'],
survery_content=json.dumps(info),
survery_observation='Ehhg',
#userid=userid, (person)
person=person,
task=tarea)
encuesta.full_clean()
encuesta.save()
data = {'code': 201, 'status': 'success'}
utilidades.puntajeTarea(tareaid)
utilidades.puntajeProyecto(tarea.project.proj_id)
utilidades.puntajePersona(person.pers_id)
equipos = utilidades.equiposDePersona(person.pers_id)
for equipo in list(equipos):
utilidades.puntajeEquipo(equipo['team_id'])
except ObjectDoesNotExist:
data = {'code': 404, 'status': 'error'}
except ValidationError:
data = {'code': 400, 'status': 'error'}
return JsonResponse(data, status=data['code'], safe=False)
def deletePersonNotifications(request):
with transaction.atomic():
user = usuarioAutenticado(request)
person = models.Person.objects.get(user__userid__exact=user.userid)
query = "DELETE FROM opx.notification \
WHERE opx.notification.person_id = '" + str(
person.pers_id) + "';"
with connection.cursor() as cursor:
cursor.execute(query)
data = {
'code': 200,
'status': 'success',
'notificaciones': [],
}
return JsonResponse(data, safe=False, status=data['code'])
def almacenarDecision(request):
userid = usuarioAutenticado(request).userid
decision = models.Decision(
decs_name = request.POST.get('decs_name'),
decs_description = request.POST.get('decs_description')
)
try:
with transaction.atomic():
decision.full_clean()
decision.save()
data = serializers.serialize('python', [decision])
return JsonResponse(data, safe = False, status = 201)
except ValidationError as e:
return JsonResponse(dict(e), safe = True, status = 400)
def listadoEquipos(request):
user = usuarioAutenticado(request)
person = models.Person.objects.get(user__userid=user.userid)
rol = str(person.role.role_id)
if (rol == '8945979e-8ca5-481e-92a2-219dd42ae9fc'):
query = "select equipo.*, persona.pers_name, persona.pers_lastname from opx.team as equipo inner join opx.person as persona on equipo.team_leader_id = persona.pers_id;"
with connection.cursor() as cursor:
cursor.execute(query)
equipos = dictfetchall(cursor)
for e in equipos:
e['team_miembros'] = len(
models.TeamPerson.objects.filter(
team__team_id__exact=e['team_id']))
response = {'code': 200, 'data': list(equipos), 'status': 'success'}
elif (rol == '628acd70-f86f-4449-af06-ab36144d9d6a'):
EQUIPO_CIUDADANOS_ID = 'b4879f48-8ab1-4d79-8f5b-7585b75cfb07'
query = "select equipo.*, persona.pers_name, persona.pers_lastname from opx.team as equipo inner join opx.person as persona on equipo.team_leader_id = persona.pers_id where equipo.team_leader_id = '" + str(
person.pers_id
) + "'" + " or equipo.team_id = '" + EQUIPO_CIUDADANOS_ID + "';"
with connection.cursor() as cursor:
cursor.execute(query)
equipos = dictfetchall(cursor)
for e in equipos:
e['team_miembros'] = len(
models.TeamPerson.objects.filter(
team__team_id__exact=e['team_id']))
response = {'code': 200, 'data': list(equipos), 'status': 'success'}
else:
response = {
'code': 403,
'message': 'Usuario no permitido',
'status': 'error'
}
return JsonResponse(response, safe=False, status=response['code'])
def listadoPlantillas(request):
user = usuarioAutenticado(request)
rol = str(user.rolid)
if (rol == '628acd70-f86f-4449-af06-ab36144d9d6a'
or rol == '8945979e-8ca5-481e-92a2-219dd42ae9fc'):
plantillas = PlantillaEquipo.objects.filter(
userid__exact=user.userid).values()
response = {'code': 200, 'data': list(plantillas), 'status': 'success'}
else:
response = {
'code': 403,
'message': 'Usuario no permitido',
'status': 'error'
}
return JsonResponse(response, safe=False, status=response['code'])
def crearComentario(request, projid):
user = usuarioAutenticado(request)
comentario = models.Comment(
comment_title=request.POST.get('comment_title'),
comment_description=request.POST.get('comment_description'),
project=models.Project.objects.get(pk=projid))
try:
with transaction.atomic():
comentario.full_clean()
comentario.save()
response = {
'code': 201,
'data': model_to_dict(comentario),
'status': 'success'
}
except ValidationError as e:
response = {'code': 400, 'errors': dict(e), 'status': 'success'}
return JsonResponse(response, safe=False, status=response['code'])
def almacenarContextualizacion(request):
user = usuarioAutenticado(request)
contextualizacion = models.Contextualization(
conflict=models.Conflict.objects.get(
pk=(request.POST.get('conflicto_id'))),
city=models.City.objects.get(pk=(request.POST.get('ciudad_id'))),
neighborhood=models.Neighborhood.objects.get(
pk=(request.POST.get('barrio_id'))),
person=models.Person.objects.get(user__userid=user.userid),
title=request.POST.get('titulo'),
description=request.POST.get('descripcion'))
try:
with transaction.atomic():
contextualizacion.full_clean()
contextualizacion.save()
data = serializers.serialize('python', [contextualizacion])
return JsonResponse(data, safe=False, status=201)
except ValidationError as e:
return JsonResponse(dict(e), safe=True, status=400)
def AgregarElemento(request, tareid):
try:
tarea = models.Task.objects.get(pk=tareid)
#instrumento = models.Instrument.objects.get(pk = tarea.instrument.instrument_id)
instrumento = tarea.instrument
if instrumento.instrument_type == 2:
data = json.loads(request.body)
osmelement = models.OsmElement.objects.get(pk=data['osmelement'])
if osmelement.closed_way == 1:
coordinates = data['coordinates']
else:
coordinates = data['coordinates']
nodes = []
changeset = agregarChangeset()
nodeCount = 0
# Armando XML
root = Element('osmChange')
root.set('version', '0.6')
create = SubElement(root, 'create')
# Creando Nodos
for c in coordinates:
nodeCount -= 1
longitud = str(c['lng'])
latitud = str(c['lat'])
node = SubElement(create, 'node')
node.set('id', str(nodeCount))
node.set('lon', longitud)
node.set('lat', latitud)
node.set('version', "0")
node.set('changeset', changeset)
nodes.append(node)
#Creando Way
way = SubElement(create, 'way')
way.set('id', '-1')
way.set('changeset', changeset)
#Especificando Nodos del way
for node in nodes:
nd = SubElement(way, 'nd')
nd.set('ref', node.get('id'))
if osmelement.closed_way == 1:
nd = SubElement(way, 'nd')
nd.set('ref', nodes[0].get('id'))
#Etiqueta de Elemento tipo Way
tag = SubElement(way, 'tag')
tag.set('k', osmelement.osm_key)
tag.set('v', osmelement.osm_value)
# Obteniendo cadena XML a enviar a OSM
xmlRequest = str(tostring(root), 'utf-8')
#return HttpResponse(xmlRequest)
#Almacendo Elemento en OSM
client = http.client.HTTPSConnection(osmRestApiUrl)
client.request('POST',
'/api/0.6/changeset/' + changeset + '/upload',
xmlRequest, osmHeaders())
response = client.getresponse()
if response.status == 200:
# Cerrar Changeset OSM
cerrarChangeset(changeset)
xmlResponse = str(response.read(), 'utf-8')
xmlObject = ET.fromstring(xmlResponse)
wayElement = xmlObject.findall('way')[0]
#Almacenando Cartografia
user = usuarioAutenticado(request)
person = models.Person.objects.get(
user__userid__exact=user.userid)
cartografia = almacenarCartografia(instrumento,
wayElement.get('new_id'),
osmelement, person, tarea)
response = {
'code': 200,
#'cartografia': cartografia,
'status': 'success'
}
else:
xmlResponse = str(response.read(), 'utf-8')
raise TypeError(
"Error al momento de crear el elemento en OSM: " +
xmlResponse)
else:
raise TypeError("El tipo de instrumento es inválido")
except ObjectDoesNotExist as e:
response = {'code': 404, 'message': str(e), 'status': 'error'}
except ValidationError as e:
response = {'code': 400, 'message': str(e), 'status': 'error'}
except json.JSONDecodeError:
response = {'code': 400, 'message': 'JSON inválido', 'status': 'error'}
except IntegrityError as e:
response = {'code': 400, 'message': str(e), 'status': 'error'}
except TypeError as e:
response = {'code': 400, 'message': str(e), 'status': 'error'}
# except:
# response = {
# 'code': 500,
# 'status': 'error'
# }
return JsonResponse(response, status=response['code'])
def listadoProyectos(request):
search = request.GET.get('search')
page = request.GET.get('page')
all = request.GET.get('all')
try:
if 'HTTP_AUTHORIZATION' in request.META.keys() and request.META['HTTP_AUTHORIZATION'] != 'null':
# # Decodificando el access token
# tokenBackend = TokenBackend(settings.SIMPLE_JWT['ALGORITHM'], settings.SIMPLE_JWT['SIGNING_KEY'],
# settings.SIMPLE_JWT['VERIFYING_KEY'])
# tokenDecoded = tokenBackend.decode(request.META['HTTP_AUTHORIZATION'].split()[1], verify=True)
# #consultando el usuario
# user = models.Usuario.objects.get(pk = tokenDecoded['user_id'])
user = usuarioAutenticado(request)
# ============================ Consultando proyectos ====================================
#Consulta de proyectos para super administrador
if str(user.rolid) == '8945979e-8ca5-481e-92a2-219dd42ae9fc':
proyectos = models.Proyecto.objects.all()
# Consulta de proyectos para proyectista
elif str(user.rolid) == '628acd70-f86f-4449-af06-ab36144d9d6a':
proyectos = models.Proyecto.objects.filter(proypropietario__exact = user.userid)
# Consulta de proyectos para voluntarios o validadores
elif str(user.rolid) == '0be58d4e-6735-481a-8740-739a73c3be86' or str(user.rolid) == '53ad3141-56bb-4ee2-adcf-5664ba03ad65':
proyectosAsignados = models.Equipo.objects.filter(userid__exact = user.userid)
proyectosAsignadosID = []
for p in proyectosAsignados:
proyectosAsignadosID.append(p.proyid)
proyectos = models.Proyecto.objects.filter(pk__in = proyectosAsignadosID)
#Tipo de usuario distinto
else:
proyectos = models.Proyecto.objects.filter(proynombre = 'qwerty')
# Usuario Invitado
else:
proyectos = models.Proyecto.objects.all()
# ================= Busqueda de proyectos
if search:
proyectos = proyectos.filter(proynombre__icontains = search)
# Especificando orden
proyectos = proyectos.order_by('-proyfechacreacion')
# convirtiendo a lista de diccionarios
proyectos = list(proyectos.values())
listadoProyectos = []
for p in proyectos:
#Consulta del proyectista
p['proyectista'] = models.Usuario.objects.get(pk = p['proypropietario']).userfullname
if 'user' in locals() and str(user.rolid) == '628acd70-f86f-4449-af06-ab36144d9d6a':
p['dimensiones_territoriales'] = []
dimensionesTerritoriales = models.DelimitacionGeografica.objects\
.filter(proyid__exact = p['proyid'])\
.filter(estado=1)\
.values()
dimensionesTerritoriales = list(dimensionesTerritoriales)
for dim in dimensionesTerritoriales:
tareas = list(models.Tarea.objects.filter(dimensionid__exact=dim['dimensionid'])\
.filter(proyid = p['proyid'])\
.values())
dim['tareas'] = tareas
p['dimensiones_territoriales'].append(dim)
# Reportes
p['reportes'] = reporteEstadoProyecto(p['proyid'])
listadoProyectos.append(p)
if all is not None and all == "1":
data = {
'code': 200,
'proyectos': listadoProyectos,
'status': 'success'
}
else:
# Paginación
paginator = Paginator(listadoProyectos, 10)
# Validación de página
if page is None:
page = 1
#Petición de página
proyectos = paginator.page(page).object_list
data = {
'code': 200,
'paginator': {
'currentPage': int(page),
'perPage': paginator.per_page,
'lastPage': paginator.num_pages,
'total': paginator.count
},
'proyectos': proyectos,
'status': 'success',
}
except EmptyPage:
data = {
'code': 404,
'message': 'Página inexistente',
'status': 'error'
}
except IndexError:
data = {
'code': 400,
'status': 'error'
}
except TokenBackendError as e:
data = {
'code': 400,
'message': str(e),
'status': 'error'
}
return JsonResponse(data, safe = False, status = data['code'])
def listadoProyectos(request):
search = request.GET.get('search')
page = request.GET.get('page')
all = request.GET.get('all')
try:
if 'HTTP_AUTHORIZATION' in request.META.keys(
) and request.META['HTTP_AUTHORIZATION'] != 'null':
# # Decodificando el access token
# tokenBackend = TokenBackend(settings.SIMPLE_JWT['ALGORITHM'], settings.SIMPLE_JWT['SIGNING_KEY'],
# settings.SIMPLE_JWT['VERIFYING_KEY'])
# tokenDecoded = tokenBackend.decode(request.META['HTTP_AUTHORIZATION'].split()[1], verify=True)
# #consultando el usuario
# user = models.Usuario.objects.get(pk = tokenDecoded['user_id'])
user = usuarioAutenticado(request)
# ============================ Consultando proyectos ====================================
#Consulta de proyectos para super administrador
person = models.Person.objects.get(user__userid=user.userid)
if str(person.role.role_id) == ROL_SUPER_ADMIN:
proyectos = models.Project.objects.all()
# Especificando orden
proyectos = proyectos.order_by('-proj_creation_date')
# convirtiendo a lista de diccionarios
proyectos = list(proyectos.values())
# Consulta de proyectos para proyectista
elif str(person.role.role_id) == ROL_PROYECTISTA:
proyectos = models.Project.objects.filter(
proj_owner__pers_id__exact=person.pers_id)
# Especificando orden
proyectos = proyectos.order_by('-proj_creation_date')
# convirtiendo a lista de diccionarios
proyectos = list(proyectos.values())
# Consulta de proyectos para voluntarios o validadores
elif str(person.role.role_id) == ROL_VOLUNTARIO or str(
person.role.role_id) == ROL_VALIDADOR:
#consultar los proyectos a los que está asociado el voluntario o validador
query = "select distinct pj.* from opx.team_person as tp inner join opx.project_team as pt on pt.team_id = tp.team_id inner join opx.project as pj on pt.project_id = pj.proj_id where tp.person_id = '" + str(
person.pers_id) + "' order by pj.proj_creation_date DESC;"
with connection.cursor() as cursor:
cursor.execute(query)
PJ = dictfetchall(cursor)
proyectos = list(PJ)
#Tipo de usuario distinto
else:
proyectos = models.Project.objects.filter(proj_name='qwerty')
# Usuario Invitado
else:
proyectos = models.Project.objects.all()
# ================= Busqueda de proyectos
if search:
proyectos = models.Project.objects.filter(
proj_name__icontains=search)
proyectos = list(proyectos.values())
listadoProyectos = []
type(proyectos)
for p in proyectos:
type(p)
#Consulta del proyectista
name = p['proj_external_id']
#proj_owner_id = p['proj_owner_id']
persona = models.Person.objects.get(pk=p['proj_owner_id'])
p['proyectista'] = persona.pers_name + ' ' + persona.pers_lastname
if 'user' in locals() and (
str(person.role.role_id) == ROL_PROYECTISTA
or str(person.role.role_id) == ROL_SUPER_ADMIN):
p['dimensiones_territoriales'] = []
query = "select dim.* from opx.territorial_dimension as dim inner join opx.project_dimension as pd on pd.territorial_dimension_id = dim.dimension_id where pd.project_id = '" + str(
p['proj_id']) + "';"
with connection.cursor() as cursor:
cursor.execute(query)
territorios = dictfetchall(cursor)
p['dimensiones_territoriales'] = list(territorios)
query1 = "select tarea.*, dim.* from opx.task as tarea \
inner join opx.territorial_dimension as dim on dim.dimension_id = tarea.territorial_dimension_id \
where tarea.project_id = '" + str(p['proj_id']) + "';"
with connection.cursor() as cursor:
cursor.execute(query1)
tareas = dictfetchall(cursor)
p['tareas'] = list(tareas)
#Reportes
p['reportes'] = reporteEstadoProyecto(str(p['proj_id']))
listadoProyectos.append(p)
if all is not None and all == "1":
data = {
'code': 200,
'proyectos': listadoProyectos,
'status': 'success'
}
else:
# Paginación
paginator = Paginator(listadoProyectos, 10)
# Validación de página
if page is None:
page = 1
#Petición de página
proyectos = paginator.page(page).object_list
data = {
'code': 200,
'paginator': {
'currentPage': int(page),
'perPage': paginator.per_page,
'lastPage': paginator.num_pages,
'total': paginator.count
},
'proyectos': proyectos,
'status': 'success',
}
except EmptyPage:
data = {
'code': 404,
'message': 'Página inexistente',
'status': 'error'
}
except IndexError:
data = {'code': 400, 'status': 'error'}
except TokenBackendError as e:
data = {'code': 400, 'message': str(e), 'status': 'error'}
return JsonResponse(data, safe=False, status=data['code'])
def almacenamientoProyecto(request):
user = usuarioAutenticado(request)
person = models.Person.objects.get(user__userid=user.userid)
# Decodificando el access token
tokenBackend = TokenBackend(settings.SIMPLE_JWT['ALGORITHM'],
settings.SIMPLE_JWT['SIGNING_KEY'],
settings.SIMPLE_JWT['VERIFYING_KEY'])
tokenDecoded = tokenBackend.decode(
request.META['HTTP_AUTHORIZATION'].split()[1], verify=True)
delimintacionBarrio = request.POST.get('dimensionesPre')
decisiones = request.POST.get('decisiones')
contextos = request.POST.get('contextos')
equipos = request.POST.get('plantillas')
delimitacionGeograficas = request.POST.get('delimitacionesGeograficas')
tipoP = models.ProjectType.objects.get(
projtype_id__exact=request.POST.get('tiproid'))
try:
with transaction.atomic():
if ((delimitacionGeograficas != "[]") and (decisiones != "[]")
and (contextos != "[]") and (equipos != "[]")):
proyecto = models.Project(
proj_name=request.POST.get('proynombre'),
proj_description=request.POST.get('proydescripcion'),
proj_external_id=12345,
proj_close_date=request.POST.get('proyfechacierre'),
proj_start_date=request.POST.get('proyfechainicio'),
proj_completness=0,
project_type=tipoP,
proj_owner=person)
proyecto.full_clean()
proyecto.save()
delimintacionBarrio = json.loads(delimintacionBarrio)
almacenarDelimitacionesPrecarga(proyecto, delimintacionBarrio)
delimitacionGeograficas = json.loads(delimitacionGeograficas)
almacenarDelimitacionesGeograficas(proyecto,
delimitacionGeograficas)
decisiones = json.loads(decisiones)
almacenarDecisionProyecto(proyecto, decisiones)
contextos = json.loads(contextos)
almacenarContextosProyecto(proyecto, contextos)
equipos = json.loads(equipos)
asignarEquipos(proyecto, equipos)
data = serializers.serialize('python', [proyecto])[0]
data = {'code': 201, 'proyecto': data, 'status': 'success'}
else:
raise ValidationError({'Información incompleta'})
except ValidationError as e:
try:
errors = dict(e)
except ValueError:
errors = list(e)[0]
data = {
'code': 400,
'errors': errors,
'message': str(e),
'status': 'error'
}
except IntegrityError as e:
data = {'code': 500, 'message': str(e), 'status': 'success'}
except ObjectDoesNotExist as e:
data = {'code': 404, 'message': str(e), 'status': 'error'}
return JsonResponse(data, safe=False, status=data['code'])
def listadoTareas(request):
try:
# Obtener usuario autenticado
usuario = usuarioAutenticado(request)
# Superadministrador
if str(usuario.rolid) == '8945979e-8ca5-481e-92a2-219dd42ae9fc':
proyectosUsuario = []
# Consulta de proyectos para un usuario proyectista
elif str(usuario.rolid) == '628acd70-f86f-4449-af06-ab36144d9d6a':
proyectosUsuario = list(
models.Proyecto.objects.filter(
proypropietario=usuario.userid).values('proyid'))
# Consulta de proyectos para un usuario voluntario o validador
elif str(usuario.rolid
) == '0be58d4e-6735-481a-8740-739a73c3be86' or str(
usuario.rolid) == '53ad3141-56bb-4ee2-adcf-5664ba03ad65':
proyectosUsuario = list(
models.Equipo.objects.filter(
userid=usuario.userid).values('proyid'))
# ================ Obtener página validación de la misma ========================
page = request.GET.get('page')
if (page is None):
page = 1
all = request.GET.get('all')
# Obtener Búsqueda y validación de la misma
search = request.GET.get('search')
query = "select t.*, i.instrnombre, p.proynombre from v1.tareas as t " \
"inner join v1.proyectos as p on t.proyid = p.proyid " \
"inner join v1.instrumentos as i on t.instrid = i.instrid"
if len(proyectosUsuario) > 0 or search is not None:
query += " where "
# Busqueda de tareas por proyecto
if len(proyectosUsuario) == 1:
query += "t.proyid = '" + str(
proyectosUsuario[0]['proyid']) + "'"
if len(proyectosUsuario) > 1:
firstItemQuery = True
for p in proyectosUsuario[:-1]:
if firstItemQuery:
query += "("
firstItemQuery = False
query += "t.proyid = '" + str(p['proyid']) + "' or "
query += "t.proyid = '" + str(
proyectosUsuario[-1]['proyid']) + "')"
# Busqueda por Nombre
if search is not None:
if len(proyectosUsuario) > 0:
query += " and"
query += " (t.tarenombre ~* '" + search + "');"
with connection.cursor() as cursor:
cursor.execute(query)
# formatear respuesta de base de datos
tareas = dictfetchall(cursor)
# Progreso de las Tareas
for t in tareas:
# Tipo encuesta
if t['taretipo'] == 1:
encuestas = models.Encuesta.objects.filter(
tareid__exact=t['tareid'])
progreso = (len(encuestas) * 100) / t['tarerestriccant']
t['progreso'] = progreso
# instrumento = models.Instrumento.objects.get(pk=t['instrid'])
# detalleFormulario = detalleFormularioKoboToolbox(instrumento.instridexterno)
#
# if(detalleFormulario):
# progreso = (detalleFormulario['deployment__submission_count'] * 100) / t['tarerestriccant']
# t['progreso'] = progreso
if all is not None and all == "1":
data = {'code': 200, 'tareas': tareas, 'status': 'success'}
else:
# Obtener Página
paginator = Paginator(tareas, 10)
# Obtener lista de tareas
tareas = paginator.page(page).object_list
data = {
'code': 200,
'paginator': {
'currentPage': page,
'perPage': paginator.per_page,
'lastPage': paginator.num_pages,
'total': paginator.count
},
'tareas': tareas,
'status': 'success'
}
except EmptyPage:
data = {
'code': 400,
'message': 'Página inexistente',
'status': 'error'
}
return JsonResponse(data, safe=False, status=data['code'])
def usuariosDisponiblesProyecto(request, proyid):
try:
proyecto = models.Proyecto.objects.get(pk = proyid)
user = usuarioAutenticado(request)
# Superadministrador o Proyectista
if (str(user.rolid) == '628acd70-f86f-4449-af06-ab36144d9d6a' or str(user.rolid) == '8945979e-8ca5-481e-92a2-219dd42ae9fc'):
# Busqueda de Usuarios
search = request.GET.get('search')
# query = "select u.userid, u.userfullname from v1.usuarios u where (u.rolid = '0be58d4e-6735-481a-8740-739a73c3be86' or u.rolid = '53ad3141-56bb-4ee2-adcf-5664ba03ad65') and u.userid not in (select e.userid from v1.equipos e where e.proyid = '" + proyid + "')"
query = "select distinct on(u.userid) \
u.userid, u.userfullname \
from v1.miembros_plantilla as mp \
inner join v1.usuarios as u on u.userid = mp.userid \
inner join v1.plantillas_equipo as pe on pe.planid = mp.planid \
where pe.userid = '{}' \
and u.userid not in (select e.userid from v1.equipos e where e.proyid = '{}') \
and (u.rolid = '0be58d4e-6735-481a-8740-739a73c3be86' or u.rolid = '53ad3141-56bb-4ee2-adcf-5664ba03ad65')" \
.format(user.userid, proyid)
if search is not None:
query += "and u.userfullname ~* '" + search + "'"
with connection.cursor() as cursor:
cursor.execute(query)
usuarios = dictfetchall(cursor)
for u in usuarios:
u['equipos'] = ''
equiposUsuario = models.MiembroPlantilla.objects.filter(userid=u['userid'])
for equs in equiposUsuario:
team = models.PlantillaEquipo.objects.get(pk=equs.planid)
if team.userid == user.userid:
u['equipos'] += str(team.descripcion) + ', '
data = {
'code': 200,
'usuarios': usuarios,
'status': 'success'
}
else:
data = {
'code': 403,
'message': 'Usuario no permitido',
'status': 'error'
}
except ObjectDoesNotExist:
data = {
'code': 404,
'message': 'El proyecto no existe',
'status': 'error'
}
except ValidationError as e:
data = {
'code': 400,
'errors': tuple(e),
'status': 'error'
}
return JsonResponse(data, safe = False, status = data['code'])
def equipoProyecto(request, proyid):
try:
if proyid is None:
data = {
'code': 400,
'equipo': 'El proyecto no fue especificado',
'status': 'error'
}
else:
#query = "select e.equid, u.userfullname, u.latitud, u.longitud, u.horaubicacion from v1.equipos as e inner join v1.usuarios as u on u.userid = e.userid where e.proyid = '" + proyid + "'"
user = usuarioAutenticado(request)
# Superadministrador o Proyectista
if (str(user.rolid) == '628acd70-f86f-4449-af06-ab36144d9d6a' or str(user.rolid) == '8945979e-8ca5-481e-92a2-219dd42ae9fc'):
query = "select distinct on(u.userid) \
u.userid, e.equid, u.userfullname, u.latitud, u.longitud, u.horaubicacion \
from v1.equipos as e \
inner join v1.usuarios as u on u.userid = e.userid \
and e.proyid = '{}'" \
.format(proyid)
with connection.cursor() as cursor:
cursor.execute(query)
equipo = dictfetchall(cursor)
for eq in equipo:
eq['equipos'] = ''
equiposUsuario = models.MiembroPlantilla.objects.filter(userid = eq['userid'])
for equs in equiposUsuario:
team = models.PlantillaEquipo.objects.get(pk=equs.planid)
if team.userid == user.userid:
eq['equipos'] += str(team.descripcion) + ', '
data = {
'code': 200,
'equipo': equipo,
'status': 'success'
}
else:
data = {
'code': 403,
'message': 'Usuario no permitido',
'status': 'error'
}
except ValidationError as e:
data = {
'code': 400,
'equipo': list(e),
'status': 'success'
}
return JsonResponse(data, safe = False, status = data['code'])
def listadoTareas(request):
try:
# Obtener usuario autenticado
usuario = usuarioAutenticado(request)
person = models.Person.objects.get(user__userid=usuario.userid)
tareasUsuario = []
proyectosUsuario = []
n = ""
# Superadministrador
if str(person.role_id) == ROL_SUPER_ADMIN:
tareasUsuario = []
n = "select tk.* from opx.task as tk order by tk.task_creation_date DESC;"
# Consulta de proyectos para un usuario proyectista
elif str(person.role_id) == ROL_PROYECTISTA:
n = "select tk.*, restric.* \
from opx.person as persona \
inner join opx.project as proyecto on proyecto.proj_owner_id = persona.pers_id \
inner join opx.task as tk on tk.project_id = proyecto.proj_id \
inner join opx.task_restriction as restric on tk.task_restriction_id = restric.restriction_id \
where persona.pers_id = '" + str(
person.pers_id) + "' order by tk.task_creation_date DESC;"
# Consulta de proyectos para un usuario voluntario o validador
elif str(person.role_id) == ROL_VOLUNTARIO or str(
person.pers_id) == ROL_VALIDADOR:
n = "select distinct tk.*, restric.* \
from opx.person as person \
inner join opx.team_person as tp on person.pers_id = tp.person_id \
inner join opx.project_team as pt on tp.team_id = pt.team_id \
inner join opx.task as tk on tk.project_id = pt.project_id \
inner join opx.task_restriction as restric on tk.task_restriction_id = restric.restriction_id \
where person.pers_id = '" + str(
person.pers_id) + "' order by tk.task_creation_date DESC;"
# ================ Obtener página validación de la misma ========================
page = request.GET.get('page')
if (page is None):
page = 1
all = request.GET.get('all')
with connection.cursor() as cursor:
cursor.execute(n)
# formatear respuesta de base de datos
tareas = dictfetchall(cursor)
# Progreso de las Tareas
for t in tareas:
t['task_type_name'] = (models.TaskType.objects.get(
pk=t['task_type_id'])).task_type_name
t['instrument_name'] = (models.Instrument.objects.get(
pk=t['instrument_id'])).instrument_name
t['proj_name'] = (models.Project.objects.get(
pk=t['project_id'])).proj_name
t['priority_name'] = (models.TaskPriority.objects.get(
pk=t['task_priority_id'])).priority_name
t['task_completness'] = t['task_completness'] * 100
# Obtener Búsqueda y validación de la misma
search = request.GET.get('search')
if search is not None:
tareas = models.Task.objects.filter(task_name__icontains=search)
tareas = list(tareas.values())
if all is not None and all == "1":
data = {'code': 200, 'tareas': tareas, 'status': 'success'}
else:
# Obtener Página
paginator = Paginator(tareas, 10)
# Obtener lista de tareas
tareas = paginator.page(page).object_list
data = {
'code': 200,
'paginator': {
'currentPage': page,
'perPage': paginator.per_page,
'lastPage': paginator.num_pages,
'total': paginator.count
},
'tareas': tareas,
'status': 'success'
} # Obtener Búsqueda y validación de la misma
except EmptyPage:
data = {
'code': 400,
'message': 'Página inexistente',
'status': 'error'
}
return JsonResponse(data, safe=False, status=data['code'])
