Exemple #1
0
        public IActionResult Registrar(RegistrarViewModelInput registrarViewModelInput)
        {
            // var migracoesPendentes = context.Database.GetPendingMigrations();
            // if (migracoesPendentes.Any())
            // {
            //     context.Database.Migrate();
            // }

            var usuario = new Usuario();

            usuario.Login = registrarViewModelInput.Login;
            usuario.Email = registrarViewModelInput.Email;
            usuario.Senha = registrarViewModelInput.Senha;
            _usuarioRepository.Adicionar(usuario);
            _usuarioRepository.Commit();

            return(Created("", registrarViewModelInput));
        }
        [ValidacaoModelStateCustomizado]//mesma coisa aqui
        public IActionResult Registrar(RegistroViewModelInput loginViewModelInput)
        {
            //var migracoesPendentes = contexto.Database.GetPendingMigrations();
            //if(migracoesPendentes.Count() > 0)
            //{
            //    contexto.Database.Migrate();
            //}

            var usuario = new Usuario();

            usuario.Login = loginViewModelInput.Login;
            usuario.Senha = loginViewModelInput.Senha;
            usuario.Email = loginViewModelInput.Email;
            _usuarioRepository.Adicionar(usuario);
            _usuarioRepository.Commit();

            return(Created("", loginViewModelInput));//funfou, retorna
        }
        public async Task <Result> Handle(UsuarioInsertCommand command, CancellationToken cancellationToken)
        {
            var result = _usuarioService.Validar(command);

            if (!result.Valido)
            {
                return(await Task.FromResult(result));
            }

            var domain = UsuarioFactory.Criar(command);

            domain.Criar();

            _usuarioRepository.Adicionar(_usuarioService.ToEntity(domain));
            _unitOfWork.SaveChanges();

            return(await Task.FromResult(result));
        }
        public void Test_nao_pode_inserir_usuario_duplicado()
        {
            try
            {
                var cmd = new CriarUsuarioCommand();
                cmd.Id    = idUsuario;
                cmd.Login = loginUsuario;
                cmd.Senha = "123456";

                var usuario = Usuario.Criar(cmd, _validator);
                _repositorio.Adicionar(usuario);
            }
            catch (BusinessValidationException ex)
            {
                var nomeExistente = ex.Message.Contains(CriarUsuarioValidation.MensagensValidacao.EXISTE_LOGIN_CADASTRADO);
                Assert.AreEqual(nomeExistente, true);
            }
        }
Exemple #5
0
        public AspNetUsers AdicionarAspNetUser(AspNetUsers user)
        {
            if (IsValid(user, "Gravar"))
            {
                foreach (var item in user.Usuario)
                {
                    _usuario.Adicionar(item);

                    foreach (var tel in item.Telefones)
                    {
                        _telefone.Adicionar(tel);
                    }
                }
                user.validateResult.Success = "Usuário cadastrado com sucesso :)";
            }

            return(user);
        }
        public void ConfigInitialization()
        {
            _repositorio = Resolve <IUsuarioRepository>();
            _validator   = Resolve <CriarUsuarioValidation>();

            idUsuario = Guid.NewGuid();

            var cmd = new CriarUsuarioCommand();

            cmd.Id    = idUsuario;
            cmd.Login = loginUsuario;
            cmd.Senha = "123456";

            var usuario = Usuario.Criar(cmd, _validator);

            _repositorio.Adicionar(usuario);
            usuarioCriado = usuario;
        }
Exemple #7
0
        public Task <IActionResult> Post([FromBody] Models.UsuarioVM usuarioVM)
        {
            var error = CheckModelState();

            if (error != null)
            {
                return(Task.FromResult <IActionResult>(Json(error)));
            }

            var usuario =
                new Usuario(usuarioVM.Nome, usuarioVM.Email);

            _repo.Adicionar(usuario);
            _repo.Salvar();

            Response.StatusCode = (int)HttpStatusCode.Created;
            return(Task.FromResult <IActionResult>(Json(usuario)));
        }
        public IActionResult Post([FromBody] Usuario usuario)
        {
            try
            {
                // Criptografamos antes de salvar a senha
                usuario.Senha = Cripto.Criptografar(usuario.Senha, usuario.Email.Substring(0, 3));

                //Adiciona um novo usuário
                _usuarioRepository.Adicionar(usuario);

                //statusCode 200
                return(Ok(usuario));
            }
            catch (Exception ex)
            {
                return(BadRequest(ex.Message));
            }
        }
        public IActionResult Registrar(RegistroViewModelInput registroViewModelInput)
        {
            /*var migracoesPendentes = _context.Database.GetPendingMigrations();
             *
             * if (migracoesPendentes.Count() > 0)
             * {
             *  _context.Database.Migrate();
             * }*/

            var usuario = new Usuario();

            usuario.Login = registroViewModelInput.Login;
            usuario.Senha = registroViewModelInput.Senha;
            usuario.Email = registroViewModelInput.Email;
            _usuarioRepository.Adicionar(usuario);
            _usuarioRepository.Commit();

            return(Created("", registroViewModelInput));
        }
