source: seguimiento_proyectos/sepai/proyectos/views.py @ a7b5a73

# -*- encoding: utf-8 -*-
"""!
Vista que controla los procesos de los proyectos

@author Ing. Leonel P. Hernandez M. (lhernandez 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 09-01-2017
@version 1.0.0
"""

import os
import json
from django.conf import settings
from django.contrib.auth.mixins import LoginRequiredMixin
from django.contrib import messages
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
from django.core.serializers import serialize
from django.shortcuts import (
    render, redirect, render_to_response
)
from django.contrib.admin.models import LogEntry, ADDITION, CHANGE, DELETION
from django.contrib.contenttypes.models import ContentType
from django.http import HttpResponse, Http404
from django.template import RequestContext
from django.core.files.storage import default_storage
from django.core.files.base import ContentFile
from django.core.urlresolvers import reverse_lazy, reverse
from django.views.generic import ListView, TemplateView, FormView
from django.views.generic.detail import DetailView
from django.views.generic.edit import (
    CreateView,
    UpdateView,
    DeleteView
)
from dal import autocomplete
from multi_form_view import MultiModelFormView

from .utils import (
    listObjetivoHistoricoNacional, listObjetivoEstrategico,
    listObjetivoGenerales
)

from .models import *
from .forms import *

from utils.forms import (
    UploadFileForm
)

from users.utils import (
    LoginRequeridoPerAuth
)

from users.models import UserProfile


## Carga de datos del archivo csv a la base de datos
def carga_masiva_csv(ruta_archivo_hist, ruta_archivo_naci, ruta_archivo_estr, ruta_archivo_genr):
    n_reg_obj_hist = CargaMasivaObjetivosHistoricos.import_from_filename(ruta_archivo_hist)
    n_reg_obj_naci = CargaMasivaObjetivosNacional.import_from_filename(ruta_archivo_naci)
    n_reg_obj_estr = CargaMasivaObjetivosEstrategico.import_from_filename(ruta_archivo_estr)
    n_reg_obj_genr = CargaMasivaObjetivosGeneral.import_from_filename(ruta_archivo_genr)

    return n_reg_obj_hist, n_reg_obj_naci, n_reg_obj_estr, n_reg_obj_genr


def cargaObjetivos(request):
    """!
    Funcion que permite cargar un archivo csv desde la interfaz del Administrador 

    @author Ing. Leonel P. Hernandez M. (lhernandez 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 09-01-2017
    @version 1.0.0
    """
    form = UploadFileForm()
    context = {'form': form}
    if request.method == 'POST':
        form = UploadFileForm(request.POST, request.FILES)
        if form.is_valid():
            archivo_objetivos = request.FILES['cargar']
            extension_objetivos = str(archivo_objetivos).split('.')
            longitud_historico = len(extension_objetivos)
            if extension_objetivos[longitud_historico - 1] == 'csv':
                data_historico = archivo_objetivos.readlines()
                formato_cabeceras = False
                mensaje_error = ""
                for cabecera_historico in range(0, 1):
                    separador_historico = data_historico[cabecera_historico].split(b"|")
                    if (separador_historico[0]).decode('UTF-8') == "OBJETIVOS HISTÓRICOS" \
                    and (separador_historico[1]).decode('UTF-8') == "OBJETIVOS NACIONALES" and \
                    (separador_historico[2]).decode('UTF-8') == "OBJETIVOS ESTRATÉGICOS" and \
                    (separador_historico[3]).decode('UTF-8') == "OBJETIVOS GENERALES\n":
                        formato_cabeceras = True
                    else:
                        formato_cabeceras = False
                        mensaje_error_historico = "Existe un error en la cabecera del csv, del formato del Plan de la Patria\n"
            else:
                mensaje_error = "El formato de archivo debe ser csv"
                messages.error(request, mensaje_error)
            if formato_cabeceras:
                datos_obj = listObjetivoHistoricoNacional(data_historico)
                datos_obj_est = listObjetivoEstrategico(data_historico, datos_obj[1])
                datos_obj_gene =listObjetivoGenerales(data_historico, datos_obj_est)
                archivo_obj_hist = ''.join(datos_obj[0])
                archivo_obj_naci = ''.join(datos_obj[1])
                archivo_obj_est = ''.join(datos_obj_est)
                archivo_obj_gene = ''.join(datos_obj_gene)
                #path_historico = default_storage.save('tmp/formato_historico.csv', ContentFile(archivo_obj_hist))
                #path_nacional = default_storage.save('tmp/formato_nacional.csv', ContentFile(archivo_obj_naci))
                #path_estrategico = default_storage.save('tmp/formato_estrategico.csv', ContentFile(archivo_obj_est))
                #path_general = default_storage.save('tmp/formato_general.csv', ContentFile(archivo_obj_gene))
                #ruta_historico = os.path.join(settings.MEDIA_ROOT, path_historico)
                #ruta_nacional = os.path.join(settings.MEDIA_ROOT, path_nacional)
                #ruta_estrategico = os.path.join(settings.MEDIA_ROOT, path_estrategico)
                #ruta_general = os.path.join(settings.MEDIA_ROOT, path_general)
                #carga_masiva_csv(ruta_historico, ruta_nacional, ruta_estrategico, ruta_general)
                #path_historico = default_storage.delete('tmp/formato_historico.csv')
                #path_nacional = default_storage.delete('tmp/formato_nacional.csv')
                #path_estrategico = default_storage.delete('tmp/formato_estrategico.csv')
                #path_general = default_storage.delete('tmp/formato_general.csv')
                messages.success(request, 'La data se cargo con exito')
            else:
                messages.error(request, mensaje_error_historico)
        else:
            return render(request, 'utils/cargar_historica.html', context)

        context = {'form': form}
        return render(request, 'utils/cargar_historica.html', context)

    else:
        return render(request, 'utils/cargar_historica.html', context)


