Пример #1
0
    private void _ExcluirUsuario(Guid usu_id)
    {
        try
        {
            //Carrega os grupos do usuário
            SYS_UsuarioBO.GetGruposUsuario(usu_id, _VS_Grupos, _VS_EntidadeUA);

            //Remove o grupo do usuário
            SYS_UsuarioBO.RemoveTmpGrupo(_VS_gru_id, _VS_Grupos, _VS_EntidadeUA);

            //Recupera os dados do usuário
            SYS_Usuario usu = new SYS_Usuario {
                usu_id = usu_id
            };
            SYS_UsuarioBO.GetEntity(usu);

            usu.usu_senha = string.Empty;

            //Deleta o grupo do usuário
            if (SYS_UsuarioBO.Save(usu, _VS_Grupos, _VS_EntidadeUA, false, string.Empty, string.Empty, string.Empty, string.Empty, null))
            {
                ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Delete, "gru_id: " + _VS_gru_id + "; usu_id: " + usu_id.ToString());
                _lblMessage.Text = UtilBO.GetErroMessage(String.Format("Associação do usuário excluída com sucesso."), UtilBO.TipoMensagem.Sucesso);
            }

            //Carrega o grid de usuário
            _LoadGridUsuarios();
        }
        catch (Exception ex)
        {
            ApplicationWEB._GravaErro(ex);
            _lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar excluir a associação do usuário.", UtilBO.TipoMensagem.Erro);
        }
    }
Пример #2
0
    private bool _LoadGrupos(bool update)
    {
        IList <SYS_Grupo> grupos;

        if (update)
        {
            grupos = SYS_UsuarioBO.GetSistemaGrupo();
        }
        else
        {
            grupos = SYS_UsuarioBO.GetSistemaGrupoNotExists(_VS_Grupos);
        }

        _ddlGrupos.AppendDataBoundItems = true;
        _ddlGrupos.Items.Clear();
        _ddlGrupos.Items.Insert(0, new ListItem("-- Selecione um sistema - grupo --", Guid.Empty.ToString(), true));
        _ddlGrupos.DataValueField = "gru_id";
        _ddlGrupos.DataTextField  = "gru_nome";
        _ddlGrupos.DataSource     = grupos;
        _ddlGrupos.DataBind();
        //Monta a tela de inserção de grupos
        if (grupos.Count > 0)
        {
            _VisibleUa(grupos[0].vis_id);
        }

        return(grupos.Count > 0);
    }
        /// <summary>
        /// Realiza a sincroniza��o das senhas alteradas no AD com o Autenticador.
        /// </summary>
        /// <param name="log">Dados do usu�rio.</param>
        /// <returns></returns>
        public static bool SincronizaSenhaAlteradaAD(sLOG_UsuarioAD log)
        {
            bool processou = false;

            switch (log.usuarioAD.usa_acao)
            {
            case (short)LOG_UsuarioAD.eAcao.IncluirUsuario:
            case (short)LOG_UsuarioAD.eAcao.ExcluirUsuario:
                break;

            case (short)LOG_UsuarioAD.eAcao.AlterarSenha:
            {
                SYS_Usuario entityUsuario = log.usuario;
                entityUsuario.IsNew     = false;
                entityUsuario.usu_senha = log.dadosUsuario.senha;
                processou = SYS_UsuarioBO.AlterarSenhaAtualizarUsuario(entityUsuario, false, true);
            }
            break;

            default:
                throw new ValidationException("Opera��o inv�lida.");
            }

            return(processou);
        }
Пример #4
0
        public static void AutenticarUsuarioDaRespostaDoSaml(string nameIdValue)
        {
            var dadosUsuario = nameIdValue.Split('\\');

            Guid   entidadeId;
            string login;

            if (dadosUsuario.Length == 2)
            {
                entidadeId = Guid.Parse(dadosUsuario[0]);
                login      = dadosUsuario[1];

                var usuarioCore = new SYS_Usuario {
                    ent_id = entidadeId, usu_login = login
                };

                if (SYS_UsuarioBO.GetSelectBy_ent_id_usu_login(usuarioCore))
                {
                    AutenticarUsuario(usuarioCore);
                }
                else
                {
                    throw new Exception("Usuário(Saml) não encontrado");
                }
            }
            else
            {
                throw new Exception("Nome de Usuário inválido! Usuario(saml): " + nameIdValue);
            }
        }
Пример #5
0
    private void _AlterarUsuario(Guid usu_id, string usu_login)
    {
        try
        {
            _LimparDivUsuario();
            _VS_IsNew = false;

            //Carrega os grupos do usuário
            SYS_UsuarioBO.GetGruposUsuario(usu_id, _VS_Grupos, _VS_EntidadeUA);

            SYS_UsuarioBO.TmpGrupos grupo = _VS_Grupos[_VS_gru_id];
            _ckbGrupo_Bloqueado.Checked = (grupo.usg_situacao == 2) ? true : false;

            List <SYS_UsuarioBO.TmpEntidadeUA> lt = _VS_EntidadeUA[_VS_gru_id];
            foreach (SYS_UsuarioBO.TmpEntidadeUA ent in lt)
            {
                ListItem li = ent.Entidade ? new ListItem(ent.EntidadeOrUA, ent.ent_id.ToString()) : new ListItem(ent.EntidadeOrUA, String.Concat(ent.ent_id, ";", ent.uad_id));
                _lstUAs.Items.Add(li);
            }

            _txtUsu_id.Value = usu_id.ToString();
            _txtUsuario.Text = usu_login;

            _btnUsuario.Visible = false;
            _btnUA.Focus();

            ScriptManager.RegisterClientScriptBlock(this, GetType(), "AlterarUsuario", "$('#divUsuario').dialog('open');", true);
        }
        catch (Exception ex)
        {
            ApplicationWEB._GravaErro(ex);
            _lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar carregar o grupo.", UtilBO.TipoMensagem.Erro);
        }
    }
Пример #6
0
    private void UCUA1BuscaUsuario(IDictionary <string, object> parameters)
    {
        try
        {
            _LimparDivUsuario();

            _txtUsu_id.Value = parameters["usu_id"].ToString();
            _VS_ent_id       = new Guid(parameters["ent_id"].ToString());
            _txtUsuario.Text = parameters["usu_login"].ToString();

            //Carrega os grupos do usuário
            SYS_UsuarioBO.GetGruposUsuario(new Guid(_txtUsu_id.Value), _VS_Grupos, _VS_EntidadeUA);

            if (_VS_EntidadeUA.ContainsKey(_VS_gru_id))
            {
                List <SYS_UsuarioBO.TmpEntidadeUA> lt = _VS_EntidadeUA[_VS_gru_id];
                foreach (SYS_UsuarioBO.TmpEntidadeUA ent in lt)
                {
                    ListItem li = ent.Entidade
                                      ? new ListItem(ent.EntidadeOrUA, ent.ent_id.ToString())
                                      : new ListItem(ent.EntidadeOrUA, String.Concat(ent.ent_id, ";", ent.uad_id));
                    _lstUAs.Items.Add(li);
                }
            }
        }
        catch (Exception ex)
        {
            _lblMessageUsuario.Text = UtilBO.GetErroMessage("Erro ao tentar carregar o usuário.", UtilBO.TipoMensagem.Erro);
            ApplicationWEB._GravaErro(ex);
        }
        finally
        {
            _updUsuario.Update();
        }
    }
