static void Main(string[] args)
        {
            Console.WriteLine("Executando...");
            try
            {
                // Busca todos os usuários dos sistema
                // que devem ter a senha alterada (grupos específicos que não estejam marcados para expirar senha).
                DataTable dtUsuarios        = SYS_UsuarioBO.SelecionaUsuariosSenhaPadrao();
                string    usuariosAtualizar = string.Empty;

                // Variáveis utilizadas para fazer a atualização aos poucos, porque senão não cabe na variável.
                int       contador     = 0;
                const int maxAtualizar = 100;

                // Percorre a lista de usuários
                foreach (DataRow drUsuario in dtUsuarios.Rows)
                {
                    contador++;

                    // Aplica a criptografia na senha padrão
                    eCriptografa criptografia = (eCriptografa)Enum.Parse(typeof(eCriptografa), drUsuario["usu_criptografia"].ToString(), true);
                    string       senhaPadrao  = UtilBO.CriptografarSenha(drUsuario["senhaPadrao"].ToString(), criptografia);

                    // Compara a criptografia com a senha do usuário
                    string senhaAtual = drUsuario["usu_senha"].ToString();
                    if (UtilBO.EqualsSenha(senhaAtual, senhaPadrao, criptografia))
                    {
                        // Se for a mesma, coloco o usuário para expirar a senha (usu_situacao = 5)
                        if (string.IsNullOrEmpty(usuariosAtualizar))
                        {
                            usuariosAtualizar = drUsuario["usu_id"].ToString();
                        }
                        else
                        {
                            usuariosAtualizar += string.Format(",{0}", drUsuario["usu_id"].ToString());
                        }
                    }

                    if (contador == maxAtualizar && !string.IsNullOrEmpty(usuariosAtualizar))
                    {
                        SYS_UsuarioBO.ExpiraUsuariosSenhaPadrao(usuariosAtualizar);
                        contador          = 0;
                        usuariosAtualizar = string.Empty;
                    }
                }

                if (!string.IsNullOrEmpty(usuariosAtualizar))
                {
                    SYS_UsuarioBO.ExpiraUsuariosSenhaPadrao(usuariosAtualizar);
                }

                Console.WriteLine("Usuários atualizados com sucesso!");
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }

            Console.ReadLine();
        }