class AlcanceAutocomplete(autocomplete.Select2QuerySetView):
    """!
    Clase que crea el autocompletado del alcance de los proyectos en un select 

    @author Ing. Leonel P. Hernandez M. (lhernandez 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 09-01-2017
    @version 1.0.0
    """

    def get_queryset(self):
        # No se olvide de filtrar los resultados en función del visitante !
        if not self.request.user.is_authenticated():
            return Alcance.objects.none()

        qs = Alcance.objects.all()
        if self.q:
            qs = qs.filter(opcion_alcance__istartswith=self.q)

        return qs

class OptionsMangProjectsView(LoginRequeridoPerAuth, TemplateView):
    """!
    Lista las opciones para la gestion de proyectos

    @author Ing. Leonel P. Hernandez M. (lhernandez 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 09-01-2017
    @version 1.0.0
    """
    template_name = "proyectos/gestion_proyectos.html"
    group_required = [u"Administradores", u"Usuarios Supervisores", u"Usuarios Enlace" ]

    def __init__(self):
        super(OptionsMangProjectsView, self).__init__()

    def get_context_data(self, **kwargs):
        """Use this to add extra context."""
        try:
            perfil = UserProfile.objects.select_related().get(fk_user=self.request.user.id)
        except:
            perfil = None
        try:
            proyectos = Proyecto.objects.all()
        except:
            proyectos = None
        context = super(OptionsMangProjectsView, self).get_context_data(**kwargs)
        context['userprofile'] = perfil
        context['proyectos'] = proyectos
        return context




class ProjectsList(LoginRequeridoPerAuth, ListView):
    """!
    Clase que lista los proyectos

    @author Ing. Leonel P. Hernandez M. (lhernandez 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 09-01-2017
    @version 1.0.0
    """
    model = Proyecto
    success_url = reverse_lazy('projects:consultar_subproyectos')
    record_id=None
    group_required = [u"Administradores", u"Usuarios Supervisores", u"Usuarios Enlace" ]

    def __init__(self):
        super(ProjectsList, self).__init__()


    def get_context_data(self, **kwargs):
        context = super(ProjectsList, self).get_context_data(**kwargs)
        context['projects_list'] = Proyecto.objects.filter(fk_user=self.request.user.id, activo=True).values("nombre", "pk")
        for i in context['projects_list']:
            i["contar_pro"] = SubProyecto.objects.filter(fk_proyecto=i["pk"]).count()
        return context


