source: consulta_publica/consulta/views.py @ 32be06f

# -*- coding: utf-8 -*-
"""
Sistema de Consulta Pública

Copyleft (@) 2017 CENDITEL nodo Mérida - https://planificacion.cenditel.gob.ve/trac/wiki/ModeladoTopicos_2017
"""
## @package consulta.views
#
# Vistas correspondientes a la aplicación consulta
# @author Rodrigo Boet (rboet at cenditel.gob.ve)
# @author <a href='http://www.cenditel.gob.ve'>Centro Nacional de Desarrollo e Investigación en Tecnologías Libres
# (CENDITEL) nodo Mérida - Venezuela</a>
# @copyright <a href='http://www.gnu.org/licenses/gpl-2.0.html'>GNU Public License versión 2 (GPLv2)</a>
# @version 1.0
import json
from django.shortcuts import render
from django.conf import settings
from django.core.urlresolvers import reverse_lazy
from django.http import JsonResponse
from django.contrib.auth.models import User
from django.views.generic import (
    CreateView, ListView, TemplateView, DeleteView,
    DetailView, UpdateView, FormView
    )
from django.contrib.messages.views import SuccessMessageMixin
from django.contrib.auth.mixins import LoginRequiredMixin
from braces.views import GroupRequiredMixin
from easy_pdf.views import PDFTemplateView
from .models import Consulta, Pregunta, TipoPregunta, Opcion
from .forms import ConsultaForm, ConsultaPreguntaForm, ConsultaSearchForm
from participacion.models import RespuestaSino, RespuestaOpciones, RespuestaAbierta
from users.models import Perfil, Universidades
from base.constant import OBJETIVOS, SECTORES, SECTOR_ESTUDIANTE, SECTOR_TRABAJADOR
from base.models import Entidad, Municipio, Parroquia
 
class ConsultaIndex(GroupRequiredMixin, LoginRequiredMixin, TemplateView):
    """!
    Clase que gestiona la vista principal de la consulta

    @author Rodrigo Boet (rboet at cenditel.gob.ve)
    @copyright <a href='http://www.gnu.org/licenses/gpl-2.0.html'>GNU Public License versión 2 (GPLv2)</a>
    @date 15-02-2017
    @version 1.0.0
    """
    template_name = "consulta.index.html"
    group_required = u"Administrador"


