Beispiel #1
0
        public async Task <IActionResult> GoogleLogin(GoogleLoginRequest request)
        {
            Payload payload = null;

            try
            {
                payload = await ValidateAsync(request.IdToken, new ValidationSettings
                {
                    Audience = new[] { "598105055249-eeim29vgq4e3lese6hvn2bt8n1epkt7q.apps.googleusercontent.com" }
                });

                // It is important to add your ClientId as an audience in order to make sure
                // that the token is for your application!
            }
            catch (Exception ex)
            {
                Console.WriteLine($"message: {ex.Message}");
                // Invalid token
            }

            var(token, whoLoggedIn, error) = await _acc.GetOrCreateExternalLoginUser("google", payload.Subject, payload.Email,
                                                                                     payload.GivenName, payload.FamilyName, request.Role, payload.EmailVerified, payload.Picture);

            if (token != null)
            {
                UserViewModel dto = whoLoggedIn.Convert <ApplicationUser, UserViewModel>(_mapper);
                dto.Token = token;
                return(Ok(dto));
            }
            return(BadRequest(new { Message = error }));
        }
        public async Task <IActionResult> GoogleLogin([FromBody] GoogleLoginRequest model)
        {
            var dd = new DeviceDetector(Request.Headers["User-Agent"]);

            var response = await _accountService.GoogleLogin(model, IpAddress(), dd, Request.Headers["origin"]);

            Response.SetTokenCookie(response.RefreshToken);

            return(Ok(response));
        }
Beispiel #3
0
        public HttpResponseMessage GoogleLogin(GoogleLoginRequest model)
        {
            bool authToken = usersService.GoogleLogin(model);

            if (!authToken)
            {
                return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "User cannot be authenticated"));
            }
            return(Request.CreateResponse(HttpStatusCode.OK, authToken));
        }
        public bool GoogleLogin(GoogleLoginRequest model)
        {
            bool userAuthenticated = false;
            int  userId            = 0;

            // CLIENT ID REMOVED
            string         googleClientId = "";
            string         gapiRespObject;
            string         gapiAuthUrl = "https://www.googleapis.com/oauth2/v3/tokeninfo?id_token=";
            HttpWebRequest webReq      = (HttpWebRequest)WebRequest.Create(gapiAuthUrl + model.GoogleToken);

            webReq.Method = "GET";
            HttpWebResponse webResp = (HttpWebResponse)webReq.GetResponse();

            using (Stream stream = webResp.GetResponseStream())
            {
                StreamReader reader = new StreamReader(stream, System.Text.Encoding.UTF8);
                gapiRespObject = reader.ReadToEnd();
            }

            var    gapiRespString = (JObject)JsonConvert.DeserializeObject(gapiRespObject);
            string authEmail      = gapiRespString["email"].Value <string>();
            string authAud        = gapiRespString["aud"].Value <string>();
            string authFirstName  = gapiRespString["given_name"].Value <string>();
            string authLastName   = gapiRespString["family_name"].Value <string>();
            string authPassword   = gapiRespString["sub"].Value <string>();

            if (authAud == googleClientId)
            {
                userAuthenticated = true;

                dataProvider.ExecuteCmd(
                    "Users_GoogleLogin",
                    inputParamMapper: (parameters) =>
                {
                    parameters.AddWithValue("@Email", authEmail);
                    parameters.AddWithValue("@FirstName", authFirstName);
                    parameters.AddWithValue("@LastName", authLastName);
                    parameters.AddWithValue("@UserTypeId", (object)DBNull.Value);
                    parameters.AddWithValue("@Password", authPassword);
                },
                    singleRecordMapper: (reader, resultsSetNumber) =>
                {
                    userId = (int)reader["Id"];
                });

                UserAuthData userAuthData = new UserAuthData()
                {
                    Id = userId
                };
                authenticationService.Login(userAuthData, true);
            }
            return(userAuthenticated);
        }