Пример #7
0
        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();
        }
Пример #8
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);
        }
    }
Пример #9
0
    /// <summary>
    /// Valida se já existe usuário com o email.
    /// </summary>
    /// <param name="email">Email.</param>
    /// <param name="usu_id">ID do usuário.</param>
    /// <returns></returns>
    public static bool ValidarEmailExistente(string email, Guid usu_id)
    {
        SYS_Usuario entityUsuario = new SYS_Usuario {
            usu_id = usu_id
        };

        SYS_UsuarioBO.GetEntity(entityUsuario);

        entityUsuario.usu_email = email;

        return(string.IsNullOrEmpty(entityUsuario.usu_email) || !SYS_UsuarioBO.VerificaEmailExistente(entityUsuario));
    }
Пример #10
0
        private void LoadSession(SYS_Usuario entityUsuario)
        {
            __SessionWEB.__UsuarioWEB.Usuario     = entityUsuario;
            __SessionWEB.__UsuarioWEB.responsavel = RadioButtonList1.SelectedIndex == 1;
            if (__SessionWEB.__UsuarioWEB.responsavel)
            {
                SYS_Usuario entityUsuarioAluno = new SYS_Usuario
                {
                    ent_id = UCComboEntidade1.Valor
                    ,
                    usu_login = ACA_ParametroAcademicoBO.ParametroValorPorEntidade(eChaveAcademico.PREFIXO_LOGIN_ALUNO_AREA_ALUNO, __SessionWEB.__UsuarioWEB.Usuario.ent_id) + txtLogin.Text
                };

                SYS_UsuarioBO.GetSelectBy_ent_id_usu_login(entityUsuarioAluno);
                __SessionWEB.__UsuarioWEB.pes_idAluno = entityUsuarioAluno.pes_id;
            }

            // Carrega grupos do usuário
            IList <SYS_Grupo> list = SYS_GrupoBO.GetSelectBySis_idAndUsu_id(__SessionWEB.__UsuarioWEB.Usuario.usu_id, ApplicationWEB.AreaAlunoSistemaID);

            // Verifica se foi carregado os grupos do usuário
            if (list.Count > 0)
            {
                __SessionWEB.__UsuarioWEB.Grupo = list[0];
            }
            else
            {
                throw new ValidationException("Não foi possível atender a solicitação, nenhum grupo de usuário encontrado.");
            }

            // Armazena o cid_id referente a entidade do usuário na Session
            Guid ene_id = SYS_EntidadeEnderecoBO.Select_ene_idBy_ent_id(__SessionWEB.__UsuarioWEB.Usuario.ent_id);
            SYS_EntidadeEndereco entityEntidadeEndereco = new SYS_EntidadeEndereco {
                ent_id = __SessionWEB.__UsuarioWEB.Usuario.ent_id, ene_id = ene_id
            };

            SYS_EntidadeEnderecoBO.GetEntity(entityEntidadeEndereco);

            END_Endereco entityEndereco = new END_Endereco {
                end_id = entityEntidadeEndereco.end_id
            };

            END_EnderecoBO.GetEntity(entityEndereco);
            __SessionWEB._cid_id = entityEndereco.cid_id;

            // Armazena o nome da pessoa ou o login do usuário na Session
            PES_Pessoa EntityPessoa = new PES_Pessoa {
                pes_id = __SessionWEB.__UsuarioWEB.Usuario.pes_id
            };

            PES_PessoaBO.GetEntity(EntityPessoa);
            __SessionWEB.UsuarioLogado = string.IsNullOrEmpty(EntityPessoa.pes_nome) ? __SessionWEB.__UsuarioWEB.Usuario.usu_login : EntityPessoa.pes_nome;
        }
Пример #11
0
        /// <summary>
        /// Executa o JOB que expira as senhas que n�o foram alteradas desde o prazo do par�metro
        /// </summary>
        public static void ExecJobExpiraSenha()
        {
            SYS_Servico servico = GetEntity(new SYS_Servico()
            {
                ser_id = (short)eChaveServico.ExpiraSenha
            });

            if (servico.ser_ativo)
            {
                SYS_UsuarioBO.ExpirarSenhas();
            }
        }
Пример #12
0
        public HttpResponseMessage SelectUsersByEnt([FromUri] UsuarioEntradaDTO data)
        {
            try
            {
                if (data == null)
                {
                    throw new ValidationException("É necessário informar o(s) parâmetro(s).");
                }

                if (data.ent_id == Guid.Empty)
                {
                    throw new ValidationException("Entidade é obrigatório.");
                }

                byte[]    arquivo    = null;
                DataTable dtUsuarios = string.IsNullOrEmpty(data.dataBase.ToString()) ?
                                       SYS_UsuarioBO.SelecionaPorEntidade(data.ent_id, data.pes_id, data.trazerFoto) :
                                       SYS_UsuarioBO.SelecionaPorEntidade(data.ent_id, data.pes_id, data.trazerFoto, data.dataBase);
                var usuarios = (from dr in dtUsuarios.Rows.Cast <DataRow>()
                                select new
                {
                    usu_id = new Guid(Convert.ToString(dr["usu_id"])),
                    usu_login = Convert.ToString(dr["usu_login"]),
                    usu_email = Convert.ToString(dr["usu_email"]),
                    usu_senha = Convert.ToString(dr["usu_senha"]),
                    usu_criptografia = Convert.ToByte(dr["usu_criptografia"]),
                    usu_situacao = Convert.ToByte(dr["usu_situacao"]),
                    pes_id = string.IsNullOrEmpty(Convert.ToString(dr["pes_id"])) ? Guid.Empty : new Guid(Convert.ToString(dr["pes_id"])),
                    pes_nome = Convert.ToString(dr["pes_nome"]),
                    pes_sexo = string.IsNullOrEmpty(dr["pes_sexo"].ToString()) ? 0 : Convert.ToByte(dr["pes_sexo"]),
                    foto = string.IsNullOrEmpty(Convert.ToString(dr["foto"])) ? arquivo : (byte[])dr["foto"],
                    usu_dataCriacao = Convert.ToDateTime(dr["usu_dataCriacao"]),
                    usu_dataAlteracao = Convert.ToDateTime(dr["usu_dataAlteracao"]),
                    pes_dataNascimento = string.IsNullOrEmpty(dr["pes_dataNascimento"].ToString())
                                         ? new DateTime()
                                         : Convert.ToDateTime(dr["pes_dataNascimento"])
                }).ToList();

                return(Request.CreateResponse(HttpStatusCode.OK, usuarios));
            }
            catch (ValidationException ex)
            {
                Util.GravarErro(ex);
                return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message));
            }
            catch (Exception ex)
            {
                Util.GravarErro(ex);
                return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex.Message));
            }
        }