class ConsultaCreate(GroupRequiredMixin, LoginRequiredMixin,SuccessMessageMixin,CreateView):
    """!
    Clase que gestiona la creación de consultas

    @author Rodrigo Boet (rboet at cenditel.gob.ve)
    @copyright <a href='http://www.gnu.org/licenses/gpl-2.0.html'>GNU Public License versión 2 (GPLv2)</a>
    @date 15-02-2017
    @version 1.0.0
    """
    model = Consulta
    form_class = ConsultaPreguntaForm
    template_name = "consulta.create.html"
    success_message = "Se creó la consulta con éxito"
    success_url = reverse_lazy('consulta_index')
    group_required = u"Administrador"
    
    def get_context_data(self, **kwargs):
        """!
        Metodo que permite cargar de nuevo valores en los datos de contexto de la vista
    
        @author Rodrigo Boet (rboet at cenditel.gob.ve)
        @copyright GNU/GPLv2
        @date 16-02-2017
        @param self <b>{object}</b> Objeto que instancia la clase
        @param kwargs <b>{object}</b> Objeto que contiene los datos de contexto
        @return Retorna los datos de contexto
        """
        if 'tipo_pregunta_modal' in self.request.POST and 'texto_pregunta_modal' in self.request.POST:
            post_data = dict(self.request.POST.lists())
            if ((len(post_data['tipo_pregunta_modal'])>0 and len(post_data['texto_pregunta_modal'])>0) and (len(post_data['texto_pregunta_modal']) == len(post_data['tipo_pregunta_modal']))):
                valores = {}
                for i in range(len(post_data['tipo_pregunta_modal'])):
                    valores[i] = {'texto_pregunta':post_data['texto_pregunta_modal'][i],'tipo_pregunta':post_data['tipo_pregunta_modal'][i]}
                kwargs['opciones'] = json.dumps(valores)
        return super(ConsultaCreate, self).get_context_data(**kwargs)
        
    
    def form_valid(self,form):
        """!
        Metodo que valida si el formulario es valido
    
        @author Rodrigo Boet (rboet at cenditel.gob.ve)
        @copyright GNU/GPLv2
        @date 15-02-2017
        @param self <b>{object}</b> Objeto que instancia la clase
        @param form <b>{object}</b> Objeto que contiene el formulario de registro
        @return Retorna el formulario validado
        """
        
        post_data = dict(self.request.POST.lists())
        user = User.objects.get(pk=self.request.user.id)
        
        ## Se crea el objeto de la consulta
        self.object = form.save(commit=False)
        self.object.nombre_consulta = form.cleaned_data['nombre_consulta']
        self.object.activa = form.cleaned_data['activa']
        self.object.user = user
        self.object.save()
        
        ## Se crea la pregunta que se pide por defecto
        tipo = TipoPregunta.objects.get(pk=form.cleaned_data['tipo_pregunta'])
        pregunta = Pregunta()
        pregunta.texto_pregunta = form.cleaned_data['texto_pregunta']
        pregunta.tipo_pregunta = tipo
        pregunta.consulta = self.object
        pregunta.save()
         
        ## Si se agregaron más preguntas se crean
        if 'tipo_pregunta_modal' in self.request.POST and 'texto_pregunta_modal' in self.request.POST:
            self.create_questions(self.object,post_data)
        
        return super(ConsultaCreate, self).form_valid(form)
    
    
    def create_questions(self,objeto,data):
        """!
        Metodo para crear preguntas adicionales
    
        @author Rodrigo Boet (rboet at cenditel.gob.ve)
        @copyright GNU/GPLv2
        @date 16-02-2017
        @param self <b>{object}</b> Objeto que instancia la clase
        @param objeto <b>{object}</b> Objeto de la consulta
        @param data <b>{dict}</b> Diccionario con los valores a guardar
        """
        if len(data['texto_pregunta_modal']) == len(data['tipo_pregunta_modal']):
            print data['texto_pregunta_modal']
            for i in range(len(data['texto_pregunta_modal'])):
                tipo = TipoPregunta.objects.get(pk=data['tipo_pregunta_modal'][i])
                pregunta = Pregunta()
                pregunta.texto_pregunta = data['texto_pregunta_modal'][i]
                pregunta.tipo_pregunta = tipo
                pregunta.consulta = objeto
                pregunta.save()
    
class ConsultaList(GroupRequiredMixin, LoginRequiredMixin,ListView):
    """!
    Clase que gestiona la lista de consultas

    @author Rodrigo Boet (rboet at cenditel.gob.ve)
    @copyright <a href='http://www.gnu.org/licenses/gpl-2.0.html'>GNU Public License versión 2 (GPLv2)</a>
    @date 15-02-2017
    @version 1.0.0
    """
    model = Consulta
    template_name = "consulta.list.html"
    group_required = u"Administrador"
    
    
class ConsultaDetail(GroupRequiredMixin, LoginRequiredMixin,DetailView):
    """!
    Clase que gestiona el detalle de una consulta

    @author Rodrigo Boet (rboet at cenditel.gob.ve)
    @copyright <a href='http://www.gnu.org/licenses/gpl-2.0.html'>GNU Public License versión 2 (GPLv2)</a>
    @date 17-02-2017
    @version 1.0.0
    """
    model = Consulta
    template_name = "consulta.detail.html"
    group_required = u"Administrador"
    
    def get_context_data(self, **kwargs):
        """!
        Metodo que permite cargar de nuevo valores en los datos de contexto de la vista
    
        @author Rodrigo Boet (rboet at cenditel.gob.ve)
        @copyright GNU/GPLv2
        @date 17-02-2017
        @param self <b>{object}</b> Objeto que instancia la clase
        @param kwargs <b>{object}</b> Objeto que contiene los datos de contexto
        @return Retorna los datos de contexto
        """
        kwargs['preguntas'] = Pregunta.objects.filter(consulta_id=kwargs['object'].id).all()
        kwargs['respuestas'] = True if RespuestaSino.objects.filter(pregunta__consulta=kwargs['object'].id) else False
        kwargs['respuestas'] = True if RespuestaOpciones.objects.filter(opcion__pregunta__consulta=kwargs['object'].id) else kwargs['respuestas']
        kwargs['respuestas_abierta'] = True if RespuestaAbierta.objects.filter(pregunta__consulta=kwargs['object'].id) else False
        return super(ConsultaDetail, self).get_context_data(**kwargs)
    