Exemple #10
0
        public IActionResult Post([FromBody] Usuario usuario)
        {
            try
            {
                var usuarioCadastrado = _usuarioRepository.Obter(usuario.NomeUsuario);

                if (usuarioCadastrado != null)
                {
                    return(BadRequest("Usuário já cadastrado no sistema."));
                }

                _usuarioRepository.Adicionar(usuario);
                return(Ok());
            }
            catch (Exception ex)
            {
                return(BadRequest(ex.ToString()));
            }
        }
Exemple #11
0
        public async Task <UsuarioDto> AdicionarUsuario(RegisterViewModel usuario)
        {
            var userEntity = _usuarioRepository.Buscar(user =>
                                                       user.Email == usuario.Email || user.CPF == usuario.CPF).FirstOrDefault();

            if (userEntity != null)
            {
                //TODO: Notificar erro (Já existe um usuário cadastrado com o mesmo Email ou CPF informado).
            }

            var resultCriarUsuarioIdentity = await _userService.CriarUsuarioIdentity(usuario);

            if (resultCriarUsuarioIdentity != null)
            {
                //TODO: Notificar erro (erros do identity).
            }

            var resultClaim = await _userService.AtualizarPermissoes(usuario.Email, usuario.CargoId);

            if (!resultClaim.Succeeded)
            {
                //TODO: Notificar erro (criar permissões).
            }

            var usuarioEntity = new Usuario(usuario.Nome, usuario.CPF, usuario.Telefone, usuario.Email);

            _usuarioRepository.Adicionar(usuarioEntity);

            if (_uow.Commit())
            {
                var usuarioSalvo = _usuarioRepository
                                   .Buscar(usuarioObtido =>
                                           usuarioObtido.Email == usuario.Email).FirstOrDefault();
                if (usuarioSalvo == null)
                {
                    return(null);
                }
                var usuarioHelper = new UsuarioHelper();
                return(usuarioHelper.EntityToDto(usuarioSalvo));
            }

            return(null);
        }
        public void Handle(IncluirEmpresaCommand cmd)
        {
            Empresa empresa = new Empresa(cmd.Id, cmd.RazaoSocial, cmd.Email, StringHelper.RemoverCaracteresEspeciais(cmd.Telefone), cmd.Facebook, StringHelper.RemoverCaracteresEspeciais(cmd.Cnpj), cmd.EnderecoId);

            Usuario usuario = new Usuario(Guid.NewGuid(), cmd.RazaoSocial, DateTime.Now, cmd.Email, cmd.Senha, empresa, empresa.Id);

            if (!usuario.IsValid())
            {
                NotificarValidacoesErro(usuario.ValidationResult);
                return;
            }

            _usuarioRepository.Adicionar(usuario);

            if (Commit())
            {
                _mediator.PublicarEvento(new EmpresaAdicionadaEvent(empresa.Id, empresa.RazaoSocial, empresa.Email, empresa.Telefone, empresa.Facebook, empresa.Cnpj, empresa.EnderecoId));
            }
        }
Exemple #13
0
        public IActionResult Registrar(RegistroViewModelInput registroViewModelinput)
        {
            // var migracoesPendentes = contexto.Database.GetPendingMigrations();
            // if(migracoesPendentes.Count() > 0)
            // {
            //     contexto.Database.Migrate();
            // }

            var usuario = new Usuario()
            {
                Login = registroViewModelinput.Login,
                Senha = registroViewModelinput.Senha,
                Email = registroViewModelinput.Email
            };

            _usuarioRepository.Adicionar(usuario);
            _usuarioRepository.Comnit();

            return(Created("", registroViewModelinput));
        }