Пример #13
0
        /// <summary>
        /// Método utilizado via Web API para alteração de login de um usuário
        /// </summary>
        /// <param name="data">Parametros de entrada: Id Entidade, login antigo, login novo</param>
        /// <param name="entityUsuarioAPI">Usuário da API usado para gravar log de ação</param>
        public static void UpdateLogin(AlterarLoginEntradaDTO data, CFG_UsuarioAPI entityUsuarioAPI)
        {
            if (data.ent_id == Guid.Empty || string.IsNullOrWhiteSpace(data.usu_login_antigo) || string.IsNullOrWhiteSpace(data.usu_login_novo))
            {
                throw new ValidationException("Todos os campos são obrigatórios.");
            }

            SYS_Usuario entity = new SYS_Usuario
            {
                ent_id    = data.ent_id,
                usu_login = data.usu_login_antigo
            };

            SYS_UsuarioBO.GetSelectBy_ent_id_usu_login(entity);

            if (!entity.IsNew)
            {
                //Validação de usuário padrão do sistema
                if (entity.usu_situacao == (byte)SYS_UsuarioBO.eSituacao.Padrao_Sistema)
                {
                    throw new ValidationException("Não é possível alterar dados do usuário padrão do sistema.");
                }

                entity.usu_login = data.usu_login_novo;
            }
            else
            {
                throw new ValidationException("Usuário não existe.");
            }

            SYS_UsuarioBO.Save(entity);

            #region [ Log de ação]

            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.AlteracaoLogin
            }
            );

            #endregion
        }
Пример #14
0
    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));
    }
Пример #15
0
        protected virtual void LoadUser(AuthenticationIdentity user, HttpActionContext actionContext)
        {
            if (HttpContext.Current != null)
            {
                BaseApiController baseApiController = actionContext.ControllerContext.Controller as BaseApiController;

                if (baseApiController != null)
                {
                    // Chave padrão do cache - nome do método + parâmetros.
                    string chave = RetornaChaveCache_LoadUser(user);
                    object cache = HttpContext.Current.Cache[chave];

                    if (cache == null)
                    {
                        #region Load user values

                        UsuarioWEB userLogged = new UsuarioWEB();

                        // Carrega usuário na session através do ticket de authenticação
                        userLogged.Usuario = new SYS_Usuario
                        {
                            ent_id = user.Entity
                            ,
                            usu_login = user.Login
                        };
                        SYS_UsuarioBO.GetSelectBy_ent_id_usu_login(userLogged.Usuario);

                        userLogged.Grupo = SYS_GrupoBO.GetEntity(new SYS_Grupo {
                            gru_id = user.Group
                        });

                        baseApiController.__userLogged = userLogged;

                        #endregion

                        HttpContext.Current.Cache.Insert(chave, userLogged, null, DateTime.Now.AddMinutes(GestaoEscolarUtilBO.MinutosCacheMedio)
                                                         , System.Web.Caching.Cache.NoSlidingExpiration);
                    }
                    else
                    {
                        baseApiController.__userLogged = cache as UsuarioWEB;
                    }
                }
            }
        }
Пример #16
0
        public static SYS_Usuario ObterUsuarioDoClaimsIdentity()
        {
            SYS_Usuario usuarioCore = null;
            var         identity    = HttpContext.Current.User.Identity as ClaimsIdentity;

            if (identity != null)
            {
                var usuarioIdClaim = identity.FindFirst(ClaimTypes.NameIdentifier);

                usuarioCore = new SYS_Usuario
                {
                    usu_id = Guid.Parse(usuarioIdClaim.Value)
                };

                SYS_UsuarioBO.GetEntity(usuarioCore);
            }
            return(usuarioCore);
        }
Пример #17
0
    private void AlterarSenhaEsqueci(Guid usu_id, byte usu_situacao, byte usu_integracaoAD)
    {
        if (ValidarAlterarSenhaEsqueci())
        {
            try
            {
                if (usu_situacao == (byte)SYS_UsuarioBO.eSituacao.Ativo || usu_situacao == (byte)SYS_UsuarioBO.eSituacao.Senha_Expirada)
                {
                    SYS_Usuario entityUsuario = new SYS_Usuario
                    {
                        usu_id = usu_id
                    };
                    SYS_UsuarioBO.GetEntity(entityUsuario);

                    entityUsuario.usu_situacao      = 1;
                    entityUsuario.usu_senha         = txtNovaSenhaEsqueci.Text;
                    entityUsuario.usu_dataAlteracao = DateTime.Now;
                    SYS_UsuarioBO.AlterarSenhaAtualizarUsuario(entityUsuario, usu_integracaoAD == (byte)SYS_UsuarioBO.eIntegracaoAD.IntegradoADReplicacaoSenha);

                    ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Login, "Senha alterada com sucesso.");
                    _lblMessage.Text = UtilBO.GetErroMessage("Senha alterada com sucesso.", UtilBO.TipoMensagem.Sucesso);
                }
                else if (usu_situacao == (byte)SYS_UsuarioBO.eSituacao.Padrao_Sistema)
                {
                    ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Login, "Erro na alteração de senha. Usuário padrão.");
                    _lblMessage.Text = UtilBO.GetErroMessage("Usuário padrão.", UtilBO.TipoMensagem.Alerta);
                }
                else
                {
                    ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Login, "Erro na alteração de senha. Usuário bloqueado.");
                    _lblMessage.Text = UtilBO.GetErroMessage("Usuário bloqueado.", UtilBO.TipoMensagem.Alerta);
                }
            }
            catch (DuplicateNameException ex)
            {
                _lblMessage.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Alerta);
            }
            catch (Exception ex)
            {
                ApplicationWEB._GravaErro(ex);
                _lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar alterar a senha do usuário.", UtilBO.TipoMensagem.Erro);
            }
        }
    }
        public LoginStatus ValidarAutenticacao(SYS_Usuario entityUsuario)
        {
            eVerificaTipoAutenticacao validacaoStatus = eVerificaTipoAutenticacao.UsuNaoEncontrado;
            int indexAD = entityUsuario.usu_login.IndexOf('\\');

            if (indexAD <= 0)
            {
                validacaoStatus = VerificaTipoAutenticacao(entityUsuario);
            }
            else
            {
                validacaoStatus = eVerificaTipoAutenticacao.Autenticador;
            }

            LoginStatus status = LoginStatus.NaoEncontrado;

            //VERIFICA O TIPO DE VALIDAÇÃO
            if (validacaoStatus == eVerificaTipoAutenticacao.Autenticador)
            {
                // Checa as credenciais do usuário
                status = SYS_UsuarioBO.ValidarLogin(entityUsuario);
            }
            else if (validacaoStatus == eVerificaTipoAutenticacao.WebService)
            {
                eValidacaoWebService ValidacaoStatus = VerificaSenhaUsuarioWebService(entityUsuario);

                if (ValidacaoStatus == eValidacaoWebService.ValidarNoWebService)
                {
                    // TEM QUE VERIFICAR QUAL A INTEGRACAO EXTERNA E DIRECIONAR
                    status = ValidaUsuarioWebService(entityUsuario);
                }
                else if (ValidacaoStatus == eValidacaoWebService.ValidarComSenhaDoHistorico &&
                         (ValidarUsuarioHistoricoSenha(entityUsuario) == LoginStatus.SenhaInvalida))
                {
                    status = ValidaUsuarioWebService(entityUsuario);
                }
                else if (ValidacaoStatus == eValidacaoWebService.IntegrcacaoNaoEncontrada)
                {
                    status = LoginStatus.Erro;
                }
            }

            return(status);
        }
