public async Task <SigningInResponseModel> FacebookLoginAsync(FacebookLoginModel facebookLoginModel)
{
if (string.IsNullOrEmpty(facebookLoginModel.facebookToken))
{
throw new Exception("token is null");
}
var facebookUser = await _facebookService.GetUserFromFacebookAsync(facebookLoginModel.facebookToken);
if (facebookUser == null)
{
throw new Exception("Invalid OAuth access token,cannot get facebook user");
}
var userLoginInfo = new UserLoginInfo(GlobalVariables.FacebookProviderName, facebookUser.id, GlobalVariables.FacebookProviderDisplayName);
var domainUser = await _userManager.FindByLoginAsync(GlobalVariables.FacebookProviderName, facebookUser.id);
if (domainUser == null)
{
domainUser = await RegisterFBUser(facebookUser);
}
return(GetSigningInResponseModel(domainUser, GlobalVariables.CustomerRole));
/*return new AuthTokensModel
* {
* accessToken=_jWThandlerService.CreateAccessToken(domainUser,GlobalVariables.CustomerRole),
* refreshToken=_jWThandlerService.CreateRefreshToken(domainUser)
* };*/
}
public JsonResult FacebookLogin(FacebookLoginModel fb)
{
//Session["uid"] = fb.uid;
//Session["accessToken"] = fb.accessToken;
return(Json(new { success = true }));
}
public JsonResult FacebookLogin(FacebookLoginModel model)
{
Session["uid"] = model.uid;
Session["accessToken"] = model.accessToken;
return(Json(new { success = true }));
}
public async Task <IResponse> FacebookSignIn([FromBody] FacebookLoginModel facebookLoginModel)
{
ExternalLoginResponse externalLoginResponse = new ExternalLoginResponse();
externalLoginResponse.IsModelValid = ModelState.IsValid;
if (ModelState.IsValid)
{
FacebookDataModel facebookData = await FacebookAPI.GetUserLoginData(facebookLoginModel.AccessToken);
ExternalLoginInfo info = CustomExternalLoginInfo.FromLoginModel("Facebook", facebookData);
var result = await _signInManager.ExternalLoginSignInAsync(info.LoginProvider, info.ProviderKey, true);
if (result.Succeeded)
{
_logger.LogInformation("User logged in");
}
externalLoginResponse.IsRegistered = result.Succeeded;
externalLoginResponse.Result = result;
}
else
{
externalLoginResponse.Errors = ModelState.Values.SelectMany(v => v.Errors.Select(b => b.ErrorMessage));
}
return(externalLoginResponse);
}
public async Task <IActionResult> FacebookLogin(
[FromForm] FacebookLoginModel model,
CancellationToken ct = default)
{
if (model.Email == null)
{
_logger.LogInformation($"Redirect without internal registartion.");
return(Redirect(model.ReturnUrl));
}
IdentityUser existUser = await _userManager.FindByNameAsync(model.Email);
if (existUser != null)
{
return(Redirect(model.ReturnUrl));
}
_logger.LogInformation($"User with email: {model.Email} try to register with facebook auth.");
string tempPassword = Guid.NewGuid().ToString();
RegisterModel fbRegisterModel = _mapper.Map <RegisterModel>(model);
fbRegisterModel.Password = tempPassword;
fbRegisterModel.ConfirmPassword = tempPassword;
return(await InternalRegister(fbRegisterModel, ct));
}
public async Task <JsonResult> FacebookLogin(FacebookLoginModel model)
{
Session["uid"] = model.uid;
Session["accessToken"] = model.accessToken;
new UserRepository().CreateUser(model.accessToken);
return(Json(new { success = true }));
}
public DataModel FacebookLogin(FacebookLoginModel model)
{
HttpContext.Session.SetObjectAsJson("uid", model.uid);
HttpContext.Session.SetObjectAsJson("accessToken", model.accessToken);
DataModel respuesta = new DataModel();
respuesta.data.Add("uidData", model.uid);
respuesta.data.Add("accessToken", model.accessToken);
return(respuesta);
}
public JsonResult login(FacebookLoginModel model)
{
Session["uid"] = model.uid;
Session["accessToken"] = model.accessToken;
if ((String)Session["flag"] != "0")
{
Session["flag"] = model.flag;
}
return(Json(new { success = true }));
}
public async Task <bool> ValidateFacebookToken(FacebookLoginModel facebookUser)
{
var appAccessTokenResponse = await httpClient.GetStringAsync($"https://graph.facebook.com/oauth/access_token?client_id=2814753781954441&client_secret=837cc4ab983d8c9c4a51da9ed50e470b&grant_type=client_credentials");
var appAccessToken = JsonConvert.DeserializeObject <FacebookAppAccessToken>(appAccessTokenResponse);
var userAccessTokenValidationResponse = await httpClient.GetStringAsync($"https://graph.facebook.com/debug_token?input_token={facebookUser.Token}&access_token={appAccessToken.AccessToken}");
var userAccessTokenValidation = JsonConvert.DeserializeObject <FacebookUserAccessTokenValidation>(userAccessTokenValidationResponse);
return(userAccessTokenValidation.Data.IsValid);
}
public async Task RegisterFacebookUser(FacebookLoginModel facebookUser)
{
var userIdentity = mapper.Map <ApplicationUserEntity>(facebookUser);
entityContext.Users.Add(userIdentity);
var confirmationToken = await userManager.GenerateEmailConfirmationTokenAsync(userIdentity);
await entityContext.SaveChangesAsync();
await userManager.AddToRoleAsync(userIdentity, "User");
await userManager.ConfirmEmailAsync(userIdentity, confirmationToken);
}
public async Task <SignInResponseModel> FacebookLogin([FromBody] FacebookLoginModel model)
{
if (model == null || !ModelState.IsValid)
{
throw new CustomException(Errors.INVALID_REQUEST, Errors.INVALID_REQUEST_MSG);
}
var verifyResult = await this.VerifyFacebookAccessToken(model.AccessToken);
if (verifyResult.IsValid)
{
var existAccount = await _accountService.FindByExternalProviderAsync("facebook", verifyResult.FacebookId);
if (existAccount == null)
{
throw new CustomException(Errors.ACCOUNT_NOT_FOUND, Errors.ACCOUNT_NOT_FOUND_MSG);
}
else if (existAccount.Status == UserStatus.InActive)
{
throw new CustomException(Errors.ACCOUNT_INACTIVE, Errors.ACCOUNT_INACTIVE_MSG);
}
if (existAccount.AccountType == JobHop.Common.Enums.AccountType.Jobseeker && !existAccount.PhoneNumberVerified)
{
//return phone number in message for verify
throw new CustomException(Errors.WAIT_FOR_VERIFICATION, existAccount.PhoneNumber);
}
var uname = string.IsNullOrEmpty(existAccount.UserName) ? $"Facebook:{verifyResult.FacebookId}" : existAccount.UserName;
var permissions = await _accountService.GetPermissionsOfAccountAsync(existAccount.Id);
var now = DateTime.UtcNow;
var encodedJwt = TokenProviderMiddleware.GenerateAccessToken(_tokenOptions, now, uname, existAccount.Id.ToString(), permissions.ToArray());
var response = new SignInResponseModel
{
AccessToken = encodedJwt,
Expires = now.AddSeconds((int)_tokenOptions.Expiration.TotalSeconds),
Account = existAccount.ToViewModel()
};
return(response);
}
else
{
throw new CustomException(Errors.INVALID_REQUEST, Errors.INVALID_REQUEST_MSG);
}
}
public async Task <bool> FacebookLogin(FacebookLoginModel model)
{
var result = await AccountManager.FacebookLoginAsync(model.AccessToken, new FullUser(model.FullName, model.BirthDay, model.City, model.WorkPlace));
if (result.Success)
{
UserToken = result.Token;
DisplayUserInfo = (await AccountManager.GetUserInfoAsync(result.Token));
return(true);
}
else
{
return(false);
}
}
public async Task <AuthorizedUserModel> LoginFacebookUser(FacebookLoginModel facebookUser)
{
var user = await userManager.FindByEmailAsync(facebookUser.Email);
var refreshToken = authentificationService.GenerateRefreshToken();
authorizedUserModel.Token = await authentificationService.GenerateToken(user.Email);
authorizedUserModel.RefreshToken = refreshToken;
await userManager.RemoveAuthenticationTokenAsync(user, "UniversityApp", "RefreshToken");
await userManager.SetAuthenticationTokenAsync(user, "UniversityApp", "RefreshToken", refreshToken);
return(authorizedUserModel);
}
public JsonResult UserDetail(FacebookLoginModel model)
{
Session["uid"] = model.uid;
Session["accessToken"] = model.accessToken;
var client = new FacebookClient(model.accessToken);
dynamic fbresult = client.Get("me?fields=id,email,first_name,last_name,gender");
FacebookUserModel facebookUser =
Newtonsoft.Json.JsonConvert.DeserializeObject <FacebookUserModel>(fbresult.ToString());
User lgnUser = Current.Context.User.FirstOrDefault(d => d.FacebookId == facebookUser.id);
if (lgnUser != null)
{
Current.setSessionItem("userInfo", lgnUser);
}
else
{
var newUser = new User();
var oldUserInfo = Current.Context.User.FirstOrDefault(a => !string.IsNullOrEmpty(facebookUser.email) && a.Email == facebookUser.email);
if (oldUserInfo != null)
{
//eğer adam kendi mail adresiyle daha önceden kaydolmuşsa bu hesapla facebooku eşleştirelim
oldUserInfo.FacebookId = facebookUser.id;
Current.Context.SaveChanges();
Current.setSessionItem("userInfo", oldUserInfo);
}
else
{
newUser = new User
{
Name = facebookUser.first_name,
Surname = facebookUser.last_name,
Email = facebookUser.email,
FacebookId = facebookUser.id,
UserTypeId = Constants.USER_TYPE_GUEST,
Status = true
};
Current.Context.User.Add(newUser);
Current.Context.SaveChanges();
Current.setSessionItem("userInfo", newUser);
}
}
return(Json(new { success = true }));
}
public async Task <IActionResult> FacebbookSign(FacebookLoginModel model)
{
if (ModelState.IsValid)
{
try
{
_accountService.SetCurrentContext(HttpContext, Url);
var response = await _accountService.FacebookLoginAsync(model);
_transactionHelper.CommitChanges();
return(Ok(response));
}
catch (Exception ex)
{
_transactionHelper.RollBackChanges();
return(BadRequest(ex.Message));
}
}
return(BadRequest(ModelState));
}
public async Task <ActionResult> FacebookLoginUser(FacebookLoginModel facebookUser)
{
var isTokenValid = facebookAuthenticationService.ValidateFacebookToken(facebookUser);
if (!isTokenValid.Result)
{
return(BadRequest("Invalid facebook token"));
}
if (userManager.FindByEmailAsync(facebookUser.Email).Result == null)
{
await facebookAuthenticationService.RegisterFacebookUser(facebookUser);
}
var authorizedFacebookUser = facebookAuthenticationService.LoginFacebookUser(facebookUser).Result;
if (entityContext.CourseSubscribers.Where(user => user.UserId.Contains(user.UserId)).ToList().Count > 0)
{
authorizedFacebookUser.IsSubscribedOncourses = true;
}
return(Ok(authorizedFacebookUser));
}
public async Task <LoginReturn> FacebookLoginHub([FromBody] FacebookLoginModel model)
{
LoginReturn ret = new LoginReturn();
if (!ModelState.IsValid)
{
ret.errors.Add("ModelState Error");
ret.success = false;
//return BadRequest(ModelState);
return(ret);
}
var user = await UserManager.FindByNameAsync(model.FacebookId);
if (user == null)
{
RegisterFacebookModel m = new RegisterFacebookModel();
m.FacebookAccessToken = model.FacebookAccessToken;
var reg = await RegisterWithFacebook(m);
if (reg.success == false)
{
ret.success = false;
ret.errors = reg.errors;
return(ret);
}
user = await UserManager.FindByNameAsync(model.FacebookId);
await ChatModel.CreateSessionWithUser();
await ChatModel.SignUpForChat(user);
// await ChatModel.SignUpForChat(user);
}
///Must be registered by now
///Refresh Tokena
if (!await UserManager.CheckPasswordAsync(user, model.FacebookAccessToken))
{
RegisterFacebookModel m = new RegisterFacebookModel();
m.FacebookAccessToken = model.FacebookAccessToken;
var reg = await ChangeFacebookAccessToken(m);
if (reg.success == false)
{
ret.success = false;
ret.errors = reg.errors;
return(ret);
}
}
return(ret);
}
