示例#1
0
        private void PreencherMenu(ManterPagina manterPagina, Usuario usuarioLogado)
        {
            var paginas = manterPagina.ObterTodasPaginas(true).Where(p => p.Profundidade == 1 && p.PossuiPermissao(usuarioLogado));

            foreach (var pagina in paginas)
            {
                var li = new HtmlGenericControl("li");
                li.Attributes.Add("class", "item-menu " + pagina.Estilo);

                var link = new HtmlGenericControl("a");
                link.Attributes.Add("href", pagina.CaminhoRelativo);
                link.InnerHtml = "<span class=\"glyphicon glyphicon-" + pagina.IconeMenu + " menu-icon\"></span><br/>" + pagina.Nome;


                li.Controls.Add(link);

                barraMenu.Controls.Add(li);
            }

            // Inserir o gerenciador de páginas no menu principal.
            if (usuarioLogado.SuperAdministrador)
            {
                var li = new HtmlGenericControl("li");
                li.Attributes.Add("class", "item-menu paginas");

                var link = new HtmlGenericControl("a");
                link.Attributes.Add("href", "/Paginas.aspx");
                link.InnerHtml = "<span class=\"glyphicon glyphicon-list menu-icon\"></span><br/>" + "Páginas";

                li.Controls.Add(link);

                barraMenu.Controls.Add(li);
            }
        }
示例#2
0
        private Dominio.Classes.Pagina ObterPaginaAtual(ManterPagina manterPagina = null)
        {
            manterPagina = manterPagina ?? new ManterPagina();

            return(manterPagina.ObterPaginaPorCaminhoRelativo(Request.Url.PathAndQuery) ??
                   manterPagina.ObterPaginaPorCaminhoRelativo(Request.Url.AbsolutePath));
        }
示例#3
0
        private void EstilizarPagina(Usuario usuarioLogado, ManterPagina manterPagina, Dominio.Classes.Pagina paginaAtual)
        {
            string estilo;
            string nomePagina;

            if (paginaAtual.Profundidade == 1)
            {
                estilo     = paginaAtual.Estilo;
                nomePagina = paginaAtual.Nome;
            }
            else
            {
                var menuAtual = manterPagina.ObterMenuPai(paginaAtual);

                if (menuAtual == null)
                {
                    RedirecionarPaginaInexistente(usuarioLogado, manterPagina, enumPermissaoPagina.PaginaInexistente);
                    return;
                }

                estilo     = menuAtual.Estilo;
                nomePagina = menuAtual.Nome;
            }

            MainBody.Attributes["class"] = estilo;
            NomeLocalizacao.InnerText    = nomePagina;
        }
示例#4
0
        private Dominio.Classes.Pagina ObterPaginaPai()
        {
            var manterPagina = new ManterPagina();

            var paginaPaiId = int.Parse(hdnIdPaginaPai.Value);

            return(paginaPaiId == 0 ? null : manterPagina.ObterPaginaPorID(paginaPaiId, true, true));
        }
