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));
}
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);
}
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>();
}
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;
}
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(""));
}