Пример #19
0
    private void EnviaNovaSenhaEmail(Guid usu_id, byte usu_situacao, string pes_nome, byte usu_integracaoAD)
    {
        try
        {
            if (usu_situacao == (byte)SYS_UsuarioBO.eSituacao.Ativo || usu_situacao == (byte)SYS_UsuarioBO.eSituacao.Senha_Expirada)
            {
                SYS_Usuario usu = new SYS_Usuario {
                    usu_id = usu_id
                };
                SYS_UsuarioBO.GetEntity(usu);

                usu.usu_situacao = (byte)SYS_UsuarioBO.eSituacao.Senha_Expirada;

                SYS_UsuarioBO.Save(usu, pes_nome, __SessionWEB.TituloGeral, ApplicationWEB._EmailHost, ApplicationWEB._EmailSuporte, ApplicationWEB.EmailRemetente);

                ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Login, "Senha enviada para o e-mail com sucesso.");

                string mensagemSucesso = SYS_MensagemSistemaBO.RetornaValor(SYS_MensagemSistemaChave.LoginMensagemSenhaEmailEnviadaSucesso);
                _lblMessage.Text = UtilBO.GetErroMessage(string.IsNullOrEmpty(mensagemSucesso) ? "Senha enviada para o e-mail com sucesso." : mensagemSucesso, UtilBO.TipoMensagem.Sucesso);
            }
            else if (usu_situacao == (byte)SYS_UsuarioBO.eSituacao.Padrao_Sistema)
            {
                ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Login, "Erro no envio de senha. Usuário padrão.");
                _lblMessage.Text = UtilBO.GetErroMessage("Usuário padrão.", UtilBO.TipoMensagem.Alerta);
            }
            else
            {
                ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Login, "Erro no envio de senha. Usuário bloqueado.");
                _lblMessage.Text = UtilBO.GetErroMessage("Usuário bloqueado.", UtilBO.TipoMensagem.Alerta);
            }
        }
        catch (DuplicateNameException ex)
        {
            _lblMessage.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Alerta);
            ScriptManager.RegisterClientScriptBlock(this, GetType(), "EsqueciSenhaErro", "$('#divEsqueciSenha').dialog('close');", true);
        }
        catch (Exception ex)
        {
            ApplicationWEB._GravaErro(ex);
            _lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar enviar e-mail com a senha para o usuário.", UtilBO.TipoMensagem.Erro);
            ScriptManager.RegisterClientScriptBlock(this, GetType(), "EsqueciSenhaErro", "$('#divEsqueciSenha').dialog('close');", true);
        }
    }
        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);
                }
            }
        }
Пример #21
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);
    }
Пример #22
0
    protected void _dgvUsuario_RowCommand(object sender, GridViewCommandEventArgs e)
    {
        if (e.CommandName == "Deletar")
        {
            try
            {
                int  index  = int.Parse(e.CommandArgument.ToString());
                Guid usu_id = new Guid(_dgvUsuario.DataKeys[index].Value.ToString());

                //DELETA O VINCULO DE USUARIO COM USUARIOLOGINPROVIDER (CASO EXISTA)
                SYS_UsuarioLoginProviderBO.DeleteBy_usu_id(usu_id);

                SYS_Usuario entity = new SYS_Usuario {
                    usu_id = usu_id
                };
                SYS_UsuarioBO.GetEntity(entity);

                if (SYS_UsuarioBO.Delete(entity, null))
                {
                    _dgvUsuario.PageIndex = 0;
                    _dgvUsuario.DataBind();

                    ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Delete, "usu_id: " + usu_id);
                    _lblMessage.Text = UtilBO.GetErroMessage("Usuário excluído com sucesso.", UtilBO.TipoMensagem.Sucesso);
                }
                else
                {
                    _lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar excluir o usuário.", UtilBO.TipoMensagem.Erro);
                }
            }
            catch (Exception ex)
            {
                ApplicationWEB._GravaErro(ex);
                _lblMessage.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Erro);
            }
        }
    }
Пример #23
0
        public HttpResponseMessage UserAuthorized([FromBody] UsuarioEntradaDTO data)
        {
            try
            {
                if (data == null || data.usu_login == null)
                {
                    throw new ValidationException("É necessário informar o(s) parâmetro(s).");
                }

                SYS_Usuario usuario = new SYS_Usuario
                {
                    usu_login = data.usu_login,
                    usu_senha = data.senha,
                    ent_id    = data.ent_id
                };
                LoginStatus status = SYS_UsuarioBO.LoginWEB(usuario, false);

                bool retorno = false;
                if (status == LoginStatus.Sucesso)
                {
                    retorno = true;
                }

                return(Request.CreateResponse(HttpStatusCode.OK, retorno));
            }
            catch (ValidationException ex)
            {
                Util.GravarErro(ex);
                return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message));
            }
            catch (Exception ex)
            {
                Util.GravarErro(ex);
                return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex.Message));
            }
        }