示例#5
0
        private bool VerificarPermissaoPagina(Usuario usuarioLogado, ManterPagina manterPagina, Dominio.Classes.Pagina paginaAtual)
        {
            if (Request.Url.AbsolutePath.ToLower() == "/paginas.aspx" && usuarioLogado.SuperAdministrador)
            {
                MainBody.Attributes["class"] = "paginas";
                NomeLocalizacao.InnerText    = "Páginas";

                sidebar.Visible = false;
                contentArea.Attributes.Remove("class");

                return(false);
            }

            // Verificar se a página atual foi cadastrada.
            if (paginaAtual == null)
            {
                RedirecionarPaginaInexistente(usuarioLogado, manterPagina, enumPermissaoPagina.PaginaInexistente);
                return(false);
            }

            // Verificar permissão de Perfil.
            if (!paginaAtual.TodosPerfis)
            {
                if (!usuarioLogado.ListaPerfil.Any(lp => paginaAtual.Perfis.Any(p => p.ID == lp.Perfil.ID)))
                {
                    // Usuário não possui perfil para visualizar a página.
                    RedirecionarPaginaInexistente(usuarioLogado, manterPagina, enumPermissaoPagina.PerfilNaoPermitido);
                    return(false);
                }
            }

            // Verificar permissão de UF.
            if (!paginaAtual.TodasUfs)
            {
                if (paginaAtual.Ufs.All(u => u.ID != usuarioLogado.UF.ID) && usuarioLogado.UF.IsNacionalizado())
                {
                    // Usuário não está em uma UF com permissão para visualizar a página.
                    RedirecionarPaginaInexistente(usuarioLogado, manterPagina, enumPermissaoPagina.UfNaoAutorizada);
                    return(false);
                }
            }

            // Verificar permissão de Nível Ocupacional.
            if (!paginaAtual.TodosNiveisOcupacionais)
            {
                if (paginaAtual.NiveisOcupacionais.All(n => n.ID != usuarioLogado.NivelOcupacional.ID))
                {
                    // Usuário está em um Nível Ocupacional para visualizar a página.
                    RedirecionarPaginaInexistente(usuarioLogado, manterPagina, enumPermissaoPagina.NivelOcupacionalNaoAutorizado);
                    return(false);
                }
            }

            return(true);
        }
        private Dominio.Classes.Pagina ObterPaginaAtual()
        {
            // Certifica que a página atual está salva na sessão.
            if (Session["paginaAtual"] == null)
            {
                var manterPagina = new ManterPagina();

                Session["paginaAtual"] = manterPagina.ObterPaginaPorCaminhoRelativo(Request.Url.PathAndQuery) ??
                                         manterPagina.ObterPaginaPorCaminhoRelativo(Request.Url.AbsolutePath);
            }

            return(Session["paginaAtual"] as Dominio.Classes.Pagina);
        }
示例#7
0
        // Métodos
        private void AtualizarGridView()
        {
            var manterPagina = new ManterPagina();

            var paginas = manterPagina.ObterTodasPaginas(true, false, false);

            if (Request["nivel"] != null)
            {
                int profundidade;

                switch (Request["nivel"])
                {
                case "menu":
                    profundidade = 1;
                    break;

                case "agrupador":
                    profundidade = 2;
                    break;

                case "pagina":
                    profundidade = 3;
                    break;

                case "cadastro":
                    profundidade = 4;
                    break;

                case "subcadastro":
                    profundidade = 5;
                    break;

                default:
                    profundidade = 0;
                    break;
                }

                ddlFiltroProfundidade.SelectedValue = profundidade.ToString();

                if (profundidade != 0)
                {
                    paginas = paginas.Where(p => p.Profundidade <= profundidade);
                }
            }

            gdvPaginas.DataSource = paginas;
            gdvPaginas.DataBind();
        }
示例#8
0
        private void ExcluirPagina(int paginaId)
        {
            var manterPagina = new ManterPagina();

            try
            {
                manterPagina.ExcluirPagina(paginaId);

                WebFormHelper.ExibirMensagem(enumTipoMensagem.Sucesso, "Página excluída com sucesso");

                AtualizarGridView();
            }
            catch (AcademicoException ex)
            {
                WebFormHelper.ExibirMensagem(enumTipoMensagem.Erro, string.Format(ex.Message));
            }
        }
示例#9
0
        /// <summary>
        /// Caso a página sendo acessada não exista, redireciona Super Administrador para a página de gerenciamento de páginas ou usuário comum para a página inicial ou para o Login, caso não haja página inicial.
        /// </summary>
        /// <param name="usuarioLogado"></param>
        /// <param name="manterPagina"></param>
        private void RedirecionarPaginaInexistente(Usuario usuarioLogado, ManterPagina manterPagina, enumPermissaoPagina erroPermissaoEnum)
        {
            string redirect;

            if (usuarioLogado.SuperAdministrador)
            {
                redirect = "/Paginas.aspx";
            }
            else
            {
                var paginaInicial = manterPagina.ObterPaginaInicial();
                redirect = paginaInicial != null ? paginaInicial.CaminhoRelativo : "/Default.aspx?logout=0";
            }

            string mensagem;

            switch (erroPermissaoEnum)
            {
            case enumPermissaoPagina.PaginaInexistente:
                mensagem = "A página selecionada não existe";
                break;

            case enumPermissaoPagina.PerfilNaoPermitido:
                mensagem = "Seu perfil de usuário não está autorizado a visualizar esta página";
                break;

            case enumPermissaoPagina.UfNaoAutorizada:
                mensagem = "Sua UF (" + usuarioLogado.UF.Nome + ") não está autorizada a visualizar esta página";
                break;

            case enumPermissaoPagina.NivelOcupacionalNaoAutorizado:
                mensagem = "Seu Nível Ocupacional (" + usuarioLogado.NivelOcupacional.Nome + ") não está autorizado a visualizar esta página";
                break;

            default:
                mensagem = "Página não autorizada";
                break;
            }

            mensagem += "<br/>Contate um administrador do sistema";

            WebFormHelper.ExibirMensagem(enumTipoMensagem.Atencao, mensagem, redirect);
        }
