/// <summary>
        /// Método que permite eliminar 
        /// un registro en la tabla componente
        /// </summary>
        /// <param name="poComponente">Componente a eliminar</param>
        /// <returns>Int valor del resultado de la ejecución de la sentencia</returns>
        public static int deleteComponente(cls_componente poComponente)
        {
            int vi_resultado;

            try
            {
                String vs_comando = "PA_cont_componenteDelete";
                cls_parameter[] vu_parametros =
                {
                 		new cls_parameter("@paramPK_componente", poComponente.pPK_componente)
                };

                cls_sqlDatabase.beginTransaction();

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

                cls_interface.insertarTransacccionBitacora(cls_constantes.ELIMINAR, cls_constantes.COMPONENTE, poComponente.pPK_componente.ToString());

                cls_sqlDatabase.commitTransaction();

                return vi_resultado;

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

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

                cls_sqlDatabase.beginTransaction();

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

                // Se obtiene el número del registro insertado.
                poComponente.pPK_componente = Convert.ToInt32(cls_gestorUtil.selectMax(cls_constantes.COMPONENTE, "PK_componente"));

                cls_interface.insertarTransacccionBitacora(cls_constantes.INSERTAR, cls_constantes.COMPONENTE, poComponente.pPK_componente.ToString());

                cls_sqlDatabase.commitTransaction();

                return vi_resultado;

            }
            catch (Exception po_exception)
            {
                cls_sqlDatabase.rollbackTransaction();
                throw new Exception("Ocurrió un error al insertar el componente.", po_exception);
            }
        }
        /// <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>
        /// 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>
        /// 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>
        /// 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 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 que valida el cambio del índice del listboz de componentes
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void lbx_componentes_SelectedIndexChanged(object sender, EventArgs e)
        {
            try
            {
                int componenteSeleccionado;
                componenteSeleccionado = Convert.ToInt32(lbx_componentesasociados.SelectedValue.ToString());

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

                //Se inicializan los paquetes asociados al componente específico
                inicializarPaquetesPorComponente(vo_componente);
            }
            catch (Exception po_exception)
            {
                String vs_error_usuario = "Ocurrió un error al seleccionar el entregable de proyecto.";
                this.lanzarExcepcion(po_exception, vs_error_usuario);
            }
        }
Пример #10
0
        /// <summary>
        /// Cuando se seleccionada un botón del grid.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void grd_listaComponente_RowCommand(object sender, GridViewCommandEventArgs e)
        {
            try
            {
                int vi_indice = Convert.ToInt32(e.CommandArgument);

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

                cls_componente vo_componente = new cls_componente();

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

                switch (e.CommandName.ToString())
                {
                    case cls_constantes.VER:
                        vo_componente = cls_gestorComponente.seleccionarComponente(vo_componente);

                        ((CSLA.web.App_Variables.cls_variablesSistema)this.Session[CSLA.web.App_Constantes.cls_constantes.VARIABLES]).obj = vo_componente;

                        ((CSLA.web.App_Variables.cls_variablesSistema)this.Session[CSLA.web.App_Constantes.cls_constantes.VARIABLES]).tipoEstado = e.CommandName;

                        this.cargarObjeto();

                        this.ard_principal.SelectedIndex = 1;
                        break;

                    case cls_constantes.EDITAR:
                        vo_componente = cls_gestorComponente.seleccionarComponente(vo_componente);

                        ((CSLA.web.App_Variables.cls_variablesSistema)this.Session[CSLA.web.App_Constantes.cls_constantes.VARIABLES]).obj = vo_componente;

                        ((CSLA.web.App_Variables.cls_variablesSistema)this.Session[CSLA.web.App_Constantes.cls_constantes.VARIABLES]).tipoEstado = e.CommandName;

                        this.cargarObjeto();

                        this.ard_principal.SelectedIndex = 1;
                        break;

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

                    default:
                        break;
                }

            }
            catch (Exception po_exception)
            {
                String vs_error_usuario = "Ocurrió un error al intentar acceder a la información del registro.";
                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>
        /// 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);
            }
        }
