/// <summary>
        /// Método que permite eliminar 
        /// un registro en la tabla entregable
        /// </summary>
        /// <param name="poEntregable">Estado a eliminar</param>
        /// <returns>Int valor del resultado de la ejecución de la sentencia</returns>
        public static int deleteEntregable(cls_entregable poEntregable)
        {
            int vi_resultado;

            try
            {
                String vs_comando = "PA_cont_entregableDelete";
                cls_parameter[] vu_parametros =
                {
                 		new cls_parameter("@paramPK_entregable", poEntregable.pPK_entregable)
                };

                cls_sqlDatabase.beginTransaction();

                vi_resultado = cls_sqlDatabase.executeNonQuery(vs_comando, true, vu_parametros);

                cls_interface.insertarTransacccionBitacora(cls_constantes.ELIMINAR, cls_constantes.ENTREGABLE, poEntregable.pPK_entregable.ToString(), poEntregable.pUsuarioTransaccion);

                cls_sqlDatabase.commitTransaction();

                return vi_resultado;

            }
            catch (Exception po_exception)
            {
                cls_sqlDatabase.rollbackTransaction();
                throw new Exception("Ocurrió un error al eliminar el entregable.", po_exception);
            }
        }
        /// <summary>
        /// Método que permite insertar 
        /// un nuevo registro en la tabla entregable
        /// </summary>
        /// <param name="poEntregable">Estado a insertar</param>
        /// <returns>Int valor del resultado de la ejecución de la sentencia</returns>
        public static int insertEntregable(cls_entregable poEntregable)
        {
            int vi_resultado;

            try
            {
                String vs_comando = "PA_cont_entregableInsert";
                cls_parameter[] vu_parametros =
                {
                    new cls_parameter("@paramcodigo", poEntregable.pCodigo),
                    new cls_parameter("@paramnombre", poEntregable.pNombre),
                    new cls_parameter("@paramdescripcion", poEntregable.pDescripcion)
                };

                cls_sqlDatabase.beginTransaction();

                vi_resultado = cls_sqlDatabase.executeNonQuery(vs_comando, true, vu_parametros);

                // Se obtiene el número del registro insertado.
                poEntregable.pPK_entregable = Convert.ToInt32(cls_gestorUtil.selectMax(cls_constantes.ENTREGABLE, "PK_entregable"));

                cls_interface.insertarTransacccionBitacora(cls_constantes.INSERTAR, cls_constantes.ENTREGABLE, poEntregable.pPK_entregable.ToString(),poEntregable.pUsuarioTransaccion);

                cls_sqlDatabase.commitTransaction();

                return vi_resultado;

            }
            catch (Exception po_exception)
            {
                cls_sqlDatabase.rollbackTransaction();
                throw new Exception("Ocurrió un error al insertar el entregable.", po_exception);
            }
        }
        /// <summary>
        /// Constructor de la clase cls_proyecto_entregable.
        /// </summary>
        public cls_proyectoEntregable()
        {
            this.entregable = new cls_entregable();
            this.proyecto = new cls_proyecto();
            this.entregableComponente = new cls_entregableComponente();

            this.entregableList = new List<cls_entregable>();
            this.entregableComponenteList = new List<cls_entregableComponente>();
        }
        /// <summary>
        /// Constructor de la clase cls_paqueteActividad.
        /// </summary>
        public cls_paqueteActividad()
        {
            this.proyecto = new cls_proyecto();
            this.entregable = new cls_entregable();
            this.componente = new cls_componente();
            this.paquete = new cls_paquete();
            this.actividad = new cls_actividad();

            this.actividadList = new List<cls_actividad>();
        }
        /// <summary>
        /// Método que filtra los paquetes del componente seleccionado
        /// </summary>
        /// <param name="po_componentePaquete"></param>
        private void cargarPaquetesPorComponente(cls_componentePaquete po_componentePaquete)
        {
            DataSet vo_dataSet = new DataSet();

            try
            {
                //Si la lista de memoria se encuentra vacía, se realiza la consulta en base de datos
                if (cls_variablesSistema.vs_proyecto.pComponentePaqueteListaMemoria.Count == 0)
                {
                    vo_dataSet = cls_gestorComponentePaquete.selectComponentePaquete(cls_variablesSistema.vs_proyecto);

                    foreach (DataRow row in vo_dataSet.Tables[0].Rows)
                    {

                        cls_entregable vo_entregable = new cls_entregable();
                        cls_componente vo_componente = new cls_componente();
                        cls_paquete vo_paquete = new cls_paquete();
                        cls_componentePaquete vo_componentePaquete = new cls_componentePaquete();

                        vo_entregable.pPK_entregable = Convert.ToInt32(row["PK_entregable"]);
                        vo_componente.pPK_componente = Convert.ToInt32(row["PK_componente"]);
                        vo_paquete.pPK_Paquete = Convert.ToInt32(row["PK_paquete"]);
                        vo_paquete.pNombre = Convert.ToString(row["nombre"]);

                        vo_componentePaquete.pEntregable = vo_entregable;
                        vo_componentePaquete.pComponente = vo_componente;
                        vo_componentePaquete.pPaquete = vo_paquete;

                        //Si el elemento no se encuentra en la lista de memoria que mantiene los elementos que se obtienen de base de datos, se agrega
                        if (cls_variablesSistema.vs_proyecto.pComponentePaqueteListaBaseDatos.Where(searchLinQ => searchLinQ.pPK_Paquete == vo_componentePaquete.pPK_Paquete).Count() == 0)
                        {
                            cls_variablesSistema.vs_proyecto.pComponentePaqueteListaBaseDatos.Add(vo_componentePaquete);
                        }
                        //Si el elemento no se encuentra asignado a la lista de memoria, se agrega
                        if (cls_variablesSistema.vs_proyecto.pEntregableComponenteListaMemoria.Where(searchLinQ => searchLinQ.pPK_Componente == vo_componentePaquete.pPK_Componente).Count() > 0)
                        {
                            if (cls_variablesSistema.vs_proyecto.pComponentePaqueteListaMemoria.Where(searchLinQ => searchLinQ.pPK_Paquete == vo_componentePaquete.pPK_Paquete).Count() == 0)
                            {
                                cls_variablesSistema.vs_proyecto.pPaqueteLista.Add(vo_paquete);
                                cls_variablesSistema.vs_proyecto.pComponentePaqueteListaMemoria.Add(vo_componentePaquete);
                            }
                        }
                    }

                }

                //Se respetan los paquetes que hayan sido asignados en memoria
                if (cls_variablesSistema.vs_proyecto.pComponentePaqueteListaMemoria.Where(searchLinQ => searchLinQ.pPK_Componente == po_componentePaquete.pPK_Componente).Count() > 0)
                {
                    lbx_paqasociados.DataSource = cls_variablesSistema.vs_proyecto.pComponentePaqueteListaMemoria.Where(searchLinQ => searchLinQ.pPK_Componente == po_componentePaquete.pPK_Componente);
                    lbx_paqasociados.DataTextField = "pNombrePaquete";
                    lbx_paqasociados.DataValueField = "pPK_Paquete";

                    //Se realiza el Binding luego de saber de donde se tomarán los datos
                    lbx_paqasociados.DataBind();

                    if (lbx_paqasociados.Items.Count > 0)
                    {
                        //Si se leyeron datos asociados, se activa el botón de siguiente
                        btnNxt.Enabled = true;
                    }
                }
                //Si el elemento no se encuentra en memoria, se realiza la consulta en base de datos
                else
                {
                    vo_dataSet = cls_gestorComponentePaquete.selectComponentePaquete(po_componentePaquete);
                    lbx_paqasociados.DataSource = vo_dataSet;
                    lbx_paqasociados.DataTextField = "Nombre";
                    lbx_paqasociados.DataValueField = "PK_Paquete";

                    //Se realiza el Binding luego de saber de donde se tomarán los datos
                    lbx_paqasociados.DataBind();

                    if (lbx_paqasociados.Items.Count > 0)
                    {
                        ListBox lbx_pivot = new ListBox();

                        lbx_pivot.DataSource = vo_dataSet;
                        lbx_pivot.DataTextField = "Nombre";
                        lbx_pivot.DataValueField = "PK_Paquete";
                        lbx_pivot.DataBind();

                        foreach (ListItem item in lbx_pivot.Items)
                        {
                            if (cls_variablesSistema.vs_proyecto.pComponentePaqueteListaMemoria.Where(searchLinQ => searchLinQ.pPK_Entregable == po_componentePaquete.pPK_Entregable &&
                                                                                                              searchLinQ.pPK_Componente == po_componentePaquete.pPK_Componente &&
                                                                                                              searchLinQ.pPK_Paquete == Convert.ToInt32(item.Value)).Count() == 0)
                            {
                                lbx_paqasociados.Items.Remove(item);
                            }
                        }

                        //Si se leyeron datos asociados, se activa el botón de siguiente
                        btnNxt.Enabled = true;
                    }
                }

            }
            catch (Exception po_exception)
            {
                throw new Exception("Ocurrió un error al cargar los paquetes asociados al proyecto.", po_exception);
            }
        }
        /// <summary>
        /// Método para obtener los componentes que se encuentran asociados a un entregable específico
        /// </summary>
        private void cargarComponentesPorEntregable()
        {
            DataSet vo_dataSet = new DataSet();
            int cantidadCompAsociados;
            int cantidadComponentes;
            bool validacionMemoria = false;

            try
            {
                //Se limpia el listbox con los componentes asociados
                if (lbx_compasociados.Items.Count > 0)
                {
                    cantidadCompAsociados = lbx_compasociados.Items.Count;

                    for (int i = 0; i < cantidadCompAsociados; i++ )
                    {
                        lbx_compasociados.Items.RemoveAt(0);
                    }
                }
                //Se limpia el listbox que mantiene la totalidad de los componentes
                if (lbx_componentes.Items.Count > 0)
                {
                    cantidadComponentes = lbx_componentes.Items.Count;

                    for (int i = 0; i < cantidadComponentes; i++)
                    {
                        lbx_componentes.Items.RemoveAt(0);
                    }
                }

                //Se realiza la consulta para obtener todos los componentes asociados a un entregable del proyecto seleccionado
                vo_dataSet = cls_gestorEntregableComponente.selectEntregableComponente(cls_variablesSistema.vs_proyecto);

                foreach (DataRow row in vo_dataSet.Tables[0].Rows)
                {

                    cls_entregable vo_entregable = new cls_entregable();
                    cls_componente vo_componente = new cls_componente();
                    cls_entregableComponente vo_entregableComponente = new cls_entregableComponente();

                    vo_entregable.pPK_entregable = Convert.ToInt32(row["PK_entregable"]);
                    vo_componente.pPK_componente = Convert.ToInt32(row["PK_componente"]);
                    vo_componente.pNombre = Convert.ToString(row["nombre"]);

                    vo_entregableComponente.pEntregable = vo_entregable;
                    vo_entregableComponente.pComponente = vo_componente;

                    //Si no se encuentra el elemento en la lista de memoria que mantiene los objetos de base de datos, se agrega
                    if (cls_variablesSistema.vs_proyecto.pEntregableComponenteListaBaseDatos.Where(searchLinQ => searchLinQ.pPK_Componente == vo_entregableComponente.pPK_Componente).Count() == 0)
                    {
                        cls_variablesSistema.vs_proyecto.pEntregableComponenteListaBaseDatos.Add(vo_entregableComponente);
                    }
                    //Si no se encuentra el elemento en la lista de memoria que se está creando, se agrega
                    if (cls_variablesSistema.vs_proyecto.pProyectoEntregableListaMemoria.Where(searchLinQ => searchLinQ.pPK_Entregable == vo_entregableComponente.pPK_Entregable).Count() > 0)
                    {
                        validacionMemoria = true;

                        if (cls_variablesSistema.vs_proyecto.pEntregableComponenteListaMemoria.Where(searchLinQ => searchLinQ.pPK_Componente == vo_entregableComponente.pPK_Componente).Count() == 0)
                        {
                            cls_variablesSistema.vs_proyecto.pComponenteLista.Add(vo_componente);
                            cls_variablesSistema.vs_proyecto.pEntregableComponenteListaMemoria.Add(vo_entregableComponente);
                        }
                    }
                }
                //Si la validación es True, se encontró al menos un elemento nuevo en la lista, por lo que se puede proseguir
                if (validacionMemoria)
                {
                    if (lbx_compasociados.Items.Count == 0 && btnNxt != null && cls_variablesSistema.vs_proyecto.pEntregableComponenteListaBaseDatos.Count == 0)
                    {
                        btnNxt.Enabled = false;
                    }
                    else
                    {
                        btnNxt.Enabled = true;
                    }
                }
                else
                {
                    btnNxt.Enabled = false;
                }

            }
            catch (Exception po_exception)
            {
                throw new Exception("Ocurrió un error al cargar los entregables asociados al proyecto.", po_exception);
            }
        }
        /// <summary>
        /// Se cargan los entregables que están asociados al proyecto, ya sea por Base de Datos o por memoria
        /// </summary>
        private void cargarEntregablesPorProyecto()
        {
            DataSet vo_dataSet = new DataSet();

            try
            {
                if(cls_variablesSistema.vs_proyecto.pProyectoEntregableListaMemoria.Count > 0)
                {
                    //Si la variable en memoria SI posee algún valor, se va a efectuar una "Actualizacion" al proyecto
                    cls_variablesSistema.tipoEstado = cls_constantes.EDITAR;

                    lbx_entasociados.DataSource = cls_variablesSistema.vs_proyecto.pProyectoEntregableListaMemoria;
                    lbx_entasociados.DataTextField = "pNombreEntregable";
                    lbx_entasociados.DataValueField = "pPK_Entregable";
                }
                else
                {

                    vo_dataSet = cls_gestorProyectoEntregable.selectProyectoEntregable(cls_variablesSistema.vs_proyecto);

                    if (vo_dataSet.Tables[0].Rows.Count > 0)
                    {
                        //Si la variable en memoria SI posee algún valor, se va a efectuar una "Actualizacion" al proyecto
                        cls_variablesSistema.tipoEstado = cls_constantes.EDITAR;
                    }
                    else
                    {
                        //Si la variable en memoria NO posee algún valor, se va a efectuar una "Insercion" de proyecto
                        cls_variablesSistema.tipoEstado = cls_constantes.AGREGAR;
                    }

                    //Se recorren los entregables pertenecientes a un proyecto y se asignan en el listbox para los asociados
                    foreach (DataRow row in vo_dataSet.Tables[0].Rows)
                    {

                        cls_entregable vo_entregable = new cls_entregable();
                        cls_proyectoEntregable vo_proyectoEntregable = new cls_proyectoEntregable();

                        vo_entregable.pPK_entregable = Convert.ToInt32(row["PK_entregable"]);
                        vo_entregable.pNombre = Convert.ToString(row["nombre"]);

                        vo_proyectoEntregable.pEntregable = vo_entregable;

                        cls_variablesSistema.vs_proyecto.pEntregableLista.Add(vo_entregable);
                        cls_variablesSistema.vs_proyecto.pProyectoEntregableListaMemoria.Add(vo_proyectoEntregable);
                        cls_variablesSistema.vs_proyecto.pProyectoEntregableListaBaseDatos.Add(vo_proyectoEntregable);
                    }

                    lbx_entasociados.DataSource = vo_dataSet;
                    lbx_entasociados.DataTextField = "nombre";
                    lbx_entasociados.DataValueField = "PK_entregable";
                }

                lbx_entasociados.DataBind();

                //Se elimina los entregables ya asociados de la totalidad, para evitar duplicidad en los datos por asignar
                if (lbx_entasociados.Items.Count > 0)
                {
                    foreach (ListItem item in lbx_entasociados.Items)
                    {
                        lbx_entregables.Items.Remove(item);
                    }
                }

            }
            catch (Exception po_exception)
            {
                throw new Exception("Ocurrió un error al cargar los entregables asociados al proyecto.", po_exception);
            }
        }
        /// <summary>
        /// Evento que maneja el cambio de índice sobre el dropdownlist de entregables
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void lbx_entregables_SelectedIndexChanged(object sender, EventArgs e)
        {
            try
            {
                int entregableSeleccionado;
                entregableSeleccionado = Convert.ToInt32(lbx_entregablesasociados.SelectedValue.ToString());

                cls_entregable vo_entregable = new cls_entregable();
                vo_entregable.pPK_entregable = entregableSeleccionado;

                inicializarComponentesPorEntregable(vo_entregable);
            }
            catch (Exception po_exception)
            {
                String vs_error_usuario = "Ocurrió un error al intentar obtener la información del entregable.";
                this.lanzarExcepcion(po_exception, vs_error_usuario);
            }
        }
        /// <summary>
        /// Método que permite seleccionar  
        /// un único registro en la tabla entregable
        /// </summary>
        /// <returns>poEntregable valor del resultado de la ejecución de la sentencia</returns>
        public static cls_entregable seleccionarEntregable(cls_entregable poEntregable)
        {
            try
               {
               String vs_comando = "PA_cont_entregableSelectOne";
               cls_parameter[] vu_parametros = {
                                                   new cls_parameter("@paramPK_entregable", poEntregable.pPK_entregable)
                                               };

               DataSet vu_dataSet = cls_sqlDatabase.executeDataset(vs_comando, true, vu_parametros);

               poEntregable = new cls_entregable();

               poEntregable.pPK_entregable = Convert.ToInt32(vu_dataSet.Tables[0].Rows[0]["PK_entregable"]);

               poEntregable.pCodigo = vu_dataSet.Tables[0].Rows[0]["codigo"].ToString();

               poEntregable.pNombre = vu_dataSet.Tables[0].Rows[0]["nombre"].ToString();

               poEntregable.pDescripcion = vu_dataSet.Tables[0].Rows[0]["descripcion"].ToString();

               return poEntregable;

               }
               catch (Exception po_exception)
               {
               throw new Exception("Ocurrió un error al obtener el entregable específico.", po_exception);
               }
        }
        /// <summary>
        /// Método que obtiene los componentes asociados al entregable que se le indica
        /// </summary>
        /// <param name="po_entregable"></param>
        private void inicializarComponentesPorEntregable(cls_entregable po_entregable)
        {
            try
            {
                cls_entregableComponente vo_entregableComponente = new cls_entregableComponente();

                vo_entregableComponente.pProyecto = cls_variablesSistema.vs_proyecto;
                vo_entregableComponente.pEntregable = po_entregable;

                cargarComponentesPorEntregable(vo_entregableComponente);

                cargarListaComponentes();
            }
            catch (Exception po_exception)
            {
                throw new Exception("Ocurrió un error al los componentes asociados a proyecto.", po_exception);
            }
        }
        /// <summary>
        /// Evento que se encarga de remover componentes pertenecientes a un entregable específico
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void btn_removerComponente_Click(object sender, EventArgs e)
        {
            int entSeleccionado;
            //Se escoge el entregable sobre el que realizara la desasignación
            entSeleccionado = Convert.ToInt32(lbx_entregablesasociados.SelectedValue.ToString());

            cls_entregable vo_entregable = new cls_entregable();
            vo_entregable.pPK_entregable = entSeleccionado;

            try
            {
                //Se recorren los componentes ya asociados
                for (int i = lbx_compasociados.Items.Count - 1; i >= 0; i--)
                {
                    if (lbx_compasociados.Items[i].Selected == true)
                    {
                        cls_componente vo_componente = new cls_componente();
                        vo_componente.pPK_componente = Convert.ToInt32(lbx_compasociados.Items[i].Value.ToString());
                        vo_componente.pNombre = lbx_compasociados.Items[i].Text;

                        cls_entregableComponente vo_entregableComponente = new cls_entregableComponente();

                        vo_entregableComponente.pEntregable = vo_entregable;
                        vo_entregableComponente.pComponente = vo_componente;

                        //Se realiza un barrido de las asignaciones posteriores que tuviese el elemento a nivel de memoria, de los subniveles siguientes
                        if (cls_variablesSistema.vs_proyecto.pEntregableComponenteListaMemoria.Where(searchLinQ => searchLinQ.pPK_Entregable == vo_entregable.pPK_entregable &&
                                                                                                                   searchLinQ.pPK_Componente == vo_componente.pPK_componente).Count() > 0)
                            {
                                //Se realiza una eliminación de todas las posibles referencias que se presenten a nivel de memoria para el entregable que se está eliminando
                                foreach (cls_componentePaquete compPaq in cls_variablesSistema.vs_proyecto.pComponentePaqueteListaMemoria)
                                {
                                    if (compPaq.pPK_Componente == vo_componente.pPK_componente)
                                    {
                                        foreach (cls_paqueteActividad paqAct in cls_variablesSistema.vs_proyecto.pPaqueteActividadListaMemoria)
                                        {
                                            if (paqAct.pPK_Componente == compPaq.pPK_Componente)
                                            {
                                                cls_variablesSistema.vs_proyecto.pActividadLista.RemoveAll(searchLinQ => searchLinQ.pPK_Actividad == paqAct.pPK_Actividad);
                                            }
                                        }

                                        cls_variablesSistema.vs_proyecto.pPaqueteActividadListaMemoria.RemoveAll(searchLinQ => searchLinQ.pPK_Paquete == compPaq.pPK_Paquete);

                                        cls_variablesSistema.vs_proyecto.pPaqueteLista.RemoveAll(searchLinQ => searchLinQ.pPK_Paquete == compPaq.pPK_Paquete);
                                    }
                                }
                                cls_variablesSistema.vs_proyecto.pComponentePaqueteListaMemoria.RemoveAll(searchLinQ => searchLinQ.pPK_Componente == vo_componente.pPK_componente);

                                cls_variablesSistema.vs_proyecto.pComponenteLista.RemoveAll(searchLinQ => searchLinQ.pPK_componente == vo_componente.pPK_componente);
                                cls_variablesSistema.vs_proyecto.pEntregableComponenteListaMemoria.RemoveAll(searchLinQ => searchLinQ.pPK_Componente == vo_componente.pPK_componente);
                            }

                        lbx_componentes.Items.Add(lbx_compasociados.Items[i]);
                        ListItem li = lbx_compasociados.Items[i];
                        lbx_compasociados.Items.Remove(li);

                    }
                }

                //Luego del barrido, si no quedó ningún elemento asociado, no se habilita el botón de siguiente
                if (lbx_compasociados.Items.Count == 0 && cls_variablesSistema.vs_proyecto.pEntregableComponenteListaMemoria.Count == 0 && cls_variablesSistema.vs_proyecto.pEntregableComponenteListaBaseDatos.Count == 0)
                {
                    btnNxt.Enabled = false;
                }
                else
                {
                    btnNxt.Enabled = true;
                }
            }
            catch (Exception po_exception)
            {
                String vs_error_usuario = "Ocurrió un error al intentar remover el componente seleccionado.";
                this.lanzarExcepcion(po_exception, vs_error_usuario);
            }
        }
        /// <summary>
        /// Método que elimina un entregable
        /// </summary>
        /// <param name="po_entregable">Permiso a eliminar</param>
        private void eliminarDatos(cls_entregable po_entregable)
        {
            try
            {
                cls_gestorEntregable.deleteEntregable(po_entregable);

                this.llenarGridView();

                this.upd_Principal.Update();
            }
            catch (Exception po_exception)
            {
                throw new Exception("Ocurrió un error al tratar de eliminar el entregable.", po_exception);
            }
        }
        /// <summary>
        /// Método que obtiene los entregables asociados al entregable seleccionado
        /// </summary>
        /// <param name="po_entregableComponente"></param>
        private void cargarComponentesPorEntregable(cls_entregableComponente po_entregableComponente)
        {
            DataSet vo_dataSet = new DataSet();

            try
            {
                //Si la lista de memoria se encuentra vacía, se realiza la consulta a nivel de base de datos
                if (((CSLA.web.App_Variables.cls_variablesSistema)this.Session[CSLA.web.App_Constantes.cls_constantes.VARIABLES]).vs_proyecto.pEntregableComponenteListaMemoria.Count == 0)
                {
                    vo_dataSet = cls_gestorEntregableComponente.selectEntregableComponente(((CSLA.web.App_Variables.cls_variablesSistema)this.Session[CSLA.web.App_Constantes.cls_constantes.VARIABLES]).vs_proyecto);

                    //Se recorren los registros obtenidos en la consulta
                    foreach (DataRow row in vo_dataSet.Tables[0].Rows)
                    {

                        cls_entregable vo_entregable = new cls_entregable();
                        cls_componente vo_componente = new cls_componente();
                        cls_entregableComponente vo_entregableComponente = new cls_entregableComponente();

                        vo_entregable.pPK_entregable = Convert.ToInt32(row["PK_entregable"]);
                        vo_componente.pPK_componente = Convert.ToInt32(row["PK_componente"]);
                        vo_componente.pNombre = Convert.ToString(row["nombre"]);

                        vo_entregableComponente.pEntregable = vo_entregable;
                        vo_entregableComponente.pComponente = vo_componente;

                        //Si el objeto no se encuentra en memoria, se agrega
                        if (((CSLA.web.App_Variables.cls_variablesSistema)this.Session[CSLA.web.App_Constantes.cls_constantes.VARIABLES]).vs_proyecto.pEntregableComponenteListaBaseDatos.Where(searchLinQ => searchLinQ.pPK_Componente == vo_entregableComponente.pPK_Componente).Count() == 0)
                        {
                            ((CSLA.web.App_Variables.cls_variablesSistema)this.Session[CSLA.web.App_Constantes.cls_constantes.VARIABLES]).vs_proyecto.pEntregableComponenteListaBaseDatos.Add(vo_entregableComponente);
                        }
                        //Si el objeto no se encuentra en memoria, se agrega
                        if (((CSLA.web.App_Variables.cls_variablesSistema)this.Session[CSLA.web.App_Constantes.cls_constantes.VARIABLES]).vs_proyecto.pProyectoEntregableListaMemoria.Where(searchLinQ => searchLinQ.pPK_Entregable == vo_entregableComponente.pPK_Entregable).Count() > 0)
                        {
                            if (((CSLA.web.App_Variables.cls_variablesSistema)this.Session[CSLA.web.App_Constantes.cls_constantes.VARIABLES]).vs_proyecto.pEntregableComponenteListaMemoria.Where(searchLinQ => searchLinQ.pPK_Componente == vo_entregableComponente.pPK_Componente).Count() == 0)
                            {
                                ((CSLA.web.App_Variables.cls_variablesSistema)this.Session[CSLA.web.App_Constantes.cls_constantes.VARIABLES]).vs_proyecto.pComponenteLista.Add(vo_componente);
                                ((CSLA.web.App_Variables.cls_variablesSistema)this.Session[CSLA.web.App_Constantes.cls_constantes.VARIABLES]).vs_proyecto.pEntregableComponenteListaMemoria.Add(vo_entregableComponente);
                            }
                        }
                    }

                }

                //Si el objeto está asociado en memoria se utiliza
                if (((CSLA.web.App_Variables.cls_variablesSistema)this.Session[CSLA.web.App_Constantes.cls_constantes.VARIABLES]).vs_proyecto.pEntregableComponenteListaMemoria.Where(searchLinQ => searchLinQ.pPK_Entregable == po_entregableComponente.pPK_Entregable).Count() > 0)
                {
                    lbx_compasociados.DataSource = ((CSLA.web.App_Variables.cls_variablesSistema)this.Session[CSLA.web.App_Constantes.cls_constantes.VARIABLES]).vs_proyecto.pEntregableComponenteListaMemoria.Where(searchLinQ => searchLinQ.pPK_Entregable == po_entregableComponente.pPK_Entregable);
                    lbx_compasociados.DataTextField = "pNombreComponente";
                    lbx_compasociados.DataValueField = "pPK_Componente";

                    //Se realiza el Binding luego de saber de donde se tomarán los datos
                    lbx_compasociados.DataBind();

                    if (lbx_compasociados.Items.Count > 0)
                    {
                        //Si se leyeron datos asociados, se activa el botón de siguiente
                        btnNxt.Enabled = true;
                    }
                }
                //De lo contrario se consulta en base de datos para obtener, si existen, los registros asociados
                else
                {
                    vo_dataSet = cls_gestorEntregableComponente.selectEntregableComponente(po_entregableComponente);
                    lbx_compasociados.DataSource = vo_dataSet;
                    lbx_compasociados.DataTextField = "Nombre";
                    lbx_compasociados.DataValueField = "PK_Componente";

                    //Se realiza el Binding luego de saber de donde se tomarán los datos
                    lbx_compasociados.DataBind();

                    if (lbx_compasociados.Items.Count > 0)
                    {
                        ListBox lbx_pivot = new ListBox();

                        lbx_pivot.DataSource = vo_dataSet;
                        lbx_pivot.DataTextField = "Nombre";
                        lbx_pivot.DataValueField = "PK_Componente";
                        lbx_pivot.DataBind();

                        foreach (ListItem item in lbx_pivot.Items)
                        {
                            if (((CSLA.web.App_Variables.cls_variablesSistema)this.Session[CSLA.web.App_Constantes.cls_constantes.VARIABLES]).vs_proyecto.pEntregableComponenteListaMemoria.Where(searchLinQ => searchLinQ.pPK_Entregable == po_entregableComponente.pPK_Entregable &&
                                                                                                                       searchLinQ.pPK_Componente == Convert.ToInt32(item.Value)).Count() == 0)
                            {
                                lbx_compasociados.Items.Remove(item);
                            }
                        }

                        //Si se leyeron datos asociados, se activa el botón de siguiente
                        btnNxt.Enabled = true;
                    }
                }

            }
            catch (Exception po_exception)
            {
                throw new Exception("Ocurrió un error al cargar los entregables asociados al proyecto.", po_exception);
            }
        }
        /// <summary>
        /// Cuando se seleccionada un botón del grid.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void grd_listaEntregable_RowCommand(object sender, GridViewCommandEventArgs e)
        {
            try
            {
                int vi_indice = Convert.ToInt32(e.CommandArgument);

                GridViewRow vu_fila = this.grd_listaEntregable.Rows[vi_indice];

                cls_entregable vo_entregable = new cls_entregable();

                vo_entregable.pPK_entregable = Convert.ToInt32(vu_fila.Cells[0].Text.ToString());
                vo_entregable.pCodigo = vu_fila.Cells[1].Text.ToString();
                vo_entregable.pNombre = vu_fila.Cells[2].Text.ToString();
                vo_entregable.pDescripcion = vu_fila.Cells[3].Text.ToString();

                switch (e.CommandName.ToString())
                {
                    case cls_constantes.VER:
                        vo_entregable = cls_gestorEntregable.seleccionarEntregable(vo_entregable);

                        cls_variablesSistema.obj = vo_entregable;

                        cls_variablesSistema.tipoEstado = e.CommandName;

                        this.cargarObjeto();

                        this.ard_principal.SelectedIndex = 1;
                        break;

                    case cls_constantes.EDITAR:
                        vo_entregable = cls_gestorEntregable.seleccionarEntregable(vo_entregable);

                        cls_variablesSistema.obj = vo_entregable;

                        cls_variablesSistema.tipoEstado = e.CommandName;

                        this.cargarObjeto();

                        this.ard_principal.SelectedIndex = 1;
                        break;

                    case cls_constantes.ELIMINAR:
                        this.eliminarDatos(vo_entregable);
                        break;

                    default:
                        break;
                }

            }
            catch (Exception po_exception)
            {
                String vs_error_usuario = "Ocurrió un error al intentar acceder a la información del registro seleccionado.";
                this.lanzarExcepcion(po_exception, vs_error_usuario);
            }
        }
        /// <summary>
        /// Crea un objeto de tipo
        /// cls_entregable con la informacón
        /// que se encuentra en el formulario
        /// web
        /// </summary>
        /// <returns>cls_entregable</returns>
        private cls_entregable crearObjeto()
        {
            cls_entregable vo_entregable = new cls_entregable();

            try
            {
                if (cls_variablesSistema.tipoEstado != cls_constantes.AGREGAR)
                {
                    vo_entregable = (cls_entregable)cls_variablesSistema.obj;
                }
                vo_entregable.pCodigo = txt_codigo.Text;
                vo_entregable.pNombre = txt_nombre.Text;
                vo_entregable.pDescripcion = txt_descripcion.Text;
                return vo_entregable;
            }
            catch (Exception po_exception)
            {
                throw new Exception("Ocurrió un error al crear el entregable para el registro.", po_exception);
            }
        }
        public void RemoverEntregableEncontrado(cls_entregable po_entregable)
        {
            //bool encontrado = false;

            pProyectoEntregableList.RemoveAll(po => po.pPK_Entregable == po_entregable.pPK_entregable);

            //return encontrado;
        }
        /// <summary>
        /// Método que permite listar 
        /// todos los registros en la tabla entregable
        /// </summary>
        /// <returns> List<cls_entregable>  valor del resultado de la ejecución de la sentencia</returns>
        public static List<cls_entregable> listarEntregable()
        {
            List<cls_entregable> vo_lista = null;
               cls_entregable poEntregable = null;
               try
               {
               String vs_comando = "PA_cont_entregableSelect";
               cls_parameter[] vu_parametros = { };

               DataSet vu_dataSet = cls_sqlDatabase.executeDataset(vs_comando, true, vu_parametros);

               vo_lista = new List<cls_entregable>();
               for (int i = 0; i < vu_dataSet.Tables[0].Rows.Count; i++)
               {
                   poEntregable = new cls_entregable();

                   poEntregable.pPK_entregable = Convert.ToInt32(vu_dataSet.Tables[0].Rows[i]["PK_entregable"]);

                   poEntregable.pCodigo = vu_dataSet.Tables[0].Rows[i]["codigo"].ToString();

                   poEntregable.pNombre = vu_dataSet.Tables[0].Rows[i]["nombre"].ToString();

                   poEntregable.pDescripcion = vu_dataSet.Tables[0].Rows[i]["descripcion"].ToString();

                   vo_lista.Add(poEntregable);
               }

               return vo_lista;
               }
               catch (Exception po_exception)
               {
               throw new Exception("Ocurrió un error al obtener el listado de los entregables.", po_exception);
               }
        }
        /// <summary>
        /// Método que permite actualizar 
        /// un registro en la tabla entregable
        /// </summary>
        /// <param name="poEntregable">Estado a actualizar</param>
        /// <returns>Int valor del resultado de la ejecución de la sentencia</returns>
        public static int updateEntregable(cls_entregable poEntregable)
        {
            int vi_resultado;

            try
            {
                String vs_comando = "PA_cont_entregableUpdate";
                cls_parameter[] vu_parametros =
                {
                 	new cls_parameter("@paramPK_entregable", poEntregable.pPK_entregable),
                    new cls_parameter("@paramcodigo", poEntregable.pCodigo),
                    new cls_parameter("@paramnombre", poEntregable.pNombre),
                    new cls_parameter("@paramdescripcion", poEntregable.pDescripcion)
                };

                cls_sqlDatabase.beginTransaction();

                vi_resultado = cls_sqlDatabase.executeNonQuery(vs_comando, true, vu_parametros);

                cls_interface.insertarTransacccionBitacora(cls_constantes.MODIFICAR, cls_constantes.ENTREGABLE, poEntregable.pPK_entregable.ToString(), poEntregable.pUsuarioTransaccion);

                cls_sqlDatabase.commitTransaction();

                return vi_resultado;

            }
            catch (Exception po_exception)
            {
                cls_sqlDatabase.rollbackTransaction();
                throw new Exception("Ocurrió un error al modificar el entregable.", po_exception);
            }
        }
        /// <summary>
        /// Método que obtiene los paquetes asociados a un componente en específico
        /// </summary>
        private void cargarPaquetesPorComponente()
        {
            DataSet vo_dataSet = new DataSet();
            int cantidadPaqAsociados;
            int cantidadPaquetes;
            bool validacionMemoria = false;

            try
            {
                //Se limpia el listbox de paquetes asociados
                if (lbx_paqasociados.Items.Count > 0)
                {
                    cantidadPaqAsociados = lbx_paqasociados.Items.Count;

                    for (int i = 0; i < cantidadPaqAsociados; i++ )
                    {
                        lbx_paqasociados.Items.RemoveAt(0);
                    }
                }
                //Se limpia el listbox de la totalidad de paquetes
                if (lbx_paquetes.Items.Count > 0)
                {
                    cantidadPaquetes = lbx_paquetes.Items.Count;

                    for (int i = 0; i < cantidadPaquetes; i++)
                    {
                        lbx_paquetes.Items.RemoveAt(0);
                    }
                }

                //Se aplica la consulta en base de datos para obtener todos los paquetes asociados a los componentes que se encuentran asignados en memoria para el proyecto
                vo_dataSet = cls_gestorComponentePaquete.selectComponentePaquete(cls_variablesSistema.vs_proyecto);

                foreach (DataRow row in vo_dataSet.Tables[0].Rows)
                {

                    cls_entregable vo_entregable = new cls_entregable();
                    cls_componente vo_componente = new cls_componente();
                    cls_paquete vo_paquete = new cls_paquete();
                    cls_componentePaquete vo_componentePaquete = new cls_componentePaquete();

                    vo_entregable.pPK_entregable = Convert.ToInt32(row["PK_entregable"]);
                    vo_componente.pPK_componente = Convert.ToInt32(row["PK_componente"]);
                    vo_paquete.pPK_Paquete = Convert.ToInt32(row["PK_paquete"]);
                    vo_paquete.pNombre = Convert.ToString(row["nombre"]);

                    vo_componentePaquete.pEntregable = vo_entregable;
                    vo_componentePaquete.pComponente = vo_componente;
                    vo_componentePaquete.pPaquete = vo_paquete;

                    //Si le elemento leído no se encuentra en la lista de base de datos, se agrega
                    if (cls_variablesSistema.vs_proyecto.pComponentePaqueteListaBaseDatos.Where(searchLinQ => searchLinQ.pPK_Paquete == vo_componentePaquete.pPK_Paquete).Count() == 0)
                    {
                        cls_variablesSistema.vs_proyecto.pComponentePaqueteListaBaseDatos.Add(vo_componentePaquete);
                    }
                    //Si el elemento leído no se encuentra en la lista de memoria, se agrega
                    if (cls_variablesSistema.vs_proyecto.pEntregableComponenteListaMemoria.Where(searchLinQ => searchLinQ.pPK_Componente == vo_componentePaquete.pPK_Componente).Count() == 1)
                    {
                        validacionMemoria = true;

                        cls_entregableComponente vo_entregableComponente = new cls_entregableComponente();
                        vo_entregableComponente = (cls_entregableComponente)cls_variablesSistema.vs_proyecto.pEntregableComponenteListaMemoria.Find(searchLinQ => searchLinQ.pPK_Componente == vo_componentePaquete.pPK_Componente);

                        if (vo_componentePaquete.pPK_Entregable == vo_entregableComponente.pPK_Entregable && vo_componentePaquete.pPK_Componente == vo_entregableComponente.pPK_Componente)
                        {
                            //Si el paquete no ha sido insertado en memoria, se agrega
                            if (cls_variablesSistema.vs_proyecto.pComponentePaqueteListaMemoria.Where(searchLinQ => searchLinQ.pPK_Paquete == vo_componentePaquete.pPK_Paquete).Count() == 0)
                            {
                                cls_variablesSistema.vs_proyecto.pPaqueteLista.Add(vo_paquete);
                                cls_variablesSistema.vs_proyecto.pComponentePaqueteListaMemoria.Add(vo_componentePaquete);
                            }
                        }

                    }
                }
                //Si la validación es True significa que se ha agregado al menos un elemento, por lo cuál el botón de siguiente puede habilitarse
                if (validacionMemoria)
                {
                    if (lbx_paqasociados.Items.Count == 0 && btnNxt != null && cls_variablesSistema.vs_proyecto.pComponentePaqueteListaBaseDatos.Count == 0)
                    {
                        btnNxt.Enabled = false;
                    }
                    else
                    {
                        btnNxt.Enabled = true;
                    }
                }
                else
                {
                    btnNxt.Enabled = false;
                }

            }
            catch (Exception po_exception)
            {
                throw new Exception("Ocurrió un error al obtener los paquetes asociados al proyecto.", po_exception);
            }
        }
        /// <summary>
        /// Método que obtiene los componentes asociados al entregable que se le indica
        /// </summary>
        /// <param name="po_entregable"></param>
        private void inicializarComponentesPorEntregable(cls_entregable po_entregable)
        {
            try
            {
                cls_entregableComponente vo_entregableComponente = new cls_entregableComponente();

                vo_entregableComponente.pProyecto = ((CSLA.web.App_Variables.cls_variablesSistema)this.Session[CSLA.web.App_Constantes.cls_constantes.VARIABLES]).vs_proyecto;
                vo_entregableComponente.pEntregable = po_entregable;

                cargarComponentesPorEntregable(vo_entregableComponente);

                cargarListaComponentes();
            }
            catch (Exception po_exception)
            {
                throw new Exception("Ocurrió un error al los componentes asociados a proyecto.", po_exception);
            }
        }
        /// <summary>
        /// Evento para la asigación de un nuevo componente para un entregable específico
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void btn_asignarComponente_Click(object sender, EventArgs e)
        {
            int entSeleccionado;
            //Se obtiene el entregable seleccionado
            entSeleccionado = Convert.ToInt32(lbx_entregablesasociados.SelectedValue.ToString());

            cls_entregable vo_entregable = new cls_entregable();
            vo_entregable.pPK_entregable = entSeleccionado;

            try
            {
                //Se recorre la lista de componentes para validar a quien es el que se va a asignar
                for (int i = lbx_componentes.Items.Count - 1; i >= 0; i--)
                {
                    if (lbx_componentes.Items[i].Selected == true)
                    {
                        cls_componente vo_componente = new cls_componente();
                        vo_componente.pPK_componente = Convert.ToInt32(lbx_componentes.Items[i].Value.ToString());
                        vo_componente.pNombre = lbx_componentes.Items[i].Text;

                        cls_entregableComponente vo_entregableComponente = new cls_entregableComponente();

                        vo_entregableComponente.pEntregable = vo_entregable;
                        vo_entregableComponente.pComponente = vo_componente;

                        //Se recorre la lista de los entregables asociados a proyecto en memoria
                        foreach (cls_proyectoEntregable proyEnt in cls_variablesSistema.vs_proyecto.pProyectoEntregableListaMemoria)
                        {
                            //Si los entregables coinciden, este es el que se va a asignar
                            if (proyEnt.pPK_Entregable == vo_entregable.pPK_entregable)
                            {
                                //Si en el siguiente nivel, en entregable-componente no se encuentra la asignación, se realiza para ese proyecto-entregable
                                if (cls_variablesSistema.vs_proyecto.pEntregableComponenteListaMemoria.Where(searchLinQ => searchLinQ.pPK_Entregable == vo_entregable.pPK_entregable &&
                                                                                                                     searchLinQ.pPK_Componente == vo_componente.pPK_componente).Count() == 0)
                                {
                                    cls_variablesSistema.vs_proyecto.pComponenteLista.Add(vo_componente);
                                    cls_variablesSistema.vs_proyecto.pEntregableComponenteListaMemoria.Add(vo_entregableComponente);
                                }
                            }
                        }

                        lbx_compasociados.Items.Add(lbx_componentes.Items[i]);
                        ListItem li = lbx_componentes.Items[i];
                        lbx_componentes.Items.Remove(li);

                    }
                }

                //Si existe al menos un elemento asociado, se puede continuar
                if (lbx_compasociados.Items.Count > 0)
                {
                    btnNxt.Enabled = true;
                }
            }
            catch (Exception po_exception)
            {
                String vs_error_usuario = "Ocurrió un error al intentar asignar el componente seleccionado.";
                this.lanzarExcepcion(po_exception, vs_error_usuario);
            }
        }
        public bool EntregableEncontrado(cls_entregable po_entregable)
        {
            bool encontrado = false;

            if(pProyectoEntregableList.Where(po => po.pPK_Entregable == po_entregable.pPK_entregable).Count() > 0)
            {
                encontrado = true;
            }

            return encontrado;
        }
        /// <summary>
        /// Evento para la asignación de los entregables a un proyecto específico
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void btn_asignarEntregable_Click(object sender, EventArgs e)
        {
            try
            {
                for (int i = lbx_entregables.Items.Count - 1; i >= 0; i--)
                {
                    if (lbx_entregables.Items[i].Selected == true)
                    {
                        cls_entregable vo_entregable = new cls_entregable();
                        vo_entregable.pPK_entregable = Convert.ToInt32(lbx_entregables.Items[i].Value.ToString());
                        vo_entregable.pNombre = lbx_entregables.Items[i].Text;

                        cls_proyectoEntregable vo_proyectoEntregable = new cls_proyectoEntregable();

                        vo_proyectoEntregable.pEntregable = vo_entregable;

                        //Si el registro no existe en memoria, se agrega
                        if (!(cls_variablesSistema.vs_proyecto.pProyectoEntregableListaMemoria.Where(searchLinQ => searchLinQ.pPK_Entregable == vo_entregable.pPK_entregable).Count() > 0))
                        {
                            cls_variablesSistema.vs_proyecto.pEntregableLista.Add(vo_entregable);
                            cls_variablesSistema.vs_proyecto.pProyectoEntregableListaMemoria.Add(vo_proyectoEntregable);
                        }

                        lbx_entasociados.Items.Add(lbx_entregables.Items[i]);
                        ListItem li = lbx_entregables.Items[i];
                        lbx_entregables.Items.Remove(li);
                    }
                }

                //Si hay entregables asociados, se habilita el botón de navegación de siguiente
                if (lbx_entasociados.Items.Count > 0)
                {
                    btnNxt.Enabled = true;
                }
            }
            catch (Exception po_exception)
            {
                String vs_error_usuario = "Ocurrió un error al intentar asignar el entregable al proyecto.";
                this.lanzarExcepcion(po_exception, vs_error_usuario);
            }
        }
        /// <summary>
        /// Método que carga las actividades para un paquete en específico
        /// </summary>
        /// <param name="po_paqueteActividad"></param>
        private void cargarActividadesPorPaquete(cls_paqueteActividad po_paqueteActividad)
        {
            DataSet vo_dataSet = new DataSet();

            try
            {
                //Si se encuentran elementos en la lista de memoria, se verifica en estos
                if (cls_variablesSistema.vs_proyecto.pPaqueteActividadListaMemoria.Count == 0)
                {
                    vo_dataSet = cls_gestorPaqueteActividad.selectPaqueteActividad(cls_variablesSistema.vs_proyecto);

                    foreach (DataRow row in vo_dataSet.Tables[0].Rows)
                    {

                        cls_entregable vo_entregable = new cls_entregable();
                        cls_componente vo_componente = new cls_componente();
                        cls_paquete vo_paquete = new cls_paquete();
                        cls_actividad vo_actividad = new cls_actividad();
                        cls_paqueteActividad vo_paqueteActividad = new cls_paqueteActividad();

                        vo_entregable.pPK_entregable = Convert.ToInt32(row["PK_entregable"]);
                        vo_componente.pPK_componente = Convert.ToInt32(row["PK_componente"]);
                        vo_paquete.pPK_Paquete = Convert.ToInt32(row["PK_paquete"]);
                        vo_actividad.pPK_Actividad = Convert.ToInt32(row["PK_actividad"]);
                        vo_actividad.pNombre = Convert.ToString(row["nombre"]);

                        vo_paqueteActividad.pEntregable = vo_entregable;
                        vo_paqueteActividad.pComponente = vo_componente;
                        vo_paqueteActividad.pPaquete = vo_paquete;
                        vo_paqueteActividad.pActividad = vo_actividad;

                        //Si en la lista de memoria que mantiene los objetos leídos a nivel de base de datos, no se encuentra el elemente, se agrega
                        if (cls_variablesSistema.vs_proyecto.pPaqueteActividadListaBaseDatos.Where(searchLinQ => searchLinQ.pPK_Actividad == vo_paqueteActividad.pPK_Actividad).Count() == 0)
                        {
                            cls_variablesSistema.vs_proyecto.pPaqueteActividadListaBaseDatos.Add(vo_paqueteActividad);
                        }
                        //Si en la lista de memoria no se encuentra el elemento, se agrega
                        if (cls_variablesSistema.vs_proyecto.pComponentePaqueteListaMemoria.Where(searchLinQ => searchLinQ.pPK_Entregable == vo_paqueteActividad.pPK_Entregable &&
                                                                                                                searchLinQ.pPK_Componente == vo_paqueteActividad.pPK_Componente &&
                                                                                                                searchLinQ.pPK_Paquete == vo_paqueteActividad.pPK_Paquete).Count() > 0)
                        {
                            cls_variablesSistema.vs_proyecto.pActividadLista.Add(vo_actividad);
                            cls_variablesSistema.vs_proyecto.pPaqueteActividadListaMemoria.Add(vo_paqueteActividad);
                        }
                    }

                }

                //Si el elemento se encuentra en la lista de memoria, se respeta para la asignación
                if (cls_variablesSistema.vs_proyecto.pPaqueteActividadListaMemoria.Where(searchLinQ => searchLinQ.pPK_Paquete == po_paqueteActividad.pPK_Paquete).Count() > 0)
                {
                    lbx_actasociadas.DataSource = cls_variablesSistema.vs_proyecto.pPaqueteActividadListaMemoria.Where(searchLinQ => searchLinQ.pPK_Paquete == po_paqueteActividad.pPK_Paquete);
                    lbx_actasociadas.DataTextField = "pNombreActividad";
                    lbx_actasociadas.DataValueField = "pPK_Actividad";

                    //Se realiza el Binding luego de saber de donde se tomarán los datos
                    lbx_actasociadas.DataBind();

                    if (lbx_actasociadas.Items.Count > 0)
                    {
                        //Si se leyeron datos asociados, se activa el botón de siguiente
                        btnNxt.Enabled = true;
                    }
                }
                else
                {
                    vo_dataSet = cls_gestorPaqueteActividad.selectPaqueteActividad(po_paqueteActividad);
                    lbx_actasociadas.DataSource = vo_dataSet;
                    lbx_actasociadas.DataTextField = "Nombre";
                    lbx_actasociadas.DataValueField = "PK_Actividad";

                    //Se realiza el Binding luego de saber de donde se tomarán los datos
                    lbx_actasociadas.DataBind();

                    //Si se encuentran elementos asociados
                    if (lbx_actasociadas.Items.Count > 0)
                    {
                        ListBox lbx_pivot = new ListBox();

                        lbx_pivot.DataSource = vo_dataSet;
                        lbx_pivot.DataTextField = "Nombre";
                        lbx_pivot.DataValueField = "PK_Actividad";
                        lbx_pivot.DataBind();

                        //Si la actividad ya se encuentra asociada, se elimina del listbox de asociación
                        foreach (ListItem item in lbx_pivot.Items)
                        {
                            if (cls_variablesSistema.vs_proyecto.pPaqueteActividadListaMemoria.Where(searchLinQ => searchLinQ.pPK_Entregable == po_paqueteActividad.pPK_Entregable &&
                                                                                                                   searchLinQ.pPK_Componente == po_paqueteActividad.pPK_Componente &&
                                                                                                                   searchLinQ.pPK_Paquete == po_paqueteActividad.pPK_Paquete &&
                                                                                                                   searchLinQ.pPK_Actividad == Convert.ToInt32(item.Value)).Count() == 0)
                            {
                                lbx_actasociadas.Items.Remove(item);
                            }
                        }
                    }

                    //Si se leyeron datos asociados, se activa el botón de siguiente
                    btnNxt.Enabled = true;
                }

            }
            catch (Exception po_exception)
            {
                throw new Exception("Ocurrió un error al cargar los actividades asociadas al proyecto.", po_exception);
            }
        }
        /// <summary>
        /// Evento para la eliminación de un entregable asignado a un proyecto
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void btn_removerEntregable_Click(object sender, EventArgs e)
        {
            try
            {
                for (int i = lbx_entasociados.Items.Count - 1; i >= 0; i--)
                {
                    if (lbx_entasociados.Items[i].Selected == true)
                    {

                        cls_entregable vo_entregable = new cls_entregable();
                        vo_entregable.pPK_entregable = Convert.ToInt32(lbx_entasociados.Items[i].Value.ToString());
                        vo_entregable.pNombre = lbx_entasociados.Items[i].Text;

                        cls_proyectoEntregable vo_proyectoEntregable = new cls_proyectoEntregable();

                        vo_proyectoEntregable.pEntregable = vo_entregable;

                        //Se realiza una eliminación de todas las posibles referencias que se presenten a nivel de memoria para el entregable que se está eliminando
                        foreach (cls_entregableComponente entComp in cls_variablesSistema.vs_proyecto.pEntregableComponenteListaMemoria)
                        {
                            if (entComp.pPK_Entregable == vo_entregable.pPK_entregable)
                            {
                                foreach (cls_componentePaquete compPaq in cls_variablesSistema.vs_proyecto.pComponentePaqueteListaMemoria)
                                {
                                    if (compPaq.pPK_Entregable == entComp.pPK_Entregable)
                                    {
                                        foreach (cls_paqueteActividad paqAct in cls_variablesSistema.vs_proyecto.pPaqueteActividadListaMemoria)
                                        {
                                            if (paqAct.pPK_Entregable == entComp.pPK_Entregable)
                                            {
                                                cls_variablesSistema.vs_proyecto.pActividadLista.RemoveAll(searchLinQ => searchLinQ.pPK_Actividad == paqAct.pPK_Actividad);
                                            }
                                        }

                                        cls_variablesSistema.vs_proyecto.pPaqueteActividadListaMemoria.RemoveAll(searchLinQ => searchLinQ.pPK_Paquete == compPaq.pPK_Paquete);

                                        cls_variablesSistema.vs_proyecto.pPaqueteLista.RemoveAll(searchLinQ => searchLinQ.pPK_Paquete == compPaq.pPK_Paquete);
                                    }
                                }

                                cls_variablesSistema.vs_proyecto.pComponentePaqueteListaMemoria.RemoveAll(searchLinQ => searchLinQ.pPK_Componente == entComp.pPK_Componente);

                                cls_variablesSistema.vs_proyecto.pComponenteLista.RemoveAll(searchLinQ => searchLinQ.pPK_componente == entComp.pPK_Componente);
                            }
                        }

                        cls_variablesSistema.vs_proyecto.pEntregableComponenteListaMemoria.RemoveAll(searchLinQ => searchLinQ.pPK_Entregable == vo_entregable.pPK_entregable);

                        cls_variablesSistema.vs_proyecto.pEntregableLista.RemoveAll(searchLinQ => searchLinQ.pPK_entregable == vo_entregable.pPK_entregable);
                        cls_variablesSistema.vs_proyecto.pProyectoEntregableListaMemoria.RemoveAll(searchLinQ => searchLinQ.pPK_Entregable == vo_entregable.pPK_entregable);

                        lbx_entregables.Items.Add(lbx_entasociados.Items[i]);
                        ListItem li = lbx_entasociados.Items[i];
                        lbx_entasociados.Items.Remove(li);
                    }
                }

                //Si luego de desasociar los entregables, si la lista queda vacía, no se puede proseguir hasta que no se realice al menos una asignación
                if (lbx_entasociados.Items.Count == 0 && cls_variablesSistema.vs_proyecto.pProyectoEntregableListaMemoria.Count == 0)
                {
                    btnNxt.Enabled = false;
                }
                else
                {
                    btnNxt.Enabled = true;
                }
            }
            catch (Exception po_exception)
            {
                String vs_error_usuario = "Ocurrió un error al intentar remover el entregable del proyecto.";
                this.lanzarExcepcion(po_exception, vs_error_usuario);
            }
        }
        /// <summary>
        /// Método que obtiene las actividades asociadas a un paquete específico
        /// </summary>
        private void cargarActividadesPorPaquete()
        {
            DataSet vo_dataSet = new DataSet();
            int cantidadActAsociadas;
            int cantidadActividades;
            bool validacionMemoria = false;

            try
            {
                //Se limpia el listbox que mantiene la asociación de actividades
                if (lbx_actasociadas.Items.Count > 0)
                {
                    cantidadActAsociadas = lbx_actasociadas.Items.Count;

                    for (int i = 0; i < cantidadActAsociadas; i++)
                    {
                        lbx_actasociadas.Items.RemoveAt(0);
                    }
                }
                //Se limpia el listbox que obtiene la totalidad de actividades
                if (lbx_actividades.Items.Count > 0)
                {
                    cantidadActividades = lbx_actividades.Items.Count;

                    for (int i = 0; i < cantidadActividades; i++)
                    {
                        lbx_actividades.Items.RemoveAt(0);
                    }
                }

                //Se realiza la consulta en base de datos para obtener las actividades asociadas a los paquetes del proyecto
                vo_dataSet = cls_gestorPaqueteActividad.selectPaqueteActividad(cls_variablesSistema.vs_proyecto);

                foreach (DataRow row in vo_dataSet.Tables[0].Rows)
                {

                    cls_entregable vo_entregable = new cls_entregable();
                    cls_componente vo_componente = new cls_componente();
                    cls_paquete vo_paquete = new cls_paquete();
                    cls_actividad vo_actividad = new cls_actividad();
                    cls_paqueteActividad vo_paqueteActividad = new cls_paqueteActividad();

                    vo_entregable.pPK_entregable = Convert.ToInt32(row["PK_entregable"]);
                    vo_componente.pPK_componente = Convert.ToInt32(row["PK_componente"]);
                    vo_paquete.pPK_Paquete = Convert.ToInt32(row["PK_paquete"]);
                    vo_actividad.pPK_Actividad = Convert.ToInt32(row["PK_actividad"]);
                    vo_actividad.pNombre = Convert.ToString(row["nombre"]);

                    vo_paqueteActividad.pEntregable = vo_entregable;
                    vo_paqueteActividad.pComponente = vo_componente;
                    vo_paqueteActividad.pPaquete = vo_paquete;
                    vo_paqueteActividad.pActividad = vo_actividad;

                    //El filtro aquí se realiza con el paquete y la actividad, esto debido a que una actividad si puede encontrarse ya asignada a varios paquetes
                    if (cls_variablesSistema.vs_proyecto.pPaqueteActividadListaBaseDatos.Where(searchLinQ => searchLinQ.pPK_Paquete == vo_paqueteActividad.pPK_Paquete &&
                                                                                                             searchLinQ.pPK_Actividad == vo_paqueteActividad.pPK_Actividad).Count() == 0)
                    {
                        cls_variablesSistema.vs_proyecto.pPaqueteActividadListaBaseDatos.Add(vo_paqueteActividad);
                    }
                    //Si el componente-paquete que se va a asignar ya existe en memoria
                    if (cls_variablesSistema.vs_proyecto.pComponentePaqueteListaMemoria.Where(searchLinQ => searchLinQ.pPK_Paquete == vo_paqueteActividad.pPK_Paquete).Count() == 1)
                    {
                        validacionMemoria = true;

                        cls_componentePaquete vo_componentePaquete = new cls_componentePaquete();
                        vo_componentePaquete = (cls_componentePaquete)cls_variablesSistema.vs_proyecto.pComponentePaqueteListaMemoria.Find(searchLinQ => searchLinQ.pPK_Paquete == vo_paqueteActividad.pPK_Paquete);

                        //Si se está asignando sobre uno que ya existe en memoria, se tiene que corroborar con toda la llave primaria
                        if (vo_paqueteActividad.pPK_Entregable == vo_componentePaquete.pPK_Entregable && vo_paqueteActividad.pPK_Componente == vo_componentePaquete.pPK_Componente && vo_paqueteActividad.pPK_Paquete == vo_componentePaquete.pPK_Paquete)
                        {
                            //Si la actividad no ha sido insertado en memoria, se agrega
                            if (cls_variablesSistema.vs_proyecto.pPaqueteActividadListaMemoria.Where(searchLinQ => searchLinQ.pPK_Paquete == vo_paqueteActividad.pPK_Paquete &&
                                                                                                                   searchLinQ.pPK_Actividad == vo_paqueteActividad.pPK_Actividad).Count() == 0)
                            {
                                cls_variablesSistema.vs_proyecto.pActividadLista.Add(vo_actividad);
                                cls_variablesSistema.vs_proyecto.pPaqueteActividadListaMemoria.Add(vo_paqueteActividad);
                            }
                        }

                    }
                }

                //Si la validación devuelve un True, se ha asignado almenos un elemento, por lo cual se puede habilitar el botón de siguiente
                if (validacionMemoria)
                {
                    if (lbx_actasociadas.Items.Count == 0 && btnNxt != null && cls_variablesSistema.vs_proyecto.pPaqueteActividadListaBaseDatos.Count == 0)
                    {
                        btnNxt.Enabled = false;
                    }
                    else
                    {
                        btnNxt.Enabled = true;
                    }
                }
                else
                {
                    btnNxt.Enabled = false;
                }

            }
            catch (Exception po_exception)
            {
                throw new Exception("Ocurrió un error al cargar los actividades asociadas al proyecto.", po_exception);
            }
        }
        /// <summary>
        /// Método que elimina un entregable
        /// </summary>
        /// <param name="po_entregable">Permiso a eliminar</param>
        private void eliminarDatos(cls_entregable po_entregable)
        {
            try
            {
                po_entregable.pUsuarioTransaccion = ((cls_usuario)Session["cls_usuario"]).pPK_usuario;

                cls_gestorEntregable.deleteEntregable(po_entregable);

                this.llenarGridView();

                this.upd_Principal.Update();
            }
            catch (Exception po_exception)
            {
                throw new Exception("Ocurrió un error al tratar de eliminar el entregable.", po_exception);
            }
        }
        /// <summary>
        /// Hace un lista de entregables con un filtrado específico.
        /// </summary>
        /// <param name="psFiltro">String filtro.</param>
        /// <returns></returns>
        public static List<cls_entregable> listarEntregableFiltro(string psFiltro)
        {
            List<cls_entregable> vo_lista = null;
               cls_entregable voPermiso = null;
               try
               {
               DataSet vu_dataSet = cls_gestorUtil.selectFilter(cls_constantes.ENTREGABLE, string.Empty, psFiltro);

               vo_lista = new List<cls_entregable>();

               for (int i = 0; i < vu_dataSet.Tables[0].Rows.Count; i++)
               {
                   voPermiso = new cls_entregable();

                   voPermiso.pPK_entregable = Convert.ToInt32(vu_dataSet.Tables[0].Rows[i]["PK_entregable"]);

                   voPermiso.pCodigo = vu_dataSet.Tables[0].Rows[i]["codigo"].ToString();

                   voPermiso.pNombre = vu_dataSet.Tables[0].Rows[i]["nombre"].ToString();

                   voPermiso.pDescripcion = vu_dataSet.Tables[0].Rows[i]["descripcion"].ToString();

                   vo_lista.Add(voPermiso);
               }

               return vo_lista;
               }
               catch (Exception po_exception)
               {
               throw new Exception("Ocurrió un error al obtener el listado de los entregables de manera filtrada.", po_exception);
               }
        }