示例#10
0
        private Dominio.Classes.Pagina ObterObjetoPagina()
        {
            ValidarPagina();

            var manterPagina = new ManterPagina();

            var paginaId = int.Parse(hdnIdPagina.Value);

            var pagina = paginaId == 0 ? new Dominio.Classes.Pagina() : manterPagina.ObterPaginaPorID(paginaId);

            var tipoPagina = (enumTipoPagina)int.Parse(hdnTipoPagina.Value);

            // Nome
            pagina.Nome = (tipoPagina != enumTipoPagina.CadastroEdicao && tipoPagina != enumTipoPagina.Subcadastro) ? txtNome.Text.Trim() : null;

            // Descrição
            pagina.Descricao = string.IsNullOrWhiteSpace(txtDescricao.Text.Trim()) ? null : txtDescricao.Text.Trim();

            // Limpar permissões.
            pagina.RemoverTodosPerfis();
            pagina.RemoverTodasUfs();
            pagina.RemoverTodosNiveisOcupacionais();

            pagina.ConsiderarNacionalizacaoUf = ckbConsiderarNacionalizacaoUf.Checked;

            // Perfis
            if (ckbTodosPerfis.Checked)
            {
                pagina.TodosPerfis = true;
            }
            else
            {
                pagina.TodosPerfis = false;
                ObterPerfisSelecionados(pagina);
            }

            // Ufs
            if (ckbTodasUfs.Checked)
            {
                pagina.TodasUfs = true;
            }
            else
            {
                pagina.TodasUfs = false;
                ObterUfsSelecionadas(pagina);
            }

            // Níveis ocupacionais
            if (ckbTodosNiveisOcupacionais.Checked)
            {
                pagina.TodosNiveisOcupacionais = true;
            }
            else
            {
                pagina.TodosNiveisOcupacionais = false;
                ObterNiveisOcupacionaisSelecionados(pagina);
            }


            // Caminho Relativo.
            if (tipoPagina != enumTipoPagina.Agrupador)
            {
                pagina.CaminhoRelativo = FormatarCaminhoRelativo();

                if (!ckbPaginaInicial.Checked)
                {
                    pagina.Titulo = txtTitulo.Text.Trim();
                }
            }

            switch (tipoPagina)
            {
            case enumTipoPagina.Container:
                throw new AcademicoException("Página inválida");

            case enumTipoPagina.Menu:
                // Estilo.
                pagina.Estilo = ddlEstilo.SelectedValue;

                // Ícone.
                pagina.IconeMenu = hddIcone.Value;

                // Página inicial.
                if (ckbPaginaInicial.Checked)
                {
                    pagina.PaginaInicial = true;
                }

                // Descrição Administrador
                pagina.DescricaoAdministrador = string.IsNullOrWhiteSpace(txtDescricaoAdministrador.Text.Trim()) ? null : txtDescricaoAdministrador.Text.Trim();

                // Descrição Gestor
                pagina.DescricaoGestor = string.IsNullOrWhiteSpace(txtDescricaoGestor.Text.Trim()) ? null : txtDescricaoGestor.Text.Trim();

                break;

            case enumTipoPagina.Agrupador:
                // Ícone padrão.
                pagina.IconePaginas = string.IsNullOrEmpty(txtIconePaginas.Text) ? null : txtIconePaginas.Text;

                break;

            case enumTipoPagina.Pagina:
                pagina.IconeMenu = string.IsNullOrEmpty(hddIcone.Value) ? null : hddIcone.Value;
                break;

            case enumTipoPagina.CadastroEdicao:
                // Ícone.
                pagina.IconeMenu         = hddIcone.Value;
                pagina.ChaveVerificadora = txtChaveVerificadora.Text;

                break;

            case enumTipoPagina.Subcadastro:
                pagina.ChaveVerificadora = txtChaveVerificadora.Text;

                break;

            default:
                throw new ArgumentOutOfRangeException();
            }


            return(pagina);
        }