class ConsultaDelete(GroupRequiredMixin, LoginRequiredMixin,SuccessMessageMixin,DeleteView):
    """!
    Clase que gestiona el borrado de consultas

    @author Rodrigo Boet (rboet at cenditel.gob.ve)
    @copyright <a href='http://www.gnu.org/licenses/gpl-2.0.html'>GNU Public License versión 2 (GPLv2)</a>
    @date 15-02-2017
    @version 1.0.0
    """
    model = Consulta
    template_name = "consulta.delete.html"
    success_message = "Se eliminó la consulta con éxito"
    success_url = reverse_lazy('consulta_index')
    group_required = u"Administrador"
    
    
class ConsultaUpdate(GroupRequiredMixin, LoginRequiredMixin,SuccessMessageMixin,UpdateView):
    """!
    Clase que gestiona la actualización de consultas

    @author Rodrigo Boet (rboet at cenditel.gob.ve)
    @copyright <a href='http://www.gnu.org/licenses/gpl-2.0.html'>GNU Public License versión 2 (GPLv2)</a>
    @date 17-02-2017
    @version 1.0.0
    """
    model = Consulta
    form_class = ConsultaForm
    template_name = "consulta.update.html"
    success_message = "Se actualizó la consulta con éxito"
    success_url = reverse_lazy('consulta_list')
    group_required = u"Administrador"
    
    
    def get_context_data(self, **kwargs):
        """!
        Metodo que permite cargar de nuevo valores en los datos de contexto de la vista
    
        @author Rodrigo Boet (rboet at cenditel.gob.ve)
        @copyright GNU/GPLv2
        @date 17-02-2017
        @param self <b>{object}</b> Objeto que instancia la clase
        @param kwargs <b>{object}</b> Objeto que contiene los datos de contexto
        @return Retorna los datos de contexto
        """
        preguntas = Pregunta.objects.filter(consulta_id=self.object.id).all()
        kwargs['preguntas'] = preguntas
        return super(ConsultaUpdate, self).get_context_data(**kwargs)
        
        
class ConsultaStats(GroupRequiredMixin, LoginRequiredMixin,TemplateView):
    """!
    Clase que gestiona las estadísticas de la consulta

    @author Rodrigo Boet (rboet at cenditel.gob.ve)
    @copyright <a href='http://www.gnu.org/licenses/gpl-2.0.html'>GNU Public License versión 2 (GPLv2)</a>
    @date 18-04-2017
    @version 1.0.0
    """
    template_name = "consulta.stats.html"
    group_required = u"Administrador"
    
    def get_context_data(self, **kwargs):
        """!
        Metodo que permite cargar de nuevo valores en los datos de contexto de la vista
    
        @author Rodrigo Boet (rboet at cenditel.gob.ve)
        @copyright GNU/GPLv2
        @date 18-04-2017
        @param self <b>{object}</b> Objeto que instancia la clase
        @param kwargs <b>{object}</b> Objeto que contiene los datos de contexto
        @return Retorna los datos de contexto
        """
        participacion = {}
        opciones = []
        valores = []
        kwargs['participacion'] = []
        if RespuestaAbierta.objects.filter(pregunta__consulta_id=self.kwargs['pk']):
            for item in OBJETIVOS:
                respuesta = RespuestaAbierta.objects.filter(pregunta__consulta_id=self.kwargs['pk'],objetivo=item[0]).count()
                opciones.append(item[1].encode('utf8'))
                valores.append(respuesta)
            kwargs['participacion'].append({'titulo':'Respuestas por Objetivo de la Constituyente','opciones':opciones,'valores':valores})
        if RespuestaSino.objects.filter(pregunta__consulta_id=self.kwargs['pk']):
            kwargs['participacion'].append(self.get_pregunta_sino(self.kwargs['pk']))
        if RespuestaOpciones.objects.filter(opcion__pregunta__consulta_id=self.kwargs['pk']):
            for item in self.get_pregunta_opciones(self.kwargs['pk']):
                kwargs['participacion'].append(item)
        kwargs['usuarios'] = [self.get_users()]
        return super(ConsultaStats, self).get_context_data(**kwargs)
    
    def get_users(self):
        """!
        Metodo que permite cargar los usuarios por grupos de roles
    
        @author Rodrigo Boet (rboet at cenditel.gob.ve)
        @copyright GNU/GPLv2
        @date 31-05-2017
        @param self <b>{object}</b> Objeto que instancia la clase
        @return Retorna los datos del usuario
        """
        participantes = User.objects.filter(groups__name='Participante').count()
        administradores = User.objects.filter(groups__name='Administrador').count()
        data = {}
        data['titulo'] = 'Usuarios Registrados'
        data['opciones'] = ['Participante','Administrador']
        data['valores'] = [participantes, administradores]
        return data
        
    
    def get_pregunta_opciones(self,id,titulo=''):
        """!
        Metodo que permite cargar las opciones para una pregunta simple o múltiple
    
        @author Rodrigo Boet (rboet at cenditel.gob.ve)
        @copyright GNU/GPLv2
        @date 18-04-2017
        @param self <b>{object}</b> Objeto que instancia la clase
        @param id <b>{int}</b> Entero con el id de la consulta
        @return Retorna los datos de contexto
        """
        datos = []
        for pregunta in Pregunta.objects.filter(consulta_id=id,tipo_pregunta_id__in=[1,2]).all():
            options = []
            values = []
            for opciones in Opcion.objects.filter(pregunta_id=pregunta.id).all():
                options.append(opciones.texto_opcion.encode('utf8'))
                values.append(RespuestaOpciones.objects.filter(opcion_id=opciones.id).count())
            if titulo=='':
                titulo = pregunta.texto_pregunta
            data = {}
            data['titulo'] = titulo
            data['opciones'] = options
            data['valores'] = values
            datos.append(data)
        return datos
    
    def get_pregunta_sino(self,id,titulo=''):
        """!
        Metodo que permite cargar las opciones para una pregunta si o no
    
        @author Rodrigo Boet (rboet at cenditel.gob.ve)
        @copyright GNU/GPLv2
        @date 18-04-2017
        @param self <b>{object}</b> Objeto que instancia la clase
        @param id <b>{int}</b> Entero con el id de la consulta
        @return Retorna los datos de contexto
        """
        if titulo=='':
            opc = RespuestaSino.objects.filter(pregunta__consulta_id=id).first()
            titulo = opc.pregunta.texto_pregunta
        Si = RespuestaSino.objects.filter(respuesta=True,pregunta__consulta_id=id).count()
        No = RespuestaSino.objects.filter(respuesta=False,pregunta__consulta_id=id).count()
        data = {}
        data['titulo'] = titulo
        data['opciones'] = ['Si','No']
        data['valores'] = [Si, No]
        return data
    
