protected void btn_guardar_Click(object sender, EventArgs e)
        {
            if (ValidarObligatorios() == true)
            {
                oUsuario.USU_APELLIDO = txt_apellido.Text;
                oUsuario.USU_NOMBRE = txt_nombre.Text;
                oUsuario.USU_EMAIL = txt_email.Text;
                oUsuario.USU_CODIGO = txt_nombreusuario.Text;
                oUsuario.USU_ESTADO = chk_estado.Checked;
                //clave = oCCUGUsuarios.generarClaveAleatoria(8, false);

                oUsuario.GRUPOS.Clear();

                for (int i = 0; i < chklstbox_grupos.Items.Count; i++)
                {
                    grupo = chklstbox_grupos.Items[i].Text;
                    oGrupo = oCCUGGrupos.ObtenerGrupo(grupo);

                    if (chklstbox_grupos.Items[i].Selected == true)
                    {
                        oUsuario.GRUPOS.Add(oGrupo);
                    }
                }

                if (modo == "Alta")
                {
                    //clave = oCCUGUsuarios.generarClaveAleatoria(8, false);
                    oUsuario.USU_CLAVE = "clavetemp";
                    //oCCUGUsuarios.EnviarCorreo(oUsuario);
                    //oUsuario.USU_CLAVE = oCCUGUsuarios.EncriptarClave(clave);
                    oCCUGUsuarios.Agregar(oUsuario);
                    oCCUGUsuarios.ResetearClave(oUsuario);
                    Page.Response.Redirect("~/Seguridad/Gestion de Usuarios.aspx", false);
                }

                else
                {
                    //oUsuario.USU_CLAVE = oCCUGUsuarios.EncriptarClave(txt_nuevacontraseña.Text);
                    oCCUGUsuarios.Modificar(oUsuario);
                    Page.Response.Redirect("~/Seguridad/Gestion de Usuarios.aspx", false);
                }
            }
        }
        // Al hacer click en "Modificar"
        protected void botonera1_Click_Baja(object sender, EventArgs e)
        {
            if (gvGrupos.SelectedRow == null)
            {
                message.Visible = true;
                lb_error.Text = "Debe seleccionar un grupo";
            }

            else
            {
                grupo = gvGrupos.SelectedRow.Cells[1].Text;
                oGrupo = oCCUGGrupos.ObtenerGrupoPorCodigo(grupo);

                if (oCCUGGrupos.ComprobarUso(oGrupo) == true)
                {
                    message.Visible = true;
                    lb_error.Text = "Para eliminar el grupo, primero debe desasociar a todos sus miembros y eliminar todos sus perfiles";
                    return;
                }

                message.Visible = false;
                ScriptManager.RegisterStartupScript(this, this.GetType(), "pop", "openModal();", true);
            }
        }
        //evento que se ejecuta antes de llamar al load
        protected void Page_Init(object sender, EventArgs e)
        {
            grupo = Server.UrlDecode(Request.QueryString["grupo"]);
            modo = Server.UrlDecode(Request.QueryString["modo"]);

            if (grupo == "nuevo")
            {
                oGrupo = new Modelo_Entidades.GRUPO();
            }
            else
            {
                oGrupo = oCCUGGrupos.ObtenerGrupo(descripcion: grupo);
            }

            message.Visible = false;

            txt_descripcion.Enabled = true;
            chklstbox_persmisos.Enabled = false;
            chklstbox_usuarios.Enabled = true;

            if (modo != "Alta")
            {
                txt_descripcion.Text = oGrupo.GRU_DESCRIPCION;
                txt_codigo.Text = oGrupo.GRU_CODIGO;
                txt_codigo.Enabled = false;

                if (modo == "Consulta")
                {
                    txt_descripcion.Enabled = false;
                    btn_guardar.Enabled = false;
                    btn_cancelar.Text = "Cerrar";
                    chklstbox_persmisos.Enabled = false;
                    chklstbox_usuarios.Enabled = false;
                }
            }
        }
        private void frmUsuarios_Load(object sender, EventArgs e)
        {
            Modelo_Entidades.PERFIL oPerfil = collPerfilesObtenidos.Find(delegate(Modelo_Entidades.PERFIL oPerfilBuscado) { return oPerfilBuscado.PERMISOS.PER_CODIGO == "R"; });
            if (oPerfil == null)
            {
                this.btnResetearClave.Enabled = false;
                this.btnResetearClave.Visible = false;
            }

            BindingSource bsGrupos = new BindingSource();
            bsGrupos.DataSource = oCCUGrupos.ObtenerGrupos();
            Modelo_Entidades.GRUPO oGrupo = new Modelo_Entidades.GRUPO();
            oGrupo.GRU_DESCRIPCION= "TODOS";
            oGrupo.GRU_CODIGO ="TODOS";
            oGrupo.GRU_ESTADO = true;

            //bsGrupos.Add(oGrupo);
            bsGrupos.Insert(0, oGrupo);

            cbGrupo.DataSource = bsGrupos;
            cbGrupo.DisplayMember = "GRU_DESCRIPCION";
            //TablaGrupos = oCCUGrupos.ObtenerGrupos();

            cargarGrillaUsuarios();
            this.dgvUsuarios.Columns[3].Visible = false; //esconder clave
            this.dgvUsuarios.Columns[6].Visible = false; //esconder grupos
            this.dgvUsuarios.Columns[0].HeaderText = "Código de Usuario";
            this.dgvUsuarios.Columns[1].HeaderText = "Nombre del Usuario";
            this.dgvUsuarios.Columns[2].HeaderText = "Estado del Usuario";
            this.dgvUsuarios.Columns[4].HeaderText = "Apellido del Usuario";
            this.dgvUsuarios.Columns[5].HeaderText = "E-Mail del Usuario";

            this.ArmaPerfil(oUsuarioActual, this.Name);
            if (collPerfilesObtenidos.Find(delegate(Modelo_Entidades.PERFIL oPerfilBuscado) { return oPerfilBuscado.PER_CODIGO == "R"; }) == null)
            {
                this.btnResetearClave.Enabled = true;
                this.btnResetearClave.Visible = true;
            }

            /*
            oForm = oCCURPF.obtenerFormulario(frmGrupos.ObtenerInstancia().Name);
            collPerfilesObtenidos = oCCURPF.recuperarPerfilForm(oUsuarioActual, oForm);
            if (collPerfilesObtenidos.Find(delegate(Modelo_Entidades.PERFIL oPerfilBuscado) { return oPerfilBuscado.PER_CODIGO == "A"; }) == null)
            {
                this.btnAgregar.Enabled = true;
            }
            if (collPerfilesObtenidos.Find(delegate(Modelo_Entidades.PERFIL oPerfilBuscado) { return oPerfilBuscado.PER_CODIGO == "B"; }) == null)
            {
                this.btnEliminar.Enabled = true;
            }
            if (collPerfilesObtenidos.Find(delegate(Modelo_Entidades.PERFIL oPerfilBuscado) { return oPerfilBuscado.PER_CODIGO == "M"; }) == null)
            {
                this.btnModificar.Enabled = true;
            }
            */
        }
        private void btnGuardar_Click_1(object sender, EventArgs e)
        {
            if (validarObligatorios())
            {
                bool resultado;

                if (Modo == "Alta")
                {
                    resultado = oCCUGGrupos.ComprobarGrupo(tbDescripcion.Text);
                    if (resultado)
                    {
                        MessageBox.Show("Ya existe un grupo con esa descripción.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }
                    else
                    {
                        oGrupo = new Modelo_Entidades.GRUPO();
                        oGrupo = asignardatos(oGrupo);
                        try
                        {
                            resultado = oCCUGGrupos.Agregar(oGrupo);
                            if (resultado)
                            {
                                MessageBox.Show("Guardado con éxito", "Resultado", MessageBoxButtons.OK, MessageBoxIcon.Information);
                                frmGrupos.ObtenerInstancia().cargarGrillaGrupos();
                                this.Close();
                            }
                            else
                            {
                                MessageBox.Show("No guardado.", "Resultado", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                            }
                        }
                        catch (System.Data.DataException ex)
                        {
                            MessageBox.Show("No se ha podido guardar el nuevo grupo: " + ex.Message + ".", "Error de base de datos.", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        }
                    }
                }
                else //modificación
                {
                    oGrupo = asignardatos(oGrupo);
                    resultado = oCCUGGrupos.ObtenerGrupo(oGrupo.GRU_CODIGO, oGrupo.GRU_DESCRIPCION);
                    if (!resultado)
                    {
                        MessageBox.Show("Ya existe un grupo distinto con esa descripción.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }
                    else
                    {
                        try
                        {
                            resultado = oCCUGGrupos.Modificar(oGrupo);
                            if (resultado)
                            {
                                MessageBox.Show("Actualizado con éxito", "Resultado", MessageBoxButtons.OK, MessageBoxIcon.Information);
                                frmGrupos.ObtenerInstancia().cargarGrillaGrupos();
                                this.Close();
                            }
                            else
                            {
                                MessageBox.Show("No actualizado.", "Resultado", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                            }
                        }
                        catch (System.Data.DataException ex)
                        {
                            MessageBox.Show("No se ha podido actualizar el grupo: " + ex.Message + ".", "Error de base de datos.", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        }
                    }

                }
            }
        }
 public frmGrupo(Modelo_Entidades.GRUPO oGrupoEnviado)
 {
     InitializeComponent();
     Modo = "Modificacion";
     oGrupo = oGrupoEnviado;
 }
 private void btnModificar_Click(object sender, EventArgs e)
 {
     oGrupo = (Modelo_Entidades.GRUPO)bsGrupos.Current;
     if (oGrupo == null)
     {
         MessageBox.Show("Primero debe elegir un grupo.", "Error.", MessageBoxButtons.OK, MessageBoxIcon.Error);
     }
     else
     {
         frmGrupo ofrmGrupo = new frmGrupo(oGrupo);
         ofrmGrupo.Show();
     }
 }
 private void btnEliminar_Click(object sender, EventArgs e)
 {
     oGrupo = (Modelo_Entidades.GRUPO)bsGrupos.Current;
     if (oGrupo == null)
     {
         MessageBox.Show("Primero debe elegir un grupo.", "Error.", MessageBoxButtons.OK, MessageBoxIcon.Error);
     }
     else
     {
         DialogResult oDialogResult = MessageBox.Show("¿Está seguro que desea eliminar el grupo seleccionado?", "Confirmar eliminar.", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
         if (oDialogResult == DialogResult.Yes)
         {
             try
             {
                 if (ComprobarRelaciones())
                 {
                     bool resultado = oCCUGGrupos.Eliminar(oGrupo);
                     if (resultado)
                     {
                         MessageBox.Show("Grupo eliminado correctamente.", "Resultado.", MessageBoxButtons.OK, MessageBoxIcon.Information);
                         cargarGrillaGrupos();
                     }
                     else
                     {
                         MessageBox.Show("El grupo no se pudo eliminar.", "Resultado.", MessageBoxButtons.OK, MessageBoxIcon.Error);
                     }
                 }
                 else
                 {
                     MessageBox.Show("El grupo no se puede eliminar porque se le han asignado uno o más usuarios.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                 }
             }
             catch (System.Data.DataException ex)
             {
                 MessageBox.Show("No se puede borrar un grupo que contenga usuarios. Excepción interna: " + ex.InnerException.Message, "Excepción.", MessageBoxButtons.OK, MessageBoxIcon.Error);
             }
         }
     }
 }
 private void cargarComboGrupos()
 {
     Modelo_Entidades.GRUPO oGrupo = new Modelo_Entidades.GRUPO();
     oGrupo.GRU_CODIGO = "TODOS";
     oGrupo.GRU_DESCRIPCION = "TODOS";
     bsGrupos.Insert(0, oGrupo);
     cbGrupos.DataSource = bsGrupos;
     cbGrupos.DisplayMember = "GRU_DESCRIPCION";
     //cbGrupos.SelectedIndex = 0;
 }
        // Valido los datos del usuario
        private bool ValidarObligatorios()
        {
            if (cmb_grupos.SelectedValue == null)
            {
                message.Visible = true;
                lb_error.Text = "Debe ingresar un grupo";
                return false;
            }

            if (cmb_formularios.SelectedValue == null)
            {
                message.Visible = true;
                lb_error.Text = "Debe ingresar un formulario";
                return false;
            }

            if (cmb_permisos.SelectedValue == null)
            {
                message.Visible = true;
                lb_error.Text = "Debe ingresar un permiso";
                return false;
            }

            grupo = cmb_grupos.SelectedValue.ToString();
            oGrupo = oCCUGGrupos.ObtenerGrupo(grupo);

            permiso = cmb_permisos.SelectedValue.ToString();
            oPermiso = oCCURPF.ObtenerPermiso(permiso);

            formulario = cmb_formularios.SelectedValue.ToString();
            oFormulario = oCCURPF.obtenerFormulariopordesc(formulario);

            if (oCCUGPerfiles.ValidarPerfil(oGrupo, oPermiso, oFormulario) == true)
            {
                message.Visible = true;
                lb_error.Text = "El perfil ya existe, ingrese otros parámetros";
                return false;
            }

            return true;
        }
        protected void btn_eliminar_modal_Click(object sender, EventArgs e)
        {
            grupo = gvGrupos.SelectedRow.Cells[1].Text;
            oGrupo = oCCUGGrupos.ObtenerGrupoPorCodigo(grupo);

            oCCUGGrupos.Eliminar(oGrupo);

            ScriptManager.RegisterStartupScript(this, this.GetType(), "pop", "closeModal();", true);
            message.Visible = true;

            lb_error.Text = "El grupo fue eliminado";
            Arma_Lista();
        }
        private void btnGuardar_Click(object sender, EventArgs e)
        {
            if (Modo == "Alta")
            {
                if (validarObligatorios())
                {
                    oUsuario = new Modelo_Entidades.USUARIO();
                    oUsuario.USU_APELLIDO = this.tbApellido.Text;
                    oUsuario.USU_CODIGO = this.tbUsuario.Text;
                    oUsuario.USU_EMAIL = this.tbEMail.Text;
                    oUsuario.USU_ESTADO = this.cbEstado.Checked;
                    oUsuario.USU_NOMBRE = this.tbNombre.Text;
                    //vacío la colección de grupos del usuario, para que al quitar uno no quede guardado desde antes
                    oUsuario.GRUPOS.Clear();
                    //agregar todos los grupos checkeados a la lista de grupos
                    foreach (object item in clbGrupos.CheckedItems)//por cada objeto "item" de la lista de objetos checkeados en clbgrupos
                    {
                        oUsuario.GRUPOS.Add((Modelo_Entidades.GRUPO)item);//agrego el item, después de transformarlo en grupo, a la colección
                    }
                    if (this.cbEstado.Checked == true)
                    {
                        oUsuario.USU_ESTADO = true;
                    }
                    else
                    {
                        oUsuario.USU_ESTADO = false;
                    }

                    bool resultado;
                    try
                    {
                        Modelo_Entidades.USUARIO oUsuarioEncontrado = oCCUGUsuarios.ObtenerUsuario(oUsuario.USU_CODIGO);
                        if (oUsuarioEncontrado != null)
                        {
                            MessageBox.Show("El usuario ya existe.", "Resultado", MessageBoxButtons.OK, MessageBoxIcon.Error);
                            return;
                        }
                        resultado = oCCUGUsuarios.Agregar(oUsuario);
                        if (resultado)
                        {
                            MessageBox.Show("Guardado con éxito", "Resultado", MessageBoxButtons.OK, MessageBoxIcon.Information);
                            frmUsuarios.ObtenerInstancia().cargarGrillaUsuarios();
                            this.Close();
                        }
                        else
                        {
                            MessageBox.Show("No guardado.", "Resultado", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                        }
                    }
                    catch (System.Data.EntitySqlException ex)
                    {
                        MessageBox.Show("No se ha podido guardar el nuevo usuario: " + ex.InnerException.Message + ".", "Error de base de datos.", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }
                }
            }
            else
            {
                if (validarObligatorios())
                {
                    oUsuario.USU_APELLIDO = this.tbApellido.Text;
                    oUsuario.USU_CODIGO = this.tbUsuario.Text;
                    oUsuario.USU_EMAIL = this.tbEMail.Text;
                    oUsuario.USU_ESTADO = this.cbEstado.Checked;
                    oUsuario.USU_NOMBRE = this.tbNombre.Text;
                    //vacío la colección de grupos del usuario, para que al quitar uno no quede guardado desde antes
                    oUsuario.GRUPOS.Clear();
                    //agregar los grupos checkeados que no estén todavía en la lista de grupos a la misma
                    foreach (object item in clbGrupos.CheckedItems)//por cada objeto "item" de la lista de objetos checkeados en clbgrupos
                    {
                        oGrupo = (Modelo_Entidades.GRUPO)item; //convierto el item en un grupo (oGrupo)
                        Modelo_Entidades.GRUPO oGrupoEncontrado; //declaro el grupo oGrupoEncontrado
                        //busco en la lista de grupos del usuario el grupo cuyo código sea igual al código del grupo actual, oGrupo
                        oGrupoEncontrado = oUsuario.GRUPOS.ToList<Modelo_Entidades.GRUPO>().Find(delegate(Modelo_Entidades.GRUPO oGrupoBuscado) { return oGrupoBuscado.GRU_CODIGO == oGrupo.GRU_CODIGO; });
                        if (oGrupoEncontrado == null) //si el grupo encontrado es nulo (significa que el que busqué todavía no fue agregado)
                        {
                            oUsuario.GRUPOS.Add(oGrupo);//agrego el grupo encontrado a la colección
                        }
                    }
                    if (this.cbEstado.Checked == true)
                    {
                        oGrupo.GRU_ESTADO = true;
                    }
                    else
                    {
                        oGrupo.GRU_ESTADO = false;
                    }
                    bool resultado;
                    try
                    {
                        resultado = oCCUGUsuarios.Modificar(oUsuario);
                        if (resultado)
                        {
                            MessageBox.Show("Actualizado con éxito", "Resultado", MessageBoxButtons.OK, MessageBoxIcon.Information);
                            frmUsuarios.ObtenerInstancia().cargarGrillaUsuarios();
                            this.Close();
                        }
                        else
                        {
                            MessageBox.Show("No actualizado.", "Resultado", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                        }
                    }
                    catch (System.Data.EntitySqlException ex)
                    {
                        MessageBox.Show("No se ha podido actualizar el usuario: " + ex.InnerException.Message + ".", "Error de base de datos.", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }
                }
            }
        }
        private void frmUsuario_Load(object sender, EventArgs e)
        {
            bsGrupos.DataSource=oCCUGGrupos.ObtenerGrupos();
            foreach (Modelo_Entidades.GRUPO oGrupo in bsGrupos) //agregar cada grupo al checklistbox
            {
                this.clbGrupos.Items.Add(oGrupo);
            }
            if (Modo == "Modificacion")
            {
                this.tbUsuario.Text = oUsuario.USU_CODIGO;
                this.tbUsuario.Enabled = false;
                this.tbEMail.Text = oUsuario.USU_EMAIL;
                this.tbApellido.Text = oUsuario.USU_APELLIDO;
                this.tbNombre.Text = oUsuario.USU_NOMBRE;
                if (oUsuario.USU_ESTADO == true)
                {
                    this.cbEstado.Checked = true;
                }
                else
                {
                    this.cbEstado.Checked = false;
                }
                for (int i = 0; i < clbGrupos.Items.Count; i++) //para i desde 0 hasta la cantidad de items en clbgrupo(todos)
                {
                    oGrupo = (Modelo_Entidades.GRUPO)clbGrupos.Items[i];//mover el grupo con el índice 1 a oGrupo
                    foreach (Modelo_Entidades.GRUPO miGrupo in oUsuario.GRUPOS)//por cada uno de mis grupos en la colección Grupos de oUsuario
                    {
                        if (miGrupo.GRU_CODIGO == oGrupo.GRU_CODIGO)// si el código de oGrupo es igual a miGrupo
                        {
                            clbGrupos.SetItemChecked(i, true);//entonces establezco como checkeado el grupo de índice i
                        }
                    }
                }

                /*
                foreach (Modelo_Entidades.GRUPO oGrupo in oUsuario.GRUPOS)
                {
                    clbGrupos.CheckedItems;
                }
                oUsuario.GRUPOS = (Modelo_Entidades.GRUPO) clbGrupos.SelectedItems;
                //tickear los grupos elegidos
                 * */
            }
            else
            {
                cbEstado.Enabled = false;
                cbEstado.Checked = true;
            }
        }
        // Cargo los datos en los controles correspondientes
        private void CargaDatos()
        {
            chklstbox_grupos.DataSource = null;
            chklstbox_grupos.DataSource = oCCUGGrupos.ObtenerGrupos();
            chklstbox_grupos.DataBind();

            if (modo != "Alta")
            {
                for (int i = 0; i < chklstbox_grupos.Items.Count; i++)
                {
                    grupo = chklstbox_grupos.Items[i].Text;
                    oGrupo = oCCUGGrupos.ObtenerGrupo(grupo);
                    foreach (Modelo_Entidades.GRUPO miGrupo in oUsuario.GRUPOS.ToList())
                    {
                        if (oGrupo.GRU_CODIGO == miGrupo.GRU_CODIGO)
                        {
                            chklstbox_grupos.Items[i].Selected = true;
                        }
                    }
                }
            }
        }