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