public bool ValidarAtivar(CredenciadoPessoa credenciado, string senha, string confirmarSenha)
        {
            if (_da.VerificarChaveAtiva(credenciado.Chave))
            {
                Validacao.Add(Mensagem.Credenciado.CredenciadoChaveJaAtiva);
            }
            else
            {
                if (!_da.VerificarExisteChave(credenciado.Chave))
                {
                    Validacao.Add(Mensagem.Credenciado.ChaveInvalida);
                }

                if (String.IsNullOrEmpty(credenciado.Usuario.Login))
                {
                    Validacao.Add(Mensagem.Credenciado.LoginObrigatorio);
                }
                else
                {
                    UsuarioBus busUsuario = new UsuarioBus(HistoricoAplicacao.CREDENCIADO, UsuarioCredenciado);

                    if (credenciado.Usuario.Id <= 0 && busUsuario.VerificarLoginExistente(credenciado.Usuario.Login, credenciado.Usuario.Id))
                    {
                        Validacao.Add(Mensagem.Credenciado.LoginExistente);
                    }

                    if (credenciado.Usuario.Login.Length < _configUsuario.Obter <Int32>(ConfiguracaoUsuario.keyTamanhoMinLogin))
                    {
                        Validacao.Add(Mensagem.Credenciado.LoginTamanho(_configUsuario.Obter <Int32>(ConfiguracaoUsuario.keyTamanhoMinLogin)));
                    }

                    if (!UsuarioValidacao.FormatoLogin(credenciado.Usuario.Login))
                    {
                        Validacao.Add(Mensagem.Credenciado.FormatoLogin);
                    }
                }

                if (String.IsNullOrWhiteSpace(senha))
                {
                    Validacao.Add(Mensagem.Credenciado.SenhaObrigatorio);
                }

                if (String.IsNullOrWhiteSpace(confirmarSenha))
                {
                    Validacao.Add(Mensagem.Credenciado.ConfirmarSenhaObrigatorio);
                }

                if (!String.IsNullOrEmpty(senha) && senha.Length < _configUsuario.Obter <Int32>(ConfiguracaoUsuario.keyTamanhoSenha))
                {
                    Validacao.Add(Mensagem.Credenciado.SenhaTamanho(_configUsuario.Obter <Int32>(ConfiguracaoUsuario.keyTamanhoSenha)));
                }

                if (!String.IsNullOrEmpty(senha) && !senha.Equals(confirmarSenha))
                {
                    Validacao.Add(Mensagem.Credenciado.SenhaDiferente);
                }
            }

            return(Validacao.EhValido);
        }