Пример #13
0
        /// <summary>
        /// Crea un objeto de tipo
        /// cls_componente con la informacón
        /// que se encuentra en el formulario
        /// web
        /// </summary>
        /// <returns>cls_componente</returns>
        private cls_componente crearObjeto()
        {
            try
            {
                cls_componente vo_componente = new cls_componente();
                if (((CSLA.web.App_Variables.cls_variablesSistema)this.Session[CSLA.web.App_Constantes.cls_constantes.VARIABLES]).tipoEstado != cls_constantes.AGREGAR)
                {
                    vo_componente = (cls_componente)((CSLA.web.App_Variables.cls_variablesSistema)this.Session[CSLA.web.App_Constantes.cls_constantes.VARIABLES]).obj;
                }

                vo_componente.pCodigo = txt_codigo.Text;
                vo_componente.pNombre = txt_nombre.Text;
                vo_componente.pDescripcion = txt_descripcion.Text;
                return vo_componente;
            }
            catch (Exception po_exception)
            {
                throw new Exception("Ocurrió un error al crear el registro de componente.", 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 permite actualizar 
        /// un registro en la tabla componente
        /// </summary>
        /// <param name="poComponente">Componente a actualizar</param>
        /// <returns>Int valor del resultado de la ejecución de la sentencia</returns>
        public static int updateComponente(cls_componente poComponente)
        {
            int vi_resultado;

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

                cls_sqlDatabase.beginTransaction();

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

                cls_interface.insertarTransacccionBitacora(cls_constantes.MODIFICAR, cls_constantes.COMPONENTE, poComponente.pPK_componente.ToString());

                cls_sqlDatabase.commitTransaction();

                return vi_resultado;

            }
            catch (Exception po_exception)
            {
                cls_sqlDatabase.rollbackTransaction();
                throw new Exception("Ocurrió un error al modificar el componente.", po_exception);
            }
        }
        /// <summary>
        /// Método que permite seleccionar  
        /// un único registro en la tabla componente
        /// </summary>
        /// <returns>poComponente valor del resultado de la ejecución de la sentencia</returns>
        public static cls_componente seleccionarComponente(cls_componente poComponente)
        {
            try
               {
               String vs_comando = "PA_cont_componenteSelectOne";
               cls_parameter[] vu_parametros = {
                                                   new cls_parameter("@paramPK_componente", poComponente.pPK_componente) };

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

               poComponente = new cls_componente();

               poComponente.pPK_componente = Convert.ToInt32(vu_dataSet.Tables[0].Rows[0]["PK_componente"]);

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

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

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

               return poComponente;

               }
               catch (Exception po_exception)
               {
               throw new Exception("Ocurrió un error al obtener el componente específico.", po_exception);
               }
        }
        /// <summary>
        /// Hace un lista de componente con un filtrado específico.
        /// </summary>
        /// <param name="psFiltro">String filtro.</param>
        /// <returns></returns>
        public static List<cls_componente> listarComponenteFiltro(string psFiltro)
        {
            List<cls_componente> vo_lista = null;
               cls_componente voComponente = null;
               try
               {
               DataSet vu_dataSet = cls_gestorUtil.selectFilter(cls_constantes.COMPONENTE, string.Empty, psFiltro);

               vo_lista = new List<cls_componente>();

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

                   voComponente.pPK_componente = Convert.ToInt32(vu_dataSet.Tables[0].Rows[0]["PK_componente"]);

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

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

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

                   vo_lista.Add(voComponente);
               }

               return vo_lista;
               }
               catch (Exception po_exception)
               {
               throw new Exception("Ocurrió un error al obtener el listado de los componentes de manera filtrada.", po_exception);
               }
        }
        /// <summary>
        /// Método que permite listar 
        /// todos los registros en la tabla componente
        /// </summary>
        /// <returns> List<cls_componente>  valor del resultado de la ejecución de la sentencia</returns>
        public static List<cls_componente> listarComponente()
        {
            List<cls_componente> vo_lista = null;
               cls_componente poComponente = null;
               try
               {
               String vs_comando = "PA_cont_componenteSelect";
               cls_parameter[] vu_parametros = { };

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

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

                   poComponente.pPK_componente = Convert.ToInt32(vu_dataSet.Tables[0].Rows[i]["PK_componente"]);

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

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

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

                   vo_lista.Add(poComponente);
               }

               return vo_lista;
               }
               catch (Exception po_exception)
               {
               throw new Exception("Ocurrió un error al obtener el listado de los componentes.", po_exception);
               }
        }
Пример #19
0
        /// <summary>
        /// Método que elimina un componente
        /// </summary>
        /// <param name="po_componente">Permiso a eliminar</param>
        private void eliminarDatos(cls_componente po_componente)
        {
            try
            {
                po_componente.pUsuarioTransaccion = ((cls_usuario)Session["cls_usuario"]).pPK_usuario;

                cls_gestorComponente.deleteComponente(po_componente);

                this.llenarGridView();

                this.upd_Principal.Update();
            }
            catch (Exception po_exception)
            {
                throw new Exception("Ocurrió un error eliminando el componente.", 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);
            }
        }
        /// <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>
        /// 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 = ((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);
            }
        }
        /// <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);
            }
        }
Пример #25
0
        public bool ComponenteEncontrado(cls_componente po_componente)
        {
            bool encontrado = false;

            if (entregableComponenteList.Where(po => po.pPK_Componente == po_componente.pPK_componente).Count() > 0)
            {
                encontrado = true;
            }

            return encontrado;
        }
Пример #26
0
        public void RemoverComponenteEncontrado(cls_componente po_componente)
        {
            //bool encontrado = false;

            entregableComponenteList.RemoveAll(po => po.pPK_Componente == po_componente.pPK_componente);

            //return encontrado;
        }
Пример #27
0
        /// <summary>
        /// Método que elimina un componente
        /// </summary>
        /// <param name="po_componente">Permiso a eliminar</param>
        private void eliminarDatos(cls_componente po_componente)
        {
            try
            {
                cls_gestorComponente.deleteComponente(po_componente);

                this.llenarGridView();

                this.upd_Principal.Update();
            }
            catch (Exception po_exception)
            {
                throw new Exception("Ocurrió un error eliminando el componente.", po_exception);
            }
        }