class ConsultaReport(GroupRequiredMixin, LoginRequiredMixin, FormView):
    """!
    Clase que gestiona la vista principal de los reportes

    @author Rodrigo Boet (rboet at cenditel.gob.ve)
    @copyright <a href='http://www.gnu.org/licenses/gpl-2.0.html'>GNU Public License versión 2 (GPLv2)</a>
    @date 31-05-2017
    @version 1.0.0
    """
    template_name = "consulta.report.html"
    group_required = u"Administrador"
    form_class = ConsultaSearchForm
    
    def get_success_url(self):
        """!
        Metodo que permite definir la url de dirección al ser válido el formulario
        
        @author Rodrigo Boet (rboet at cenditel.gob.ve)
        @copyright GNU/GPLv2
        @date 01-06-2017
        @param self <b>{object}</b> Objeto que instancia la clase
        @return Retorna la url
        """
        tipo_pregunta = self.request.POST['tipo_pregunta']
        objetivo = self.request.POST.get('objetivo','')
        estado = self.request.POST.get('estado','')
        municipio = self.request.POST.get('municipio','')
        parroquia = self.request.POST.get('parroquia','')
        sector = self.request.POST.get('sector','')
        sector_trabajador = self.request.POST.get('sector_trabajador','')
        sector_estudiante = self.request.POST.get('sector_estudiante','')
        universidad = self.request.POST.get('universidad','')
        url = '%s?objetivo=%s&estado=%s&municipio=%s&parroquia=%s&sector=%s&sector_trabajador=%s&sector_estudiante=%s&universidad=%s' % (reverse_lazy('consulta_pdf',
            kwargs={'pk': self.kwargs['pk'],'tipo_pregunta': tipo_pregunta}),
            objetivo,estado,municipio,parroquia,sector,sector_trabajador,sector_estudiante,universidad)
        return url
    
    def get_context_data(self, **kwargs):
        """!
        Metodo que permite cargar de nuevo valores en los datos de contexto de la vista
    
        @author Rodrigo Boet (rboet at cenditel.gob.ve)
        @copyright GNU/GPLv2
        @date 17-02-2017
        @param self <b>{object}</b> Objeto que instancia la clase
        @param kwargs <b>{object}</b> Objeto que contiene los datos de contexto
        @return Retorna los datos de contexto
        """
        kwargs['pk'] = self.kwargs['pk']
        return super(ConsultaReport, self).get_context_data(**kwargs)
    