class ProyectoRegisterView(LoginRequeridoPerAuth, MultiModelFormView):
    """!
    Clase para crear los proyectos

    @author Ing. Leonel P. Hernandez M. (lhernandez 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 09-01-2017
    @version 1.0.0
    """
    template_name = 'proyectos/proyecto_form.html'
    model = Proyecto
    form_classes = {
      'proyecto': FormularioRegProyecto,
      'obj_proy': FormsetObj,
      'resp_tec': FormularioRespTec,
      'resp_gere': FormularioRespGere,
    }
    success_url = reverse_lazy('projects:crear_proyectos')
    record_id=None
    group_required = [u"Administradores", u"Usuarios Supervisores", u"Usuarios Enlace" ]

    def __init__(self):
        super(ProyectoRegisterView, self).__init__()

    def get_objects(self):
        self.record_id = self.kwargs.get('record_id', None)
        try:
            record = ObjetivosEspecificosProy.objects.get(fk_proyecto=self.record_id)
        except ObjetivosEspecificosProy.DoesNotExist:
            record = None
        return {
          'obj_proy': record,
          'proyecto': record.fk_proyecto if record else None,
          'resp_tec': record.fk_proyecto if record else None,
          'resp_gere': record.fk_proyecto if record else None,
        }

    def get_context_data(self, **kwargs):
        """Use this to add extra context."""
        try:
            perfil = UserProfile.objects.select_related().get(fk_user=self.request.user.id)
        except:
            perfil = None
        try:
            proyectos = Proyecto.objects.filter(fk_user=self.request.user.id, activo=True)
        except:
            proyectos = None
        context = super(ProyectoRegisterView, self).get_context_data(**kwargs)
        context['userprofile'] = perfil
        context['proyectos'] = proyectos
        return context

    def forms_valid(self, forms, **kwargs):
        """
        Valida el formulario del proyecto
        @return: Dirige con un mensaje de exito al registro de proyecto
        """
        nuevo_project = forms['proyecto'].save()
        objetivo_es = self.form_classes['obj_proy'](self.request.POST, instance=nuevo_project)
        if objetivo_es.is_valid():
            objetivo_es.save()
        nuevo_resp_tec = forms['resp_tec'].save(commit=False)
        nuevo_resp_gen = forms['resp_gere'].save(commit=False)
        nuevo_resp_tec.fk_proyecto = nuevo_project
        nuevo_resp_tec.save()
        nuevo_resp_gen.fk_proyecto = nuevo_project
        nuevo_resp_gen.save()
        model_proyecto = ContentType.objects.get_for_model(Proyecto).pk
        LogEntry.objects.log_action(
            user_id=self.request.user.id,
            content_type_id=model_proyecto,
            object_id=nuevo_project.pk,
            object_repr=str(nuevo_project.nombre),
            action_flag=ADDITION)
        messages.success(self.request, "El usaurio %s, ha creado con exito,\
                                        el proyecto %s" %
                         (str(self.request.user),
                          str(nuevo_project)))
        return redirect(self.success_url)

    def forms_invalid(self, forms, **kwargs):
        messages.error(self.request, "%s, %s, %s, %s" %
                       (str(forms['proyecto'].errors.as_data()),
                        str(forms['obj_proy'].errors.as_data()),
                        str(forms['resp_tec'].errors.as_data()),
                        str(forms['resp_gere'].errors.as_data())))
        return super(ProyectoRegisterView, self).forms_invalid(forms)


class ProyectoUpdate(UpdateView):
    """!
    Clase para editar o actualizar un proyecto

    @author Ing. Leonel P. Hernandez M. (lhernandez 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 09-01-2017
    @version 1.0.0
    """
    model = Proyecto
    success_url = reverse_lazy('projects:consultar_proyectos')
    fields = [
                'fk_alcance', 'fk_sector', 'codigo', 'nombre',
                'justificacion', 'objetivo_general',
                'objetivos_especificos', 'monto_proyecto', 'fecha_inicio',
                'fecha_culminacion'
             ]


class SubProjectsList(ListView):
    """!
    Clase para listar o consultar los subproyectos

    @author Ing. Leonel P. Hernandez M. (lhernandez 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 09-01-2017
    @version 1.0.0
    """
    model = SubProyecto

    def __init__(self):
        super(SubProjectsList, self).__init__()


