예제 #1
0
        public async Task <RedirectToActionResult> GoogleSigninAndroidAsync(string token,
                                                                            [FromServices] IGoogleAuth service,
                                                                            [FromServices] IDataProtectionProvider dataProtectProvider,
                                                                            CancellationToken cancellationToken
                                                                            )
        {
            var result = await service.LogInAsync(token, cancellationToken);

            if (result == null)
            {
                return(RedirectToAction("Index"));
            }

            var result2 = await _signInManager.ExternalLoginSignInAsync("Google", result.Id, true, true);

            var user2 = await _userManager.FindByEmailAsync(result.Email);

            var dataProtector = dataProtectProvider.CreateProtector("Spitball").ToTimeLimitedDataProtector();
            var code          = dataProtector.Protect(user2.Id.ToString(), DateTimeOffset.UtcNow.AddDays(5));

            return(RedirectToAction("Index", new
            {
                token = code
            }));
        }
예제 #2
0
        public async Task <ActionResult <ReturnSignUserResponse> > GoogleSignInAsync(
            [FromBody] GoogleTokenRequest model,
            [FromServices] IGoogleAuth service,
            [FromServices] IUserDirectoryBlobProvider blobProvider,


            [FromServices] TelemetryClient logClient,
            [FromServices] IHttpClientFactory clientFactory,
            CancellationToken cancellationToken)
        {
            var result = await service.LogInAsync(model.Token, cancellationToken);

            _logger.Info($"received google user {result}");
            if (result == null)
            {
                logClient.TrackTrace("result from google is null");
                ModelState.AddModelError("Google", _localizer["GoogleNoResponse"]);
                return(BadRequest(ModelState));
            }

            var result2 = await _signInManager.ExternalLoginSignInAsync("Google", result.Id, true, true);

            if (result2.Succeeded)
            {
                return(ReturnSignUserResponse.SignIn());
                //return new ReturnSignUserResponse(false);
            }

            if (result2.IsLockedOut)
            {
                logClient.TrackTrace("user is locked out");
                ModelState.AddModelError("Google", _loginLocalizer["LockOut"]);
                return(BadRequest(ModelState));
            }

            var user = await _userManager.FindByEmailAsync(result.Email);

            if (result2.IsNotAllowed && user != null && await _userManager.IsLockedOutAsync(user))
            {
                ModelState.AddModelError("Google", _loginLocalizer["LockOut"]);
                return(BadRequest(ModelState));
            }
            if (user == null)
            {
                var country = await _countryProvider.GetUserCountryAsync(cancellationToken);

                user = new User(result.Email,
                                result.FirstName, result.LastName,
                                result.Language, country)
                {
                    EmailConfirmed = true
                };


                var result3 = await _userManager.CreateAsync(user);

                if (result3.Succeeded)
                {
                    if (!string.IsNullOrEmpty(result.Picture))
                    {
                        using var httpClient = clientFactory.CreateClient();
                        var message = await httpClient.GetAsync(result.Picture, cancellationToken);

                        await using var sr = await message.Content.ReadAsStreamAsync();

                        var mimeType = message.Content.Headers.ContentType;
                        try
                        {
                            var uri = await blobProvider.UploadImageAsync(user.Id, result.Picture, sr,
                                                                          mimeType.ToString(), cancellationToken);

                            var imageProperties = new ImageProperties(uri, ImageProperties.BlurEffect.None);
                            var url             = Url.ImageUrl(imageProperties);
                            var fileName        = uri.AbsolutePath.Split('/').LastOrDefault();
                            user.UpdateUserImage(url, fileName);
                        }
                        catch (ArgumentException e)
                        {
                            logClient.TrackException(e, new Dictionary <string, string>()
                            {
                                ["FromGoogle"] = result.Picture
                            });
                        }
                    }
                    await _userManager.AddLoginAsync(user, new UserLoginInfo("Google", result.Id, result.Name));

                    return(await MakeDecisionAsync(user, true, null, cancellationToken));
                }
                logClient.TrackTrace($"failed to register {string.Join(", ", result3.Errors)}");

                ModelState.AddModelError("Google", _localizer["GoogleUserRegisteredWithEmail"]);
                return(BadRequest(ModelState));
            }
            if (!user.EmailConfirmed)
            {
                user.EmailConfirmed = true;
                await _userManager.UpdateAsync(user);
            }

            await _userManager.AddLoginAsync(user, new UserLoginInfo("Google", result.Id, result.Name));

            return(await MakeDecisionAsync(user, true, null, cancellationToken));
        }
예제 #3
0
        public async Task <IActionResult> LogInGoogle([FromBody] GoogleLogInRequest model,
                                                      [FromServices] IGoogleAuth service, CancellationToken cancellationToken)
        {
            var login = await service.LogInAsync(model.Token, cancellationToken);

            if (login is null)
            {
                return(BadRequest());
            }
            var query  = new ValidateUserQuery(login.Email);
            var result = await _queryBus.QueryAsync(query, cancellationToken);

            if (result is null)
            {
                return(Unauthorized());
            }
            var claims = new List <Claim>
            {
                new Claim(ClaimTypes.Name, login.Email),
                new Claim("FullName", $"{login.FirstName} { login.LastName}"),
                new Claim("UserId", result.Id.ToString()),
                new Claim(ClaimsPrincipalExtensions.ClaimCountry, result.Country ?? "None"),
            };
            //foreach (var resultRole in result.Roles ?? Enumerable.Empty<string>())
            //{
            //    claims.Add(new Claim(ClaimTypes.Role, resultRole));
            //}

            var claimsIdentity = new ClaimsIdentity(
                claims, CookieAuthenticationDefaults.AuthenticationScheme);

            var authProperties = new AuthenticationProperties
            {
                //AllowRefresh = <bool>,
                // Refreshing the authentication session should be allowed.

                ExpiresUtc = DateTimeOffset.UtcNow.AddHours(1),
                // The time at which the authentication ticket expires. A
                // value set here overrides the ExpireTimeSpan option of
                // CookieAuthenticationOptions set with AddCookie.

                IsPersistent = false,
                // Whether the authentication session is persisted across
                // multiple requests. When used with cookies, controls
                // whether the cookie's lifetime is absolute (matching the
                // lifetime of the authentication ticket) or session-based.

                //IssuedUtc = <DateTimeOffset>,
                // The time at which the authentication ticket was issued.

                //RedirectUri = <string>
                // The full path or absolute URI to be used as an http
                // redirect response value.
            };

            await HttpContext.SignInAsync(
                CookieAuthenticationDefaults.AuthenticationScheme,
                new ClaimsPrincipal(claimsIdentity),
                authProperties);

            return(Ok());
        }