class ConsultaPdf(PDFTemplateView):
    """!
    Clase que gestiona la renderización de reportes en PDF

    @author Rodrigo Boet (rboet at cenditel.gob.ve)
    @copyright <a href='http://www.gnu.org/licenses/gpl-2.0.html'>GNU Public License versión 2 (GPLv2)</a>
    @date 01-06-2017
    @version 1.0.0
    """
    template_name = 'consulta.pdf.template.html'

    def get_context_data(self, **kwargs):
        """!
        Metodo que permite cargar de nuevo valores en los datos de contexto de la vista
    
        @author Rodrigo Boet (rboet at cenditel.gob.ve)
        @copyright GNU/GPLv2
        @date 01-06-2017
        @param self <b>{object}</b> Objeto que instancia la clase
        @param kwargs <b>{object}</b> Objeto que contiene los datos de contexto
        @return Retorna los datos de contexto
        """
        pk = int(self.kwargs['pk'])
        tipo_pregunta = int(self.kwargs['tipo_pregunta'])
        ## Variables por get
        objetivo = self.request.GET['objetivo']
        estado = self.request.GET['estado']
        municipio = self.request.GET['municipio']
        parroquia = self.request.GET['parroquia']
        sector = self.request.GET['sector']
        sector_trabajador = self.request.GET['sector_trabajador']
        sector_estudiante = self.request.GET['sector_estudiante']
        universidad = self.request.GET['universidad']
        resp = 0
        est, mun, parr = 0, 0, 0
        preg = Pregunta.objects.get(pk=tipo_pregunta)
        if preg.tipo_pregunta_id >=1 and preg.tipo_pregunta_id <3:
            resp = RespuestaOpciones.objects.filter(opcion__pregunta_id=tipo_pregunta)
        elif preg.tipo_pregunta_id >2 and preg.tipo_pregunta_id <5:
            resp = RespuestaSino.objects.filter(pregunta__id=tipo_pregunta)
        elif preg.tipo_pregunta_id == 5:
            resp = RespuestaAbierta.objects.filter(pregunta_id=tipo_pregunta,objetivo=objetivo)
        ## Se validan los filtros por territorio
        if estado == '':
            datos = []
            for estado in Entidad.objects.all():
                data = Perfil.objects.filter(parroquia__municipio__entidad_id=estado.id,user_id__in=resp.values_list('user_id',flat=True)).count()
                datos.append([estado.nombre,data])
            kwargs['estados'] = datos
        elif estado !='' and (municipio=='' and parroquia==''):
            est = Perfil.objects.filter(parroquia__municipio__entidad_id=estado,user_id__in=resp.values_list('user_id',flat=True))
            kwargs['lugar'] = est.count()
            kwargs['ubicacion'] = Entidad.objects.get(pk=estado)
            ## Muestra los datos por los municipios del estado
            datos = []
            for municipio in Municipio.objects.filter(entidad_id=estado).all():
                data = Perfil.objects.filter(parroquia__municipio_id=municipio.id,user_id__in=resp.values_list('user_id',flat=True)).count()
                datos.append([municipio.nombre,data])
            kwargs['municipios'] = datos
        elif municipio!='' and parroquia=='':
            mun = Perfil.objects.filter(parroquia__municipio_id=municipio,user_id__in=resp.values_list('user_id',flat=True))
            kwargs['lugar'] = mun.count()
            kwargs['ubicacion'] = Municipio.objects.get(pk=municipio)
            ## Muestra los datos por la parroquia
            datos = []
            for parroquia in Parroquia.objects.filter(municipio_id=municipio).all():
                data = Perfil.objects.filter(parroquia_id=parroquia.id,user_id__in=resp.values_list('user_id',flat=True)).count()
                datos.append([parroquia.nombre,data])
            kwargs['parroquias'] = datos
        elif parroquia!='':
            parr = Perfil.objects.filter(parroquia_id=parroquia,user_id__in=resp.values_list('user_id',flat=True))
            kwargs['lugar'] = parr.count()
            kwargs['ubicacion'] = Parroquia.objects.get(pk=parroquia)
        ## Se validan los filtros por sector
        SECTOR = dict(SECTORES)
        ST = dict(SECTOR_TRABAJADOR)
        SE = dict(SECTOR_ESTUDIANTE)
        if sector=='':
            datos = []
            for sec in SECTOR:
                data = Perfil.objects.filter(sector=sec,user_id__in=resp.values_list('user_id',flat=True)).count()
                datos.append([SECTOR[sec],data])
            kwargs['sectores'] = datos
        elif sector == 'TR' and sector_trabajador!='':
            sec = Perfil.objects.filter(sector=sector,user_id__in=resp.values_list('user_id',flat=True))
            kwargs['sector'] = sec.count()
            kwargs['sector_texto'] = SECTOR[sector]
            sec = sec.filter(sector_trabajador=sector_trabajador)
            kwargs['sector_trabajador'] = sec.count()
            kwargs['sector_trabajador_texto'] = ST[sector_trabajador]
        elif sector == 'ES' and sector_estudiante!='':
            sec = Perfil.objects.filter(sector=sector,user_id__in=resp.values_list('user_id',flat=True))
            kwargs['sector'] = sec.count()
            kwargs['sector_texto'] = SECTOR[sector]
            sec = sec.filter(sector_estudiante=sector_estudiante)
            kwargs['sector_estudiante'] = sec.count()
            kwargs['sector_estudiante_texto'] = SE[sector_estudiante]
            #universidades
            if(universidad!=''):
                uni = Universidades.objects.get(pk=universidad)
                sec = sec.filter(universidad_id=universidad)
                kwargs['universidad'] = sec.count()
                kwargs['universidad_texto'] = uni.nombre
            else:
                datos = []
                for uni in Universidades.objects.all():
                    data = Perfil.objects.filter(universidad_id=uni.id,user_id__in=resp.values_list('user_id',flat=True)).count()
                    datos.append([uni.nombre,data])
                kwargs['universidades'] = datos
        else:
            sec = Perfil.objects.filter(sector=sector,user_id__in=resp.values_list('user_id',flat=True))
            kwargs['sector'] = sec.count()
            kwargs['sector_texto'] = SECTOR[sector]
        kwargs['respuestas'] = resp.count()
        kwargs['pregunta_texto'] = preg.texto_pregunta
        kwargs['objetivo_texto'] = OBJETIVOS[int(objetivo)-1][1] if objetivo else None
        return super(ConsultaPdf, self).get_context_data(**kwargs)

    
