Пример #1
0
        public async Task <IActionResult> Register([FromBody] RegisterModel model)
        {
            if (!ModelState.IsValid)
            {
                return(Response(model));
            }

            IdentityUser user = new IdentityUser {
                UserName = model.Input.Email, Email = model.Input.Email
            };

            IdentityResult result = await _userManager.CreateAsync(user, model.Input.Password);

            if (result.Succeeded)
            {
                RegistrarOrganizadorCommand registroCommand = new RegistrarOrganizadorCommand(Guid.Parse(user.Id), Input.Nome, Input.Cpf, Input.Email);
                _bus.SendCommand(registroCommand);

                if (!OperacaoValida())
                {
                    await _userManager.DeleteAsync(user);

                    return(Response(model));
                }

                _logger.LogInformation(1, "Usuário criado com sucesso");

                return(Response(model));
            }

            AdicionarErrosIdentity(result);
            return(Response(model));
        }
Пример #2
0
        public async Task<IActionResult> Register([FromBody] RegisterViewModel model, int version)
        {
            if (version == 2)
            {
                return Response(new { Message = "API V2 não disponível na versão 2." });
            }

            if (!ModelState.IsValid) return Response(model);

            var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
            var result = await _userManager.CreateAsync(user, model.Password);

            if (result.Succeeded)
            {
                var registroCommand = new RegistrarOrganizadorCommand(Guid.Parse(user.Id), model.Nome, model.CPF, user.Email);
                _bus.SendCommand(registroCommand);

                if (OperacaoValida())
                {
                    await _userManager.DeleteAsync(user);
                    return Response(model);
                }

                _logger.LogInformation(1, "Usuário criado com sucesso!");
                var response = GerarTokenUsuario(new LoginViewModel {Email = model.Email, Password = model.Password});
                return Response(response);
            }
            AdicionarErrosIdentity(result);
            return Response(model);
        }
        public async Task <IActionResult> Registrar([FromBody] RegisterViewModel model)
        {
            if (!ModelState.IsValid)
            {
                NotificarErroModelInvalida();
                return(Response(model));
            }

            var user = new ApplicationUser {
                UserName = model.Nome, Email = model.Email
            };
            var result = await _userManager.CreateAsync(user, model.Password);

            if (result.Succeeded)
            {
                var registroCommand = new RegistrarOrganizadorCommand(
                    Guid.Parse(user.Id), model.Nome, model.CPF, model.Email);
                _bus.SendCommand(registroCommand);

                // Validação no domínio
                if (!OperacaoValida())
                {
                    await _userManager.DeleteAsync(user);

                    return(Response(model));
                }

                _logger.LogInformation(1, "Usuário criado com sucesso");
                return(Response(model));
            }

            AdicionaErrosIdentity(result);
            return(Response(model));
        }
Пример #4
0
        public async Task <IActionResult> Register([FromBody] RegisterViewModel model, int version)
        {
            if (version == 2)
            {
                return(Response(new { Message = "API V2 não disponível" }));
            }

            if (!ModelState.IsValid)
            {
                return(Response(model));
            }

            var user = new ApplicationUser {
                UserName = model.Email, Email = model.Email
            };
            var result = await _userManager.CreateAsync(user, model.Password);

            if (result.Succeeded)
            {
                #region register claims
                IEnumerable <Claim> claims = new List <Claim>()
                {
                    new Claim("Eventos", "Ler"),
                    new Claim("Eventos", "Gravar")
                };
                await _userManager.AddClaimsAsync(user, claims);

                #endregion

                var registerCommand = new RegistrarOrganizadorCommand(Guid.Parse(user.Id), model.Nome, model.CPF, user.Email);
                _bus.SendCommands(registerCommand);

                if (!OperacaoValida())
                {
                    await _userManager.DeleteAsync(user);

                    return(Response(model));
                }

                _logger.LogInformation(1, "Usuario criado com sucesso!");
                var response = GerarTokenUsuario(new LoginViewModel {
                    Email = model.Email, Password = model.Password
                });
                return(Response(response));
            }

            AdicionarErrosIdentity(result);
            return(Response(model));
        }