class SubProyectoCreation(LoginRequeridoPerAuth, MultiModelFormView):
    """!
    Clase que crear los subproyectos

    @author Ing. Leonel P. Hernandez M. (lhernandez 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 09-01-2017
    @version 1.0.0
    """
    template_name = 'proyectos/subproyecto_form.html'
    model = SubProyecto
    success_url = reverse_lazy('projects:consultar_subproyectos')
    form_classes = {
      'subproyecto': FormularioSubProyecto,
      'fase': FormularioFaseSubPro,
      'meta': FormularioRespTec,
    }
    group_required = [u"Administradores", u"Usuarios Supervisores",
                      u"Usuarios Enlace"]
    record_id = None

    def __init__(self):
        super(SubProyectoCreation, self).__init__()

    def get_objects(self):
        self.record_id = self.kwargs.get('record_id', None)
        try:
            record = FaseSubproyecto.objects.get(fk_subproyecto=self.record_id)
        except FaseSubproyecto.DoesNotExist:
            record = None
        return {
          'subproyecto': record,
          'fase':  None,
          'meta': record.fk_subproyecto if record else None,
        }

    def get_context_data(self, **kwargs):
        """Use this to add extra context."""
        try:
            perfil = UserProfile.objects.select_related().get(fk_user=self.request.user.id)
        except:
            perfil = None
        try:
            proyectos = Proyecto.objects.filter(fk_user=self.request.user.id, activo=True)
        except:
            proyectos = None
        context = super(SubProyectoCreation, self).get_context_data(**kwargs)
        context['userprofile'] = perfil
        context['proyectos'] = proyectos
        return context




class SubProyectoUpdate(UpdateView):
    """!
    Clase que permite actualizar o editar los subproyectos

    @author Ing. Leonel P. Hernandez M. (lhernandez 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 09-01-2017
    @version 1.0.0
    """
    model = SubProyecto
    success_url = reverse_lazy('projects:consultar_subproyectos')
    fields = [
                'fk_proyecto', 'parroquia', 'codigo', 'nombre',
                'descripcion_bien_servicio', 'unidad_medida',
                'meta', 'fecha_inicio', 'fecha_culminacion', 'comunidad',
                'monto_subproyecto'
             ]


class ActividadList(ListView):
    """!
    Clase que permite listar o consular las actividades

    @author Ing. Leonel P. Hernandez M. (lhernandez 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 09-01-2017
    @version 1.0.0
    """
    model = Actividad

    def __init__(self):
        super(ActividadList, self).__init__()


class ActividadCreation(CreateView):
    """!
    Clase que permite crear las actividades

    @author Ing. Leonel P. Hernandez M. (lhernandez 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 09-01-2017
    @version 1.0.0
    """
    model = Actividad
    success_url = reverse_lazy('projects:consultar_actividades')
    fields = [
                'fk_subproyecto', 'descripcion', 'unidad_medida', 'fecha_inicio',
                'fecha_culminacion', 'horas_estimadas_ejecucion',
                'costo_estimadao_ejecucion', 'peso_actividad',
                'cantidad_estimada_trabajo'
             ]


class ActividadUpdate(UpdateView):
    """!
    Clase que permite actualizar o editar las actividades

    @author Ing. Leonel P. Hernandez M. (lhernandez 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 09-01-2017
    @version 1.0.0
    """
    success_url = reverse_lazy('projects:consultar_actividades')
    fields = [
                'fk_subproyecto', 'descripcion', 'unidad_medida', 'fecha_inicio',
                'fecha_culminacion', 'horas_estimadas_ejecucion',
                'costo_estimadao_ejecucion', 'peso_actividad',
                'cantidad_estimada_trabajo'
             ]