Exemple #14
0
        public async Task AdicionarAsync(Usuario usuarioDTO)
        {
            try
            {
                bool existe = await _usuarioRepository.PesquisarPorUserNameAsync(usuarioDTO);

                if (existe == false)
                {
                    _notificador.Add("Usuario", "Já existe um usuario com esse username");
                    return;
                }


                await _usuarioRepository.Adicionar(usuarioDTO);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Exemple #15
0
        public IActionResult Registrar(ResgistrarViewModel resgistrarViewModel)
        {
            /*
             *
             * var migrationPending = context.Database.GetPendingMigrations(); //recebe as migrations pendentes
             *
             * if (migrationPending.Count() > 0)
             * {
             *    context.Database.Migrate();
             * } */

            var usuario = new User();

            usuario.Login    = resgistrarViewModel.Login;
            usuario.Email    = resgistrarViewModel.Email;
            usuario.Password = resgistrarViewModel.Passoword;
            _usuarioRepository.Adicionar(usuario);
            _usuarioRepository.Comit();

            return(Created("", resgistrarViewModel));
        }
Exemple #16
0
        public IActionResult Post([FromBody] Usuario usuario)
        {
            try
            {
                var usuarioCadastrado = _usuarioRepository.Obter(usuario.Email);

                if (usuarioCadastrado != null)
                {
                    return(BadRequest("Usuário já cadastrado!!"));
                }

                _usuarioRepository.Adicionar(usuario);

                return(Ok());
                // return Created("api/Usuario", usuario);
            }
            catch (Exception ex)
            {
                return(BadRequest(ex.ToString()));
            }
        }
Exemple #17
0
        public string Salvar(Usuario usuario)
        {
            try
            {
                if (usuario.IdUsuario == 0)
                {
                    UsuarioRepository.Adicionar(usuario);
                }
                else
                {
                    UsuarioRepository.Alterar(usuario);
                }
                UsuarioRepository.SalvarAlteracoes();

                return(null);
            }
            catch (Exception ex)
            {
                return(ex.Message);
            }
        }
        public ActionResult Post([FromBody] Usuario usuario)
        {
            try
            {
                var usuarioCadastrado = _usuarioRepositorio.Obter(usuario.Email);

                if (usuarioCadastrado != null)
                {
                    return(BadRequest("Usuario já cadastrado no sistema"));
                }

                //usuario.EhAdministrador = true;
                _usuarioRepositorio.Adicionar(usuario);

                return(Ok());
            }
            catch (Exception ex)
            {
                return(BadRequest(ex.ToString()));
            }
        }
        public Task Handle(RegistrarUsuarioCommand message, CancellationToken cancellationToken)
        {
            var usuario = Usuario.UsuarioFactory.NovoUsuarioCompleto(message.Id, message.Nome, message.Email);

            if (!UsuarioValido(usuario))
            {
                return(Task.FromCanceled(cancellationToken));
            }

            // TODO:
            // Validacoes de negocio!
            // Organizador pode registrar usuario?

            _usuarioRepository.Adicionar(usuario);

            if (Commit())
            {
                _mediator.PublicarUsuario(new UsuarioRegistradoEvent(usuario.Id, usuario.Nome, usuario.Email));
            }
            return(Task.CompletedTask);
        }
        public IActionResult Post([FromBody] Usuario usuario)
        {
            //Criptografar a senha
            //SALT - será as 5 primeiras letras do e-mail do usuário
            usuario.Senha = Crypto.Criptografar(usuario.Senha, usuario.Email.Substring(0, 5));


            try
            {
                //Adicionar um usuário
                _usuarioRepository.Adicionar(usuario);

                //Retorna OK e os usuários
                return(Ok(usuario));
            }
            catch (Exception ex)
            {
                //Caso ocorra um erro retorna uma mensagem de erro
                return(BadRequest(ex.Message));
            }
        }
Exemple #21
0
        public async Task <Response> Handle(AdicionarUsuarioRequest request, CancellationToken cancellationToken)
        {
            var  response       = new Response();
            bool emailExistente = EmailExistente(request);

            if (emailExistente)
            {
                response.AdicionarNotificacao("E-mail cadastrado", "O e-mail informado já está sendo utilizado");
            }

            var usuario = new Entities.Usuario(
                primeiroNome: request.PrimeiroNome,
                ultimoNome: request.UltimoNome,
                email: request.Email,
                senha: request.Senha);

            _usuarioRepository.Adicionar(usuario);

            await _mediator.Publish(new AdicionarUsuarioNotification(usuario)).ConfigureAwait(false);

            return(await Task.FromResult(new Response("Usuário adicionado com sucesso")).ConfigureAwait(false));
        }
Exemple #22
0
        public async Task <IActionResult> CriarUsuario([FromBody] UsuarioCadastroViewModel usuario)
        {
            IdentityResult result = null;

            if (ModelState.IsValid)
            {
                var user = new User {
                    UserName = usuario.Usuario.Email, Email = usuario.Usuario.Email
                };
                result = await _userManager.CreateAsync(user, usuario.Usuario.Senha);

                if (!result.Succeeded)
                {
                    await _usuarioRepository.Adicionar(usuario);

                    var errors = result.Errors.Select(e => e.Description);
                    return(BadRequest(errors));
                }
                await _userManager.AddToRoleAsync(user, "Administrator");
            }
            return(Ok(result.Succeeded));
        }
Exemple #23
0
        public IActionResult Registrar(LoginViewModelInput loginInput)
        {
            //var optionsBuilder = new DbContextOptionsBuilder<CursoDbContext>();
            //optionsBuilder.UseSqlServer("Server=(localdb)\\mssqllocaldb;Database=CursoNet5Api;Integrated Security=True");
            //CursoDbContext contexto = new CursoDbContext(optionsBuilder.Options);

            //var migracoesPendentes = contexto.Database.GetPendingMigrations(); //Verifica se existe migrações pendentes
            //if(migracoesPendentes.Count() > 0)
            //{
            //    contexto.Database.Migrate();
            //}
            var usuario = new Usuario();

            usuario.Login = loginInput.Login;
            usuario.Senha = loginInput.Senha;
            usuario.Email = loginInput.Email;

            _usuarioRepository.Adicionar(usuario);
            _usuarioRepository.Commit();

            return(Created("", loginInput));
        }
Exemple #24
0
        public IActionResult Registrar(RegistroViewModelInput loginViewModelInput)
        {
            //var optionsBuilder = new DbContextOptionsBuilder<CursoDBContext>();
            //optionsBuilder.UseSqlServer("Server=localhost;Database=CURSO;user=sa;password=App@223020");
            //CursoDBContext contexto = new CursoDBContext(optionsBuilder.Options);

            //var migracoesPendentes = contexto.Database.GetPendingMigrations();
            //if (migracoesPendentes.Count() > 0)
            //{
            //    contexto.Database.Migrate();

            //}

            var usuario = new Usuario();

            usuario.Login = loginViewModelInput.Login;
            usuario.Senha = loginViewModelInput.Senha;
            usuario.Email = loginViewModelInput.Email;
            _usuarioRepository.Adicionar(usuario);
            _usuarioRepository.Commit();

            return(Created("", loginViewModelInput));
        }
        public async Task <ValidationResult> Handle(RegistrarUsuarioCommand message, CancellationToken cancellationToken)
        {
            if (!message.EhValido())
            {
                return(message.ValidationResult);
            }

            var usuario = new Usuario(message.Id, message.Nome, message.Email, message.Cpf);

            var usuarioExistente = await _usuarioRepository.ObterPorCpf(usuario.Cpf.Numero);

            if (usuarioExistente != null)
            {
                AdicionarErro("Este CPF já está em uso.");
                return(ValidationResult);
            }

            _usuarioRepository.Adicionar(usuario);

            usuario.AdicionarEvento(new UsuarioRegistradoEvent(message.Id, message.Nome, message.Email, message.Cpf));

            return(await PersistirDados(_usuarioRepository.UnitOfWork));
        }
Exemple #26
0
        public IActionResult Post([FromBody] Usuario Usuario)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(Usuario.Nome) ||
                    string.IsNullOrWhiteSpace(Usuario.Email) ||
                    string.IsNullOrWhiteSpace(Usuario.Senha) ||
                    string.IsNullOrWhiteSpace(Usuario.CPF))
                {
                    return(BadRequest("Todos os campos precisam ser preenchidos"));
                }
                else if (Usuario.IdPerfilUsuario <= 0)
                {
                    return(BadRequest("O IdPerfilUsuario precisa ser válido"));
                }

                _repo.Adicionar(Usuario);
                return(Ok("Operação Concluida"));
            }
            catch (System.Exception)
            {
                return(StatusCode(500));
            }
        }
Exemple #27
0
 public bool Adicionar(Usuario usuario)
 {
     _usuarioRepository.Adicionar(usuario);
     return(true);
 }
Exemple #28
0
 public async Task Adicionar(Usuarios usuarios)
 {
     await _usuarioRepository.Adicionar(usuarios);
 }
Exemple #29
0
 public Usuario Adicionar(Usuario obj)
 {
     return(_usuarioRepository.Adicionar(obj));
 }
 public Usuario Cadastrar(Usuario usuario)
 {
     return(_usuarioRepository.Adicionar(usuario));
 }