Example #1
0
 /// <summary>
 /// Descripción: Actualiza informacion del rol/menu.
 /// Author: Terceros.
 /// Fecha Creacion: 01/01/2017
 /// Fecha Modificación: 02/02/2017.
 /// Modificación: Se agregaron comentarios.
 /// </summary>
 /// <param name="rolMenu"></param>
 public void UpdateMenuByRol(RolMenu rolMenu)
 {
     using (var rolMenuDal = new RolMenuDal())
     {
         rolMenuDal.UpdateMenuByRol(rolMenu);
     }
 }
    protected void Menu1_MenuItemDataBound(object sender, MenuEventArgs e)
    {
        if (!Page.IsCallback)
        {
            System.Web.UI.WebControls.Menu menu = (System.Web.UI.WebControls.Menu)sender;
            SiteMapNode mapNode = (SiteMapNode)e.Item.DataItem;

            bool bEsMiembro = false;

            foreach (string RolMenu in mapNode.Roles)
            {
                if (RolMenu == "*")
                {
                    if (mapNode.Title == "Reconexión" && Session["PERFIL"].ToString() != "A")
                    {
                        bEsMiembro = false;
                    }
                    else
                    {
                        bEsMiembro = true;
                    }
                    break;
                }
                string RolMenuAux = RolMenu.Trim();
                if (RolMenuAux != "")
                {
                    foreach (string MiRol in ((RolePrincipal)Page.User).GetRoles())
                    {
                        if (RolMenu == MiRol)
                        {
                            bEsMiembro = true;
                            break;
                        }
                    }
                }
                if (bEsMiembro)
                {
                    break;
                }
            }

            if (!bEsMiembro)
            {
                System.Web.UI.WebControls.MenuItem itemToRemove = menu.FindItem(mapNode.Title);

                if (e.Item.Depth == 0)
                {
                    menu.Items.Remove(e.Item);
                }
                else
                {
                    System.Web.UI.WebControls.MenuItem parent = e.Item.Parent;
                    if (parent != null)
                    {
                        parent.ChildItems.Remove(e.Item);
                    }
                }
            }
        }
    }
        //Metodos Particulares
        private void CargarGridAsignacion(ref Anthem.GridView Grid, MenuInfo ObjetoMenu)
        {
            //Declaracion de Varibles
            var ResultadoMenu    = new Resultado <MenuInfo>();
            var ResultadoRolMenu = new Resultado <RolMenu>();
            var NegMenu          = new NegMenus();
            var ObjetoRolMenu    = new RolMenu();

            try
            {
                ResultadoMenu = NegMenu.Buscar(ObjetoMenu);
                if (ResultadoMenu.ResultadoGeneral)
                {
                    Controles.CargarGrid <MenuInfo>(ref Grid, ResultadoMenu.Lista, new string[] { "Id" });
                }
                string ID = Grid.ID;
                for (int i = 0; i <= Grid.Rows.Count - 1; i++)
                {
                    ObjetoRolMenu         = new RolMenu();
                    ObjetoRolMenu.Menu_Id = int.Parse(Grid.DataKeys[i].Values["Id"].ToString());
                    ObjetoRolMenu.Rol_Id  = int.Parse(ddlRol.SelectedValue.ToString());
                    ResultadoRolMenu      = NegMenu.RolMenu(ObjetoRolMenu);

                    ObjetoRolMenu = ResultadoRolMenu.Objeto;
                    if (ObjetoRolMenu != null)
                    {
                        if (Grid.ID == Constantes.gvMantenedores || Grid.ID == Constantes.gvHijosMantenedores)
                        {
                            ((CheckBox)Grid.Rows[i].FindControl(Constantes.chkAcceso)).Checked = (ObjetoRolMenu.Acceso == true);

                            ((CheckBox)Grid.Rows[i].FindControl(Constantes.chkCrear)).Checked = (ObjetoRolMenu.PermisoCrear == true);

                            ((CheckBox)Grid.Rows[i].FindControl(Constantes.chkModificar)).Checked = (ObjetoRolMenu.PermisoModificar == true);

                            ((CheckBox)Grid.Rows[i].FindControl(Constantes.chkEliminar)).Checked = (ObjetoRolMenu.PermisoEliminar == true);
                        }
                        else if (Grid.ID == Constantes.gvOperacionales || Grid.ID == Constantes.gvHijosOperacionales)
                        {
                            ((CheckBox)Grid.Rows[i].FindControl(Constantes.chkAcceso)).Checked = (ObjetoRolMenu.Acceso == true);
                        }
                    }
                    else
                    {
                        ((CheckBox)Grid.Rows[i].FindControl(Constantes.chkAcceso)).Checked = false;
                    }
                }
            }
            catch (Exception Ex)
            {
                if (Constantes.ModoDebug == true)
                {
                    Controles.MostrarMensajeError(Ex.Message);
                }
                else
                {
                    Controles.MostrarMensajeError(ArchivoRecursos.ObtenerValorNodo(Constantes.MensajesUsuario.ErrorCargarEntidad.ToString() + "ConfiguracionGeneral"));
                }
            }
        }