class TablerSubProyectos(LoginRequeridoPerAuth, FormView):
    """!
    Clase que permite controlar el formulario para los subproyectos

    @author Ing. Leonel P. Hernandez M. (lhernandez 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 28-09-2017
    @version 1.0.0
    """
    template_name = 'proyectos/tablero_subproyecto_form.html'
    form_class = FormularioSubProyecto
    group_required = [u"Administradores", u"Usuarios Supervisores",
                      u"Usuarios Enlace"]
    success_url = None
    record_id = None

    def __init__(self):
        super(TablerSubProyectos, self).__init__()

    def get_context_data(self, **kwargs):
        """Use this to add extra context."""
        proyecto = self.kwargs.get('pk', None)
        context = super(TablerSubProyectos, self).get_context_data(**kwargs)
        try:
            perfil = UserProfile.objects.select_related().get(fk_user=self.request.user.id)
        except:
            perfil = None
        try:
            proyectos = Proyecto.objects.get(pk=proyecto, activo=True)
        except:
            proyectos = None

        sub_proyecto_list = SubProyecto.objects.filter(fk_proyecto=proyecto)

        paginator = Paginator(sub_proyecto_list, 6) # Show 3 sub proyectos per page

        page = self.request.GET.get('page')
        try:
            sub = paginator.page(page)
        except PageNotAnInteger:
            # If page is not an integer, deliver first page.
            sub = paginator.page(1)
        except EmptyPage:
            # If page is out of range (e.g. 9999), deliver last page of results.
            sub = paginator.page(paginator.num_pages)
        rango = range(0, sub.paginator.num_pages)
        context['userprofile'] = perfil
        context['proyectos'] = proyectos
        context['subproyectos'] = sub
        fases_list = []
        for subs in sub:
            fases_list += FaseSubproyecto.objects.select_related().filter(fk_subproyecto=subs.pk),
        metas_list = []
        for fase in fases_list:
            for fas in fase:
                metas_list += MetaFaseSubproyecto.objects.select_related().filter(fk_fase=fas.pk),
        context['fases'] = fases_list
        context['metas'] = metas_list
        context['rango'] = rango
        return context

    def form_valid(self, form, **kwargs):
        """
        Valida el formulario de subproyecto
        @return: Dirige con un mensaje de exito al registro de proyecto
        """
        proyecto = self.kwargs.get('pk', None)
        try:
            proyectos = Proyecto.objects.get(pk=proyecto, activo=True)
        except:
            proyectos = None
        form.instance.fk_proyecto = proyectos
        nuevo_subproyecto = form.save()
        self.success_url = reverse_lazy('projects:crear_subproyectos_tablero', kwargs = {'pk' : proyecto, })
        context = {}
        context['subproyecto'] = {'id':str(nuevo_subproyecto.pk),
                                  'nombre': str(nuevo_subproyecto),
                                  }
        return HttpResponse(json.dumps(context), content_type="application/json")

    def form_invalid(self, form, **kwargs):
        return super(TablerSubProyectos, self).form_invalid(form)


class TablerFaseProyectos(LoginRequeridoPerAuth, FormView):
    """!
    Clase que permite controlar el formulario para las fases

    @author Ing. Leonel P. Hernandez M. (lhernandez 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 28-09-2017
    @version 1.0.0
    """
    template_name = 'proyectos/tablero_fases_sub.html'
    form_class = FormularioFaseSubPro
    group_required = [u"Administradores", u"Usuarios Supervisores",
                      u"Usuarios Enlace"]
    success_url = None
    record_id = None

    def __init__(self):
        super(TablerFaseProyectos, self).__init__()

    def get_context_data(self, **kwargs):
        """Use this to add extra context."""
        proyecto = self.kwargs.get('pk', None)
        sub_proyecto = self.kwargs.get('pk_sub', None)
        try:
            perfil = UserProfile.objects.select_related().get(fk_user=self.request.user.id)
            proyectos = Proyecto.objects.get(pk=proyecto, activo=True)
            sub_proyectos = SubProyecto.objects.get(pk=sub_proyecto, activo=True)
        except:
            proyectos = None
            perfil = None
            sub_proyectos = None
        context = super(TablerFaseProyectos, self).get_context_data(**kwargs)
        context['userprofile'] = perfil
        context['proyectos'] = proyectos
        context['sub_proy'] = sub_proyectos
        return context

    def form_valid(self, form, **kwargs):
        """
        Valida el formulario del proyecto
        @return: Dirige con un mensaje de exito al registro de proyecto
        """
        proyecto = self.kwargs.get('pk', None)
        sub_proyecto = self.kwargs.get('pk_sub', None)
        try:
            proyectos = Proyecto.objects.get(pk=proyecto, activo=True)
            sub_proyectos = SubProyecto.objects.get(pk=sub_proyecto, activo=True)
        except:
            proyectos = None
            sub_proyectos = None
        form.instance.fk_subproyecto = sub_proyectos
        nueva_fase = form.save(commit=True)
        self.success_url = reverse_lazy('projects:crear_subproyectos_tablero', kwargs = {'pk' : proyecto, })
        context = {}
        context['fase'] = {'id':str(nueva_fase.pk),
                                  'nombre': str(nueva_fase),
                                  }
        return HttpResponse(json.dumps(context), content_type="application/json")

    def form_invalid(self, form, **kwargs):
        return super(TablerFaseProyectos, self).form_invalid(form)


