public async Task <IActionResult> Facebook([FromBody] FacebookAuthViewModel model)
{
// 1.generate an app access token
var appAccessTokenResponse = await Client.GetStringAsync(
string.Format(_facebookAppAccessTokenUrl, _fbAuthSettings.AppId, _fbAuthSettings.AppSecret));
var appAccessToken = JsonConvert.DeserializeObject <FacebookAppAccessToken>(appAccessTokenResponse);
// 2. validate the user access token
var userAccessTokenValidationResponse = await Client.GetStringAsync(
string.Format(_facebookAccessTokenValidationUrl, model.AccessToken, appAccessToken.AccessToken));
var userAccessTokenValidation =
JsonConvert.DeserializeObject <FacebookUserAccessTokenValidation>(userAccessTokenValidationResponse);
if (!userAccessTokenValidation.Data.IsValid)
{
return(BadRequest(new { Error = "Invalid facebook token." }));
}
// 3. we've got a valid token so we can request user data from fb
var userInfoResponse = await Client.GetStringAsync(
string.Format(_facebookUserUrl, model.AccessToken));
var userInfo = JsonConvert.DeserializeObject <FacebookUserData>(userInfoResponse);
// 4. plug in below:
// Find user in database
// If no user exists, add user to database
// Create new access token for logged in user
// 5. change this to return created access token
return(Ok(userInfo));
}
public async Task <IActionResult> Facebook([FromBody] FacebookAuthViewModel model)
{
// 1.generate an app access token
var appAccessTokenResponse = await Client.GetStringAsync($"https://graph.facebook.com/oauth/access_token?client_id={_fbAuthSettings.AppId}&client_secret={_fbAuthSettings.AppSecret}&grant_type=client_credentials");
var appAccessToken = JsonConvert.DeserializeObject <FacebookAppAccessToken>(appAccessTokenResponse);
// 2. validate the user access token
var userAccessTokenValidationResponse = await Client.GetStringAsync($"https://graph.facebook.com/debug_token?input_token={model.AccessToken}&access_token={appAccessToken.AccessToken}");
var userAccessTokenValidation = JsonConvert.DeserializeObject <FacebookUserAccessTokenValidation>(userAccessTokenValidationResponse);
if (!userAccessTokenValidation.Data.IsValid)
{
return(BadRequest(Errors.AddErrorToModelState("login_failure", "Invalid facebook token.", ModelState)));
}
// 3. we've got a valid token so we can request user data from fb
var userInfoResponse = await Client.GetStringAsync($"https://graph.facebook.com/v2.8/me?fields=id,email,first_name,last_name,name,gender,locale,birthday,picture&access_token={model.AccessToken}");
var userInfo = JsonConvert.DeserializeObject <FacebookUserData>(userInfoResponse);
// 4. ready to create the local user account (if necessary) and jwt
var user = await _userManager.FindByEmailAsync(userInfo.Email);
if (user == null)
{
var appUser = new AppUser
{
FirstName = userInfo.FirstName,
LastName = userInfo.LastName,
FacebookId = userInfo.Id,
Email = userInfo.Email,
UserName = userInfo.Email,
PictureUrl = userInfo.Picture.Data.Url
};
var result = await _userManager.CreateAsync(appUser, Convert.ToBase64String(Guid.NewGuid().ToByteArray()).Substring(0, 8));
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
//await _appDbContext.Customers.AddAsync(new Customer { IdentityId = appUser.Id, Location = "", Locale = userInfo.Locale, Gender = userInfo.Gender });
//await _appDbContext.SaveChangesAsync();
}
// generate the jwt for the local user...
var localUser = await _userManager.FindByNameAsync(userInfo.Email);
if (localUser == null)
{
return(BadRequest(Errors.AddErrorToModelState("login_failure", "Failed to create local user account.", ModelState)));
}
var jwt = await Tokens.GenerateJwt(_jwtFactory.GenerateClaimsIdentity(localUser.UserName, localUser.Id),
_jwtFactory, localUser.UserName, _jwtOptions, new JsonSerializerSettings { Formatting = Formatting.Indented });
return(new OkObjectResult(jwt));
}
public async Task <ActionResult> Facebook(FacebookAuthViewModel model)
{
var appAccessTokenResponse = await Client.GetStringAsync($"https://graph.facebook.com/oauth/access_token?client_id={_appSettings.FbAppId}&client_secret={_appSettings.FbAppSecret}&grant_type=client_credentials");
var appAccessToken = JsonConvert.DeserializeObject <FacebookAppAccessToken>(appAccessTokenResponse);
var userAccessTokenValidationResponse = await Client.GetStringAsync($"https://graph.facebook.com/debug_token?input_token={model.AccessToken}&access_token={appAccessToken.AccessToken}");
var userAccessTokenValidation = JsonConvert.DeserializeObject <FacebookUserAccessTokenValidation>(userAccessTokenValidationResponse);
if (!userAccessTokenValidation.Data.IsValid)
{
return(BadRequest("Invalid facebook token."));
}
var userInfoResponse = await Client.GetStringAsync($"https://graph.facebook.com/v5.0/me?fields=id,email,first_name,last_name,name,gender,locale,birthday,picture&access_token={model.AccessToken}");
var userInfo = JsonConvert.DeserializeObject <FacebookUserData>(userInfoResponse);
var user = await _userManager.FindByEmailAsync(userInfo.Email);
if (user == null)
{
var appUser = new ApplicationUser
{
Email = userInfo.Email,
UserName = userInfo.Email,
};
var result = await _userManager.CreateAsync(appUser, Convert.ToBase64String(Guid.NewGuid().ToByteArray()).Substring(0, 8));
if (!result.Succeeded)
{
return(new BadRequestObjectResult(result));
}
await _userManager.AddClaimsAsync(appUser, new List <Claim>()
{
new Claim("FirstName", userInfo.FirstName),
new Claim("LastName", userInfo.LastName),
new Claim("FacebookId", userInfo.Id.ToString()),
new Claim("PictureUrl1", userInfo.Picture.Data.Url)
});
//await _appDbContext.Customers.AddAsync(new Customer { IdentityId = appUser.Id, Location = "", Locale = userInfo.Locale, Gender = userInfo.Gender });
//await _appDbContext.SaveChangesAsync();
}
var localUser = await _userManager.FindByEmailAsync(userInfo.Email);
if (localUser == null)
{
return(BadRequest("Failed to create local user account."));
}
var jwt = await Tokens.GenerateJwtToken(localUser, _userManager, _appSettings);
return(new OkObjectResult(jwt));
}
public async Task <IActionResult> Facebook([FromBody] FacebookAuthViewModel model)
{
if (model == null || string.IsNullOrWhiteSpace(model.AccessToken))
{
throw new FacebookException("Invalid facebook token");
}
// 1.generate an app access token
var appId = _config["Facebook:AppID"];
var appSecret = _config["Facebook:AppSecret"];
var appAccessTokenResponse = await Client.GetStringAsync($"https://graph.facebook.com/oauth/access_token?client_id={appId}&client_secret={appSecret}&grant_type=client_credentials");
var appAccessToken = JsonConvert.DeserializeObject <FacebookAppAccessToken>(appAccessTokenResponse);
// 2. validate the user access token
var userAccessTokenValidationResponse = await Client.GetStringAsync($"https://graph.facebook.com/debug_token?input_token={model.AccessToken}&access_token={appAccessToken.AccessToken}");
var userAccessTokenValidation = JsonConvert.DeserializeObject <FacebookApiResponses>(userAccessTokenValidationResponse);
if (!userAccessTokenValidation.Data.IsValid)
{
throw new FacebookException("Invalid facebook token");
}
// 3. we've got a valid token so we can request user data from fb
var userInfoResponse = await Client.GetStringAsync($"https://graph.facebook.com/v2.8/me?fields=id,email,first_name,last_name,name,gender,locale,birthday,picture&access_token={model.AccessToken}");
var userInfo = JsonConvert.DeserializeObject <FacebookUserData>(userInfoResponse);
// 4. ready to create the local user account (if necessary) and jwt
var user = await _playerService.GetPlayerByEmailAsync(userInfo.Email);
if (user == null)
{
var newPlayer = new PlayerViewModel
{
FirstName = userInfo.FirstName,
LastName = userInfo.LastName,
Email = userInfo.Email
};
await _playerService.RegisterPlayerAsync(newPlayer);
user = await _playerService.GetPlayerByEmailAsync(userInfo.Email);
}
// generate the jwt for the local user...
if (user == null)
{
throw new FacebookException("Failed to create local player account");
}
var tokenString = BuildToken();
return(Ok(new { token = tokenString }));
}
public async Task <IActionResult> Facebook([FromBody] FacebookAuthViewModel model)
{
// 1.generate an app access token
var appId = "2442240719384458";
var appSecret = _facebook.AppSecret;
var appAccessTokenResponse = await Client.GetStringAsync($"https://graph.facebook.com/oauth/access_token?client_id={appId}&client_secret={appSecret}&grant_type=client_credentials");
var appAccessToken = JsonConvert.DeserializeObject <FacebookAppAccessToken>(appAccessTokenResponse);
// 2. validate the user access token
var userAccessTokenValidationResponse = await Client.GetStringAsync($"https://graph.facebook.com/debug_token?input_token={model.AccessToken}&access_token={appAccessToken.AccessToken}");
var userAccessTokenValidation = JsonConvert.DeserializeObject <FacebookUserAccessTokenValidation>(userAccessTokenValidationResponse);
if (!userAccessTokenValidation.Data.IsValid)
{
return(BadRequest(new { message = "Sorry" }));
// return BadRequest(Errors.AddErrorToModelState("login_failure", "Invalid facebook token.", ModelState));
}
// 3. we've got a valid token so we can request user data from fb
var userInfoResponse = await Client.GetStringAsync($"https://graph.facebook.com/v2.8/me?fields=id,email,first_name,last_name,name,gender,locale,birthday,picture&access_token={model.AccessToken}");
var userInfo = JsonConvert.DeserializeObject <FacebookUserData>(userInfoResponse);
var user = _userService.getFacebookUser(userInfo.Email);
// 4. ready to create the local user account (if necessary) and jwt
if (user == null)
{
var appUser = new User
{
FirstName = userInfo.FirstName,
LastName = userInfo.LastName,
Username = userInfo.Email,
PasswordHash = null,
PasswordSalt = null,
};
var result = _userService.Create(appUser, null, true);
// if (!result.Succeeded) return new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState));
await _context.SaveChangesAsync();
}
var existingUser = _userService.authenticateFacebookUser(userInfo.Email);
if (existingUser == null)
{
return(BadRequest(new { message = "Couldn't authenticate" }));
}
return(Ok(existingUser));
}
public async Task <ActionResult <TokenVM> > Facebook([FromBody] FacebookAuthViewModel model)
{
// 1.generate an app access token
var appAccessTokenResponse = await client.GetStringAsync($"https://graph.facebook.com/oauth/access_token?client_id={_fbAuthConfiguration.AppId}&client_secret={_fbAuthConfiguration.AppSecret}&grant_type=client_credentials");
var appAccessToken = JsonConvert.DeserializeObject <FacebookAppAccessToken>(appAccessTokenResponse);
// 2. validate the user access token
var userAccessTokenValidationResponse = await client.GetStringAsync($"https://graph.facebook.com/debug_token?input_token={model.AccessToken}&access_token={appAccessToken.AccessToken}");
var userAccessTokenValidation = JsonConvert.DeserializeObject <FacebookUserAccessTokenValidation>(userAccessTokenValidationResponse);
if (!userAccessTokenValidation.Data.IsValid)
{
return(BadRequest());
/*return BadRequest(Errors.AddErrorToModelState("login_failure", "Invalid facebook token.", ModelState));*/
}
// 3. we've got a valid token so we can request user data from fb
var userInfoResponse = await client.GetStringAsync($"https://graph.facebook.com/v2.8/me?fields=id,email,first_name,last_name,name,gender,locale,birthday&access_token={model.AccessToken}");
var userInfo = JsonConvert.DeserializeObject <FacebookUserData>(userInfoResponse);
// 4. ready to create the local user account (if necessary) and jwt
var user = await userManager.FindByEmailAsync(userInfo.Email);
if (user == null)
{
var appUser = new ApplicationUser
{
Email = userInfo.Email,
UserName = userInfo.Email,
FullName = userInfo.LastName + userInfo.FirstName
};
var password = "******";
var result = await userManager.CreateAsync(appUser, password);
if (!result.Succeeded)
{
return(BadRequest());
}
}
// generate the jwt for the local user...
var localUser = await userManager.FindByNameAsync(userInfo.Email);
await userManager.AddToRoleAsync(localUser, "User"); // Add to "user" role
return(Ok(AuthTokenUtil.GetJwtTokenString(localUser.UserName, userManager, config).Result));
}
public async Task <IActionResult> FacebookAuthentication([FromBody] FacebookAuthViewModel model)
{
FacebookUserData userInfo = await this.authService.GetFacebookUserInfoAsync(model.AccessToken);
ApplicationUser user = await userManager.FindByNameAsync(userInfo.Email);
if (user == null)
{
user = new ApplicationUser
{
Name = userInfo.FirstName,
Email = userInfo.Email,
UserName = userInfo.Email,
};
var result = await userManager.CreateAsync(user, Convert.ToBase64String(Guid.NewGuid().ToByteArray()).Substring(0, 8));
}
return(Ok(this.authService.GenerateJwtToken(user)));
}
public LoginViewModel()
{
OnFacebookLoginSuccessCmd = new Command <string>(
async(authToken) =>
{
var httpHandler = DependencyService.Get <IHttpHandler>();
var identityUrl = AppSettingsManager.Settings["identityUrl"];
var facebookAuthViewModel = new FacebookAuthViewModel()
{
AccessToken = authToken
};
var jsonBody = JsonConvert.SerializeObject(facebookAuthViewModel);
var tokenModel = await httpHandler.AuthPostAsync <TokenModel>(string.Empty, identityUrl, AppSettingsManager.Settings["facebookLogin"], jsonBody);
if (!Application.Current.Properties.ContainsKey("AccessToken"))
{
Application.Current.Properties.Add("AccessToken", tokenModel.AccessToken);
}
else
{
Application.Current.Properties["AccessToken"] = tokenModel.AccessToken;
}
if (!Application.Current.Properties.ContainsKey("RefreshToken"))
{
Application.Current.Properties.Add("RefreshToken", tokenModel.RefreshToken);
}
else
{
Application.Current.Properties["RefreshToken"] = tokenModel.RefreshToken;
}
Application.Current.MainPage = new WizardPage();
});
OnFacebookLoginErrorCmd = new Command <string>(
(err) => DisplayAlert("Error", $"Authentication failed: { err }"));
OnFacebookLoginCancelCmd = new Command(
() => DisplayAlert("Cancel", "Authentication cancelled by the user."));
}
public async Task <ActionResult <ApiResponse <JwtToken> > > Facebook([FromBody] FacebookAuthViewModel model)
{
// 1.generate an app access token
var appAccessTokenResponse = await Client.GetStringAsync($"https://graph.facebook.com/oauth/access_token?client_id={_fbAuthSettings.AppId}&client_secret={_fbAuthSettings.AppSecret}&grant_type=client_credentials");
var appAccessToken = JsonConvert.DeserializeObject <FacebookAppAccessToken>(appAccessTokenResponse);
// 2. validate the user access token
var userAccessTokenValidationResponse = await Client.GetStringAsync($"https://graph.facebook.com/debug_token?input_token={model.AccessToken}&access_token={appAccessToken.AccessToken}");
var userAccessTokenValidation = JsonConvert.DeserializeObject <FacebookUserAccessTokenValidation>(userAccessTokenValidationResponse);
if (!userAccessTokenValidation.Data.IsValid)
{
throw new WebApiApplicationException(StatusCodes.Status409Conflict, ErrorMessages.InvalidFbToken, MethodBase.GetCurrentMethod().GetParameters());
}
// 3. we've got a valid token so we can request user data from fb
var userInfoResponse = await Client.GetStringAsync($"https://graph.facebook.com/v2.8/me?fields=id,email,first_name,last_name,name,gender,locale,birthday,picture&access_token={model.AccessToken}");
var userInfo = JsonConvert.DeserializeObject <FacebookUserData>(userInfoResponse);
var registerUser = new RegisterUserViewModel()
{
FirstName = userInfo.FirstName,
LastName = userInfo.LastName,
FacebookId = userInfo.Id,
Email = userInfo.Email,
PictureUrl = userInfo.Picture.Data.Url
};
JwtToken result = await _auth.ExternalAuthenticationAsync(registerUser);
if (result == null)
{
throw new WebApiApplicationException(StatusCodes.Status401Unauthorized, ErrorMessages.InvalidUser);
}
return(Ok(result, InfoMessages.UserSignin));
}
public async Task <IActionResult> Facebook([FromBody] FacebookAuthViewModel model)
{
// 1.generate an app access token
var appAccessTokenResponse = await Client.GetStringAsync($"https://graph.facebook.com/oauth/access_token?client_id={_fbAuthSettings.AppId}&client_secret={_fbAuthSettings.AppSecret}&grant_type=client_credentials");
var appAccessToken = JsonConvert.DeserializeObject <FacebookAppAccessToken>(appAccessTokenResponse);
// 2. validate the user access token
var userAccessTokenValidationResponse = await Client.GetStringAsync($"https://graph.facebook.com/debug_token?input_token={model.AccessToken}&access_token={appAccessToken.AccessToken}");
var userAccessTokenValidation = JsonConvert.DeserializeObject <FacebookUserAccessTokenValidation>(userAccessTokenValidationResponse);
if (!userAccessTokenValidation.Data.IsValid)
{
_loginUseCase.Fail("Invalid facebook token.", _loginPresenter);
return(_loginPresenter.ContentResult);
}
// 3. we've got a valid token so we can request user data from fb
var userInfoResponse = await Client.GetStringAsync($"https://graph.facebook.com/v2.8/me?fields=id,email,first_name,last_name,name,gender,locale,birthday,picture&access_token={model.AccessToken}");
var userInfo = JsonConvert.DeserializeObject <FacebookUserData>(userInfoResponse);
if (userInfo.Picture != null)
{
await _loginUseCase.Handle(new FacebookLoginRequest(
userInfo.Id, userInfo.Name, userInfo.Email, userInfo.FirstName, userInfo.LastName, userInfo.Gender, userInfo.Locale, userInfo.Picture.Data.Url, userInfo.Picture.Data.Height, userInfo.Picture.Data.Width, userInfo.Picture.Data.IsSilhouette),
_loginPresenter);
}
else
{
await _loginUseCase.Handle(new FacebookLoginRequest(
userInfo.Id, userInfo.Name, userInfo.Email, userInfo.FirstName, userInfo.LastName, userInfo.Gender, userInfo.Locale),
_loginPresenter);
}
return(_loginPresenter.ContentResult);
}
public async Task <IActionResult> Facebook([FromBody] FacebookAuthViewModel model)
{
try
{
var facebookUser = await _facebookService.GetAccountAsync(model.AccessToken);
if (string.IsNullOrEmpty(facebookUser.Id))
{
return(BadRequest("Invalid facebook token."));
}
// 4. ready to create the local user account (if necessary) and jwt
var user = GetUserByExternalId(facebookUser.Id, ExternalProviderTyper.Facebook);
var isCreate = user == null;
var refreshToken = _tokenService.GenerateRefreshToken();
var projectPath = _hostingEnvironment.ContentRootPath;
if (isCreate)
{
var appUser = new ApplicationUser
{
FirstName = facebookUser.FirstName,
LastName = facebookUser.LastName,
FacebookId = facebookUser.Id,
Email = facebookUser.Email,
Nickname = Regex.Replace(facebookUser.Name, @"[^\w]", "").ToLower(),
UserName = Guid.NewGuid().ToString(),
PictureUrl = SaveImageUrlToDisk.SaveImage(facebookUser.Picture.Data.Url, projectPath, ImageFormat.Png),
Birthday = DateTime.ParseExact(facebookUser.Birthday, "MM/dd/yyyy", CultureInfo.InvariantCulture),
Gender = facebookUser.Gender.TryConvertToEnum <Gender>().GetValueOrDefault(),
RefreshToken = refreshToken
};
if (!IsEmailUnique(appUser.Email))
{
return(BadRequest("Email baska bir kullaniciya ait."));
}
appUser.CreationDate = DateTime.Now;
var result = await userManager.CreateAsync(appUser, _randomPasswordHelper.GenerateRandomPassword());
if (!result.Succeeded)
{
return(new BadRequestObjectResult(result.Errors.FirstOrDefault()));
}
}
// generate the jwt for the local user...
var localUser = GetUserByExternalId(facebookUser.Id, ExternalProviderTyper.Facebook);
if (localUser == null)
{
return(BadRequest("Failed to create local user account."));
}
var accessToken = _tokenService.GenerateAccessToken(localUser);
await _spotPlayerSyncService.SyncSpotPlayerTableAsync(new CreateOrUpdateSpotPlayerViewModel
{
FirstName = localUser.FirstName,
LastName = localUser.LastName,
Nickname = localUser.Nickname,
UserId = localUser.Id,
PictureUrl = localUser.PictureUrl,
Latitude = localUser.Latitude,
Longitude = localUser.Longitude
}, accessToken);
return(Ok(new TokenModel(accessToken, refreshToken)));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public async Task <IActionResult> Google([FromBody] FacebookAuthViewModel model)
{
int mark = 1;
string d = "info";
try{
mark++;
var values = new Dictionary <string, string>();
values.Add("code", model.AccessToken);
values.Add("client_id", "313078532206-b01t045uahrop8264g97jrnt1j2dmbrt.apps.googleusercontent.com");
values.Add("client_secret", "YZjprBnuzhD1K31y3F4reKXj");
values.Add("redirect_uri", "http://localhost:5000/facebook-auth.html");
values.Add("grant_type", "authorization_code");
mark++;
var appAccessTokenResponse = await Client.PostAsync("https://accounts.google.com/o/oauth2/token", new FormUrlEncodedContent(values));
mark++;
if (appAccessTokenResponse.StatusCode != HttpStatusCode.OK)
{
return(BadRequest(Errors.AddErrorToModelState("login_failure", "Invalid google token.", ModelState)));
}
mark++;
d = "a1";
var res = await appAccessTokenResponse.Content.ReadAsStringAsync();
d = "a2";
var appAccessToken = JsonConvert.DeserializeObject <TokenPreseneter>(res);
d = "a3";
var userInfoResp = await Client.GetStringAsync($"https://www.googleapis.com/oauth2/v1/userinfo?alt=json&access_token={appAccessToken.AccessToken}");
d = "a4";
var userInfo = JsonConvert.DeserializeObject <GoogleUserInfo>(userInfoResp);
d = "a5->" + userInfoResp;
var user = await _userManager.FindByEmailAsync(userInfo.Email);
d = "a6";
mark++;
if (user == null)
{
var appUser = new AppUser
{
FirstName = userInfo.GivenName,
LastName = userInfo.FamilyName,
Email = userInfo.Email,
UserName = userInfo.Email,
PictureUrl = userInfo.Picture
};
mark++;
var result = await _userManager.CreateAsync(appUser, Convert.ToBase64String(Guid.NewGuid().ToByteArray()).Substring(0, 8));
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
_userManager.AddDefaultClaims(appUser);
}
mark++;
// generate the jwt for the local user...
var localUser = await _userManager.FindByNameAsync(userInfo.Email);
if (localUser == null)
{
return(BadRequest(Errors.AddErrorToModelState("login_failure", "Failed to create local user account.", ModelState)));
}
mark++;
var claims = await _userManager.GetClaimsAsync(localUser);
var identity = _jwtFactory.GenerateClaimsIdentity(localUser.UserName, claims.ToArray());
var jwt = await Tokens.GenerateJwt(identity, _jwtFactory, localUser.UserName, _jwtOptions, new JsonSerializerSettings { Formatting = Formatting.Indented });
return(new OkObjectResult(jwt));
}
catch (Exception ex) {
return(BadRequest(Errors.AddErrorToModelState($"unhandled error:{mark}{d}", ex.Message, ModelState)));
}
}
public async Task <IActionResult> Facebook([FromBody] FacebookAuthViewModel model)
{
// 1.generate an app access token
var appAccessTokenResponse = await Client.GetStringAsync($"https://graph.facebook.com/oauth/access_token?client_id={base.AppSettings.FacebookAuthSettings.AppId}&client_secret={base.AppSettings.FacebookAuthSettings.AppSecret}&grant_type=client_credentials");
var appAccessToken = JsonConvert.DeserializeObject <FacebookAppAccessToken>(appAccessTokenResponse);
// 2. validate the user access token
var userAccessTokenValidationResponse = await Client.GetStringAsync($"https://graph.facebook.com/debug_token?input_token={model.AccessToken}&access_token={appAccessToken.AccessToken}");
var userAccessTokenValidation = JsonConvert.DeserializeObject <FacebookUserAccessTokenValidation>(userAccessTokenValidationResponse);
if (!userAccessTokenValidation.Data.IsValid)
{
return(new BadRequestObjectResult(new { error = "Invalid facebook token." }));
}
// 3. we've got a valid token so we can request user data from fb
var userInfoResponse = await Client.GetStringAsync($"https://graph.facebook.com/v3.0/me?fields=id,email,first_name,last_name,name,gender,locale,birthday,picture&access_token={model.AccessToken}");
var userInfo = JsonConvert.DeserializeObject <FacebookUserData>(userInfoResponse);
// 4. ready to create the local user account (if necessary) and jwt
var user = await accountManager.UserManager.FindByEmailAsync(userInfo.Email);
if (user == null)
{
var appUser = new ApplicationUser
{
FirstName = userInfo.FirstName,
LastName = userInfo.LastName,
FacebookId = userInfo.Id,
Email = userInfo.Email,
UserName = userInfo.Email,
PictureUrl = userInfo.Picture.Data.Url
};
var result = await accountManager.UserManager.CreateAsync(appUser, Convert.ToBase64String(Guid.NewGuid().ToByteArray()).Substring(0, 8));
if (!result.Succeeded)
{
var sb = new StringBuilder();
foreach (var item in result.Errors)
{
sb.Append($"{item.Code}: {item.Description}.");
}
return(new BadRequestObjectResult(new { error = sb.ToString() }));
}
}
// generate the jwt for the local user...
var localUser = await accountManager.UserManager.FindByNameAsync(userInfo.Email);
//var roles = await _userManager.GetRolesAsync(localUser); ---- NOT WORKING ?!?!?
IEnumerable <string> roles = accountManager.GetUserRoleNames(localUser);;
if (localUser == null)
{
return(new BadRequestObjectResult(new { error = "Failed to create local user account." }));
}
var jwt = await Token.GenerateJwt(
jwtFactory.GenerateClaimsIdentity(localUser.UserName, localUser.Id, roles),
jwtFactory,
localUser.UserName,
jwtOptions, new JsonSerializerSettings { Formatting = Formatting.Indented });
return(new OkObjectResult(jwt));
}
public async Task <IActionResult> Facebook([FromBody] FacebookAuthViewModel model)
{
// 1.generate an app access token
var appAccessTokenResponse = await Client.GetStringAsync($"https://graph.facebook.com/oauth/access_token?client_id={_fbAuthSettings.AppId}&client_secret={_fbAuthSettings.AppSecret}&grant_type=client_credentials");
var appAccessToken = JsonConvert.DeserializeObject <FacebookAppAccessToken>(appAccessTokenResponse);
// 2. validate the user access token
var userAccessTokenValidationResponse = await Client.GetStringAsync($"https://graph.facebook.com/debug_token?input_token={model.AccessToken}&access_token={appAccessToken.AccessToken}");
var userAccessTokenValidation = JsonConvert.DeserializeObject <FacebookUserAccessTokenValidation>(userAccessTokenValidationResponse);
if (!userAccessTokenValidation.Data.IsValid)
{
return(BadRequest(new ErrorResponseModel
{
Message = $"{Constants.Errors.FbLoginFailed.Code},{Constants.Errors.FbLoginFailed.Desc}",
Code = 400,
Exception = nameof(Constants.Errors.FbLoginFailed)
}));
}
// 3. we've got a valid token so we can request user data from fb
var userInfoResponse = await Client.GetStringAsync($"https://graph.facebook.com/v2.8/me?fields=id,email,first_name,last_name,name,gender,locale,birthday,picture&access_token={model.AccessToken}");
var userInfo = JsonConvert.DeserializeObject <FacebookUserData>(userInfoResponse);
// 4. ready to create the local user account (if necessary) and jwt
var user = await _userManager.FindByEmailAsync(userInfo.Email);
if (user == null)
{
var appUser = new AppUser
{
FirstName = userInfo.FirstName,
LastName = userInfo.LastName,
FacebookId = userInfo.Id,
Email = userInfo.Email,
UserName = userInfo.Email,
PictureUrl = userInfo.Picture.Data.Url
};
var result = await _userManager.CreateAsync(appUser, (Guid.NewGuid().ToByteArray().ToBase64String()).Substring(0, 8));
if (!result.Succeeded)
{
ModelState.AddErrorsToModelState(result);
return(BadRequestDueToModelState());
}
await _userContext.Users.AddAsync(new User { IdentityId = appUser.Id, Gender = userInfo.Gender });
await _userContext.SaveChangesAsync();
}
// generate the jwt for the local user...
var localUser = await _userManager.FindByNameAsync(userInfo.Email);
if (localUser == null)
{
//mark modelstate as invalid
//return BadRequest(ModelState.AddErrorToModelState(Constants.Errors.LoginFailed.Code,Constants.Errors.LoginFailed.Desc));
return(BadRequest(new ErrorResponseModel
{
Message = $"{Constants.Errors.LoginFailed.Code},{Constants.Errors.LoginFailed.Desc}",
Code = 400,
Exception = nameof(Constants.Errors.LoginFailed)
}));
}
var identity = _tokenUtility.GenerateClaimsIdentity(localUser.UserName, localUser.Id);
var jwt = await identity.GenerateJwtJson(_tokenUtility, localUser.UserName, _jwtOptions, new JsonSerializerSettings { Formatting = Formatting.Indented });
return(new OkObjectResult(jwt));
}
public async Task <IActionResult> Facebook([FromBody] FacebookAuthViewModel model)
{
var appAccessToken = JsonConvert.DeserializeObject <FacebookAppAccessToken>(
await GetHttpResponse(_fbAuthSettings.GetAppAccessUrl())
);
var userAccessTokenValidation = JsonConvert.DeserializeObject <FacebookUserAccessTokenValidation>(
await GetHttpResponse(_fbAuthSettings.GetUserAccessUrl(model.AccessToken, appAccessToken.AccessToken))
);
var userInfo = JsonConvert.DeserializeObject <FacebookUserData>(
await GetHttpResponse(_fbAuthSettings.GetUserInfoUrl(model.AccessToken))
);
if (!userAccessTokenValidation.Data.IsValid)
{
return(BadRequest(
Errors.AddErrorToModelState("login_failure", "Invalid facebook token.", ModelState)
));
}
var user = await _userManager.FindByEmailAsync(userInfo.Email);
if (user == null)
{
var roleId = _roleManager.FindByNameAsync("User").Id;
var newUser = new User
{
FirstName = userInfo.FirstName,
LastName = userInfo.LastName,
FacebookId = userInfo.Id,
Email = userInfo.Email,
UserName = userInfo.Email,
Photo = userInfo.Picture.Data.Url,
};
var result = await _userManager.CreateAsync(newUser, "123qweR!");
if (!result.Succeeded)
{
return(BadRequest(
Errors.AddErrorsToModelState(result, ModelState)
));
}
}
var localUser = await _userManager.FindByNameAsync(userInfo.Email);
if (localUser == null)
{
return(BadRequest(
Errors.AddErrorToModelState("login_failure", "Failed to create local user account.", ModelState)
));
}
var jwt = await Tokens.GenerateJwt(
_jwtFactory.GenerateClaimsIdentity(localUser.UserName, localUser.Id.ToString()),
_jwtFactory,
localUser.UserName,
_jwtOptions,
new JsonSerializerSettings { Formatting = Formatting.Indented }
);
return(Ok(jwt));
}
public async Task <object> Facebook([FromBody] FacebookAuthViewModel model)
{
string role = "User";
var url = $"https://graph.facebook.com/oauth/access_token?client_id={_fbAuthSettings.AppId}&client_secret={_fbAuthSettings.AppSecret}&grant_type=client_credentials";
// 1.generate an app access token
var appAccessTokenResponse = await Client.GetStringAsync(url);
var appAccessToken = JsonConvert.DeserializeObject <FacebookAppAccessToken>(appAccessTokenResponse);
// 2. validate the user access token
var userAccessTokenValidationResponse = await Client.GetStringAsync($"https://graph.facebook.com/debug_token?input_token={model.AccessToken}&access_token={appAccessToken.AccessToken}");
var userAccessTokenValidation = JsonConvert.DeserializeObject <FacebookUserAccessTokenValidation>(userAccessTokenValidationResponse);
if (!userAccessTokenValidation.Data.IsValid)
{
return(new ResponseMessage()
{
IsSuccess = false, Message = "Invalid facebook token"
});
}
// 3. we've got a valid token so we can request user data from fb
var userInfoResponse = await Client.GetStringAsync($"https://graph.facebook.com/v2.8/me?fields=id,email,first_name,last_name,name,gender,locale,birthday,picture&access_token={model.AccessToken}");
var userInfo = JsonConvert.DeserializeObject <FacebookUserData>(userInfoResponse);
// 4. ready to create the local user account (if necessary) and jwt
var userName = userInfo.Email.Split("@").FirstOrDefault();
var user = await _userManager.FindByNameAsync(userName);
if (user == null)
{
var appUser = new AppUser
{
UserName = userName
};
if (!string.IsNullOrEmpty(userInfo.Email))
{
appUser.Email = userInfo.Email;
}
if (!string.IsNullOrEmpty(userInfo.FirstName))
{
appUser.FirstName = userInfo.FirstName;
}
if (!string.IsNullOrEmpty(userInfo.LastName))
{
appUser.LastName = userInfo.LastName;
}
//if (!string.IsNullOrEmpty(userInfo.Picture?.Data?.Url))
//{
//appUser.Photo = userInfo.Picture?.Data?.Url;
//}
appUser.Photo = string.Format("http://graph.facebook.com/{0}/picture?type=large", userInfo.Id);
var result = await _userManager.CreateAsync(appUser, Convert.ToBase64String(Guid.NewGuid().ToByteArray()).Substring(0, 8));
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
var newUser = await _userManager.FindByNameAsync(userName);
await _userManager.AddToRoleAsync(newUser, role);
}
// generate the jwt for the local user...
var localUser = await _userManager.FindByNameAsync(userName);
if (localUser == null)
{
return(new ResponseMessage()
{
IsSuccess = false, Message = "Failed to create local user account"
});
}
var roles = await _userManager.GetRolesAsync(localUser);
var claims = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.Sub, localUser.UserName),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(ClaimTypes.NameIdentifier, localUser.UserName),
};
foreach (var tempRole in roles)
{
claims.Add(new Claim(ClaimTypes.Role, tempRole));
}
var jwt = await Tokens.GenerateJwt(_jwtFactory.GenerateClaimsIdentity(localUser.UserName, localUser.Id),
_jwtFactory, localUser.UserName, localUser.FirstName, localUser.LastName, roles, _jwtOptions, new JsonSerializerSettings { Formatting = Formatting.Indented });
var jwtObj = JsonConvert.DeserializeObject <JwtViewModel>(jwt);
return(new JwtLoginResponseMessage {
IsSuccess = true, Jwt = jwtObj
});
}
public async Task <IActionResult> Facebook([FromBody] FacebookAuthViewModel model)
{
try
{
var facebookUser = await _facebookService.GetAccountAsync(model.AccessToken);
if (string.IsNullOrEmpty(facebookUser.Id))
{
return(BadRequest(_localizer.GetString("InvalidTokenFacebook")));
}
// 4. ready to create the local user account (if necessary) and jwt
var user = GetUserByExternalId(facebookUser.Id, ExternalProviderTyper.Facebook);
var isCreate = user == null;
var refreshToken = _tokenService.GenerateRefreshToken();
var appUser = new ApplicationUser(facebookUser, refreshToken);
if (isCreate)
{
if (!IsEmailUnique(appUser.Email))
{
return(BadRequest(_localizer.GetString("EmailIsInUse")));
}
appUser.CreationDate = DateTime.Now;
var result = await _userManager.CreateAsync(appUser, _randomPasswordHelper.GenerateRandomPassword());
if (!result.Succeeded)
{
return(BadRequest(_localizer.GetString("LoginFailed")));
}
}
else
{
user.RefreshToken = refreshToken;
user.PictureUrl = ImageHelper.SaveImageUrl(facebookUser.Picture.Data.Url, ImageFormat.Png);
user.LargePictureUrl = ImageHelper.SaveImageUrl(facebookUser.LargePictureUrl, ImageFormat.Png);
var result = await _userManager.UpdateAsync(user);
if (!result.Succeeded)
{
return(BadRequest(_localizer.GetString("LoginFailed")));
}
}
// generate the jwt for the local user...
var localUser = GetUserByExternalId(facebookUser.Id, ExternalProviderTyper.Facebook);
if (localUser == null)
{
return(BadRequest(_localizer.GetString("LoginFailed")));
}
var accessToken = _tokenService.GenerateAccessToken(localUser);
// Syncing the Challenge DB User table
await SyncChallengeUserTable(localUser, accessToken);
// Syncing the Loyalty DB Loyalty table
await SyncLoyaltyTable(isCreate, localUser, accessToken);
// Syncing the Loyalty DB User table
await SyncLoyaltyUserTable(isCreate, localUser, accessToken);
// Syncing the Game DB User table
await SyncGameUserTable(localUser, accessToken);
return(Ok(new TokenModel(accessToken, refreshToken)));
}
catch (Exception ex)
{
_logger.LogError(ex, _localizer.GetString("LoginFailed"));
return(BadRequest(_localizer.GetString("LoginFailed")));
}
}
public async Task <IActionResult> Facebook([FromBody] FacebookAuthViewModel model)
{
// 1.generate an app access token
var appAccessTokenResponse = await Client.GetStringAsync($"https://graph.facebook.com/oauth/access_token?client_id={_fbAuthSettings.AppId}&client_secret={_fbAuthSettings.AppSecret}&grant_type=client_credentials");
var appAccessToken = JsonConvert.DeserializeObject <FacebookAppAccessToken>(appAccessTokenResponse);
// 2. validate the user access token
var userAccessTokenValidationResponse = await Client.GetStringAsync($"https://graph.facebook.com/debug_token?input_token={model.AccessToken}&access_token={appAccessToken.AccessToken}");
var userAccessTokenValidation = JsonConvert.DeserializeObject <FacebookUserAccessTokenValidation>(userAccessTokenValidationResponse);
if (!userAccessTokenValidation.Data.IsValid)
{
return(BadRequest(new { invalid = "Invalid facebook token!" }));
}
// 3. we've got a valid token so we can request user data from fb
var userInfoResponse = await Client.GetStringAsync($"https://graph.facebook.com/v2.8/me?fields=id,email,first_name,last_name,name,gender,locale,birthday,picture&access_token={model.AccessToken}");
var userInfo = JsonConvert.DeserializeObject <FacebookUserData>(userInfoResponse);
// 4. ready to create the local user account (if necessary) and jwt
var user = await _userManager.FindByEmailAsync(userInfo.Email);
if (user == null)
{
string path = _fileService.UploadFacebookImage(userInfo.Picture.Data.Url);
user = new DbUser
{
FirstName = userInfo.FirstName,
LastName = userInfo.LastName,
Email = userInfo.Email,
UserName = userInfo.Email,
SignUpTime = DateTime.Now,
AvatarUrl = path
};
var result = await _userManager.CreateAsync(user, RandomPasswordGenerator.GenerateRandomPassword());
if (!result.Succeeded)
{
var errors = CustomValidator.GetErrorsByIdentityResult(result);
return(BadRequest(errors));
}
var roleName = "User";
var roleresult = _roleManager.CreateAsync(new DbRole
{
Name = roleName
}).Result;
result = _userManager.AddToRoleAsync(user, roleName).Result;
await _signInManager.SignInAsync(user, isPersistent : false);
if (!result.Succeeded)
{
return(BadRequest(new { invalid = "We can't create user" }));
}
}
else
{
user = await _userManager.FindByEmailAsync(userInfo.Email);
if (user == null)
{
return(BadRequest(new { invalid = "Failed to create local user account." }));
}
}
await _signInManager.SignInAsync(user, isPersistent : false);
return(Ok(_jWTTokenService.CreateToken(_configuration, user, _userManager)));
}
public async Task <IActionResult> Facebook([FromBody] FacebookAuthViewModel model)
{
// 1.generate an app access token
var appAccessTokenResponse = await Client.GetStringAsync($"https://graph.facebook.com/oauth/access_token?client_id={_secretOptions.FacebookAppId}&client_secret={_secretOptions.FacebookAppSecret}&grant_type=client_credentials");
var appAccessToken = JsonConvert.DeserializeObject <FacebookAppAccessToken>(appAccessTokenResponse);
// 2. validate the user access token
var userAccessTokenValidationResponse = await Client.GetStringAsync($"https://graph.facebook.com/debug_token?input_token={model.AccessToken}&access_token={appAccessToken.AccessToken}");
var userAccessTokenValidation = JsonConvert.DeserializeObject <FacebookUserAccessTokenValidation>(userAccessTokenValidationResponse);
if (!userAccessTokenValidation.Data.IsValid)
{
ModelState.AddModelError("Message", "Invalid facebook token.");
return(BadRequest(ModelState));
}
// 3. we've got a valid token so we can request user data from fb
var userInfoResponse = await Client.GetStringAsync($"https://graph.facebook.com/v2.8/me?fields=id,email,first_name,last_name,name,gender,locale,birthday,picture&access_token={model.AccessToken}");
var userInfo = JsonConvert.DeserializeObject <FacebookUserData>(userInfoResponse);
// 4. ready to create the local user account (if necessary) and jwt
var user = await _userManager.FindByEmailAsync(userInfo.Email);
if (user == null)
{
var appUser = new ApplicationUser
{
FirstName = userInfo.FirstName,
LastName = userInfo.LastName,
FacebookId = userInfo.Id,
Email = userInfo.Email,
UserName = userInfo.Email,
Avatar = userInfo.Picture.Data.Url
};
var result = await _userManager.CreateAsync(appUser, Convert.ToBase64String(Guid.NewGuid().ToByteArray()).Substring(0, 8));
if (!result.Succeeded)
{
ModelState.AddModelError("Message", "Something wrong when login with facebook.");
return(BadRequest(ModelState));
}
}
// generate the jwt for the local user...
ApplicationUser localUser = await _userManager.FindByNameAsync(userInfo.Email);
if (localUser == null)
{
ModelState.AddModelError("Message", "Failed to create local user account.");
return(BadRequest(ModelState));
}
var identity = _authService.GenerateClaimsIdentity(localUser.UserName, localUser.Id);
var roles = await _userManager.GetRolesAsync(user);
var jwt = await _authService.GenerateJwt(identity, localUser.UserName, new JsonSerializerSettings { Formatting = Formatting.Indented }, roles);
return(new OkObjectResult(jwt));
}
private void TransformFacebookAuthViewModel(SmartAppInfo manifest)
{
var template = new FacebookAuthViewModel(manifest);
_writingService.WriteFile(Path.Combine(_context.BasePath, template.OutputPath), template.TransformText());
}
public async Task <IActionResult> Facebook([FromBody] FacebookAuthViewModel model)
{
// 1.generate an app access token
var appAccessTokenResponse = await Client.GetStringAsync(
$"https://graph.facebook.com/oauth/access_token?client_id={AppId}&client_secret={AppSecret}&grant_type=client_credentials");
var appAccessToken = JsonConvert.DeserializeObject <FacebookAppAccessToken>(appAccessTokenResponse);
// 2. validate the user access token
var userAccessTokenValidationResponse = await Client.GetStringAsync(
$"https://graph.facebook.com/debug_token?input_token={model.AccessToken}&access_token={appAccessToken.AccessToken}");
var userAccessTokenValidation =
JsonConvert.DeserializeObject <FacebookUserAccessTokenValidation>(userAccessTokenValidationResponse);
if (!userAccessTokenValidation.Data.IsValid)
{
return(BadRequest("Invalid facebook token"));
}
// 3. we've got a valid token so we can request user data from fb
var userInfoResponse = await Client.GetStringAsync(
$"https://graph.facebook.com/v2.8/me?fields=id,email,first_name,last_name,name,gender,locale,birthday,picture&access_token={model.AccessToken}");
var userInfo = JsonConvert.DeserializeObject <FacebookUserData>(userInfoResponse);
if (string.IsNullOrWhiteSpace(userInfo.Email))
{
return(BadRequest("Could not get user's email address from facebook. Please check login permissions"));
}
// 4. ready to create the local user account (if necessary) and jwt
var existingUser = _userService.GetByEmailAddress(userInfo.Email);
if (existingUser == null)
{
var newUser = new User
{
FirstName = userInfo.FirstName,
LastName = userInfo.LastName,
FacebookId = userInfo.Id,
EmailAddress = userInfo.Email,
UserName = $"{userInfo.FirstName} {userInfo.LastName}",
PictureUrl = userInfo.Picture.Data.Url
};
_userService.Create(newUser, Guid.NewGuid().ToString());
}
// generate the jwt for the local user...
existingUser = _userService.GetByEmailAddress(userInfo.Email);
if (existingUser == null)
{
return(BadRequest("Could not create user account"));
}
var token = _tokenIssuer.Issue(existingUser);
return(Ok(new
{
existingUser.Id,
token
}));
}