Exemple #2
0
    private void Salvar()
    {
        // Configura criptografia da senha
        eCriptografa criptografia = (eCriptografa)Enum.Parse(typeof(eCriptografa), Convert.ToString(__SessionWEB.__UsuarioWEB.Usuario.usu_criptografia), true);

        if (!Enum.IsDefined(typeof(eCriptografa), criptografia))
        {
            criptografia = eCriptografa.SHA512;
        }

        try
        {
            if (UtilBO.EqualsSenha(__SessionWEB.__UsuarioWEB.Usuario.usu_senha, UtilBO.CriptografarSenha(txtSenhaAtual.Text, criptografia), criptografia))
            {
                // Configura entidade SYS_Usuario
                SYS_Usuario entityUsuario = new SYS_Usuario {
                    usu_id = __SessionWEB.__UsuarioWEB.Usuario.usu_id
                };
                SYS_UsuarioBO.GetEntity(entityUsuario);
                if (!string.IsNullOrEmpty(txtNovaSenha.Text))
                {
                    entityUsuario.usu_senha        = txtNovaSenha.Text;
                    entityUsuario.usu_criptografia = (byte)eCriptografa.SHA512;
                }

                entityUsuario.usu_email = txtEmail.Text;
                // Altera os dados do usuário
                SYS_UsuarioBO.AlterarDadosUsuario(entityUsuario, !string.IsNullOrEmpty(txtNovaSenha.Text));
                // Grava Log de sistema
                ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Update, "usu_id: " + entityUsuario.usu_id);
                Response.Redirect(ApplicationWEB._DiretorioVirtual + ApplicationWEB._PaginaLogoff, false);
            }
            else
            {
                string mensagemSenhaAtualInvalida = SYS_MensagemSistemaBO.RetornaValor(SYS_MensagemSistemaChave.MeusDadosMensagemSenhaAtualIncorreta);
                lblMessage.Text = UtilBO.GetErroMessage(string.IsNullOrEmpty(mensagemSenhaAtualInvalida) ? "Senha atual inválida." : mensagemSenhaAtualInvalida, UtilBO.TipoMensagem.Alerta);
            }
        }
        catch (DuplicateNameException ex)
        {
            lblMessage.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Alerta);
        }
        catch (ValidationException ex)
        {
            lblMessage.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Alerta);
        }
        catch (ArgumentException ex)
        {
            lblMessage.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Alerta);
        }
        catch (Exception ex)
        {
            ApplicationWEB._GravaErro(ex);
            lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar salvar o usuário.", UtilBO.TipoMensagem.Erro);
        }
    }
        /// <summary>
        /// Salvar a senha do usuário no hitórico
        /// </summary>
        /// <param name="usu">Objeto Usuário carregado do autenticador</param>
        /// <param name="retornoWebService">Retorno do Webservice do cliente (por enquanto configurado o de Integração Externa : 0 [sucesso] e -1 [não encontrado / usuário ou senha não estão corretos])</param>
        /// <returns>Enum LoginStatus: 0 [Sucesso] ou  5[Erro]</returns>
        public static LoginStatus SalvarSenhaUsuario(SYS_Usuario usu, string retornoWebService)
        {
            SYS_UsuarioSenhaHistoricoDAO dao = new SYS_UsuarioSenhaHistoricoDAO();
            LoginStatus status = LoginStatus.Sucesso;

            try
            {
                if (retornoWebService.Equals("0"))
                {
                    string senhaDescriptografada = usu.usu_senha;
                    dao._Banco.Open(IsolationLevel.ReadCommitted);


                    eCriptografa criptografia = (eCriptografa)Enum.Parse(typeof(eCriptografa), Convert.ToString(usu.usu_criptografia), true);

                    if (!Enum.IsDefined(typeof(eCriptografa), criptografia))
                    {
                        criptografia = eCriptografa.TripleDES;
                    }

                    usu.usu_senha = UtilBO.CriptografarSenha(usu.usu_senha, criptografia);

                    if (SYS_UsuarioSenhaHistoricoBO.Salvar(usu, dao._Banco))
                    {
                        status = LoginStatus.Sucesso;
                    }
                }
                else if (retornoWebService.Equals("-1"))
                {// CASO NÃO ENCONTRE O USUARIO OU A SENHA NÃO ESTEJA EM CONFORME
                    status = LoginStatus.NaoEncontrado;
                }
                else
                {// OUTRO ERRO
                    status = LoginStatus.Erro;
                }
            }
            catch (Exception e)
            {
                status = LoginStatus.Erro;
                dao._Banco.Close(e);
                // msg("Houve um erro na autenticação (SOAP).")
            }
            finally
            {
                dao._Banco.Close();
            }
            return(status);
        }
    public static bool ValidarSenhaAtual(string senhaAtual, Guid usu_id)
    {
        SYS_Usuario entityUsuario = new SYS_Usuario {
            usu_id = usu_id
        };

        SYS_UsuarioBO.GetEntity(entityUsuario);

        eCriptografa criptografia = (eCriptografa)Enum.Parse(typeof(eCriptografa), Convert.ToString(entityUsuario.usu_criptografia), true);

        if (!Enum.IsDefined(typeof(eCriptografa), criptografia))
        {
            criptografia = eCriptografa.SHA512;
        }

        return(UtilBO.EqualsSenha(entityUsuario.usu_senha, UtilBO.CriptografarSenha(senhaAtual, criptografia), criptografia));
    }
        public void SetPassword(CSEntry csentry, string NewPassword)
        {
            List <SYS_Usuario> ltUsuario = SYS_UsuarioBO.SelecionaPorLogin(csentry.DN.ToString());

            foreach (SYS_Usuario usuario in ltUsuario)
            {
                try
                {
                    // Configura criptografia da senha
                    eCriptografa criptografia = (eCriptografa)Enum.Parse(typeof(eCriptografa), Convert.ToString(usuario.usu_criptografia), true);
                    if (!Enum.IsDefined(typeof(eCriptografa), criptografia))
                    {
                        criptografia = eCriptografa.TripleDES;
                    }
                    string novaSenhaCript = UtilBO.CriptografarSenha(NewPassword, criptografia);

                    if (!novaSenhaCript.Equals(usuario.usu_senha))
                    {
                        LOG_UsuarioAD logUsuario = new LOG_UsuarioAD
                        {
                            usu_id = usuario.usu_id
                            ,
                            usa_acao = (short)LOG_UsuarioAD.eAcao.AlterarSenha
                            ,
                            usa_status = (short)LOG_UsuarioAD.eStatus.Pendente
                            ,
                            usa_dataAcao = DateTime.Now
                            ,
                            usa_origemAcao = (short)LOG_UsuarioAD.eOrigem.AD
                            ,
                            usa_dados = LOG_UsuarioADBO.GetDadosUsuarioAD(usuario, NewPassword)
                        };

                        LOG_UsuarioADBO.Save(logUsuario);
                    }
                }
                catch (Exception ex)
                {
                    UtilBO.GravarErro(ex);
                }
            }
        }
        /// <summary>
        /// Valida senha do usuário no histórico
        /// </summary>
        /// <param name="usu">Objeto Usuário carregado do autenticador</param>
        /// <returns>Enum LoginStatus : Sucesso, Expirado, Bloqueado e SenhaInvalida</returns>
        public static LoginStatus ValidarUsuarioHistoricoSenha(SYS_Usuario usu)
        {
            LoginStatus status  = LoginStatus.Sucesso;
            DataTable   dtSenha = SYS_UsuarioSenhaHistoricoBO.SelecionaUltimaSenha(usu.usu_id, null);

            if (dtSenha.Rows.Count > 0)
            {
                string senhaSalva = dtSenha.Rows[0]["ush_senha"].ToString();
                string senha      = usu.usu_senha;

                eCriptografa criptografia = (eCriptografa)Enum.Parse(typeof(eCriptografa), Convert.ToString(usu.usu_criptografia), true);

                if (!Enum.IsDefined(typeof(eCriptografa), criptografia))
                {
                    criptografia = eCriptografa.TripleDES;
                }

                usu.usu_senha = UtilBO.CriptografarSenha(usu.usu_senha, criptografia);

                if (!senhaSalva.Equals(usu.usu_senha))
                {
                    status = LoginStatus.SenhaInvalida;
                }
                else if ((usu.usu_situacao == 2) || (usu.usu_situacao == 3))
                {
                    status = LoginStatus.Bloqueado;
                }
                else if (usu.usu_situacao == 5)
                {
                    status = LoginStatus.Expirado;
                }
                else
                {
                    status = LoginStatus.Sucesso;
                }
            }

            return(status);
        }
