示例#1
0
        public IActionResult Post([FromBody] UsuarioDados usuarioDados)
        {
            try
            {
                usuarioDados.Validate();
                if (!usuarioDados.EhValido)
                {
                    return(BadRequest(usuarioDados.ObterMensagensValidacao()));
                }

                if (usuarioDados.Id > 0)
                {
                    _usuarioDadosRepositorio.Atualizar(usuarioDados);
                }
                else
                {
                    _usuarioDadosRepositorio.Adicionar(usuarioDados);
                }

                return(Created("api/usuarioDados", usuarioDados));
            }
            catch (Exception ex)
            {
                return(BadRequest(ex.ToString()));
            }
        }
        public JsonResult SalvarCadastro(string strDados)
        {
            UsuarioDados  json          = null;
            string        Erro          = string.Empty;
            RetornoPadrao RetornoPadrao = new RetornoPadrao();

            try
            {
                json = new JavaScriptSerializer().Deserialize <UsuarioDados>(strDados);

                if (json != null)
                {
                    Usuario user = new Usuario();
                    user.idUsuario      = json.idUsuario;
                    user.dsNome         = json.dsNome;
                    user.dsTelefone     = json.dsTelefone;
                    user.dsTipoTelefone = json.dsTipoTelefone;

                    RetornoPadrao = _repo.CadastrarAlterar(user);
                    return(Json(RetornoPadrao, JsonRequestBehavior.AllowGet));
                }
            }
            catch (Exception ex)
            {
                Erro = ex.ToString();
                RetornoPadrao.Mensagem = Erro;
            }

            return(Json(RetornoPadrao, JsonRequestBehavior.AllowGet));
        }
        public void CPF_DeveTer11Caracteres_DeveSerCPFValido(string cpf, string mensagemEsperada)
        {
            var usuarioDados = new UsuarioDados(Guid.NewGuid(), NOME_VALIDO, cpf);

            usuarioDados.EstaValido();

            AssertMensagemEsperada(mensagemEsperada, usuarioDados);
        }
        public void Nome_DeveTerEntre2e150Caracteres(string nome, string mensagemEsperada)
        {
            var usuarioDados = new UsuarioDados(Guid.NewGuid(), nome, CPF_VALIDO);

            usuarioDados.EstaValido();

            AssertMensagemEsperada(mensagemEsperada, usuarioDados);
        }
示例#5
0
        public List<string> UsuariosCadastrados()
        {
            UsuarioDados usuarioDados = new UsuarioDados();

            List<string> nomes = usuarioDados.obternomes();

            return nomes;
        }
示例#6
0
        public ActionResult AlterarSenha(Usuario User)
        {
            Usuario usuario;

            //Verifica se o usuário está ativo! Caso não esteja, vai para a tela de login
            //----------------------------------------------------------------------------------------------------------------------
            usuario = (Usuario)Session["Usuario"];

            if (usuario == null || usuario.Ativo != true)
            {
                return(RedirectToAction("Logar", "Usuario"));
            }
            //----------------------------------------------------------------------------------------------------------------------
            ViewBag.IdEmpresa = usuario.Empresa.IdEmpresa; ViewBag.NomeEmpresa = usuario.Empresa.NomeFantasia; ViewBag.NomeUsuario = usuario.Login; ViewBag.CNPJEmpresa = "CNPJ: " + @Convert.ToUInt64(usuario.Empresa.CNPJ).ToString(@"00\.000\.000\/0000\-00");


            //Senha Inválida!
            //----------------------------------------------------------------------------------
            if (Request.Form["Senha"] != Request.Form["ConfirmarSenha"])
            {
                usuario.Senha         = "";
                ViewBag.MensagemErro  = "";
                ViewBag.MensagemSenha = "A senha não confere!";
                return(View(usuario));
            }
            //----------------------------------------------------------------------------------

            bool Retorno = UsuarioDados.ConfereSenhaAtual(usuario);

            if (Retorno == false)
            {
                ViewBag.MensagemErro  = "";
                ViewBag.MensagemSenha = "A Senha já foi alterada por outra sessão.";
                return(View(usuario));
            }
            //----------------------------------------------------------------------------------

            usuario.Senha          = User.Senha;
            usuario.ConfirmarSenha = User.ConfirmarSenha;

            try
            {
                //Gravar o usuario
                //----------------------------------------------------------------------------------
                UsuarioDados.AlterarSenha(usuario);

                return(RedirectToAction("Index", "Home"));

                //----------------------------------------------------------------------------------
            }
            catch (Exception erro)
            {
                ViewBag.MensagemErro  = erro;
                ViewBag.MensagemSenha = "";
                //Em caso de erro retorna a mensagem de erro
                return(View(usuario));
            }
        }