Пример #5
0
        public async Task <IActionResult> Register([FromBody] RegisterViewModel model, int version)
        {
            // O código abaixo é só um exemplo, vc pode definir códigos diferentes conforme a versão
            // colocando-os em métodos diferentes que serão chamados sempre do mesmo método Register
            if (version == 2)
            {
                return(Response(new { Message = "API V2 não disponível " }));
            }

            // Não deu certo e o que vc mandou foi isto aqui (model)
            if (!ModelState.IsValid)
            {
                return(Response(model));
            }

            var user = new ApplicationUser {
                UserName = model.Email, Email = model.Email
            };
            var result = await _userManager.CreateAsync(user, model.Senha);

            if (result.Succeeded)
            {
                await _userManager.AddClaimAsync(user, new Claim("Eventos", "Ler"));

                await _userManager.AddClaimAsync(user, new Claim("Eventos", "Gravar"));

                var registroCommand = new RegistrarOrganizadorCommand(Guid.Parse(user.Id), model.Nome, model.CPF, user.Email);
                _mediator.EnviarComando(registroCommand);

                // Se o organizador não for criado por algum motivo apaga também o usuário criado no Identity
                if (!OperacaoValida())
                {
                    await _userManager.DeleteAsync(user);

                    return(Response(model));
                }

                // O número 1 sou eu quem defino, posso definir números diferentes para mensagens diferentes
                _logger.LogInformation(1, "Usuário criado com sucesso!");
                var response = await GerarTokenUsuario(new LoginViewModel { Email = model.Email, Senha = model.Senha });

                return(Response(response));
            }

            AdicionarErrosIdentity(result);
            return(Response(model));
        }
Пример #6
0
        public async Task <IActionResult> Register([FromBody] RegisterViewModel model, int version)
        {
            if (!ModelState.IsValid)
            {
                return(Response(model));
            }

            var user = new ApplicationUser {
                UserName = model.Email, Email = model.Email
            };

            var result = await _userManager.CreateAsync(user, model.Password);

            if (result.Succeeded)
            {
                // Claims de permissão do usuário
                await _userManager.AddClaimsAsync(user, new[]
                {
                    new Claim("Eventos", "Consultar"),
                    new Claim("Eventos", "Gravar"),
                    new Claim("Eventos", "Excluir")
                });

                // Executando o papel da Camada de Application
                var registroCommand = new RegistrarOrganizadorCommand(Guid.Parse(user.Id), model.Nome, model.CpfCnpj, model.Email);
                _bus.SendCommand(registroCommand);

                if (!OperacaoValida())
                {
                    await _userManager.DeleteAsync(user);

                    return(Response(model));
                }

                _logger.LogInformation(1, "Usuário criado com sucesso");

                // Usuário criado com sucesso
                // Retorna o token para não precisar efetuar o login
                var response = await GerarTokenUsuario(new LoginViewModel { Email = model.Email, Password = model.Password });

                return(Response(response));
            }

            AdicionarErrosIdentity(result);
            return(Response(model));
        }
        public async Task <IActionResult> Register([FromBody] RegisterViewModel model, int version)
        {
            if (version == 2)
            {
                return(Response(new { Message = "API V2 não disponível" }));
            }


            if (!ModelState.IsValid)
            {
                NotificarErroModelInvalida();
                return(Response());
            }

            var user = new ApplicationUser {
                UserName = model.Email, Email = model.Email
            };
            var result = await _userManager.CreateAsync(user, model.Senha);

            if (result.Succeeded)
            {
                await _userManager.AddClaimAsync(user, new Claim("Eventos", "Ler"));

                await _userManager.AddClaimAsync(user, new Claim("Eventos", "Gravar"));

                var registroCommand = new RegistrarOrganizadorCommand(Guid.Parse(user.Id), model.Nome, model.CPF, user.Email);
                await _mediator.EnviarComando(registroCommand);

                if (!OperacaoValida())
                {
                    await _userManager.DeleteAsync(user);

                    return(Response(model));
                }

                _logger.LogInformation(1, "Usuário criado com sucesso!");
                return(Response(await GerarTokenUsuario(new LoginViewModel {
                    Email = model.Email, Senha = model.Senha
                })));
            }

            AdicionarErrosIdentity(result);
            return(Response(model));
        }