Exemple #7
0
    /// <summary>
    /// Validação de senha de acordo com suas senhas anteriores.
    /// </summary>
    /// <param name="novaSenha">Nova senha.</param>
    /// <param name="usu_id">ID do usuário.</param>
    /// <returns></returns>
    public static bool ValidarHistoricoSenha(string novaSenha, Guid usu_id)
    {
        if (SYS_ParametroBO.ParametroValorBooleano(SYS_ParametroBO.eChave.SALVAR_HISTORICO_SENHA_USUARIO))
        {
            SYS_Usuario entityUsuario = new SYS_Usuario {
                usu_id = usu_id
            };
            SYS_UsuarioBO.GetEntity(entityUsuario);

            List <SYS_UsuarioSenhaHistorico> listaHistoricoSenhas = SYS_UsuarioSenhaHistoricoBO.SelecionaUltimasSenhas(entityUsuario.usu_id);

            // Configura criptografia da senha
            eCriptografa criptografia = (eCriptografa)Enum.Parse(typeof(eCriptografa), Convert.ToString(entityUsuario.usu_criptografia), true);
            if (!Enum.IsDefined(typeof(eCriptografa), criptografia))
            {
                criptografia = eCriptografa.SHA512;
            }

            return(!listaHistoricoSenhas.Any(p => p.ush_senha == UtilBO.CriptografarSenha(novaSenha, criptografia) && p.ush_criptografia == entityUsuario.usu_criptografia));
        }

        return(true);
    }