示例#7
0
        public ActionResult Logar(Usuario usuario)
        {
            ViewBag.usuario       = "";
            ViewBag.MensagemErro  = "";
            ViewBag.MensagemSenha = "";

            try
            {
                string usuarionome  = Request.Form["nomeusuario"];
                string usuariosenha = Request.Form["senha"];

                usuarionome  = "Usuario";
                usuariosenha = "senha";

                ViewBag.usuario = usuarionome;

                string validacao = "";

                validacao = UsuarioDados.Logar(usuarionome, usuariosenha);

                //Se a validação não retornou nenhuma crítica, o usuário está autorizado
                //----------------------------------------------------------------------------------
                if (validacao == "")
                {
                    Usuario usuariobase = UsuarioDados.CarregaUsuariosPorLoginUsuario(usuarionome);

                    ////Passa as informações do usuário para o login
                    ////----------------------------------------------------------------------------------
                    Session["idUsuario"]   = usuariobase.idUsuario;
                    Session["Nome"]        = usuariobase.Nome;
                    Session["Login"]       = usuariobase.Login.ToUpper();
                    Session["IdEmpresa"]   = usuariobase.Empresa.IdEmpresa;
                    Session["NomeEmpresa"] = usuariobase.NomeEmpresa;
                    Session["CNPJEmpresa"] = usuariobase.CNPJEmpresa;
                    Session["HoraLogon"]   = System.DateTime.Now;
                    Session["Usuario"]     = usuariobase;

                    //----------------------------------------------------------------------------------

                    return(RedirectToAction("index", "Empresa"));
                }
                else
                {
                    ViewBag.MensagemErro  = validacao;
                    ViewBag.MensagemSenha = "";
                    return(View(usuario));
                }
            }
            catch (Exception erro)
            {
                ViewBag.MensagemErro  = erro.ToString();//Em caso de erro retorna a mensagem de erro
                ViewBag.MensagemSenha = "";

                return(View(usuario));
            }
        }
示例#8
0
        public async Task meusPontos()
        {
            EmbedBuilder bd = new EmbedBuilder();

            var status = $"{Context.User.Status}";

            ;


            if (status.Equals("DoNotDisturb"))
            {
                status = ":red_circle:  Não pertubar";
            }
            if (status.Equals("Idle"))
            {
                status = ":large_blue_circle:   Ausente";
            }
            if (status.Equals("Offline"))
            {
                status = ":white_circle:    Invisível";
            }
            if (status.Equals("Online"))
            {
                status = ":white_check_mark:  Disponível";
            }
            var cargores = "";

            UsuarioDados account = UsuarioDado.GetUsuarioDados(Context.User);

            foreach (SocketRole role in ((SocketGuildUser)Context.Message.Author).Roles)
            {
                cargores += " " + role.Name + ",";
            }
            var idUser = $"```{Context.User.Id}```";
            var idName = $"```{Context.User.Username}```";

            bd.WithTitle($"Perfil de {Context.User}");
            bd.WithColor(Color.Blue);
            bd.WithDescription($"Missão :```{account.missao}```");
            bd.WithThumbnailUrl($"{Context.User.GetAvatarUrl(size:2048)}");
            bd.AddInlineField("Status", status);
            bd.AddInlineField("Jogando", $":video_game: {Context.User.Game}");
            bd.AddInlineField("XP: ", $"```{account.XP}```");
            bd.AddInlineField("Diamantes : ", $"```{account.Points}```");
            bd.AddInlineField("Nome da Conta:", idName);
            bd.AddInlineField("Nível:", $"```{account.levelNumero}```");
            bd.AddInlineField("Avisos", $"```{account.NumberOfWarning}```");
            bd.AddInlineField("Conta criada em", $"{Context.User.CreatedAt}");
            bd.AddInlineField("ID:", idUser);
            bd.AddInlineField("Cargos:", $"***{cargores}***");



            await Context.Channel.SendMessageAsync("", false, bd.Build());
        }