示例#11
0
        private void ExibirModalEdicao(int paginaId)
        {
            var manterPagina = new ManterPagina();

            var pagina = manterPagina.ObterPaginaPorID(paginaId, true);

            // Setar título do Modal.
            modalCadastrarPaginaTitulo.InnerText = "Editar " + pagina.Nome + " (" + pagina._ObterTipoPagina.ToLower() + ")";

            var tipoPagina = pagina.ObterTipoPagina();

            hdnIdPagina.Value = pagina.ID.ToString();
            txtNome.Text      = pagina.Nome;
            txtDescricao.Text = pagina.Descricao;

            hdnTipoPagina.Value = pagina.Profundidade.ToString();

            // Perfis.
            ckbTodosPerfis.Checked = pagina.TodosPerfis;

            if (!pagina.TodosPerfis)
            {
                ckbTodosPerfis_OnCheckedChanged(null, null);

                foreach (ListItem item in ckblPerfis.Items)
                {
                    item.Selected = pagina.Perfis.Any(x => x.ID.ToString() == item.Value);
                }
            }

            if (pagina.ConsiderarNacionalizacaoUf.HasValue)
            {
                ckbConsiderarNacionalizacaoUf.Checked = pagina.ConsiderarNacionalizacaoUf.Value;
            }

            ckbTodasUfs.Checked = pagina.TodasUfs;

            if (!pagina.TodasUfs)
            {
                ckbTodasUfs_OnCheckedChanged(null, null);

                foreach (ListItem item in ckblUfs.Items)
                {
                    item.Selected = pagina.Ufs.Any(x => x.ID.ToString() == item.Value);
                }
            }

            // Níveis ocupacionais.
            ckbTodosNiveisOcupacionais.Checked = pagina.TodosNiveisOcupacionais;

            if (!pagina.TodosNiveisOcupacionais)
            {
                ckbTodosNiveisOcupacionais_OnCheckedChanged(null, null);

                foreach (ListItem item in cbklNiveisOcupacionais.Items)
                {
                    item.Selected = pagina.NiveisOcupacionais.Any(x => x.ID.ToString() == item.Value);
                }
            }

            if (tipoPagina != enumTipoPagina.Agrupador)
            {
                txtCaminhoRelativo.Text = pagina.CaminhoRelativo;
                txtTitulo.Text          = pagina.Titulo;
            }

            switch (tipoPagina)
            {
            case enumTipoPagina.Container:
                throw new AcademicoException("Página inválida");

            case enumTipoPagina.Menu:
                divEstilo.Visible        = true;
                divPaginaInicial.Visible = true;

                // Atribui valores do campo descricao
                txtDescricaoAdministrador.Text = pagina.DescricaoAdministrador;
                txtDescricaoGestor.Text        = pagina.DescricaoGestor;

                // Habilita campos de descricao no modal de edicao
                divDescricaoAdministrador.Visible = true;
                divDescricaoGestor.Visible        = true;

                divIconeMenu.Visible = true;

                if (pagina.IsPaginaInicial())
                {
                    divTitulo.Visible = false;
                }

                ddlEstilo.SelectedValue = pagina.Estilo;
                ckbConsiderarNacionalizacaoUf.Enabled =
                    !(pagina.PaginaInicial.HasValue && pagina.PaginaInicial.Value);
                ckbPaginaInicial.Checked = pagina.PaginaInicial.HasValue && pagina.PaginaInicial.Value;
                ckbPaginaInicial.Enabled = !(pagina.PaginaInicial.HasValue && pagina.PaginaInicial.Value);
                hddIcone.Value           = pagina.IconeMenu;

                break;

            case enumTipoPagina.Agrupador:
                divCaminhoRelativo.Visible = false;
                divTitulo.Visible          = false;
                divIconePaginas.Visible    = true;
                txtIconePaginas.Text       = pagina.IconePaginas;
                break;

            case enumTipoPagina.Pagina:
                labelIconeMenu.Text  = "Ícone do Menu";
                hddIcone.Value       = pagina.IconeMenu;
                divIconeMenu.Visible = true;
                break;

            case enumTipoPagina.CadastroEdicao:
                divNome.Visible      = false;
                divIconeMenu.Visible = true;
                hddIcone.Value       = pagina.IconeMenu;

                divChaveVerificadora.Visible = true;

                labelTitulo.Text = "Nome do objeto*";
                labelTitulo.Attributes.Add("data-help", Resources.Resource.paginaNomeDoObjeto);

                txtChaveVerificadora.Text = pagina.ChaveVerificadora;

                break;

            case enumTipoPagina.Subcadastro:
                divNome.Visible  = false;
                labelTitulo.Text = "Nome do objeto*";
                labelTitulo.Attributes.Add("data-help", Resources.Resource.paginaNomeDoObjeto);

                divChaveVerificadora.Visible = true;

                txtChaveVerificadora.Text = pagina.ChaveVerificadora;

                break;
            }

            ExibirEstruturaModal();
        }