class OpcionesCreate(GroupRequiredMixin, LoginRequiredMixin,CreateView):
    """!
    Clase que gestiona la creación de opciones

    @author Rodrigo Boet (rboet at cenditel.gob.ve)
    @copyright <a href='http://www.gnu.org/licenses/gpl-2.0.html'>GNU Public License versión 2 (GPLv2)</a>
    @date 20-02-2017
    @version 1.0.0
    """
    model = Opcion
    fields = ['texto_opcion']
    template_name = "consulta.create.html"
    group_required = u"Administrador"
            
    
    def form_valid(self,form):
        """!
        Metodo que valida si el formulario es valido
    
        @author Rodrigo Boet (rboet at cenditel.gob.ve)
        @copyright GNU/GPLv2
        @date 20-02-2017
        @param self <b>{object}</b> Objeto que instancia la clase
        @param form <b>{object}</b> Objeto que contiene el formulario de registro
        @return Retorna el formulario validado
        """
        post_data = dict(self.request.POST.lists())
        pregunta = Pregunta.objects.get(id=int(self.kwargs['pk']))
        
        ## Se guarda la primera opcion
        self.object = form.save(commit=False)
        self.object.texto_opcion = post_data['texto_opcion'][0]
        self.object.pregunta = pregunta
        self.object.save()
        
        ## Se guardan las demás opciones si existen
        for i in range(1,len(post_data['texto_opcion'])):
            opcion = Opcion()
            opcion.texto_opcion = post_data['texto_opcion'][i]
            opcion.pregunta = pregunta
            opcion.save()
            
        if self.request.is_ajax():
            return JsonResponse({"code":True})
            
        return super(OpcionesCreate, self).form_valid(form)
    
    def form_invalid(self,form):
        """!
        Metodo que valida si el formulario es invalido
    
        @author Rodrigo Boet (rboet at cenditel.gob.ve)
        @copyright GNU/GPLv2
        @date 20-02-2017
        @param self <b>{object}</b> Objeto que instancia la clase
        @param form <b>{object}</b> Objeto que contiene el formulario de registro
        @return Retorna el formulario inválido
        """
        if self.request.is_ajax():
            return JsonResponse({"code":False,'errors':form.errors})
        return super(OpcionesCreate, self).form_invalid(form)
    
    