示例#9
0
        public ActionResult EsqueciASenha(Usuario User)
        {
            Usuario usuario;

            //Senha Inválida!
            //----------------------------------------------------------------------------------
            if (Request.Form["Senha"] != Request.Form["ConfirmarSenha"])
            {
                User.Senha            = "";
                ViewBag.MensagemErro  = "";
                ViewBag.MensagemSenha = "A senha não confere!";
                return(View(User));
            }
            //----------------------------------------------------------------------------------


            //Verifica se o usuário existe
            //----------------------------------------------------------------------------------
            usuario = UsuarioDados.CarregaUsuariosPorLoginDocumento(User.Login, User.CPF);

            if (usuario.idUsuario == 0)
            {
                User.Senha            = "";
                ViewBag.MensagemErro  = "";
                ViewBag.MensagemSenha = "Usuário não Encontrado! Verifique o Login e o Documento informado!";
                return(View(User));
            }
            //----------------------------------------------------------------------------------

            //Atualiza as informações
            //----------------------------------------------------------------------------------
            usuario.Senha          = User.Senha;
            usuario.ConfirmarSenha = User.ConfirmarSenha;
            //----------------------------------------------------------------------------------

            //Grava o usuário e aponta para a tela de login
            //----------------------------------------------------------------------------------
            try
            {
                //Gravar o usuario
                //----------------------------------------------------------------------------------
                UsuarioDados.AlterarSenha(usuario);

                return(RedirectToAction("Index", "Home"));

                //----------------------------------------------------------------------------------
            }
            catch (Exception erro)
            {
                ViewBag.MensagemErro  = erro;
                ViewBag.MensagemSenha = "";
                //Em caso de erro retorna a mensagem de erro
                return(View(usuario));
            }
        }
示例#10
0
        public ActionResult CadastrarUsuario(Usuario usuario)
        {
            usuario.CNPJEmpresa = String.Join("", System.Text.RegularExpressions.Regex.Split(usuario.CNPJEmpresa, @"[^\d]"));

            //Senha Inválida!
            //----------------------------------------------------------------------------------
            if (usuario.Senha != Request.Form["ConfirmarSenha"])
            {
                usuario.Senha         = "";
                ViewBag.IdEmpresa     = usuario.Empresa.IdEmpresa; ViewBag.NomeEmpresa = usuario.Empresa.NomeFantasia; ViewBag.NomeUsuario = usuario.Login; ViewBag.CNPJEmpresa = "CNPJ: " + @Convert.ToUInt64(usuario.Empresa.CNPJ).ToString(@"00\.000\.000\/0000\-00");
                ViewBag.MensagemErro  = "";
                ViewBag.MensagemSenha = "A senha não confere!";
                return(View(usuario));
            }
            //----------------------------------------------------------------------------------


            //Verifica se o usuário já está cadastrado
            //----------------------------------------------------------------------------------
            usuario.Empresa = EmpresaDados.CarregaEmpresasPorCNPJ(usuario.CNPJEmpresa);

            bool Retorno = UsuarioDados.UsuarioJaExiste(usuario.Nome, usuario.Login);

            if (Retorno == true)
            {
                ViewBag.IdEmpresa     = usuario.Empresa.IdEmpresa; ViewBag.NomeEmpresa = usuario.Empresa.NomeFantasia; ViewBag.NomeUsuario = usuario.Login; ViewBag.CNPJEmpresa = "CNPJ: " + @Convert.ToUInt64(usuario.Empresa.CNPJ).ToString(@"00\.000\.000\/0000\-00");
                ViewBag.MensagemErro  = "";
                ViewBag.MensagemSenha = "Usuário já cadastrado.";
                return(View(usuario));
            }
            //----------------------------------------------------------------------------------


            try
            {
                //Gravar o usuario
                //----------------------------------------------------------------------------------
                UsuarioDados.Gravar(usuario);

                return(RedirectToAction("logar", "usuario"));

                //----------------------------------------------------------------------------------
            }
            catch (Exception erro)
            {
                ViewBag.IdEmpresa     = 0;
                ViewBag.MensagemErro  = "Erro ao Cadastrar usuário";
                ViewBag.erro          = erro.ToString();
                ViewBag.MensagemSenha = "";
                //Em caso de erro retorna a mensagem de erro
                return(View(usuario));
            }
        }
        private static void AssertMensagemEsperada(string mensagemEsperada, UsuarioDados usuarioDados)
        {
            Assert.Equal(usuarioDados.ValidationResult.IsValid, string.IsNullOrEmpty(mensagemEsperada));

            if (string.IsNullOrEmpty(mensagemEsperada))
            {
                Assert.Empty(usuarioDados.ValidationResult.Errors);
            }
            else
            {
                Assert.True(usuarioDados.ValidationResult.Errors.Any(e => e.ErrorMessage == mensagemEsperada));
            }
        }