示例#12
0
        private void PreencherSidebar(ManterPagina manterPagina, Usuario usuarioLogado, Dominio.Classes.Pagina paginaAtual)
        {
            if (paginaAtual.CaminhoRelativo.ToLower() == "/paginas.aspx")
            {
                // Esconde o sidebar e coloca a página em largura máxima.
                sidebar.Visible = false;
                contentArea.Attributes.Remove("class");
            }
            else
            {
                // Coloca a página em largura reduzida para caber o sidebar.
                contentArea.Attributes["class"] = "col-sm-9 conteudo_busca content-area";

                // Obtém o menu atual para filtrar somente pelas páginas dentro desse Menu.
                var menuAtual = paginaAtual.Profundidade == (int)enumTipoPagina.Menu ? paginaAtual : manterPagina.ObterMenuPai(paginaAtual);

                // Obtém todas as páginas com filtro.
                var paginas = manterPagina.ObterTodasPaginas(true).Where(p => p.PossuiPermissao(usuarioLogado) && p.IsFilhoDe(menuAtual)).ToList();

                var sidebarRow = new HtmlGenericControl("div");
                sidebarRow.Attributes["class"] = "row";

                var sidebarDiv = new HtmlGenericControl("div");
                sidebarDiv.Attributes["class"] = "col-sm-12";

                // Preencher os agrupadores
                foreach (var agrupador in paginas.Where(p => p.Profundidade == 2 && p.PossuiFilho() && p.PossuiPermissao(usuarioLogado)))
                {
                    var row = new HtmlGenericControl("div");
                    row.Attributes["class"] = "row";

                    var box = new HtmlGenericControl("div");
                    box.Attributes["class"] = "box";

                    var subtitulo = new HtmlGenericControl("div");
                    subtitulo.Attributes["class"] = "subtitulo";

                    var nome = new HtmlGenericControl("h3");
                    nome.InnerHtml = agrupador.Nome;

                    if (agrupador.IsPaiOuIguala(paginaAtual))
                    {
                        nome.Attributes.Add("class", "text-bold");
                    }

                    var contentBody = new HtmlGenericControl("div");
                    contentBody.Attributes["class"] = "contentBody";

                    var ul = new HtmlGenericControl("ul");
                    ul.Attributes.Add("class", "links");


                    // Preencher as páginas
                    foreach (var pagina in paginas.Where(p => p.Profundidade == 3 && p.IsFilhoDe(agrupador)))
                    {
                        var li = new HtmlGenericControl("li");
                        li.Attributes.Add("class", "menu-item");

                        var linkPagina = new HtmlGenericControl("a");
                        linkPagina.Attributes.Add("class", "menu-nome" + (pagina.IsPaiOuIguala(paginaAtual) ? " text-bold" : ""));
                        linkPagina.Attributes.Add("tittle", "Abrir " + pagina.Nome);
                        linkPagina.Attributes.Add("href", pagina.CaminhoRelativo);
                        linkPagina.InnerHtml = pagina.Nome;

                        var actions = new HtmlGenericControl("span");
                        actions.Attributes.Add("class", "actions visible-md visible-lg");


                        // Preencher cadastro
                        foreach (var cadastro in paginas.Where(p => p.Profundidade == 4 && p.IsFilhoDe(pagina)))
                        {
                            var cadastroIcon = new HtmlGenericControl("a");
                            cadastroIcon.Attributes.Add("href", cadastro.CaminhoRelativo);
                            cadastroIcon.Attributes.Add("class", "glyphicon glyphicon-" + cadastro.IconeMenu
                                                        + " "
                                                        + (cadastro.IsPaiOuIguala(paginaAtual) ? "link-no-underline" : " menu-relatar"));

                            actions.Controls.Add(cadastroIcon);
                        }


                        var linkIcon = new HtmlGenericControl("a");
                        linkIcon.Attributes.Add("href", pagina.CaminhoRelativo);
                        // Insere ícone padrão do agrupador ou ícone personalizado caso tenha sido informado.
                        linkIcon.Attributes.Add("class", "glyphicon glyphicon-"
                                                + (string.IsNullOrEmpty(pagina.IconeMenu) ? agrupador.IconePaginas : pagina.IconeMenu)
                                                + " "
                                                + (pagina.ID == paginaAtual.ID ? "link-no-underline" : "menu-relatar"));

                        actions.Controls.Add(linkIcon);

                        li.Controls.Add(linkPagina);
                        li.Controls.Add(actions);

                        ul.Controls.Add(li);
                    }

                    // Insere os controles em hierarquia.
                    contentBody.Controls.Add(ul);

                    subtitulo.Controls.Add(nome);
                    subtitulo.Controls.Add(contentBody);

                    box.Controls.Add(subtitulo);

                    row.Controls.Add(box);

                    sidebarDiv.Controls.Add(box);
                }

                sidebarRow.Controls.Add(sidebarDiv);

                sidebar.Controls.Add(sidebarRow);
            }
        }