class TableMetaFasesView(LoginRequeridoPerAuth, FormView):
    """!
    Clase que permite controlar el formulario para las metas

    @author Ing. Leonel P. Hernandez M. (lhernandez 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 28-09-2017
    @version 1.0.0
    """
    template_name = 'proyectos/tablero_metas_fas.html'
    form_class = FormularioMetaFases
    group_required = [u"Administradores", u"Usuarios Supervisores",
                      u"Usuarios Enlace"]
    success_url = None
    record_id = None

    def __init__(self):
        super(TableMetaFasesView, self).__init__()

    def get_context_data(self, **kwargs):
        """Use this to add extra context."""
        proyecto = self.kwargs.get('pk', None)
        sub_proyecto = self.kwargs.get('pk_sub', None)
        fase = self.kwargs.get('pk_fase', None)
        try:
            perfil = UserProfile.objects.select_related().get(fk_user=self.request.user.id)
            proyectos = Proyecto.objects.get(pk=proyecto, activo=True)
            sub_proyectos = SubProyecto.objects.get(pk=sub_proyecto, activo=True)
            fases = FaseSubproyecto.objects.get(pk=fase)
        except:
            proyectos = None
            perfil = None
            sub_proyectos = None
            fases = None
        context = super(TableMetaFasesView, self).get_context_data(**kwargs)
        context['userprofile'] = perfil
        context['proyectos'] = proyectos
        context['sub_proy'] = sub_proyectos
        context['fases'] = fases
        return context

    def form_valid(self, form, **kwargs):
        """
        Valida el formulario del proyecto
        @return: Dirige con un mensaje de exito al registro de proyecto
        """
        proyecto = self.kwargs.get('pk', None)
        sub_proyecto = self.kwargs.get('pk_sub', None)
        fase = self.kwargs.get('pk_fase', None)
        try:
            perfil = UserProfile.objects.select_related().get(fk_user=self.request.user.id)
            proyectos = Proyecto.objects.get(pk=proyecto, activo=True)
            sub_proyectos = SubProyecto.objects.get(pk=sub_proyecto, activo=True)
            fases = FaseSubproyecto.objects.get(pk=fase)
        except:
            proyectos = None
            perfil = None
            sub_proyectos = None
            fases = None
        form.instance.fk_fase = fases
        nueva_meta = form.save(commit=True)
        self.success_url = reverse_lazy('projects:crear_subproyectos_tablero', kwargs = {'pk' : proyecto, })
        context = {}
        context['meta'] = {'id':str(nueva_meta.pk),
                            'nombre': str(nueva_meta),
                                  }
        return HttpResponse(json.dumps(context), content_type="application/json")

    def form_invalid(self, form, **kwargs):
        return super(TableMetaFasesView, self).form_invalid(form)



class AjaxRecivCreateSubPro(LoginRequeridoPerAuth, FormView):
    template_name = "proyectos/ajax_tablero.html"
    form_class = FormularioSubProyecto
    success_url = reverse_lazy('projects:ajax_crear_subproyectos_tablero')
    group_required = [u"Administradores", u"Usuarios Supervisores",
                      u"Usuarios Enlace"]

    def form_valid(self, form, **kwargs):
        """Use this to add extra context."""
        super(AjaxRecivCreateSubPro, self).form_valid(form, **kwargs)