Example #4
0
        /// <summary>
        /// Descripción: Registra/Actualiza información de roles por menu.
        /// Author: Terceros.
        /// Fecha Creacion: 01/01/2017
        /// Fecha Modificación: 02/02/2017.
        /// Modificación: Se agregaron comentarios.
        /// </summary>
        /// <param name="rolMenu"></param>
        public void InsertMenuByRol(RolMenu rolMenu)
        {
            var objCommand = GetSqlCommand("pNLI_RolMenu");

            InputParameterAdd.Int(objCommand, "idRol", rolMenu.IdRol);
            InputParameterAdd.Int(objCommand, "idMenu", rolMenu.IdMenu);
            InputParameterAdd.Int(objCommand, "idUsuarioRegistro", rolMenu.IdUsuarioRegistro);

            ExecuteNonQuery(objCommand);
        }
Example #5
0
        /// <summary>
        /// Descripción: Actualiza informacion del rol/menu.
        /// Author: Terceros.
        /// Fecha Creacion: 01/01/2017
        /// Fecha Modificación: 02/02/2017.
        /// Modificación: Se agregaron comentarios.
        /// </summary>
        /// <param name="rolMenu"></param>
        public void UpdateMenuByRol(RolMenu rolMenu)
        {
            var objCommand = GetSqlCommand("pNLU_RolMenu");

            InputParameterAdd.Int(objCommand, "idRol", rolMenu.IdRol);
            InputParameterAdd.Int(objCommand, "idMenu", rolMenu.IdMenu);
            InputParameterAdd.Int(objCommand, "estado", rolMenu.Estado);
            InputParameterAdd.Int(objCommand, "idUsuarioEdicion", rolMenu.IdUsuarioEdicion);

            ExecuteNonQuery(objCommand);
        }
Example #6
0
        public static bool AssignRole(int Id, string Roles)
        {
            var RolesIds = Roles.Split(',');

            using (var Dc = new TemplateEntities())
            {
                var MenuRoles = Dc
                                .RolMenu
                                .Where(X =>
                                       X.Menu_Id == Id
                                       ).ToList();

                if (MenuRoles.Count > 0)
                {
                    Dc.RolMenu.RemoveRange(MenuRoles);
                    Dc.SaveChanges();
                }

                if (!RolesIds.Any())
                {
                    return(true);
                }
                var MenuRoles_ = new List <RolMenu>();

                foreach (var Role_ in RolesIds)
                {
                    if (string.IsNullOrEmpty(Role_))
                    {
                        continue;
                    }

                    var MenuRole = new RolMenu
                    {
                        Rol_Id  = Convert.ToInt32(Role_),
                        Menu_Id = Id
                    };

                    MenuRoles_.Add(MenuRole);
                }

                if (MenuRoles_.Count > 0)
                {
                    Dc.RolMenu.AddRange(MenuRoles_);
                    var Result = Dc.SaveChanges();

                    return(Result > 0);
                }

                return(true);
            }
        }
