Esempio n. 1
0
        public async Task <ResultDto <UserDto> > SalvarUsuario(UserDto userDto)
        {
            var userDtoValidate = new UserDtoValidate(userDto);

            if (!userDtoValidate.Validate())
            {
                return(ResultDto <UserDto> .Validation(userDtoValidate.Mensagens));
            }

            var usuarioJaCadastrado = await _userManager.Users.FirstOrDefaultAsync(c => c.Email == userDto.Email);

            if (usuarioJaCadastrado != null && usuarioJaCadastrado.IsGoogle)
            {
                return(ResultDto <UserDto> .Validation("Email já cadastrado via google!"));
            }
            else if (usuarioJaCadastrado != null && usuarioJaCadastrado.IsFacebook)
            {
                return(ResultDto <UserDto> .Validation("Email já cadastrado via facebook!"));
            }
            else if (usuarioJaCadastrado != null)
            {
                return(ResultDto <UserDto> .Validation("Email já cadastrado!"));
            }

            var user = new User(userDto);

            if (userDto.Role != "Administrador")
            {
                var userEstabelecimentos = new List <UserEstabelecimento> {
                    new UserEstabelecimento()
                    {
                        EstabelecimentoId = userDto.EstabelecimentoId
                    }
                };
                user.VincularEstabelecimento(userEstabelecimentos);
            }

            var result = await _userManager.CreateAsync(user, userDto.Senha);

            userDto.Id = user.Id;

            if (result.Succeeded && !string.IsNullOrWhiteSpace(userDto.Role))
            {
                var userDB = await _userManager.Users
                             .Include(x => x.UserEstabelecimentos)
                             .ThenInclude(x => x.Estabelecimento)
                             .FirstOrDefaultAsync(u => u.Id == userDto.Id);

                var estabelecimento = userDB.UserEstabelecimentos.FirstOrDefault().Estabelecimento;

                userDto.EstabelecimentoNomeUrl = estabelecimento.Url;
                userDto.EstabelecimentoNome    = estabelecimento.Nome;

                await _userManager.AddToRoleAsync(userDB, userDto.Role);

                _emailService.Send(userDto.Email, "Confirmação de cadastro", userDto.EstabelecimentoNome, EmailTemplate.ConfirmacaoCadastro(_configuration, userDto));
            }

            return(await Task.FromResult(ResultDto <UserDto> .Success(userDto)));
        }
Esempio n. 2
0
        public async Task <ResultDto <UserDto> > SalvarCliente(UserDto userDto)
        {
            userDto.Role = "Cliente";
            var result = await Salvar(userDto);

            if (result.StatusCode == 200)
            {
                _emailService.Send(userDto.Email, "Confirmação de cadastro", result.Data.EstabelecimentoNome, EmailTemplate.ConfirmacaoCadastro(_configuration, result.Data));
            }

            return(await Task.FromResult(result));
        }
Esempio n. 3
0
        public async Task <ResultDto <AuthenticatedDto> > LoginSocial(AuthDto authDto)
        {
            var success = await _signInManager.PasswordSignInAsync(authDto.Email, authDto.Senha, false, false);

            UserDto userDto;

            if (!success.Succeeded)
            {
                var result = await SalvarCliente(new UserDto()
                {
                    Email             = authDto.Email,
                    Senha             = authDto.Senha,
                    Nome              = authDto.Nome,
                    EstabelecimentoId = authDto.EstabelecimentoId,
                    IsFacebook        = authDto.IsFacebook,
                    IsGoogle          = authDto.IsGoogle
                });

                if (result.StatusCode != 200)
                {
                    return(await Task.FromResult(ResultDto <AuthenticatedDto> .Validation(result.Errors)));
                }

                userDto = result.Data;
            }
            else
            {
                var applicationUser = await GetUserByEmail(authDto.Email);

                if (!applicationUser.Estabelecimentos.Any(x => x.EstabelecimentoId == authDto.EstabelecimentoId))
                {
                    var user = await _userManager.Users?.FirstOrDefaultAsync(u => u.Id == applicationUser.Id);

                    var userEstabelecimento = new UserEstabelecimento()
                    {
                        EstabelecimentoId = authDto.EstabelecimentoId
                    };
                    user.AdicionarEstabelecimento(userEstabelecimento);
                    await _userManager.UpdateAsync(user);

                    applicationUser = await GetUserByEmail(authDto.Email);

                    userDto = new UserDto
                    {
                        Id                     = applicationUser.Id,
                        Nome                   = applicationUser.Nome,
                        Email                  = applicationUser.Email,
                        Role                   = applicationUser.Role,
                        Claims                 = applicationUser.Claims,
                        EstabelecimentoId      = authDto.EstabelecimentoId,
                        EstabelecimentoNomeUrl = applicationUser.Estabelecimentos.FirstOrDefault(x => x.EstabelecimentoId == authDto.EstabelecimentoId).Url,
                        EstabelecimentoNome    = applicationUser.Estabelecimentos.FirstOrDefault(x => x.EstabelecimentoId == authDto.EstabelecimentoId).Nome
                    };

                    _emailService.Send(userDto.Email, "Confirmação de cadastro", userDto.EstabelecimentoNome, EmailTemplate.ConfirmacaoCadastro(_configuration, userDto));
                }
                else
                {
                    userDto = new UserDto
                    {
                        Id                     = applicationUser.Id,
                        Nome                   = applicationUser.Nome,
                        Email                  = applicationUser.Email,
                        Role                   = applicationUser.Role,
                        Claims                 = applicationUser.Claims,
                        EstabelecimentoId      = authDto.EstabelecimentoId,
                        EstabelecimentoNomeUrl = applicationUser.Estabelecimentos.FirstOrDefault(x => x.EstabelecimentoId == authDto.EstabelecimentoId).Url,
                        EstabelecimentoNome    = applicationUser.Estabelecimentos.FirstOrDefault(x => x.EstabelecimentoId == authDto.EstabelecimentoId).Nome
                    };
                }
            }

            return(ResultDto <AuthenticatedDto> .Success(TokenWrite.WriteToken(userDto, _tokenConfigurations, _signingConfigurations)));
        }