class RecursoFisicoRegisterView(LoginRequeridoPerAuth, MultiModelFormView):
    """!
    Clase para registrar recursos fisicos seccion trabajador y capacitacion

    @author Ing. Leonel P. Hernandez M. (lhernandez 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 09-01-2017
    @version 1.0.0
    """
    template_name = 'proyectos/recursos_fisicos_form.html'
    form_classes = {
      'trabajadores': FormularioRecurFisTra,
      'capacitacion': FormsetCaptacion,
    }
    record_id=None
    group_required = [u"Administradores", u"Usuarios Supervisores",
                      u"Usuarios Enlace"]

    def get_objects(self):
        self.record_id = self.kwargs.get('record_id', None)
        try:
            record = RecursoFisicoCapacitacion.objects.get(fk_recurso_fisico_trabajador=self.record_id)
        except RecursoFisicoCapacitacion.DoesNotExist:
            record = None
        return {
          'capacitacion': record,
          'trabajadores': record.fk_recurso_fisico_trabajador if record else None,
        }

    def forms_valid(self, forms, **kwargs):
        """
        Valida el formulario de recursos fisicos trabajadore y capacitación
        @return: Dirige con un mensaje de exito al registro de proyecto
        """
        sub_proyecto = self.kwargs.get('pk', None)
        try:
            sub_proye_obj = SubProyecto.objects.get(pk=sub_proyecto, activo=True)
        except:
            sub_proye_obj = None
            messages.erro(self.request, "Esta intentando guardar un recurso \
                                         Fisico que no posee relacion con \
                                         algun subproyecto")
            success_url = reverse_lazy('projects:gestion_proyectos')
            return redirect(success_url)
        success_url = reverse_lazy('projects:subproyectos_recursos_fisicos',
                                   kwargs={'pk': sub_proye_obj.fk_proyecto.pk})
        nuevo_trabajadores = forms['trabajadores'].save(commit=False)
        nuevo_trabajadores.fk_subproyecto = sub_proye_obj
        nuevo_trabajadores.save()
        capacitaciones = self.form_classes['capacitacion'](self.request.POST, instance=nuevo_trabajadores)
        if capacitaciones.is_valid():
            capacitaciones.save()
            model_capacitacion = ContentType.objects.get_for_model(RecursoFisicoCapacitacion).pk
            LogEntry.objects.log_action(
                user_id=self.request.user.id,
                content_type_id=model_capacitacion,
                object_id=capacitaciones,
                object_repr=str(capacitaciones),
                action_flag=ADDITION)
        cantidad_empleo_dir_ind = nuevo_trabajadores.empleos_directos + nuevo_trabajadores.empleos_indirectos
        model_trabajdores = ContentType.objects.get_for_model(RecursoFisicoTrabajadores).pk
        LogEntry.objects.log_action(
            user_id=self.request.user.id,
            content_type_id=model_trabajdores,
            object_id=nuevo_trabajadores.pk,
            object_repr=str(cantidad_empleo_dir_ind),
            action_flag=ADDITION)
        messages.success(self.request, "El usaurio %s, ha creado con exito,\
                                        el recurso Fisico para el subproyecto \
                                        %s" %
                         (str(self.request.user),
                          str(sub_proye_obj)))
        return redirect(success_url)