示例#12
0
        public ActionResult RenovarSenha(int UsuarioAlterar)
        {
            //int UsuarioAlterar = 1;

            Usuario usuario;

            Session["MensagemErroAlteracaoCadastro"] = "";

            //Verifica se o usuário está ativo! Caso não esteja, vai para a tela de login
            //----------------------------------------------------------------------------------------------------------------------
            usuario = (Usuario)Session["Usuario"];

            if (usuario == null || usuario.Ativo != true)
            {
                return(RedirectToAction("Logar", "Usuario"));
            }
            //----------------------------------------------------------------------------------------------------------------------
            ViewBag.IdEmpresa = usuario.Empresa.IdEmpresa; ViewBag.NomeEmpresa = usuario.Empresa.NomeFantasia; ViewBag.NomeUsuario = usuario.Login; ViewBag.CNPJEmpresa = "CNPJ: " + @Convert.ToUInt64(usuario.Empresa.CNPJ).ToString(@"00\.000\.000\/0000\-00");

            //Funcionalidade Disponível apenas para Administradores
            if (usuario.Administrador == false)
            {
                Session["MensagemErroAlteracaoCadastro"] = "ALTERAÇÕES PERMITIDAS APENAS PARA ADMINISTRADORES";

                return(RedirectToAction("GerenciarUsuarios", "Usuario"));
            }

            try
            {
                //Gravar o usuario
                //----------------------------------------------------------------------------------
                UsuarioDados.RenovarSenha(usuario, UsuarioAlterar);

                Session["MensagemSucessoSenha"] = "A SENHA FOI ALTERADA PARA 123456";

                return(RedirectToAction("GerenciarUsuarios", "Usuario"));
                //----------------------------------------------------------------------------------
            }
            catch (Exception erro)
            {
                ViewBag.MensagemErro  = erro;
                ViewBag.MensagemSenha = "";
                //Em caso de erro retorna a mensagem de erro
                //return View(usuario);

                return(RedirectToAction("GerenciarUsuarios", "Usuario"));
            }
        }
        static void Main(string[] args)
        {
            UsuarioBC usuario = new UsuarioBC();

            usuario.CpfUsuario = "125966789";

            UsuarioDados     dao    = new UsuarioDados();
            List <UsuarioBC> listar = new List <UsuarioBC>();

            listar = dao.ListarUsuario(usuario);
            foreach (UsuarioBC u in listar)
            {
                Console.WriteLine(u.CpfUsuario + " " + u.NomeUsuario + " " + u.Sexo + " " + u.NmTelefone + " " + u.Endereco + " " + u.DtNascimento + " " + u.Status);
            }
            Console.ReadKey();
        }