class OpcionesUpdate(GroupRequiredMixin, LoginRequiredMixin,UpdateView):
    """!
    Clase que gestiona la actualización de las opciones

    @author Rodrigo Boet (rboet at cenditel.gob.ve)
    @copyright <a href='http://www.gnu.org/licenses/gpl-2.0.html'>GNU Public License versión 2 (GPLv2)</a>
    @date 20-02-2017
    @version 1.0.0
    """
    model = Opcion
    fields = ['texto_opcion']
    template_name = "consulta.update.html"
    success_url = reverse_lazy('consulta_list')
    group_required = u"Administrador"
    
    
    def post(self, request):
        """!
        Metodo que sobreescribe la acción por POST
    
        @author Rodrigo Boet (rboet at cenditel.gob.ve)
        @copyright GNU/GPLv2
        @date 20-02-2017
        @param self <b>{object}</b> Objeto que instancia la clase
        @param request <b>{object}</b> Objeto que contiene la petición
        @return Retorna los datos de contexto
        """
        post_data = dict(self.request.POST.lists())
        for i in range(len(post_data['texto_opcion'])):
            opcion = Opcion.objects.filter(id=int(post_data['texto_opcion_id'][i]))
            if(opcion):
                opcion = opcion.get()
                opcion.texto_opcion = post_data['texto_opcion'][i]
                opcion.save()

        if self.request.is_ajax():
            return JsonResponse({"code":True})
        
class OpcionesDelete(GroupRequiredMixin, LoginRequiredMixin,DeleteView):
    """!
    Clase que gestiona el borrado de una opción

    @author Rodrigo Boet (rboet at cenditel.gob.ve)
    @copyright <a href='http://www.gnu.org/licenses/gpl-2.0.html'>GNU Public License versión 2 (GPLv2)</a>
    @date 20-02-2017
    @version 1.0.0
    """
    model = Opcion
    template_name = "consulta.update.html"
    success_url = reverse_lazy('consulta_list')
    group_required = u"Administrador"
    
    def post(self, request, pk):
        """!
        Metodo que sobreescribe la acción por POST
    
        @author Rodrigo Boet (rboet at cenditel.gob.ve)
        @copyright GNU/GPLv2
        @date 20-02-2017
        @param self <b>{object}</b> Objeto que instancia la clase
        @param request <b>{object}</b> Objeto que contiene la petición
        @param pk <b>{int}</b> Recibe el id para filtrar
        @return Retorna los datos de contexto
        """
        opcion = Opcion.objects.filter(id=int(pk))
        if(opcion):
            opcion = opcion.get()
            opcion.delete()
            return JsonResponse({'success':True})
        return JsonResponse({'success':False,'mensaje':'Opción inválida'})
            
            
class PreguntaDelete(GroupRequiredMixin, LoginRequiredMixin,DeleteView):
    """!
    Clase que gestiona el borrado de una pregunta

    @author Rodrigo Boet (rboet at cenditel.gob.ve)
    @copyright <a href='http://www.gnu.org/licenses/gpl-2.0.html'>GNU Public License versión 2 (GPLv2)</a>
    @date 20-02-2017
    @version 1.0.0
    """
    model = Pregunta
    template_name = "consulta.update.html"
    success_url = reverse_lazy('consulta_list')
    group_required = u"Administrador"
    
    def post(self, request, pk):
        """!
        Metodo que sobreescribe la acción por POST
    
        @author Rodrigo Boet (rboet at cenditel.gob.ve)
        @copyright GNU/GPLv2
        @date 20-02-2017
        @param self <b>{object}</b> Objeto que instancia la clase
        @param request <b>{object}</b> Objeto que contiene la petición
        @param pk <b>{int}</b> Recibe el id para filtrar
        @return Retorna los datos de contexto
        """
        pregunta = Pregunta.objects.filter(id=int(pk))
        if(pregunta):
            pregunta = pregunta.get()
            ## Si tiene opciones, se buscan y se borran
            if(pregunta.tipo_pregunta_id==1):
                opciones = Opcion.objects.filter(pregunta_id=pregunta.id)
                if (opciones):
                    for item in opciones.all():
                        item.delete()                
            pregunta.delete()
            return JsonResponse({'success':True})
        return JsonResponse({'success':False,'mensaje':'Pregunta inválida'})
    
    