Example #7
0
        public ActionResult EliminarMenu(RolMenu rolMenu)
        {
            rolMenu.IdUsuarioEdicion = Logueado.idUsuario;
            rolMenu.Estado           = 0;

            try
            {
                _rolMenuBl.UpdateMenuByRol(rolMenu);

                return(RedirectToAction("Menues", new { id = rolMenu.IdRol }));
            }
            catch
            {
                return(View("Error"));
            }
        }
Example #8
0
        /// <summary>
        /// Método que retorna un objeto RolMenu
        /// </summary>
        /// <param name="Entidad">Objeto RolMenu con los atributos correspondientes</param>
        /// <returns>Objeto RolMenu en el atributo Objeto del resultado</returns>
        public Resultado <RolMenu> RolMenu(RolMenu Entidad)
        {
            var ObjetoResultado = new Resultado <RolMenu>();

            try
            {
                ObjetoResultado        = AccesoDatos.Buscar <RolMenu, RolMenu>(Entidad, Documental.Data.Global.SP.RolMenu_QRY);
                ObjetoResultado.Objeto = ObjetoResultado.Lista.FirstOrDefault();
                return(ObjetoResultado);
            }
            catch (Exception)
            {
                ObjetoResultado.ResultadoGeneral = false;
                ObjetoResultado.Mensaje          = ArchivoRecursos.ObtenerValorNodo(Constantes.MensajesUsuario.ErrorListar.ToString()) + " RolMenu";
                return(ObjetoResultado);
            }
        }
Example #9
0
        /// <summary>
        /// Método que Inserta o Modifica una Entidad RolMenu según Corresponda.
        /// </summary>
        /// <param name="Entidad">Objeto de la Entidad RolMenu</param>
        /// <returns>Resultado general de la Acción en el Atributo ResultadoGeneral del Objeto Resultado</returns>
        public Resultado <RolMenu> AsignarMenu(RolMenu Entidad)
        {
            var ObjetoResultado = new Resultado <RolMenu>();

            try
            {
                Entidad.UsuarioModificacion_Id = (int)Administracion.NegUsuarios.UsuarioId;
                ObjetoResultado = AccesoDatos.Operacion <RolMenu>(Entidad, Documental.Data.Global.SP.RolMenu_INS, Documental.Data.Global.Accion.Guardar);

                return(ObjetoResultado);
            }
            catch (Exception)
            {
                ObjetoResultado.ResultadoGeneral = false;
                ObjetoResultado.Mensaje          = ArchivoRecursos.ObtenerValorNodo(Constantes.MensajesUsuario.ErrorGuardar.ToString()) + " RolMenu";
                return(ObjetoResultado);
            }
        }
Example #10
0
        private void ValidarPagina()
        {
            try
            {
                var      ObjetoRolMenu = new RolMenu();
                var      NegMenu       = new NegMenus();
                string   Pagina        = HttpContext.Current.Request.AppRelativeCurrentExecutionFilePath;
                String[] url           = HttpContext.Current.Request.RawUrl.Split('?');
                var      ObjetoUsuario = new UsuarioInfo();
                if (ObjetoUsuario.UsuarioCreacion_Id != null)
                {
                    ObjetoUsuario.Id = (int)ObjetoUsuario.UsuarioCreacion_Id;
                }


                if (url.Count() > 1 && (url[1].Contains("%7e") || url[1].Contains("~")))
                {
                    Pagina = url[1].Replace("%2f", "/").Replace("%7e", "~");
                }
                ObjetoRolMenu.Usuario_Id = ObjetoUsuario.Id;
                ObjetoRolMenu.Url        = Pagina;
                ObjetoRolMenu            = NegMenu.ValidarAcceso(ObjetoRolMenu);
                //if (ObjetoRolMenu == null)
                //{
                //    Response.Redirect(Constantes.UrlSinAcceso);
                //}
                //if (ObjetoRolMenu.Acceso == false)
                //{
                //    Response.Redirect(Constantes.UrlSinAcceso);

                //}
                NegMenus.Permisos = ObjetoRolMenu;
                this.Page.Title   = ObjetoRolMenu.TituloMenu == null?ArchivoRecursos.ObtenerValorNodo(Constantes.DatosSistema.NombreAplicacion.ToString()) : "WebApp - " + ObjetoRolMenu.TituloMenu;
            }
            catch (Exception ex)
            {
                Controles.MostrarMensajeError(ex.Message);
            }
        }