示例#13
0
        protected void Page_Load(object sender, EventArgs e)
        {
            // Forçar a criação do evento de javascript __doPostBack para uso no Autocomplete.
            Page.ClientScript.GetPostBackEventReference(this, string.Empty);

            // Exibir mensagem de alerta.
            RecuperarMensageSessao();

            // Verificar simulação de perfil.
            VerificarSimulacaoPerfil();

            var manterPagina = new ManterPagina();

            var usuarioLogado = new ManterUsuario().ObterUsuarioLogado();

            // Salva o estado do usuário logado na sessão para usar nas HelperTags.
            Session["UsuarioLogadoIsAdmin"] = usuarioLogado.IsAdministrador();

            // Obter objeto da página atual.
            var paginaAtual = ObterPaginaAtual(manterPagina);

            // Salva a página atual para ser usada pelas HelperTags.
            Session["paginaAtual"] = paginaAtual;

            // Setar nome da página.
            SetarTituloPagina(paginaAtual, usuarioLogado);
            //var bmLogAcessoPagina = new BMLogAcessoPagina();
            //bmLogAcessoPagina.PreSave(usuarioLogado, paginaAtual);
            if (!IsPostBack)
            {
                var queryString = HttpContext.Current.Request.QueryString.ToString();
                var ip          = HttpContext.Current.Request.UserHostAddress;

                var log = new LogAcessoPagina
                {
                    IDUsuario     = usuarioLogado,
                    Pagina        = paginaAtual,
                    QueryString   = queryString,
                    Acao          = enumAcaoNaPagina.Visualizacao,
                    DTSolicitacao = DateTime.Now,
                    IP            = ip
                };

                new BMLogAcessoPagina().Salvar(log);
            }

            if (VerificarPermissaoPagina(usuarioLogado, manterPagina, paginaAtual))
            {
                // Setar estilo atual.
                EstilizarPagina(usuarioLogado, manterPagina, paginaAtual);

                // Preencher sidebar.
                PreencherSidebar(manterPagina, usuarioLogado, paginaAtual);
            }

            // Preencher Menu
            PreencherMenu(manterPagina, usuarioLogado);

            // Por causa do GoogleCharts não ser responsivo, indica ao javscript para recarregar
            // a página no collapse do menu lateral, para recarregar os componentes.
            if (paginaAtual != null && paginaAtual.CaminhoRelativo == "/Dashboard.aspx")
            {
                menuCollapse.Attributes.Add("data-postback", "1");
            }

            (ManterLogSincronia.Instance).IniciarThread();
        }