示例#14
0
        public ActionResult GerenciarUsuarios()
        {
            Usuario usuario;

            @ViewBag.Mensagem        = "";
            @ViewBag.MensagemSucesso = "";

            //Verifica se o usuário está ativo! Caso não esteja, vai para a tela de login
            //----------------------------------------------------------------------------------------------------------------------
            usuario = (Usuario)Session["Usuario"];

            if (usuario == null || usuario.Ativo != true)
            {
                return(RedirectToAction("Logar", "Usuario"));
            }
            //----------------------------------------------------------------------------------------------------------------------
            ViewBag.IdEmpresa = usuario.Empresa.IdEmpresa; ViewBag.NomeEmpresa = usuario.Empresa.NomeFantasia; ViewBag.NomeUsuario = usuario.Login; ViewBag.CNPJEmpresa = "CNPJ: " + @Convert.ToUInt64(usuario.Empresa.CNPJ).ToString(@"00\.000\.000\/0000\-00");


            if (Session["MensagemErroAlteracaoCadastro"] != null)
            {
                if (Session["MensagemErroAlteracaoCadastro"].ToString() != "")
                {
                    @ViewBag.Mensagem = Session["MensagemErroAlteracaoCadastro"];
                    Session["MensagemErroAlteracaoCadastro"] = "";
                }
            }
            ;

            if (Session["MensagemSucessoSenha"] != null)
            {
                if (Session["MensagemSucessoSenha"].ToString() != "")
                {
                    @ViewBag.MensagemSucesso        = Session["MensagemSucessoSenha"];
                    Session["MensagemSucessoSenha"] = "";
                }
            }
            ;


            ViewBag.SenhaAnterior = usuario.Senha;
            ViewBag.Classe        = Classe;

            var Lista = UsuarioDados.CarregarUsuarios(usuario).ToPagedList(1, 1000);

            return(View(Lista));
        }
        public InformacoesUsuarioResponse InformacoesLogin(string aEmail)
        {
            var dados = new UsuarioDados();

            var usuario = dados.BuscarUsuarioPeloEmail(aEmail);

            switch (usuario.Tipo)
            {
            case TipoUsuario.Funcionario:
                return(dados.BuscarInfoLoginFuncionario(usuario.Id));

            case TipoUsuario.Cliente:
                return(dados.BuscarInfoLoginCliente(usuario.Id));

            default:
                return(null);
            }
        }
示例#16
0
        public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
        {
            // Adiciona no cabeçalho a origem da requisicao
            context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { "*" }); //Permite todos os

            String login = context.UserName;
            String senha = context.Password;

            try
            {
                bool retorno = false;

                var db              = new EstudodbEntities();
                var usuarioDados    = new UsuarioDados(db);
                var usuarioNegocios = new UsuarioNegocio(usuarioDados);

                retorno = usuarioNegocios.VerificaUsuario(login, senha);

                if (!retorno)
                {
                    return;
                }

                //Identifica o usuário
                var identidade = new ClaimsIdentity(context.Options.AuthenticationType);
                identidade.AddClaim(new Claim(ClaimTypes.Name, login));

                //Atribui Roles
                var roles = new String[] { };
                foreach (var role in roles)
                {
                    identidade.AddClaim(new Claim(ClaimTypes.Role, role));
                }

                GenericPrincipal principal = new GenericPrincipal(identidade, roles.ToArray());
                Thread.CurrentPrincipal = principal; // Configura na Thread  principal para poder recuperar no controle

                context.Validated(identidade);
            }
            catch (Exception e)
            {
                context.SetError("Falha de Autenticação", "Falha ao realizar Autenticação.\n\n" + e.Message);
            }
        }