Пример #24
0
    protected void _btnSalvar_Click(object sender, EventArgs e)
    {
        bool validado = true;

        try
        {
            validado = ValidarIntegracaoAD();

            ManageUserLive live = new ManageUserLive();
            if (_ckbUsuarioLive.Checked)
            {
                if (!live.IsContaEmail(_txtEmail.Text))
                {
                    validado         = false;
                    _lblMessage.Text = UtilBO.GetErroMessage("E-mail inválido para integrar usuário live.", UtilBO.TipoMensagem.Alerta);
                }
                else
                {
                    if (!live.VerificarContaEmailExistente(new UserLive {
                        email = _txtEmail.Text
                    }))
                    {
                        validado         = false;
                        _lblMessage.Text = UtilBO.GetErroMessage("E-mail não encontrado no live para realizar integração.", UtilBO.TipoMensagem.Alerta);
                    }
                }
            }
            else
            {
                if (live.IsContaEmail(_txtEmail.Text))
                {
                    validado         = false;
                    _lblMessage.Text = UtilBO.GetErroMessage("Integrar usuário live é obrigatório, o email " + _txtEmail.Text +
                                                             " contém o domínio para integração com live.", UtilBO.TipoMensagem.Alerta);
                }
            }

            if (integracaoAD == SYS_UsuarioBO.eIntegracaoAD.IntegradoADReplicacaoSenha && !string.IsNullOrEmpty(_txtSenha.Text))
            {
                string regTamanhoSenha = SYS_ParametroBO.ParametroValor(SYS_ParametroBO.eChave.TAMANHO_SENHA_USUARIO);

                Regex regex = new Regex(regTamanhoSenha);
                if (!regex.IsMatch(_txtSenha.Text))
                {
                    string mensagemTamanho = SYS_MensagemSistemaBO.RetornaValor(SYS_MensagemSistemaChave.MeusDadosMensagemValidacaoComplexidadeSenhaTamanho);
                    throw new CoreLibrary.Validation.Exceptions.ValidationException(string.IsNullOrEmpty(mensagemTamanho) ? String.Format("A senha deve conter {0}.", UtilBO.GetMessageTamanhoByRegex(regTamanhoSenha)) : mensagemTamanho);
                }

                regex = new Regex(SYS_ParametroBO.ParametroValor(SYS_ParametroBO.eChave.FORMATO_SENHA_USUARIO));
                if (!regex.IsMatch(_txtSenha.Text))
                {
                    // Mensagem de validação do formato da senha.
                    string mensagemFormato = SYS_MensagemSistemaBO.RetornaValor(SYS_MensagemSistemaChave.MeusDadosMensagemValidacaoComplexidadeSenhaFormato);
                    throw new CoreLibrary.Validation.Exceptions.ValidationException(string.IsNullOrEmpty(mensagemFormato) ? "A senha deve conter pelo menos uma combinação de letras e números ou letras maiúsculas e minúsculas ou algum caracter especial (!, @, #, $, %, &) somados a letras e/ou números." : mensagemFormato);
                }
            }
        }
        catch (CoreLibrary.Validation.Exceptions.ValidationException err)
        {
            _lblMessage.Text = UtilBO.GetErroMessage(err.Message, UtilBO.TipoMensagem.Alerta);
            validado         = false;
        }
        catch (Exception ex)
        {
            ApplicationWEB._GravaErro(ex);
            _lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar salvar o usuário.", UtilBO.TipoMensagem.Erro);
            validado         = false;
        }
        if (validado)
        {
            if (chkIntegracaoExterna.Checked && ddlIntegracaoExternaTipo.SelectedIndex == 0)
            {
                _lblMessage.Text = UtilBO.GetErroMessage("Realizar Integração por WebService Externo é obrigatório.", UtilBO.TipoMensagem.Alerta);
            }
            else
            {
                if ((integracaoAD == SYS_UsuarioBO.eIntegracaoAD.IntegradoAD) && ((_ddlDominios.SelectedIndex == 0) || (_ddlDominios.SelectedIndex == _VS_OutrosDominios && string.IsNullOrEmpty(_txtDominio.Text))))
                {
                    _lblMessage.Text = UtilBO.GetErroMessage("Domínio é obrigatório.", UtilBO.TipoMensagem.Alerta);
                }
                else
                {
                    try
                    {
                        SYS_Usuario entity = new SYS_Usuario
                        {
                            ent_id = new Guid(UCComboEntidadeUsuario._Combo.SelectedValue)
                            ,
                            usu_id = _VS_usu_id
                            ,
                            usu_login = _txtLogin.Text
                            ,
                            usu_email = _txtEmail.Text
                            ,
                            usu_senha = string.IsNullOrEmpty(_txtSenha.Text) ? string.Empty : _txtSenha.Text
                            ,
                            pes_id = string.IsNullOrEmpty(_txtPes_id.Value) ? Guid.Empty : new Guid(_txtPes_id.Value)
                            ,
                            usu_criptografia = !string.IsNullOrEmpty(_txtSenha.Text) || string.IsNullOrEmpty(_txtCriptografia.Value) ? Convert.ToByte(eCriptografa.SHA512) : Convert.ToByte(_txtCriptografia.Value)
                            ,
                            usu_situacao = 1
                            ,
                            usu_dataAlteracao = DateTime.Now
                            ,
                            usu_dataCriacao = DateTime.Now
                            ,
                            usu_dominio = (_ddlDominios.SelectedIndex == _VS_OutrosDominios) ? _txtDominio.Text : _ddlDominios.SelectedValue
                            ,
                            usu_integracaoAD = (byte)integracaoAD
                            ,
                            IsNew = (_VS_usu_id != Guid.Empty) ? false : true

                            ,
                            usu_integracaoExterna = Convert.ToInt16(ddlIntegracaoExternaTipo.SelectedIndex.ToString())
                        };
                        if (_chkExpiraSenha.Checked)
                        {
                            entity.usu_situacao = 5;
                        }
                        if (_chkBloqueado.Checked)
                        {
                            entity.usu_situacao = 2;
                        }

                        if (SYS_UsuarioBO.Save(entity, _VS_Grupos, _VS_EntidadeUA, _chkSenhaAutomatica.Checked, _txtPessoa.Text, __SessionWEB.TituloGeral, ApplicationWEB._EmailHost, ApplicationWEB._EmailSuporte, null, entity.usu_integracaoAD == (byte)SYS_UsuarioBO.eIntegracaoAD.IntegradoADReplicacaoSenha, ApplicationWEB.EmailRemetente))
                        {
                            if (_VS_usu_id == Guid.Empty)
                            {
                                _VS_usu_id = entity.usu_id;

                                ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Insert, "usu_id: " + _VS_usu_id);
                                __SessionWEB.PostMessages = UtilBO.GetErroMessage(String.Format("Usuário incluído com sucesso."), UtilBO.TipoMensagem.Sucesso);
                            }
                            else
                            {
                                ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Update, "usu_id: " + _VS_usu_id);
                                __SessionWEB.PostMessages = UtilBO.GetErroMessage(String.Format("Usuário alterado com sucesso."), UtilBO.TipoMensagem.Sucesso);
                            }

                            if (__SessionWEB.__UsuarioWEB.Usuario.usu_id == _VS_usu_id)
                            {
                                Response.Redirect(ApplicationWEB._DiretorioVirtual + ApplicationWEB._PaginaLogoff, false);
                            }
                            else
                            {
                                Response.Redirect(String.Concat(__SessionWEB._AreaAtual._Diretorio, "Usuario/Busca.aspx"), false);
                            }
                        }
                        else
                        {
                            _lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar salvar o usuário.", UtilBO.TipoMensagem.Erro);
                        }
                    }
                    catch (CoreLibrary.Validation.Exceptions.ValidationException err)
                    {
                        _lblMessage.Text = UtilBO.GetErroMessage(err.Message, UtilBO.TipoMensagem.Alerta);
                    }
                    catch (ArgumentException err)
                    {
                        _lblMessage.Text = UtilBO.GetErroMessage(err.Message, UtilBO.TipoMensagem.Alerta);
                    }
                    catch (DuplicateNameException err)
                    {
                        _lblMessage.Text = UtilBO.GetErroMessage(err.Message, UtilBO.TipoMensagem.Alerta);
                    }
                    catch (Exception ex)
                    {
                        ApplicationWEB._GravaErro(ex);
                        _lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar salvar o usuário.", UtilBO.TipoMensagem.Erro);
                    }
                }
            }// valida integracao
        }
    }