Beispiel #5
0
        public async Task <ActionResult <LoginResponse> > LoginGoogleAsync([FromBody] GoogleLoginRequest userForLoginDto)
        {
            try
            {
                if (userForLoginDto == null)
                {
                    return(this.BadRequest());
                }

                var validatedToken = await GoogleJsonWebSignature.ValidateAsync(userForLoginDto.IdToken, new GoogleJsonWebSignature.ValidationSettings {
                    Audience = this.authSettings.GoogleOAuthAudiences
                });

                var user = await this.userRepository.GetByLinkedAccountAsync(validatedToken.Subject, LinkedAccountType.Google, user => user.RefreshTokens);

                if (user == null)
                {
                    return(this.NotFound("No account found for this Google account."));
                }

                user.RefreshTokens.RemoveAll(token => token.Expiration <= DateTime.UtcNow || token.DeviceId == userForLoginDto.DeviceId);

                var token        = this.GenerateJwtToken(user);
                var refreshToken = GenerateRefreshToken();

                user.RefreshTokens.Add(new RefreshToken
                {
                    Token      = refreshToken,
                    Expiration = DateTimeOffset.UtcNow.AddMinutes(authSettings.RefreshTokenExpirationTimeInMinutes),
                    DeviceId   = userForLoginDto.DeviceId
                });

                await this.userRepository.SaveAllAsync();

                var userToReturn = this.mapper.Map <UserDto>(user);

                return(this.Ok(new LoginResponse
                {
                    Token = token,
                    RefreshToken = refreshToken,
                    User = userToReturn
                }));
            }
            catch (InvalidJwtException)
            {
                return(this.Unauthorized("Invaid Id Token"));
            }
            catch
            {
                return(this.InternalServerError("Unable to login with Google."));
            }
        }
        protected override void beforeEach()
        {
            theUrl     = "login/test";
            theRequest = new GoogleLoginRequest();
            theSignIn  = new GoogleSignIn();

            MockFor <IFubuRequest>().Stub(x => x.Get <GoogleSignIn>()).Return(theSignIn);

            MockFor <IUrlRegistry>().Stub(x => x.UrlFor(theSignIn)).Return(theUrl);

            ClassUnderTest.Write(MimeType.Html.Value, theRequest);

            string html = MimeType.Html.ToString();

            theTag = MockFor <IOutputWriter>()
                     .GetArgumentsForCallsMadeOn(x => x.Write(Arg <string> .Is.Same(html), Arg <string> .Is.NotNull))
                     [0][1].As <string>();
        }