class RecursoFinanIngreRegisterView(LoginRequeridoPerAuth, MultiModelFormView):
    """!
    Clase para registrar recursos financieros seccion ingresos

    @author Ing. Leonel P. Hernandez M. (lhernandez 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 09-01-2017
    @version 1.0.0
    """
    template_name = 'proyectos/recursos_financieros_ingresos_form.html'
    model = Proyecto
    form_classes = {
      'ingresos': FormularioRecurFinIngre,
      'tablero': FormsetTablaIngreso,
      'inversion': FormularioRecurFinInv,
    }
    success_url = reverse_lazy('projects:crear_subproyectos_tablero')
    group_required = [u"Administradores", u"Usuarios Supervisores",
                      u"Usuarios Enlace"]

    def get_context_data(self, **kwargs):
        """Use this to add extra context."""
        sub_proyecto = self.kwargs.get('pk', None)
        try:
            sub_proyectos = SubProyecto.objects.get(pk=sub_proyecto, activo=True)
        except:
            sub_proyectos = None
        context = super(RecursoFinanIngreRegisterView, self).get_context_data(**kwargs)
        context['sub_proy'] = sub_proyectos
        return context

    def forms_valid(self, forms, **kwargs):
        """
        Valida el formulario de recursos financieros ingresos e inversión
        @return: Dirige con un mensaje de exito al registro de proyecto
        """
        sub_proyecto = self.kwargs.get('pk', None)
        try:
            sub_proyectos = SubProyecto.objects.get(pk=sub_proyecto, activo=True)
        except:
            sub_proyectos = None
        nuevo_ingreso = forms['ingresos'].save(commit=False)
        nuevo_ingreso.fk_subproyecto = sub_proyectos
        nuevo_ingreso.save()
        model_ingreso = ContentType.objects.get_for_model(RecursoFinancieroIngreso).pk
        LogEntry.objects.log_action(
            user_id=self.request.user.id,
            content_type_id=model_ingreso,
            object_id=nuevo_ingreso.pk,
            object_repr=str(nuevo_ingreso.organismo),
            action_flag=ADDITION)
        nuevo_tablero = self.form_classes['tablero'](self.request.POST, instance=nuevo_ingreso)
        if nuevo_tablero.is_valid():
            nuevo_tablero.save()
            model_tablero = ContentType.objects.get_for_model(TablaIngreso).pk
            LogEntry.objects.log_action(
                user_id=self.request.user.id,
                content_type_id=model_tablero,
                object_id=nuevo_tablero,
                object_repr=str(nuevo_tablero),
                action_flag=ADDITION)
        nueva_inversion = forms['inversion'].save(commit=False)
        nueva_inversion.fk_subproyecto = sub_proyectos
        nueva_inversion.save()
        model_inversion = ContentType.objects.get_for_model(RecursoFinancieroInversion).pk
        LogEntry.objects.log_action(
            user_id=self.request.user.id,
            content_type_id=model_inversion,
            object_id=nueva_inversion.pk,
            object_repr=str(nueva_inversion.nombre),
            action_flag=ADDITION)
        messages.success(self.request, "El usaurio %s, ha creado con exito,\
                                        el recurso Financiero para el subproyecto \
                                        %s" %
                         (str(self.request.user),
                          str(sub_proyectos)))
        success_url = reverse_lazy('projects:subproyectos_recursos_financieros',
                                   kwargs={'pk': sub_proyecto})
        return redirect(success_url)

    def forms_invalid(self, forms, **kwargs):
        messages.error(self.request, "%s, %s, %s" %
                       (str(forms['ingresos'].errors),
                        str(forms['tablero'].errors),
                        str(forms['inversion'].errors)))
        return super(RecursoFinanIngreRegisterView, self).forms_invalid(forms)


class FinanciamientoInversionAddView(LoginRequeridoPerAuth, FormView):
    form_class = FormularioRecurFinIngre
    group_required = [u"Administradores", u"Usuarios Supervisores",
                      u"Usuarios Enlace"]

    def post(self, request, **kwargs):
        context = {}
        sub_proyecto = self.kwargs.get('pk', None)
        pk_sub = SubProyecto.objects.get(pk=sub_proyecto)
        add_inversion = self.form_class(request.POST, instance=pk_sub)
        if add_inversion.is_valid():
            fuente = str(add_inversion.cleaned_data['fk_financiemiento'])
            organismo = str(add_inversion.cleaned_data['organismo'])
            regularidad = str(add_inversion.cleaned_data['fk_regularidad'])
            items = add_inversion.cleaned_data['num_desembolsos']
            record = {'fuente': fuente, 'organismo': organismo,
                      'items': items, 'regularidad': regularidad}
            context['data'] = {'mensaje': "Se lleno el tablero con %s numeros de desembolsos" % (items), 'validado': True,
                               'record': record}

            add_inversion.fk_subproyecto = pk_sub.pk

            form_tablero = FormsetTablaIngreso()
            form_tablero.extra = items-1
            context['formset_tablero'] = str(form_tablero)
        else:
            context['data'] = {'mensaje': "Existe un error en el formulario de ingreso %s" % str(add_inversion.errors.as_data()), 'validado': False}
        return HttpResponse(json.dumps(context),
                            content_type="application/json")