Example #11
0
    protected void Menu1_MenuItemDataBound(object sender, MenuEventArgs e)
    {
        if (!Page.IsCallback)
        {
            System.Web.UI.WebControls.Menu menu = (System.Web.UI.WebControls.Menu)sender;
            SiteMapNode mapNode = (SiteMapNode)e.Item.DataItem;

            bool bEsMiembro = false;

            foreach (string RolMenu in mapNode.Roles)
            {
                //if (
                //    (mapNode.Title == "PGE" && !Utilidades.EsModuloAccesible("PGE"))
                //    || (mapNode.Title == "PST" && !Utilidades.EsModuloAccesible("PST"))
                //    || (mapNode.Title == "IAP" && !Utilidades.EsModuloAccesible("IAP"))
                //    )//Si el acceso a los módulos está cortado, no se muestran...
                //{
                //    if (HttpContext.Current.Session["GVT_AdminActual"].ToString() != "A")
                //    {// a menos que el usuario sea administrador.
                //        bEsMiembro = false;
                //        break;
                //    }
                //}

                //if (mapNode.Title == "ADP")
                //{
                //    if (Utilidades.EsModuloAccesible("ADP") && HttpContext.Current.User.IsInRole("PER"))
                //    {
                //        bEsMiembro = true;
                //        break;
                //    }
                //}

                if (RolMenu == "*")
                {
                    //if (mapNode.Title == "Reconexión")
                    //    bEsMiembro = false;
                    //else
                    bEsMiembro = true;
                    //break;
                }
                string RolMenuAux = RolMenu.Trim();
                if (RolMenuAux != "")
                {
                    foreach (string MiRol in ((RolePrincipal)Page.User).GetRoles())
                    {
                        if (RolMenu == MiRol)
                        {
                            bEsMiembro = true;
                            break;
                        }
                    }
                }
                if (bEsMiembro)
                {
                    break;
                }
            }

            if (!bEsMiembro)
            {
                System.Web.UI.WebControls.MenuItem itemToRemove = menu.FindItem(mapNode.Title);
                if (e.Item.Depth == 0)
                {
                    menu.Items.Remove(e.Item);
                    //itemToRemove.Enabled = false;
                }
                else
                {
                    System.Web.UI.WebControls.MenuItem parent = e.Item.Parent;
                    if (parent != null)
                    {
                        parent.ChildItems.Remove(e.Item);
                        //parent.Enabled = false;
                    }
                }
            }
        }
    }