Пример #25
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));
            }
        }
Пример #26
0
 protected void _dgvGrupo_RowDeleting(object sender, GridViewDeleteEventArgs e)
 {
     SYS_UsuarioBO.RemoveTmpGrupo(new Guid(_dgvGrupo.DataKeys[e.RowIndex].Value.ToString()), _VS_Grupos, _VS_EntidadeUA);
     _LoadGridGrupos();
 }
Пример #27
0
        /// <summary>
        /// Método utilizado via Web API para deleção de um usuário
        /// </summary>
        /// <param name="data">Parametros de entrada: Id Entidade, login, senha</param>
        /// <param name="entityUsuarioAPI">Usuário da API usado para gravar log de ação</param>
        public static HttpResponseMessage Delete(DeletarUsuarioDTO data, CFG_UsuarioAPI entityUsuarioAPI, HttpRequestMessage request)
        {
            try
            {
                //Verifica se todos os dados vieram
                if (data.ent_id == Guid.Empty || string.IsNullOrWhiteSpace(data.usu_login) || string.IsNullOrWhiteSpace(data.senha))
                {
                    return(request.CreateErrorResponse(HttpStatusCode.BadRequest, "Todos os campos são obrigatórios."));
                }

                SYS_Usuario entity = new SYS_Usuario
                {
                    ent_id    = data.ent_id,
                    usu_login = data.usu_login
                };

                SYS_UsuarioBO.GetSelectBy_ent_id_usu_login(entity);

                //Validação de usuário padrão do sistema
                if (entity.usu_situacao == (byte)SYS_UsuarioBO.eSituacao.Padrao_Sistema)
                {
                    return(request.CreateErrorResponse(HttpStatusCode.BadRequest, "Não é possível alterar um usuário padrão do sistema."));
                }

                // Verifica se o id do usuário enviado existe na base de dados.
                if (entity.IsNew)
                {
                    return(request.CreateErrorResponse(HttpStatusCode.NotFound, "Usuário não encontrado."));
                }

                var senhaDescriptografada = new SymmetricAlgorithm(SymmetricAlgorithm.Tipo.TripleDES).Decrypt(entity.usu_senha);

                if (data.senha != senhaDescriptografada)
                {
                    return(request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Não foi possível excluir usuário. Acesso negado."));
                }

                SYS_UsuarioBO.Delete(entity, null);

                #region [ Log de ação]

                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.DelecaoUsuario
                }
                );

                #endregion

                return(request.CreateResponse(HttpStatusCode.OK, "Usuário excluído com sucesso."));
            }
            catch (Exception ex)
            {
                Util.GravarErro(ex);
                return(request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex.Message));
            }
        }
Пример #28
0
        /// <summary>
        /// Método utilizado via Web API para inclusão de novos grupos de usuário
        /// </summary>
        /// <param name="entityUsuarioAPI">Usuário da API usado para gravar log de ação</param>
        public static void AssociateUserGroup(Guid usu_id, AssociarUsuarioGrupoEntradaDTO data, CFG_UsuarioAPI entityUsuarioAPI)
        {
            #region [ Validação de campos obrigatórios ]

            if (data == null || data.usergroup == null || data.usergroup.Count(p => p.gru_id != Guid.Empty) == 0)
            {
                throw new ValidationException("Obrigatório no mínimo um Id de grupo do usuário.");
            }

            #endregion

            SYS_Usuario entity = SYS_UsuarioBO.GetEntity(new SYS_Usuario {
                usu_id = usu_id
            });
            entity.usu_senha         = string.Empty;
            entity.usu_dataAlteracao = DateTime.Now;

            if (!entity.IsNew)
            {
                // Validação de usuário padrão do sistema
                if (entity.usu_situacao == (byte)SYS_UsuarioBO.eSituacao.Padrao_Sistema)
                {
                    throw new ValidationException("Não é possível alterar dados do usuário padrão do sistema.");
                }

                SortedDictionary <Guid, SYS_UsuarioBO.TmpGrupos>             grupos   = new SortedDictionary <Guid, SYS_UsuarioBO.TmpGrupos>();
                SortedDictionary <Guid, List <SYS_UsuarioBO.TmpEntidadeUA> > grupoUas = new SortedDictionary <Guid, List <SYS_UsuarioBO.TmpEntidadeUA> >();
                SYS_UsuarioBO.GetGruposUsuario(entity.usu_id, grupos, grupoUas);

                foreach (UsuarioGrupoDTO grupo in data.usergroup)
                {
                    // Adiciona o grupo
                    if (grupo.gru_id != Guid.Empty)
                    {
                        SYS_UsuarioBO.AddTmpGrupo(grupo.gru_id, grupos, 1);

                        // Adiciona a unidade administrativa ao grupo, caso necessário
                        if (grupo.uad_id != Guid.Empty)
                        {
                            List <SYS_UsuarioBO.TmpEntidadeUA> ltEntidadeUA = grupoUas.ContainsKey(grupo.gru_id) ?
                                                                              grupoUas[grupo.gru_id] : new List <SYS_UsuarioBO.TmpEntidadeUA>();

                            SYS_UsuarioBO.AddTmpEntidadeUA(grupo.gru_id, entity.ent_id, grupo.uad_id, ltEntidadeUA);
                        }
                    }
                }

                SYS_UsuarioBO.Save(entity, grupos, grupoUas, false, string.Empty, string.Empty, string.Empty, string.Empty, null);
            }
            else
            {
                throw new ValidationException("Usuário não existe.");
            }

            #region [ Log de ação]

            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.AssociacaoUsuarioGrupo
            }
            );

            #endregion
        }