Exemple #8
0
        public HttpResponseMessage UpdatePassword([FromBody] RedefinirSenhaEntradaDTO data)
        {
            RedefinirSenhaSaidaDTO retorno = new RedefinirSenhaSaidaDTO();

            try
            {
                SYS_Usuario entity = new SYS_Usuario
                {
                    ent_id = data.ent_id
                    ,
                    usu_login = data.usu_login
                };
                SYS_UsuarioBO.GetSelectBy_ent_id_usu_login(entity);

                // Verifica se o id do usuário enviado existe na base de dados.
                if (entity.IsNew)
                {
                    retorno.Message    = "Usuário não encontrado.";
                    retorno.statusCode = (int)HttpStatusCode.NotFound;
                    return(Request.CreateResponse <RedefinirSenhaSaidaDTO>(HttpStatusCode.NotFound, retorno));
                }

                // Configura criptografia da senha
                eCriptografa criptografia = (eCriptografa)Enum.Parse(typeof(eCriptografa), Convert.ToString(entity.usu_criptografia), true);
                if (!Enum.IsDefined(typeof(eCriptografa), criptografia))
                {
                    criptografia = eCriptografa.TripleDES;
                }

                if (!UtilBO.EqualsSenha(entity.usu_senha, data.senhaAtual, criptografia))
                {
                    retorno.Message    = "Senha atual inválida.";
                    retorno.statusCode = (int)HttpStatusCode.Unauthorized;
                    return(Request.CreateResponse <RedefinirSenhaSaidaDTO>(HttpStatusCode.Unauthorized, retorno));
                }

                if (data.senhaAtual.Equals(data.senhaNova))
                {
                    retorno.Message    = "Senha nova deve ser diferente da atual.";
                    retorno.statusCode = (int)HttpStatusCode.BadRequest;
                    return(Request.CreateResponse <RedefinirSenhaSaidaDTO>(HttpStatusCode.BadRequest, retorno));
                }

                entity.usu_senha = data.senhaNova;

                SYS_UsuarioBO.AlterarSenhaUsuario(entity, false);

                retorno.Message    = "Senha alterada com sucesso.";
                retorno.statusCode = (int)HttpStatusCode.OK;

                CFG_UsuarioAPI entityUsuarioAPI = CFG_UsuarioAPIBO.SelecionaPorUsername(data.uap_username);

                LOG_UsuarioAPIBO.Save
                (
                    new LOG_UsuarioAPI
                {
                    usu_id = entity.usu_id
                    ,
                    uap_id = entityUsuarioAPI.uap_id
                    ,
                    lua_dataHora = DateTime.Now
                    ,
                    lua_acao = (byte)LOG_UsuarioAPIBO.eAcao.AlteracaoSenha
                }
                );

                return(Request.CreateResponse <RedefinirSenhaSaidaDTO>(HttpStatusCode.OK, retorno));
            }
            catch (Exception ex)
            {
                retorno.Message    = ex.Message;
                retorno.statusCode = (int)HttpStatusCode.InternalServerError;
                Util.GravarErro(ex);
                return(Request.CreateResponse <RedefinirSenhaSaidaDTO>(HttpStatusCode.InternalServerError, retorno));
            }
        }
    protected void _btnSalvar_Click(object sender, EventArgs e)
    {
        if (ValidarAlterarSenha())
        {
            try
            {
                SYS_Usuario entityUsuario = new SYS_Usuario
                {
                    ent_id = new Guid(UCComboEntidade1._Combo.SelectedValue)
                    ,
                    usu_login = _txtLogin.Text
                };
                SYS_UsuarioBO.GetSelectBy_ent_id_usu_login(entityUsuario);

                eCriptografa criptografia = (eCriptografa)Enum.Parse(typeof(eCriptografa), Convert.ToString(entityUsuario.usu_criptografia), true);
                if (!Enum.IsDefined(typeof(eCriptografa), criptografia))
                {
                    criptografia = eCriptografa.SHA512;
                }

                if (!UtilBO.EqualsSenha(entityUsuario.usu_senha, UtilBO.CriptografarSenha(_txtSenhaAtual.Text, criptografia), criptografia))
                {
                    string mensagemSenhaAtualInvalida = SYS_MensagemSistemaBO.RetornaValor(SYS_MensagemSistemaChave.MeusDadosMensagemSenhaAtualIncorreta);

                    _lblMessageAlterarSenha.Text = UtilBO.GetErroMessage(string.IsNullOrEmpty(mensagemSenhaAtualInvalida) ? "Senha atual inválida." : mensagemSenhaAtualInvalida, UtilBO.TipoMensagem.Erro);
                    _updAlterarSenha.Update();

                    ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Login, "Erro ao alterar senha. Senha atual inválida.");
                }
                else
                {
                    entityUsuario.usu_situacao      = 1;
                    entityUsuario.usu_senha         = _txtNovaSenha.Text;
                    entityUsuario.usu_dataAlteracao = DateTime.Now;
                    entityUsuario.usu_criptografia  = (byte)eCriptografa.SHA512;
                    SYS_UsuarioBO.AlterarSenhaAtualizarUsuario(entityUsuario, entityUsuario.usu_integracaoAD == (byte)SYS_UsuarioBO.eIntegracaoAD.IntegradoADReplicacaoSenha);

                    LoadSession(entityUsuario);
                    ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Login, "Senha alterada com sucesso.");

                    string mensagemSenhaAlterada = SYS_MensagemSistemaBO.RetornaValor(SYS_MensagemSistemaChave.LoginMensagemSenhaAlteradaSucesso);

                    __SessionWEB.PostMessages = UtilBO.GetErroMessage(string.IsNullOrEmpty(mensagemSenhaAlterada) ? "Senha alterada com sucesso." : mensagemSenhaAlterada, UtilBO.TipoMensagem.Sucesso);

                    SYS_UsuarioFalhaAutenticacaoBO.ZeraFalhaAutenticacaoUsuario(entityUsuario.usu_id);

                    ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Login, "Login efetuado com sucesso.");

                    SignHelper.AutenticarUsuario(entityUsuario);

                    LoadSession(entityUsuario);

                    RedirecionarLogin(entityUsuario.usu_id);
                }
            }
            catch (DuplicateNameException ex)
            {
                _lblMessage.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Alerta);
                ScriptManager.RegisterClientScriptBlock(this, GetType(), "AlterarSenhaErro", "$('#divAlterarSenha').dialog('close');", true);
            }
            catch (ArgumentException ex)
            {
                _lblMessage.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Alerta);
                ScriptManager.RegisterClientScriptBlock(this, GetType(), "AlterarSenhaErro", "$('#divAlterarSenha').dialog('close');", true);
            }
            catch (ValidationException ex)
            {
                _lblMessage.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Alerta);
                ScriptManager.RegisterClientScriptBlock(this, GetType(), "AlterarSenhaErro", "$('#divAlterarSenha').dialog('close');", true);
            }
            catch (Exception ex)
            {
                ApplicationWEB._GravaErro(ex);

                _lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar alterar a senha do usuário.", UtilBO.TipoMensagem.Erro);
                ScriptManager.RegisterClientScriptBlock(this, GetType(), "AlterarSenhaErro", "$('#divAlterarSenha').dialog('close');", true);
            }
        }
        else
        {
            _updAlterarSenha.Update();
        }
    }