示例#17
0
        public ActionResult DadosCadastrais(Usuario User)
        {
            Usuario usuario;

            @ViewBag.Mensagem        = "";
            @ViewBag.MensagemSucesso = "";

            //Verifica se o usuário está ativo! Caso não esteja, vai para a tela de login
            //----------------------------------------------------------------------------------------------------------------------
            usuario = (Usuario)Session["Usuario"];

            if (usuario == null || usuario.Ativo != true)
            {
                return(RedirectToAction("Logar", "Usuario"));
            }
            //----------------------------------------------------------------------------------------------------------------------
            ViewBag.IdEmpresa = usuario.Empresa.IdEmpresa; ViewBag.NomeEmpresa = usuario.Empresa.NomeFantasia; ViewBag.NomeUsuario = usuario.Login; ViewBag.CNPJEmpresa = "CNPJ: " + @Convert.ToUInt64(usuario.Empresa.CNPJ).ToString(@"00\.000\.000\/0000\-00");

            //Verifica se o usuário já está cadastrado
            //----------------------------------------------------------------------------------
            usuario.Empresa = EmpresaDados.CarregaEmpresasPorCNPJ(usuario.CNPJEmpresa);

            bool Retorno = UsuarioDados.UsuarioJaExisteEdicaoCadastral(usuario, User);

            if (Retorno == true)
            {
                ViewBag.IdEmpresa     = usuario.Empresa.IdEmpresa; ViewBag.NomeEmpresa = usuario.Empresa.NomeFantasia; ViewBag.NomeUsuario = usuario.Login; ViewBag.CNPJEmpresa = "CNPJ: " + @Convert.ToUInt64(usuario.Empresa.CNPJ).ToString(@"00\.000\.000\/0000\-00");
                ViewBag.MensagemErro  = "";
                ViewBag.MensagemSenha = "Usuário já cadastrado.";
                return(View(User));
            }
            else
            {
                //----------------------------------------------------------------------------------

                UsuarioDados.AlterarDadosCadastrais(User);

                @ViewBag.Mensagem        = "Dados Alterados com Sucesso!";
                @ViewBag.MensagemSucesso = "Dados Alterados com Sucesso!";

                return(View(User));
            }
        }
示例#18
0
        private void nome_usuario_TextBox1_KeyPress(object sender, KeyPressEventArgs e)
        {
            if (e.KeyChar == 8)
            {
                nome_usuario_TextBox1.Text = "";
            }

            if (e.KeyChar == 13)
            {
                ConexaoOracle test = new ConexaoOracle();
                UsuarioDados Logador = new UsuarioDados(test);
                if (Logador.valida(nome_usuario_TextBox1.Text, senha_usuario_TextBox1.Text) == true)
                {
                    Tela_inicial inicio = new Tela_inicial();
                    inicio.ShowDialog();
                }
                else
                {
                    texto_login_incorreto.Text = "USUÁRIO NÃO CADASTRADO";
                };
            }
        }
示例#19
0
 private void button1_Click(object sender, EventArgs e)
 {
     this.Cursor = Cursors.WaitCursor;
     ConexaoOracle test = new ConexaoOracle();
     UsuarioDados Logador = new UsuarioDados(test);
     if (Logador.valida(nome_usuario_TextBox1.Text,senha_usuario_TextBox1.Text) == true)
     {
         Tela_inicial inicio = new Tela_inicial();
         this.Cursor = Cursors.Default;
         inicio.ShowDialog();
     }
     else if(nome_usuario_TextBox1.Text == "admin" && senha_usuario_TextBox1.Text == "admin")
     {
         Tela_inicial inicio = new Tela_inicial();
         this.Cursor = Cursors.Default;
         inicio.ShowDialog();
     }
     else
     {
         texto_login_incorreto.Text = "USUÁRIO NÃO CADASTRADO";
         this.Cursor = Cursors.Default;
     }
 }
示例#20
0
 public static int Inserir(UsuarioDominio objClientes)
 {
     return(UsuarioDados.Inserir(objClientes));
 }
示例#21
0
 public UsuarioNegocio()
 {
     DadosdoUsuario = new UsuarioDados();
 }