Example #12
0
        /// <summary>
        /// Método que valida los permisos que tiene un Usuario en relacion a un Menú
        /// </summary>
        /// <param name="Entidad">Objeto Rol Menu con los atributos para realizar la valodación (Usuario_Id y la URL del Menú ) </param>
        /// <returns>Lista RolMenu con el resultado de la valodacion de los permisos</returns>
        public RolMenu ValidarAcceso(RolMenu Entidad)
        {
            var ObjetoResultado = new Resultado <RolMenu>();

            try
            {
                ObjetoResultado = AccesoDatos.Buscar <RolMenu, RolMenu>(Entidad, Documental.Data.Global.SP.ValidarAccesoMenu_QRY);
                if (ObjetoResultado.Lista == null)
                {
                    ObjetoResultado.ResultadoGeneral = false;
                    ObjetoResultado.Mensaje          = ArchivoRecursos.ObtenerValorNodo(Constantes.MensajesUsuario.ErrorListar.ToString()) + " RolMenu";
                    return(null);
                }
                else if (ObjetoResultado.Lista.Count() == 0)
                {
                    return(new RolMenu
                    {
                        Acceso = false,
                        PermisoCrear = false,
                        PermisoModificar = false,
                        PermisoEliminar = false,
                        TituloMenu = null
                    });
                }
                else if (ObjetoResultado.Lista.Count() > 1)
                {
                    var ObjetoRolMenu = new RolMenu();
                    var Acceso        = from x in ObjetoResultado.Lista
                                        where x.Acceso == true
                                        select x;

                    var Crear = from x in ObjetoResultado.Lista
                                where x.PermisoCrear == true
                                select x;

                    var Modificar = from x in ObjetoResultado.Lista
                                    where x.PermisoModificar == true
                                    select x;

                    var Eliminar = from x in ObjetoResultado.Lista
                                   where x.PermisoEliminar == true
                                   select x;

                    ObjetoRolMenu.Acceso           = (Acceso.Count() != 0);
                    ObjetoRolMenu.PermisoCrear     = (Crear.Count() != 0);
                    ObjetoRolMenu.PermisoModificar = (Modificar.Count() != 0);
                    ObjetoRolMenu.PermisoEliminar  = (Eliminar.Count() != 0);
                    ObjetoRolMenu.TituloMenu       = ObjetoResultado.Lista.FirstOrDefault().TituloMenu;

                    return(ObjetoRolMenu);
                }
                else
                {
                    return(ObjetoResultado.Lista.FirstOrDefault());
                }
            }
            catch (Exception)
            {
                ObjetoResultado.ResultadoGeneral = false;
                ObjetoResultado.Mensaje          = ArchivoRecursos.ObtenerValorNodo(Constantes.MensajesUsuario.ErrorListar.ToString()) + " RolMenu";
                return(null);
            }
        }
Example #13
0
        public Resultado <RolMenu> AsignacionMenu(GridView Grid, RolMenu ObjetoRolMenu, int MenuPadre_Id)
        {
            var  ResultadoRolMenu = new Resultado <RolMenu>();
            var  NegMenu          = new NegMenus();
            bool AsignacionPadre  = false;
            int  ContadorActivos  = 0;

            if (MenuPadre_Id != -1)
            {
                foreach (GridViewRow Row in Grid.Rows)
                {
                    CheckBox chkAcceso = (CheckBox)Row.FindControl(Constantes.chkAcceso);
                    if (chkAcceso.Checked)
                    {
                        ContadorActivos = ContadorActivos + 1;
                    }
                }


                if (ContadorActivos != 0)
                {
                    if (!AsignacionPadre)
                    {
                        ObjetoRolMenu.Acceso  = true;
                        ObjetoRolMenu.Menu_Id = MenuPadre_Id;
                        ResultadoRolMenu      = NegMenu.AsignarMenu(ObjetoRolMenu);
                        AsignacionPadre       = true;
                    }
                }
                else
                {
                    if (!AsignacionPadre)
                    {
                        ObjetoRolMenu.Acceso  = false;
                        ObjetoRolMenu.Menu_Id = MenuPadre_Id;
                        ResultadoRolMenu      = NegMenu.AsignarMenu(ObjetoRolMenu);
                        AsignacionPadre       = true;
                    }
                }
            }

            foreach (GridViewRow Row in Grid.Rows)
            {
                CheckBox chkAcceso = (CheckBox)Row.FindControl(Constantes.chkAcceso);

                ObjetoRolMenu.Acceso = chkAcceso.Checked;


                if (Grid.ID == Constantes.gvHijosMantenedores || Grid.ID == Constantes.gvMantenedores)
                {
                    CheckBox chkCrear     = (CheckBox)Row.FindControl(Constantes.chkCrear);
                    CheckBox chkModificar = (CheckBox)Row.FindControl(Constantes.chkModificar);
                    CheckBox chkEliminar  = (CheckBox)Row.FindControl(Constantes.chkEliminar);

                    ObjetoRolMenu.PermisoCrear     = chkCrear.Checked;
                    ObjetoRolMenu.PermisoModificar = chkModificar.Checked;
                    ObjetoRolMenu.PermisoEliminar  = chkEliminar.Checked;
                }
                ObjetoRolMenu.Menu_Id = int.Parse(Grid.DataKeys[Row.RowIndex].Values[Constantes.StringId].ToString());
                ResultadoRolMenu      = NegMenu.AsignarMenu(ObjetoRolMenu);
            }


            return(ResultadoRolMenu);
        }