class PreguntaCreate(GroupRequiredMixin, LoginRequiredMixin,CreateView):
    """!
    Clase que gestiona la creación de preguntas

    @author Rodrigo Boet (rboet at cenditel.gob.ve)
    @copyright <a href='http://www.gnu.org/licenses/gpl-2.0.html'>GNU Public License versión 2 (GPLv2)</a>
    @date 21-02-2017
    @version 1.0.0
    """
    model = Pregunta
    fields = ['texto_pregunta','tipo_pregunta']
    template_name = "consulta.create.html"
    success_url = reverse_lazy('consulta_index')
    group_required = u"Administrador"
    
    def form_valid(self,form):
        """!
        Metodo que valida si el formulario es valido
    
        @author Rodrigo Boet (rboet at cenditel.gob.ve)
        @copyright GNU/GPLv2
        @date 21-02-2017
        @param self <b>{object}</b> Objeto que instancia la clase
        @param form <b>{object}</b> Objeto que contiene el formulario de registro
        @return Retorna el formulario validado
        """
        post_data = dict(self.request.POST.lists())
        consulta = Consulta.objects.get(id=int(self.kwargs['pk']))
        
        ## Se guarda la primera opcion
        self.object = form.save(commit=False)
        self.object.texto_opcion = form.cleaned_data['texto_pregunta']
        self.object.tipo_pregunta = form.cleaned_data['tipo_pregunta']
        self.object.consulta = consulta
        self.object.save()
        
        ## Se guardan las demás opciones si existen
        for i in range(len(post_data['texto_pregunta'])-1):
            tipo_pregunta = TipoPregunta.objects.get(id=int(post_data['tipo_pregunta'][i]))
            pregunta = Pregunta()
            pregunta.texto_opcion = post_data['texto_pregunta'][i]
            pregunta.tipo_pregunta = post_data['tipo_pregunta'][i]
            pregunta.consulta = consulta
            pregunta.save()
            
        if self.request.is_ajax():
            return JsonResponse({"code":True})
            
        return super(OpcionesCreate, self).form_valid(form)
    
    def form_invalid(self,form):
        """!
        Metodo que valida si el formulario es invalido
    
        @author Rodrigo Boet (rboet at cenditel.gob.ve)
        @copyright GNU/GPLv2
        @date 21-02-2017
        @param self <b>{object}</b> Objeto que instancia la clase
        @param form <b>{object}</b> Objeto que contiene el formulario de registro
        @return Retorna el formulario inválido
        """
        if self.request.is_ajax():
            return JsonResponse({"code":False,'errors':form.errors})
        return super(OpcionesCreate, self).form_invalid(form)
    
class PreguntaUpdate(GroupRequiredMixin, LoginRequiredMixin, UpdateView):
    """!
    Clase que gestiona la actualización de las preguntas

    @author Rodrigo Boet (rboet at cenditel.gob.ve)
    @copyright <a href='http://www.gnu.org/licenses/gpl-2.0.html'>GNU Public License versión 2 (GPLv2)</a>
    @date 23-02-2017
    @version 1.0.0
    """
    model = Pregunta
    fields = ['texto_pregunta','tipo_pregunta']
    template_name = "consulta.update.html"
    success_url = reverse_lazy('consulta_list')
    group_required = u"Administrador"
    
    def post(self, request):
        """!
        Metodo que sobreescribe la acción por POST
    
        @author Rodrigo Boet (rboet at cenditel.gob.ve)
        @copyright GNU/GPLv2
        @date 23-02-2017
        @param self <b>{object}</b> Objeto que instancia la clase
        @param request <b>{object}</b> Objeto que contiene la petición
        @return Retorna los datos de contexto
        """
        post_data = dict(self.request.POST.lists())
        for i in range(len(post_data['texto_pregunta_modal'])):
            pregunta = Pregunta.objects.filter(id=int(post_data['texto_pregunta_id'][i]))
            if(pregunta):
                pregunta = pregunta.get()
                salvar = False
                if(pregunta.texto_pregunta != post_data['texto_pregunta_modal'][i]):
                    pregunta.texto_pregunta = post_data['texto_pregunta_modal'][i]
                    salvar = True
                if(pregunta.tipo_pregunta != post_data['tipo_pregunta_modal'][i]):
                    tipo_pregunta = TipoPregunta.objects.filter(id=int(post_data['tipo_pregunta_modal'][i])).get()
                    pregunta.tipo_pregunta = tipo_pregunta
                    salvar = True
                if(salvar):    
                    pregunta.save()

        if self.request.is_ajax():
            return JsonResponse({"code":True})