Пример #29
0
        /// <summary>
        /// Método utilizado via Web API para criação de Usuários
        /// OBSERVACAO: Este metodo faz uma busca por nome, data de nascimento e CPF
        /// para tentar vincular uma pessoa já existente com estes dados ao usuario
        /// que esta sendo criado, sendo que apenas nome e data de nascimento são requeridos.
        /// </summary>
        /// <param name="data">Parametros de entrada: Id Entidade, Id Grupo,  ID Usuario, Nome,
        /// CPF, Data de nascimento, E-mail, Senha</param>
        /// <param name="entityUsuarioAPI">Usuário da API usado para gravar log de ação</param>
        public static void Create(UsuarioEntradaDTO data, CFG_UsuarioAPI entityUsuarioAPI)
        {
            #region [ Validação de campos obrigatórios ]

            if (data.ent_id == Guid.Empty)
            {
                throw new ValidationException("Id da entidade é obrigatório.");
            }
            if (string.IsNullOrWhiteSpace(data.usu_login))
            {
                throw new ValidationException("Login do usuário é obrigatório.");
            }
            if (data.gru_id.Count() == 0)
            {
                throw new ValidationException("Ao menos um grupo deve ser informado.");
            }
            if (data.dataNascimento == new DateTime())
            {
                throw new ValidationException("Data de nascimento é obrigatória.");
            }
            if (data.sexo != null && data.sexo > 2)
            {
                throw new ValidationException("Para o sexo informe: 1 - masculino ou 2 - feminino");
            }

            #endregion

            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)
            {
                Guid?      tdo_id           = null;
                bool       savePessoaReturn = false;
                PES_Pessoa entityPessoa     = null;

                //Se não for informado nome e data de nascimento não cria a pessoa
                if (!string.IsNullOrWhiteSpace(data.nome) && data.dataNascimento != null)
                {
                    #region [Validações CPF]

                    //Se CPF existir, realiza validações
                    if (!string.IsNullOrWhiteSpace(data.CPF))
                    {
                        if (UtilBO._ValidaCPF(data.CPF))
                        {
                            //Recupera o tipo de documento CPF, utilizado para recuperar a pessoa
                            string tipoDocCPF = SYS_ParametroBO.ParametroValor(SYS_ParametroBO.eChave.TIPO_DOCUMENTACAO_CPF);
                            if (!string.IsNullOrEmpty(tipoDocCPF))
                            {
                                tdo_id = Guid.Parse(tipoDocCPF);
                            }
                        }
                        else
                        {
                            throw new ValidationException("CPF inválido.");
                        }
                    }

                    #endregion

                    //Recupera a pessoa
                    entityPessoa = PES_PessoaBO.SelecionaPorNomeNascimentoDocumento(data.nome, data.dataNascimento, tdo_id, data.CPF);

                    //Se pessoa não existir, faz o cadastro com as informações básicas
                    if (entityPessoa.pes_id == Guid.Empty)
                    {
                        #region [Cria Pessoa]

                        //Adiciona valores na entidade de pessoa

                        entityPessoa.pes_id              = Guid.Empty;
                        entityPessoa.pes_nome            = data.nome;
                        entityPessoa.pes_sexo            = data.sexo;
                        entityPessoa.pes_nome_abreviado  = string.Empty;
                        entityPessoa.pai_idNacionalidade = Guid.Empty;
                        entityPessoa.pes_naturalizado    = false;
                        entityPessoa.cid_idNaturalidade  = Guid.Empty;
                        entityPessoa.pes_dataNascimento  = (String.IsNullOrEmpty(data.dataNascimento.ToString()) ? new DateTime() : Convert.ToDateTime(data.dataNascimento.ToString()));
                        entityPessoa.pes_racaCor         = Convert.ToByte(null);
                        entityPessoa.pes_idFiliacaoPai   = Guid.Empty;
                        entityPessoa.pes_idFiliacaoMae   = Guid.Empty;
                        entityPessoa.tes_id              = Guid.Empty;
                        entityPessoa.pes_estadoCivil     = Convert.ToByte(null);
                        entityPessoa.pes_situacao        = 1;

                        PES_PessoaDeficiencia entityPessoaDeficiencia = new PES_PessoaDeficiencia
                        {
                            pes_id = Guid.Empty,
                            tde_id = Guid.Empty,
                            IsNew  = true
                        };

                        savePessoaReturn = PES_PessoaBO.Save(entityPessoa
                                                             , entityPessoaDeficiencia
                                                             , new DataTable()            //dtEndereco
                                                             , new DataTable()            //dtContato
                                                             , RetornaDocumento(data.CPF) //dtDocumento
                                                             , new DataTable()            //dtCertidao
                                                             , Guid.Empty                 //pai_idAntigo
                                                             , Guid.Empty                 //cid_idAntigo
                                                             , Guid.Empty                 //pes_idPaiAntigo
                                                             , Guid.Empty                 //pes_idMaeAntigo
                                                             , Guid.Empty                 //tes_idAntigo
                                                             , Guid.Empty                 //tde_idAntigo
                                                             , null                       //arquivosPermitidos
                                                             , 0                          //tamanhoMaximoKB
                                                             , null                       //entFoto
                                                             , false                      //ExcluirImagemAtual
                                                             );

                        #endregion
                    }
                }
                #region [ Cria usuário ]

                entity.ent_id    = data.ent_id;
                entity.usu_id    = Guid.Empty;
                entity.usu_login = data.usu_login;
                entity.usu_email = string.IsNullOrEmpty(data.email) ? string.Empty : data.email;
                entity.usu_senha = string.IsNullOrEmpty(data.senha) ? string.Empty : data.senha;

                //Se foi recuperado ou criado uma pessoa, vincula o pes_id
                if (entityPessoa != null)
                {
                    entity.pes_id = entityPessoa.pes_id;
                }

                entity.usu_criptografia  = Convert.ToByte(eCriptografa.TripleDES);
                entity.usu_situacao      = 1;
                entity.usu_dataAlteracao = DateTime.Now;
                entity.usu_dataCriacao   = DateTime.Now;
                entity.usu_dominio       = string.Empty;
                entity.usu_integracaoAD  = (byte)SYS_UsuarioBO.eIntegracaoAD.NaoIntegrado;
                entity.IsNew             = true;

                SortedDictionary <Guid, SYS_UsuarioBO.TmpGrupos> grupos = new SortedDictionary <Guid, SYS_UsuarioBO.TmpGrupos>();

                foreach (Guid gruId in data.gru_id)
                {
                    SYS_UsuarioBO.AddTmpGrupo(gruId, grupos, 1);
                }

                SortedDictionary <Guid, List <SYS_UsuarioBO.TmpEntidadeUA> > entidadeUA = new SortedDictionary <Guid, List <SYS_UsuarioBO.TmpEntidadeUA> >();

                SYS_UsuarioBO.Save(entity, grupos, entidadeUA, false, data.nome, string.Empty, string.Empty, string.Empty, null);

                #endregion
            }
            else
            {
                throw new ValidationException("Usuário já existe.");
            }

            #region [ Log de ação]

            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.CriacaoUsuario
            }
            );

            #endregion
        }