Esempio n. 2
0
        public override bool IsValid()
        {
            var usuarioValidacao = new UsuarioValidacao();

            ValidationResult = usuarioValidacao.Validate(this);

            return(ValidationResult.IsValid);
        }
        public bool Salvar(Administrador obj, String senha, String ConfirmarSenha, bool AlterarSenha)
        {
            if (String.IsNullOrEmpty(obj.Nome))
            {
                Validacao.Add(Mensagem.Administrador.NomeObrigatorio);
            }

            if (String.IsNullOrEmpty(obj.Email))
            {
                Validacao.Add(Mensagem.Administrador.EmailObrigatorio);
            }
            else if (!ValidacoesGenericasBus.Email(obj.Email))
            {
                Validacao.Add(Mensagem.Administrador.EmailInvalido);
            }

            Cpf(obj.Cpf);

            //Valores De configuracao com cache
            //_config.Obter<Int32>(ConfiguracaoUsuario.keyTamanhoSenha)
            //Valores Atuais
            //_config.Atual.TamanhoSenha

            if (obj.Usuario.Id <= 0 || !String.IsNullOrWhiteSpace(senha) || !String.IsNullOrWhiteSpace(ConfirmarSenha) || AlterarSenha)
            {
                if (String.IsNullOrWhiteSpace(senha))
                {
                    Validacao.Add(Mensagem.Administrador.SenhaObrigatorio);
                }

                if (String.IsNullOrWhiteSpace(ConfirmarSenha))
                {
                    Validacao.Add(Mensagem.Administrador.ConfirmarSenhaObrigatorio);
                }

                if (!String.IsNullOrEmpty(senha) && senha.Length < _configUsuario.Obter <Int32>(ConfiguracaoUsuario.keyTamanhoSenha))
                {
                    Validacao.Add(Mensagem.Administrador.SenhaTamanho(_configUsuario.Obter <Int32>(ConfiguracaoUsuario.keyTamanhoSenha)));
                }

                if (!String.IsNullOrEmpty(senha) && !senha.Equals(ConfirmarSenha))
                {
                    Validacao.Add(Mensagem.Administrador.SenhaDiferente);
                }
            }

            if (String.IsNullOrEmpty(obj.Usuario.Login))
            {
                Validacao.Add(Mensagem.Administrador.LoginObrigatorio);
            }
            else
            {
                if (obj.Usuario.Login.Length < _configUsuario.Obter <Int32>(ConfiguracaoUsuario.keyTamanhoMinLogin))
                {
                    Validacao.Add(Mensagem.Administrador.LoginTamanho(_configUsuario.Obter <Int32>(ConfiguracaoUsuario.keyTamanhoMinLogin)));
                }

                if (!UsuarioValidacao.FormatoLogin(obj.Usuario.Login))
                {
                    Validacao.Add(Mensagem.Administrador.FormatoLogin);
                }

                if (_usuarioBus.VerificarLoginExistente(obj.Usuario.Login, obj.Usuario.Id))
                {
                    Validacao.Add(Mensagem.Administrador.LoginExistente);
                }
            }

            return(Validacao.EhValido);
        }
 public UsuarioService(IUsuarioRepository usuarioRepository, UsuarioValidacao usuarioValidacao)
 {
     _usuarioRepository = usuarioRepository;
     _usuarioValidacao  = usuarioValidacao;
 }
        public bool Salvar(Funcionario funcionario, String senha, String ConfirmarSenha)
        {
            if (String.IsNullOrEmpty(funcionario.Nome))
            {
                Validacao.Add(Mensagem.Funcionario.NomeObrigatorio);
            }

            //if (!string.IsNullOrWhiteSpace(funcionario.Email) && !ValidacoesGenericasBus.Email(funcionario.Email))
            //{
            //    Validacao.Add(Mensagem.Funcionario.EmailInvalido);
            //}

            Cpf(funcionario.Cpf);

            if (funcionario.Cargos == null || funcionario.Cargos.Count == 0)
            {
                Validacao.Add(Mensagem.Funcionario.CargoObrigatorio);
            }

            if (funcionario.Setores == null || funcionario.Setores.Count == 0)
            {
                Validacao.Add(Mensagem.Funcionario.SetoresObrigatorio);
            }

            if (funcionario.Id > 0)            //Em edição
            {
                //Setores com posse
                List <Setor> setoresEmPosse = _da.ObterSetoresProtocolosEmPosse(funcionario.Id);

                foreach (var item in setoresEmPosse)
                {
                    if (!funcionario.Setores.Exists(x => x.Id == item.Id))
                    {
                        Validacao.Add(Mensagem.Funcionario.SetorComPosse(item.Nome));
                    }
                }

                //Setores onde funcionario é executor
                List <Setor> setoresRegistrador = _da.ObterSetoresRegistrador(funcionario.Id);

                foreach (var item in setoresRegistrador)
                {
                    if (!funcionario.Setores.Exists(x => x.Id == item.Id))
                    {
                        Validacao.Add(Mensagem.Funcionario.SetorComRegistrador(item.Nome));
                    }
                }
            }

            if (String.IsNullOrEmpty(funcionario.Usuario.Login))
            {
                Validacao.Add(Mensagem.Funcionario.LoginObrigatorio);
            }
            else
            {
                if (funcionario.Usuario.Login.Length < _configUsuario.Obter <Int32>(ConfiguracaoUsuario.keyTamanhoMinLogin))
                {
                    Validacao.Add(Mensagem.Funcionario.LoginTamanho(_configUsuario.Obter <Int32>(ConfiguracaoUsuario.keyTamanhoMinLogin)));
                }

                if (!UsuarioValidacao.FormatoLogin(funcionario.Usuario.Login))
                {
                    Validacao.Add(Mensagem.Funcionario.FormatoLogin);
                }

                if (_usuarioBus.VerificarLoginExistente(funcionario.Usuario.Login, funcionario.Usuario.Id))
                {
                    Validacao.Add(Mensagem.Funcionario.LoginExistente);
                }
            }

            if (funcionario.AlterarSenha || (funcionario.Usuario.Id <= 0))
            {
                if (String.IsNullOrWhiteSpace(senha))
                {
                    Validacao.Add(Mensagem.Funcionario.SenhaObrigatorio);
                }

                if (String.IsNullOrWhiteSpace(ConfirmarSenha))
                {
                    Validacao.Add(Mensagem.Funcionario.ConfirmarSenhaObrigatorio);
                }
            }

            if (funcionario.AlterarSenha || (funcionario.Usuario.Id <= 0 && (!String.IsNullOrWhiteSpace(senha) || !String.IsNullOrWhiteSpace(ConfirmarSenha))))
            {
                if (!String.IsNullOrEmpty(senha) && senha.Length < _configUsuario.Obter <Int32>(ConfiguracaoUsuario.keyTamanhoSenha))
                {
                    Validacao.Add(Mensagem.Funcionario.SenhaTamanho(_configUsuario.Obter <Int32>(ConfiguracaoUsuario.keyTamanhoSenha)));
                }

                if (!String.IsNullOrEmpty(senha) && !senha.Equals(ConfirmarSenha))
                {
                    Validacao.Add(Mensagem.Funcionario.SenhaDiferente);
                }
            }

            List <String> lstSetores = _da.VerificarResponsavelSetor(funcionario);

            lstSetores.ForEach(x => Validacao.Add(Mensagem.Funcionario.SetorComResponsavel(x)));

            return(Validacao.EhValido);
        }
Esempio n. 6
0
        private void ValidarUsuario(Usuario usuario)
        {
            var jogoValidate = new UsuarioValidacao();

            new FluentResultAdapter().VerificaErros(jogoValidate.Validate(usuario));
        }