Example #14
0
    protected void Menu1_MenuItemDataBound(object sender, MenuEventArgs e)
    {
        if (!Page.IsCallback)
        {
            System.Web.UI.WebControls.Menu menu = (System.Web.UI.WebControls.Menu)sender;
            SiteMapNode mapNode = (SiteMapNode)e.Item.DataItem;

            bool bEsMiembro = false;

            foreach (string RolMenu in mapNode.Roles)
            {
                //if (
                //    (mapNode.Title == "PGE" && Session["BloquearPGEByAcciones"] != null && (bool)Session["BloquearPGEByAcciones"] == true)
                //    || (mapNode.Title == "PST" && Session["BloquearPSTByAcciones"] != null && (bool)Session["BloquearPSTByAcciones"] == true)
                //    || (mapNode.Title == "IAP" && Session["BloquearIAPByAcciones"] != null && (bool)Session["BloquearIAPByAcciones"] == true)
                //    )//Si el acceso está bloqueado por alguna acción pendiente, no se muestran aunque el usuario sea administrador.
                //{
                //    bEsMiembro = false;
                //    break;
                //}


                if (
                    (mapNode.Title == "PGE" && !Utilidades.EsModuloAccesible("PGE")) ||
                    (mapNode.Title == "PST" && !Utilidades.EsModuloAccesible("PST")) ||
                    (mapNode.Title == "IAP" && !Utilidades.EsModuloAccesible("IAP"))
                    )//Si el acceso a los módulos está cortado, no se muestran...
                {
                    //if (HttpContext.Current.Session["ADMINISTRADOR_PC_ACTUAL"].ToString() != "A")
                    if (!SUPER.Capa_Negocio.Utilidades.EsAdminProduccion())
                    {// a menos que el usuario sea administrador.
                        bEsMiembro = false;
                        break;
                    }
                }

                if (mapNode.Title == "ADP")
                {
                    if (Utilidades.EsModuloAccesible("ADP") && HttpContext.Current.User.IsInRole("PER"))
                    {
                        bEsMiembro = true;
                        break;
                    }
                }

                //if (mapNode.ParentNode.Title == "Correos infomativos")
                //{
                //    if (mapNode.Title == "Activar" && (bool)HttpContext.Current.Session["RECIBIRMAILS"]) mapNode.Title = "Activar (x)";
                //    if (mapNode.Title == "Desactivar" && !(bool)HttpContext.Current.Session["RECIBIRMAILS"]) mapNode.Title = "Desactivar (√)";
                //}
                if (RolMenu == "*")
                {
                    //if (mapNode.Title == "Reconexión")
                    //    bEsMiembro = false;
                    //else
                    bEsMiembro = true;
                    //break;
                }
                string RolMenuAux = RolMenu.Trim();
                if (RolMenuAux != "")
                {
                    foreach (string MiRol in ((RolePrincipal)Page.User).GetRoles())
                    {
                        if (RolMenu == MiRol)
                        {
                            bEsMiembro = true;
                            break;
                        }
                    }
                }
                if (bEsMiembro)
                {
                    break;
                }
            }

            if (!bEsMiembro)
            {
                //System.Web.UI.WebControls.MenuItem itemToRemove = menu.FindItem(mapNode.Title);
                if (e.Item.Depth == 0)
                {
                    menu.Items.Remove(e.Item);
                    //itemToRemove.Enabled = false;
                }
                else
                {
                    System.Web.UI.WebControls.MenuItem parent = e.Item.Parent;
                    if (parent != null)
                    {
                        parent.ChildItems.Remove(e.Item);
                        //parent.Enabled = false;
                    }
                }
            }
        }
    }
        private void ProcesarAsignacion()
        {
            var  ObjetoRolMenu   = new RolMenu();
            var  NegMenu         = new NegMenus();
            var  ObjetoResultado = new Resultado <RolMenu>();
            bool AsignacionPadre = false;
            int  ContadorActivos = 0;

            try
            {
                ObjetoRolMenu.Rol_Id = int.Parse(ddlRol.SelectedValue);
                foreach (GridViewRow Row in gvMantenedores.Rows)
                {
                    CheckBox chkAcceso = (CheckBox)Row.FindControl(Constantes.chkAcceso);
                    if (chkAcceso.Checked)
                    {
                        ContadorActivos = ContadorActivos + 1;
                    }
                }
                foreach (GridViewRow Row in gvOperacionales.Rows)
                {
                    CheckBox chkAcceso = (CheckBox)Row.FindControl(Constantes.chkAcceso);
                    if (chkAcceso.Checked)
                    {
                        ContadorActivos = ContadorActivos + 1;
                    }
                }

                if (ContadorActivos != 0)
                {
                    if (!AsignacionPadre)
                    {
                        ObjetoRolMenu.Acceso  = true;
                        ObjetoRolMenu.Menu_Id = int.Parse(ddlMenu.SelectedValue);
                        ObjetoResultado       = new NegMenus().AsignarMenu(ObjetoRolMenu);
                        AsignacionPadre       = true;
                    }
                }
                else
                {
                    if (!AsignacionPadre)
                    {
                        ObjetoRolMenu.Acceso  = false;
                        ObjetoRolMenu.Menu_Id = int.Parse(ddlMenu.SelectedValue);
                        ObjetoResultado       = NegMenu.AsignarMenu(ObjetoRolMenu);
                        AsignacionPadre       = true;
                    }
                }

                if (ObjetoResultado.ResultadoGeneral == false)
                {
                    goto Error;
                }



                if (gvMantenedores.Rows.Count != 0)
                {
                    ObjetoResultado = NegMenu.AsignacionMenu(gvMantenedores, ObjetoRolMenu, -1);
                    if (ObjetoResultado.ResultadoGeneral == false)
                    {
                        goto Error;
                    }
                    foreach (GridViewRow Row in gvMantenedores.Rows)
                    {
                        GridView gvHijosMantenedores  = (GridView)Row.FindControl(Constantes.gvHijosMantenedores);
                        GridView gvHijosOperacionales = (GridView)Row.FindControl(Constantes.gvHijosOperacionales);
                        if (gvHijosMantenedores.Rows.Count != 0)
                        {
                            int MenuPadre_Id = int.Parse(gvMantenedores.DataKeys[Row.RowIndex].Values[Constantes.StringId].ToString());
                            ObjetoResultado = NegMenu.AsignacionMenu(gvHijosMantenedores, ObjetoRolMenu, MenuPadre_Id);
                            if (ObjetoResultado.ResultadoGeneral == false)
                            {
                                goto Error;
                            }
                        }

                        if (gvHijosOperacionales.Rows.Count != 0)
                        {
                            int MenuPadre_Id = int.Parse(gvMantenedores.DataKeys[Row.RowIndex].Values[Constantes.StringId].ToString());
                            ObjetoResultado = NegMenu.AsignacionMenu(gvHijosOperacionales, ObjetoRolMenu, MenuPadre_Id);
                            if (ObjetoResultado.ResultadoGeneral == false)
                            {
                                goto Error;
                            }
                        }
                    }
                }
                if (gvOperacionales.Rows.Count != 0)
                {
                    ObjetoResultado = NegMenu.AsignacionMenu(gvOperacionales, ObjetoRolMenu, -1);
                    if (ObjetoResultado.ResultadoGeneral == false)
                    {
                        goto Error;
                    }
                    foreach (GridViewRow Row in gvOperacionales.Rows)
                    {
                        GridView gvHijosMantenedores  = (GridView)Row.FindControl(Constantes.gvHijosMantenedores);
                        GridView gvHijosOperacionales = (GridView)Row.FindControl(Constantes.gvHijosOperacionales);
                        if (gvHijosMantenedores.Rows.Count != 0)
                        {
                            int MenuPadre_Id = int.Parse(gvOperacionales.DataKeys[Row.RowIndex].Values[Constantes.StringId].ToString());
                            ObjetoResultado = NegMenu.AsignacionMenu(gvHijosMantenedores, ObjetoRolMenu, MenuPadre_Id);
                            if (ObjetoResultado.ResultadoGeneral == false)
                            {
                                goto Error;
                            }
                        }

                        if (gvHijosOperacionales.Rows.Count != 0)
                        {
                            int MenuPadre_Id = int.Parse(gvOperacionales.DataKeys[Row.RowIndex].Values[Constantes.StringId].ToString());
                            ObjetoResultado = NegMenu.AsignacionMenu(gvHijosOperacionales, ObjetoRolMenu, MenuPadre_Id);
                            if (ObjetoResultado.ResultadoGeneral == false)
                            {
                                goto Error;
                            }
                        }
                    }
                }
                Controles.MostrarMensajeExito(ArchivoRecursos.ObtenerValorNodo(Constantes.MensajesUsuario.AsignacionMenuCompleta.ToString()));
                return;

Error:
                if (ObjetoResultado.ResultadoGeneral == false)
                {
                    Controles.MostrarMensajeError(ObjetoResultado.Mensaje);
                    return;
                }
            }
            catch (Exception Ex)
            {
                if (Constantes.ModoDebug == true)
                {
                    Controles.MostrarMensajeError(Ex.Message);
                }
                else
                {
                    Controles.MostrarMensajeError(ArchivoRecursos.ObtenerValorNodo(Constantes.MensajesUsuario.ErrorProcesarAsignacionMenu.ToString()));
                }
            }
        }