Пример #30
0
        /// <summary>
        /// Método utilizado via Web API para alteração de Usuários
        /// </summary>
        /// <param name="data">Parametros de entrada: Id Entidade, Id Grupo, ID Usuario, Nome,
        /// CPF, Data de nascimento, E-mail, Senha</param>
        /// <param name="entityUsuarioAPI">Usuário da API usado para gravar log de ação</param>
        public static void Update(UsuarioEntradaDTO data, CFG_UsuarioAPI entityUsuarioAPI)
        {
            #region [ Validação de campos obrigatórios ]

            if (data.ent_id == Guid.Empty || string.IsNullOrWhiteSpace(data.usu_login))
            {
                throw new ValidationException("Id da entidade e login do usuário são obrigatórios.");
            }

            #endregion

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

            PES_Pessoa entityPessoa = null;

            if (!entity.IsNew)
            {
                //Validação de usuário padrão do sistema
                if (entity.usu_situacao == (byte)SYS_UsuarioBO.eSituacao.Padrao_Sistema)
                {
                    throw new ValidationException("Não é possível alterar dados do usuário padrão do sistema.");
                }

                //Se o usuário recuperado não possuir pessoa, pula os passos de update de Pessoa
                if (entity.pes_id != Guid.Empty)
                {
                    #region [Pessoa]

                    entityPessoa = new PES_Pessoa {
                        pes_id = entity.pes_id
                    };
                    PES_PessoaBO.GetEntity(entityPessoa);

                    if (!string.IsNullOrWhiteSpace(data.nome) && entityPessoa.pes_nome.ToLower() != data.nome.ToLower())
                    {
                        entityPessoa.pes_nome = data.nome;
                    }

                    if (data.dataNascimento != new DateTime() && entityPessoa.pes_dataNascimento != data.dataNascimento)
                    {
                        entityPessoa.pes_dataNascimento = data.dataNascimento;
                    }

                    if (data.sexo == 1 || data.sexo == 2)
                    {
                        entityPessoa.pes_sexo = data.sexo;
                    }

                    entityPessoa.pes_dataAlteracao = DateTime.Now;

                    #region [Validações CPF]

                    Guid?tdo_id   = null;
                    bool criarCPF = false;

                    //Recupera os documentos da pessoa
                    DataTable documentosPessoa = PES_PessoaDocumentoBO.GetSelect(entityPessoa.pes_id, false, 1, 1);

                    //Se CPF existir, realiza validações
                    if (!string.IsNullOrWhiteSpace(data.CPF))
                    {
                        if (UtilBO._ValidaCPF(data.CPF))
                        {
                            //Recupera o tipo de documento CPF
                            string tipoDocCPF = SYS_ParametroBO.ParametroValor(SYS_ParametroBO.eChave.TIPO_DOCUMENTACAO_CPF);
                            if (!string.IsNullOrEmpty(tipoDocCPF))
                            {
                                tdo_id   = Guid.Parse(tipoDocCPF);
                                criarCPF = true;
                            }
                        }
                        else
                        {
                            throw new ValidationException("CPF inválido.");
                        }

                        if (documentosPessoa.Rows.Count > 0)
                        {
                            //Recupera o indice da linha que contém o documento do tipo CPF
                            var indiceRowCPF = documentosPessoa.AsEnumerable()
                                               .Select((row, index) => new { row, index })
                                               .Where(item => item.row.Field <Guid>("tdo_id") == tdo_id)
                                               .Select(item => item.index).ToArray();

                            //Se a pessoa possui um documento do tipo CPF, verifica se precisa alterar
                            if (indiceRowCPF.Count() > 0)
                            {
                                if (documentosPessoa.Rows[indiceRowCPF[0]]["numero"].ToString() != data.CPF)
                                {
                                    documentosPessoa.Rows[indiceRowCPF[0]]["numero"] = data.CPF;
                                }
                            }
                            else
                            {
                                //Pessoa ainda não possue CPF, nesse caso cria usando o datatable recuperado

                                DataRow rowDoc = documentosPessoa.NewRow();

                                rowDoc["tdo_id"]        = tdo_id;
                                rowDoc["unf_idEmissao"] = Guid.Empty.ToString();
                                rowDoc["unf_idAntigo"]  = Guid.Empty.ToString();
                                rowDoc["numero"]        = data.CPF;
                                rowDoc["dataemissao"]   = string.Empty;
                                rowDoc["orgaoemissao"]  = string.Empty;
                                rowDoc["info"]          = string.Empty;

                                documentosPessoa.Rows.Add(rowDoc);
                            }
                            criarCPF = false;
                        }

                        if (criarCPF)
                        {
                            if (tdo_id != null)
                            {
                                //Cria o datatable na estrutura necessária com o CPF enviado
                                documentosPessoa = RetornaDocumento(data.CPF);
                            }
                        }
                    }

                    #endregion

                    PES_PessoaDeficiencia entityPessoaDeficiencia = new PES_PessoaDeficiencia
                    {
                        pes_id = Guid.Empty,
                        tde_id = Guid.Empty,
                        IsNew  = true
                    };

                    PES_PessoaBO.Save(entityPessoa
                                      , entityPessoaDeficiencia
                                      , new DataTable()  //dtEndereco
                                      , new DataTable()  //dtContato
                                      , documentosPessoa //dtDocumento
                                      , new DataTable()  //dtCertidao
                                      , Guid.Empty       //pai_idAntigo
                                      , Guid.Empty       //cid_idAntigo
                                      , Guid.Empty       //pes_idPaiAntigo
                                      , Guid.Empty       //pes_idMaeAntigo
                                      , Guid.Empty       //tes_idAntigo
                                      , Guid.Empty       //tde_idAntigo
                                      , null             //arquivosPermitidos
                                      , 0                //tamanhoMaximoKB
                                      , null             //entFoto
                                      , false            //ExcluirImagemAtual
                                      );

                    #endregion
                }

                #region [Usuário]

                //entity.usu_login = data.usu_login;

                if (!string.IsNullOrWhiteSpace(data.email) && entity.usu_email != data.email)
                {
                    entity.usu_email = data.email;
                }

                //Se não vier senha, seta a senha da entidade como vazia para o método do sistema
                //não encriptar novamente o que já estava encriptado
                if (string.IsNullOrWhiteSpace(data.senha))
                {
                    entity.usu_senha = string.Empty;
                }
                else
                {
                    entity.usu_senha = data.senha;
                }

                if (entityPessoa != null)
                {
                    entity.pes_id = entityPessoa.pes_id;
                }

                entity.usu_criptografia  = Convert.ToByte(eCriptografa.TripleDES);
                entity.usu_dataAlteracao = DateTime.Now;

                SortedDictionary <Guid, SYS_UsuarioBO.TmpGrupos>             grupos     = new SortedDictionary <Guid, SYS_UsuarioBO.TmpGrupos>();
                SortedDictionary <Guid, List <SYS_UsuarioBO.TmpEntidadeUA> > entidadeUA = new SortedDictionary <Guid, List <SYS_UsuarioBO.TmpEntidadeUA> >();

                //Se vier grupos cria a lista com base nesses grupos
                if (data.gru_id.Count() > 0)
                {
                    foreach (Guid gruId in data.gru_id)
                    {
                        SYS_UsuarioBO.AddTmpGrupo(gruId, grupos, 1);
                    }
                }
                else
                {
                    //Senão, recupera os grupos do usuário para enviar ao método salvar
                    SYS_UsuarioBO.GetGruposUsuario(entity.usu_id, grupos, entidadeUA);
                }

                SYS_UsuarioBO.Save(entity, grupos, entidadeUA, false, data.nome, string.Empty, string.Empty, string.Empty, null);

                #endregion
            }
            else
            {
                throw new ValidationException("Usuário não existe.");
            }

            #region [ Log de ação]

            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.AlteracaoUsuario
            }
            );

            #endregion
        }