Exemple #10
0
        protected void _btnSalvar_Click(object sender, EventArgs e)
        {
            if (ValidarAlterarSenha())
            {
                try
                {
                    // Carrega os dados do usuário
                    SYS_Usuario entityUsuario = new SYS_Usuario
                    {
                        ent_id = UCComboEntidade1.Valor
                        ,
                        usu_login = (RadioButtonList1.SelectedIndex == 0
                                        ? ACA_ParametroAcademicoBO.ParametroValorPorEntidade(eChaveAcademico.PREFIXO_LOGIN_ALUNO_AREA_ALUNO, Guid.Empty)
                                        : ACA_ParametroAcademicoBO.ParametroValorPorEntidade(eChaveAcademico.PREFIXO_LOGIN_RESPONSAVEL_AREA_ALUNO, Guid.Empty)) + txtLogin.Text
                    };
                    SYS_UsuarioBO.GetSelectBy_ent_id_usu_login(entityUsuario);

                    // Configura criptografia da senha
                    eCriptografa criptografia = (eCriptografa)Enum.Parse(typeof(eCriptografa), Convert.ToString(entityUsuario.usu_criptografia), true);
                    if (!Enum.IsDefined(typeof(eCriptografa), criptografia))
                    {
                        criptografia = eCriptografa.TripleDES;
                    }

                    // Verifica a senha do usuário comparando com a senha atual
                    if (!UtilBO.EqualsSenha(entityUsuario.usu_senha, UtilBO.CriptografarSenha(_txtSenhaAtual.Text, criptografia), criptografia))
                    {
                        string mensagemSenhaAtualInvalida = SYS_MensagemSistemaBO.RetornaValor(SYS_MensagemSistemaChave.MeusDadosMensagemSenhaAtualIncorreta);

                        _lblMessageAlterarSenha.Text = UtilBO.GetErroMessage(string.IsNullOrEmpty(mensagemSenhaAtualInvalida) ? "Senha atual inválida." : mensagemSenhaAtualInvalida, UtilBO.TipoMensagem.Erro);
                        _updAlterarSenha.Update();

                        ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Login, "Erro ao alterar senha. Senha atual inválida.");
                    }
                    else
                    {
                        // Atualiza dados do usuário
                        entityUsuario.usu_situacao      = 1;
                        entityUsuario.usu_senha         = _txtNovaSenha.Text;
                        entityUsuario.usu_dataAlteracao = DateTime.Now;
                        SYS_UsuarioBO.AlterarSenhaAtualizarUsuario(entityUsuario, entityUsuario.usu_integracaoAD == (byte)SYS_UsuarioBO.eIntegracaoAD.IntegradoADReplicacaoSenha);

                        // Configura usuário na Session
                        LoadSession(entityUsuario);
                        ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Login, "Senha alterada com sucesso.");

                        string mensagemSenhaAlterada = SYS_MensagemSistemaBO.RetornaValor(SYS_MensagemSistemaChave.LoginMensagemSenhaAlteradaSucesso);

                        __SessionWEB.PostMessages = UtilBO.GetErroMessage(string.IsNullOrEmpty(mensagemSenhaAlterada) ? "Senha alterada com sucesso." : mensagemSenhaAlterada, UtilBO.TipoMensagem.Sucesso);

                        // Autenticação SAML.
                        SYS_UsuarioBO.AutenticarUsuario(entityUsuario);

                        // Configura usuário na Session
                        LoadSession(entityUsuario);

                        // Se selecionou para logar como responsável, verifica se esse ele é responsável por um aluno só,
                        //  ou caso tenha mais, redireciona para uma tela de selação de alunos
                        if (RadioButtonList1.SelectedIndex == 1)
                        {
                            DataTable dtAlunosDoResponsavel = ACA_AlunoResponsavelBO.SelecionaAlunosPorResponsavel(entityUsuario.pes_id);

                            Session["Pes_Id_Responsavel"] = entityUsuario.pes_id.ToString();

                            Session["Qtde_Filhos_Responsavel"] = dtAlunosDoResponsavel.Rows.Count;

                            if (dtAlunosDoResponsavel.Rows.Count > 1)
                            {
                                //Session["Pes_Id_Responsavel"] = entityUsuario.pes_id.ToString();
                                RedirecionarLogin(true);
                                return;
                            }
                        }

                        RedirecionarLogin(false);
                    }
                }
                catch (DuplicateNameException ex)
                {
                    lblMessage.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Alerta);
                    ScriptManager.RegisterClientScriptBlock(this, GetType(), "AlterarSenhaErro", "$('#divAlterarSenha').dialog('close');", true);
                }
                catch (ArgumentException ex)
                {
                    lblMessage.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Alerta);
                    ScriptManager.RegisterClientScriptBlock(this, GetType(), "AlterarSenhaErro", "$('#divAlterarSenha').dialog('close');", true);
                }
                catch (ValidationException ex)
                {
                    lblMessage.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Alerta);
                    ScriptManager.RegisterClientScriptBlock(this, GetType(), "AlterarSenhaErro", "$('#divAlterarSenha').dialog('close');", true);
                }
                catch (Exception ex)
                {
                    ApplicationWEB._GravaErro(ex);

                    lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar alterar a senha do usuário.", UtilBO.TipoMensagem.Erro);
                    ScriptManager.RegisterClientScriptBlock(this, GetType(), "AlterarSenhaErro", "$('#divAlterarSenha').dialog('close');", true);
                }
            }
            else
            {
                _updAlterarSenha.Update();
            }
        }