Beispiel #7
0
        public async Task <IActionResult> Google(GoogleLoginRequest userView)
        {
            try
            {
                var payload = GoogleJsonWebSignature.ValidateAsync(userView.TokenId, new GoogleJsonWebSignature.ValidationSettings()).Result;
                var user    = await _userManager.FindByEmailAsync(payload.Email);

                _userStore.TokenIdVerified = true;

                if (user == null)
                {
                    return(new NotFoundObjectResult(new { type = 0, message = "Account doesn't exist", googleName = payload.Name, email = payload.Email }));
                }
                if (!user.EmailConfirmed)
                {
                    return(new BadRequestObjectResult(new { type = 1, message = "You must confirm your email before login" }));
                }
                var token = _jwtGenerator.VerifyAndReturnToken(user);

                return(new OkObjectResult(token));
            }
            catch (Exception ex)
            {
                if (ex.Message.Contains("Expired"))
                {
                    var internalErr = new ObjectResult(new { type = 2, error = ex.Message })
                    {
                        StatusCode = 500
                    };
                    return(internalErr);
                }
                else
                {
                    var internalErr = new ObjectResult(new { type = 3, error = ex.Message })
                    {
                        StatusCode = 500
                    };
                    return(internalErr);
                }
            }
        }
        // Login with google
        public async Task <LoginResponse> GoogleLogin(GoogleLoginRequest model, string ipAddress, DeviceDetector deviceDetector, string origin)
        {
            try
            {
                var payload = await ValidateAsync(model.GoogleToken, new ValidationSettings
                {
                    Audience = new[] { "95578192260-amn3dtj5avlfmk9su13ujrkqsnhr4btm.apps.googleusercontent.com" },
                    ExpirationTimeClockTolerance = new TimeSpan(0)
                });
            }
            catch
            {
                throw new AppException("Invalid token");
            }

            return(null);

            //var facebookUser = await _facebookService.GetUser(model, origin);

            //var user = await _context.Users.Include(u => u.Photos).SingleOrDefaultAsync(u => u.FacebookUID == facebookUser.FacebookUID);

            //// Create new user in db to store needed info
            //if (user == null)
            //{
            //    var userToCreate = _mapper.Map<User>(facebookUser);
            //    userToCreate.Created = DateTime.Now;
            //    userToCreate.Role = Role.User;
            //    userToCreate.Status = Status.Active;
            //    userToCreate.Verified = DateTime.Now;

            //    _context.Users.Add(userToCreate);

            //    // Add photo url after saving to db to have user id
            //    if (await _context.SaveChangesAsync() > 0)
            //    {
            //        var createdUser = await _context.Users.Include(u => u.Photos).SingleOrDefaultAsync(u => u.FacebookUID == facebookUser.FacebookUID);

            //        var photo = new Photo
            //        {
            //            Url = facebookUser.Picture,
            //            DateAdded = DateTime.Now,
            //            IsMain = true
            //        };

            //        createdUser.Photos.Add(photo);

            //        await _context.SaveChangesAsync();
            //    }

            //    user = await _context.Users.Include(u => u.Photos).SingleOrDefaultAsync(x => x.FacebookUID == facebookUser.FacebookUID);
            //}

            //var refreshToken = GenerateRefreshToken(ipAddress, deviceDetector);

            //var jwtToken = GenerateJwtToken(user);

            //var response = _mapper.Map<LoginResponse>(user);
            //response.JwtToken = jwtToken;
            //response.RefreshToken = refreshToken.Token;

            //return response;
        }
Beispiel #9
0
        public async Task <IActionResult> GoogleUpdateInfo(GoogleLoginRequest userView)
        {
            if (!_userStore.TokenIdVerified)
            {
                return(new BadRequestObjectResult(new { type = 0, message = "Google token not verified" }));
            }

            string    imgPath;
            string    imgName   = "";
            string    extension = "";
            IFormFile img       = null;

            //if avatar is empty, use default
            if (userView.Avatar != null)
            {
                img       = userView.Avatar;
                extension = Path.GetExtension(img.FileName);

                imgName = Convert.ToBase64String(
                    System.Text.Encoding.UTF8.GetBytes(DateTime.Now.ToString())
                    );
                var path = Path.Combine(_env.ContentRootPath, $"Files/Users/{userView.UserName}/Images");
                if (!Directory.Exists(path))
                {
                    Directory.CreateDirectory(path);
                }

                imgPath = Path.Combine(path, imgName + extension);
                if (img.Length > 0)
                {
                    using var fileStream = new FileStream(imgPath, FileMode.Create);
                    img.CopyTo(fileStream);
                }
            }
            else
            {
                imgName   = "default";
                extension = ".png";
                img       = Extensions.GetDefaultAvatar(_env);
            }

            var user = new AppUser
            {
                UserName = userView.UserName,
                Email    = userView.Email,
                RealName = userView.RealName,
                DOB      = Convert.ToDateTime(userView.Dob),
                Avatar   = imgName + extension
            };

            var appUser = await _userManager.FindByNameAsync(userView.UserName);

            if (appUser != null)
            {
                return(new BadRequestObjectResult(new { type = 1, message = "Username already exists" }));
            }

            var result = await _userManager.CreateAsync(user);

            if (result.Succeeded)
            {
                appUser = await _userManager.FindByEmailAsync(userView.Email);

                //confirm email
                string token = await _userManager.GenerateEmailConfirmationTokenAsync(appUser);

                await _userManager.ConfirmEmailAsync(appUser, token);

                var userToken = _jwtGenerator.VerifyAndReturnToken(user);

                return(new OkObjectResult(userToken));
            }

            return(new NotFoundObjectResult(""));
        }