Example #16
0
        protected virtual void Dispose(bool disposing)
        {
            if (!disposedValue)
            {
                if (disposing)
                {
                    // TODO: eliminar el estado administrado (objetos administrados)
                    if (Language != null)
                    {
                        Language.Dispose();
                    }

                    if (Menu != null)
                    {
                        Menu.Dispose();
                    }

                    if (Parameters != null)
                    {
                        Parameters.Dispose();
                    }

                    if (Roles != null)
                    {
                        Roles.Dispose();
                    }

                    if (RolMenu != null)
                    {
                        RolMenu.Dispose();
                    }

                    if (Third != null)
                    {
                        Third.Dispose();
                    }

                    if (ThirdType != null)
                    {
                        ThirdType.Dispose();
                    }

                    if (TypeIdentification != null)
                    {
                        TypeIdentification.Dispose();
                    }

                    if (UserInfoDetail != null)
                    {
                        UserInfoDetail.Dispose();
                    }

                    if (User != null)
                    {
                        User.Dispose();
                    }

                    if (UserRoles != null)
                    {
                        UserRoles.Dispose();
                    }

                    if (UserStatus != null)
                    {
                        UserStatus.Dispose();
                    }
                }

                // TODO: liberar los recursos no administrados (objetos no administrados) y reemplazar el finalizador
                // TODO: establecer los campos grandes como NULL
                disposedValue = true;
            }
        }