/// <summary>
        /// Método que permite insertar 
        /// un nuevo registro en la tabla componentePaquete
        /// </summary>
        /// <param name="poComponentePaquete">ComponentePaquete a insertar</param>
        /// <returns>Int valor del resultado de la ejecución de la sentencia</returns>
        public static int insertComponentePaquete(cls_componentePaquete po_componentePaquete)
        {
            int vi_resultado;

            try
            {
                String vs_comando = "PA_cont_componente_paqueteInsert";
                cls_parameter[] vu_parametros =
                {
                    new cls_parameter("@paramPK_paquete", po_componentePaquete.pPaquete.pPK_Paquete),
                    new cls_parameter("@paramPK_componente", po_componentePaquete.pComponente.pPK_componente),
                    new cls_parameter("@paramPK_entregable", po_componentePaquete.pEntregable.pPK_entregable),
                    new cls_parameter("@paramPK_proyecto", po_componentePaquete.pProyecto.pPK_proyecto)
                };

                cls_sqlDatabase.beginTransaction();

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

                cls_interface.insertarTransacccionBitacora(cls_constantes.INSERTAR, cls_constantes.COMPONENTE_PAQUETE, po_componentePaquete.pProyecto.pPK_proyecto + "/" + po_componentePaquete.pEntregable.pPK_entregable + "/" + po_componentePaquete.pComponente.pPK_componente + "/" + po_componentePaquete.pPaquete.pPK_Paquete, po_componentePaquete.pUsuarioTransaccion);

                cls_sqlDatabase.commitTransaction();

                return vi_resultado;

            }
            catch (Exception po_exception)
            {
                cls_sqlDatabase.rollbackTransaction();
                throw new Exception("Ocurrió un error al insertar el componente del paquete.", po_exception);
            }
        }
        /// <summary>
        /// Constructor de la clase cls_entregable_componente.
        /// </summary>
        public cls_entregableComponente()
        {
            this.proyecto = new cls_proyecto();
            this.entregable = new cls_entregable();
            this.componente = new cls_componente();
            this.componentePaquete = new cls_componentePaquete();

            this.componenteList = new List<cls_componente>();
            this.componentePaqueteList = new List<cls_componentePaquete>();
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="poProyecto"></param>
        /// <returns></returns>
        public static DataSet selectComponentePaquete(cls_componentePaquete po_componentePaquete)
        {
            try
               {
               String vs_comando = "PA_cont_componentePaqueteSelect";
               cls_parameter[] vu_parametros = { new cls_parameter("@paramPK_proyecto", po_componentePaquete.pProyecto.pPK_proyecto),
                                                 new cls_parameter("@paramPK_componente", po_componentePaquete.pComponente.pPK_componente) };

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

               return vu_dataSet;
               }
               catch (Exception po_exception)
               {
               throw new Exception("Ocurrió un error al obtener el listado de los paquetes asociados a los componentes.", po_exception);
               }
        }
        /// <summary>
        /// Evento encargado de eliminar un paquete asociado a un componente específico
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void btn_removerPaquete_Click(object sender, EventArgs e)
        {
            int compSeleccionado;
            //Se obtiene el componente al que se le removerá el paquete
            compSeleccionado = Convert.ToInt32(lbx_componentesasociados.SelectedValue.ToString());

            cls_componente vo_componente = new cls_componente();
            vo_componente.pPK_componente = compSeleccionado;

            try
            {
                //Se recorre la lista de paquetes asociados
                for (int i = lbx_paqasociados.Items.Count - 1; i >= 0; i--)
                {
                    if (lbx_paqasociados.Items[i].Selected == true)
                    {
                        cls_paquete vo_paquete = new cls_paquete();
                        vo_paquete.pPK_Paquete = Convert.ToInt32(lbx_paqasociados.Items[i].Value.ToString());
                        vo_paquete.pNombre = lbx_paqasociados.Items[i].Text;

                        cls_componentePaquete vo_componentePaquete = new cls_componentePaquete();

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

                        //Se recorre la lista
                        foreach (cls_entregableComponente entComp in cls_variablesSistema.vs_proyecto.pEntregableComponenteListaMemoria)
                        {

                            if (cls_variablesSistema.vs_proyecto.pComponentePaqueteListaMemoria.Where(searchLinQ => searchLinQ.pPK_Entregable == entComp.pPK_Entregable &&
                                                                                                                    searchLinQ.pPK_Componente == vo_componente.pPK_componente &&
                                                                                                                    searchLinQ.pPK_Paquete == vo_paquete.pPK_Paquete).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_paqueteActividad paqAct in cls_variablesSistema.vs_proyecto.pPaqueteActividadListaMemoria)
                                {
                                    if (paqAct.pPK_Paquete == vo_paquete.pPK_Paquete)
                                    {
                                        cls_variablesSistema.vs_proyecto.pActividadLista.RemoveAll(searchLinQ => searchLinQ.pPK_Actividad == paqAct.pPK_Actividad);
                                    }
                                }

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

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

                        lbx_paquetes.Items.Add(lbx_paqasociados.Items[i]);
                        ListItem li = lbx_paqasociados.Items[i];
                        lbx_paqasociados.Items.Remove(li);

                    }
                }

                //Si luego de la eliminación no se encuentran elementos en las listas, se deshabilita el botón de continuar
                if (lbx_paqasociados.Items.Count == 0 && cls_variablesSistema.vs_proyecto.pComponentePaqueteListaMemoria.Count == 0 && cls_variablesSistema.vs_proyecto.pComponentePaqueteListaBaseDatos.Count == 0)
                {
                    btnNxt.Enabled = false;
                }
                else
                {
                    btnNxt.Enabled = true;
                }
            }
            catch (Exception po_exception)
            {
                String vs_error_usuario = "Ocurrió un error al remover el paquete del proyecto.";
                this.lanzarExcepcion(po_exception, vs_error_usuario);
            }
        }
        /// <summary>
        /// Evento que se encarga de asigar un paquete a un componente específico
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void btn_asignarPaquete_Click(object sender, EventArgs e)
        {
            int compSeleccionado;
            //Se obtiene el componente al que se le va a agregar el paquete seleccionado
            compSeleccionado = Convert.ToInt32(lbx_componentesasociados.SelectedValue.ToString());

            try
            {
                cls_componente vo_componente = new cls_componente();
                vo_componente.pPK_componente = compSeleccionado;

                //Se recorre la lista de paquetes hasta encontrar el que se va a asignar
                for (int i = lbx_paquetes.Items.Count - 1; i >= 0; i--)
                {
                    if (lbx_paquetes.Items[i].Selected == true)
                    {
                        cls_paquete vo_paquete = new cls_paquete();
                        vo_paquete.pPK_Paquete = Convert.ToInt32(lbx_paquetes.Items[i].Value.ToString());
                        vo_paquete.pNombre = lbx_paquetes.Items[i].Text;

                        cls_componentePaquete vo_componentePaquete = new cls_componentePaquete();

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

                        //Se recorre la lista de entregables-componentes en memoria
                        foreach (cls_entregableComponente entComp in cls_variablesSistema.vs_proyecto.pEntregableComponenteListaMemoria)
                        {
                            //Si el componente es el mismo que se va a asignar
                            if (entComp.pPK_Componente == vo_componente.pPK_componente)
                            {
                                if (cls_variablesSistema.vs_proyecto.pComponentePaqueteListaMemoria.Where(searchLinQ => searchLinQ.pPK_Entregable == entComp.pPK_Entregable &&
                                                                                                                        searchLinQ.pPK_Componente == vo_componente.pPK_componente &&
                                                                                                                        searchLinQ.pPK_Paquete == vo_paquete.pPK_Paquete).Count() == 0)
                                {
                                    //Se agrega el entregable al que pertenece el componentePaquete, puesto que se necesita al guardar el registro
                                    vo_componentePaquete.pEntregable = entComp.pEntregable;

                                    cls_variablesSistema.vs_proyecto.pPaqueteLista.Add(vo_paquete);
                                    cls_variablesSistema.vs_proyecto.pComponentePaqueteListaMemoria.Add(vo_componentePaquete);
                                }
                            }
                        }

                        lbx_paqasociados.Items.Add(lbx_paquetes.Items[i]);
                        ListItem li = lbx_paquetes.Items[i];
                        lbx_paquetes.Items.Remove(li);

                    }
                }

                //Si aún queda al menos un elemento, se habilita el botón de siguiente
                if (lbx_paqasociados.Items.Count > 0)
                {
                    btnNxt.Enabled = true;
                }
            }
            catch (Exception po_exception)
            {
                String vs_error_usuario = "Ocurrió un error al asignar el paquete al proyecto.";
                this.lanzarExcepcion(po_exception, vs_error_usuario);
            }
        }
        /// <summary>
        /// Método que obtiene los paquetes asociados al componente que se envía como parámetro
        /// </summary>
        /// <param name="po_componente"></param>
        private void inicializarPaquetesPorComponente(cls_componente po_componente)
        {
            try
            {
                cls_componentePaquete vo_componentePaquete = new cls_componentePaquete();

                vo_componentePaquete.pProyecto = cls_variablesSistema.vs_proyecto;
                vo_componentePaquete.pComponente = po_componente;

                cargarPaquetesPorComponente(vo_componentePaquete);

                cargarListaPaquetes();
            }
            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 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 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 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 obtiene los paquetes asociados al componente que se envía como parámetro
        /// </summary>
        /// <param name="po_componente"></param>
        private void inicializarPaquetesPorComponente(cls_componente po_componente)
        {
            try
            {
                cls_componentePaquete vo_componentePaquete = new cls_componentePaquete();

                vo_componentePaquete.pProyecto = ((CSLA.web.App_Variables.cls_variablesSistema)this.Session[CSLA.web.App_Constantes.cls_constantes.VARIABLES]).vs_proyecto;
                vo_componentePaquete.pComponente = po_componente;

                cargarPaquetesPorComponente(vo_componentePaquete);

                cargarListaPaquetes();
            }
            catch (Exception po_exception)
            {
                throw new Exception("Ocurrió un error al obtener los paquetes asociados al proyecto.", po_exception);
            }
        }