public async Task <LoggedUserResponse> FacebookLoginAsync(FacebookLoginRequest facebookLoginRequest)
{
if (string.IsNullOrEmpty(facebookLoginRequest.FacebookToken))
{
throw new Exception("Token is null or empty");
}
var facebookUser = await _facebookService.GetUserFromFacebookAsync(facebookLoginRequest.FacebookToken);
var applicationUser = await _appDbContext.Users.SingleOrDefaultAsync(user => user.Email == facebookUser.Email);
string token;
if (applicationUser == null)
{
var user = await CreateFacebookUser(facebookUser);
await _appDbContext.SaveChangesAsync(CancellationToken.None);
token = await Task.Run(() => JwtAuthManager.GenerateToken(user));
return(LoggedUser(user, token));
}
token = await Task.Run(() => JwtAuthManager.GenerateToken(applicationUser));
return(LoggedUser(applicationUser, token));
}
// Get user
public async Task <FacebookLoginResponse> GetUser(FacebookLoginRequest model)
{
var result = await GetAsync <dynamic>(
model.FacebookToken,
model.FacebookUID,
"fields=name,email,birthday,location,gender,picture.width(500)"
);
if (result == null)
{
throw new AppException("Invalid Facebook credentials");
}
if (await _context.Users.AnyAsync(u => u.FacebookUID == model.FacebookUID))
{
return(new FacebookLoginResponse
{
Existing = true
});
}
var facebookUser = new FacebookLoginResponse()
{
Email = result.email ?? null,
Name = result.name,
Gender = result.gender ?? null,
DateOfBirth = result.birthday ?? null,
Location = result.location != null ? result.location.name : null,
FacebookUID = model.FacebookUID,
Picture = result.picture.data.url,
Existing = false
};
return(facebookUser);
}
// Login with facebook
public async Task <LoginResponse> FacebookLogin(FacebookLoginRequest model, string ipAddress, DeviceDetector deviceDetector)
{
User user = null;
var facebookUser = await _facebookService.GetUser(model);
if (facebookUser.Existing)
{
user = await _context.Users.Include(u => u.Photos).FirstOrDefaultAsync(u => u.FacebookUID == model.FacebookUID);
}
else
{
var userToCreate = _mapper.Map <User>(facebookUser);
userToCreate.Verified = DateTime.Now;
userToCreate.Role = Role.User;
userToCreate.Status = Status.Active;
userToCreate.Created = DateTime.Now;
_context.Users.Add(userToCreate);
if (await _context.SaveChangesAsync() > 0)
{
user = await _context.Users.Include(u => u.Photos).FirstOrDefaultAsync(u => u.FacebookUID == facebookUser.FacebookUID);
if (facebookUser.Picture != null)
{
var photo = new Photo
{
Url = facebookUser.Picture,
DateAdded = DateTime.Now
};
user.Photos.Add(photo);
if (await _context.SaveChangesAsync() <= 0)
{
throw new AppException("Registered with Facebook successfully, but failed to add photo");
}
}
}
}
var refreshToken = GenerateRefreshToken(ipAddress, deviceDetector);
user.RefreshTokens.Add(refreshToken);
_context.Update(user);
await _context.SaveChangesAsync();
var jwtToken = GenerateJwtToken(user);
var response = _mapper.Map <LoginResponse>(user);
response.JwtToken = jwtToken;
response.RefreshToken = refreshToken.Token;
return(response);
}
public async Task <IActionResult> FacebookLogin([FromBody] FacebookLoginRequest model)
{
var dd = new DeviceDetector(Request.Headers["User-Agent"]);
var response = await _accountService.FacebookLogin(model, IpAddress(), dd);
Response.SetTokenCookie(response.RefreshToken);
return(Ok(response));
}
public async Task <IActionResult> LoginWithFacebook(FacebookLoginRequest request)
{
var token = await _userService.LoginWithFacebook(request);
if (token == "FAILED")
{
return(BadRequest("LOGIN FACEBOOK FAILED"));
}
HttpContext.Response.Headers.Add("Token", $"{token}");
return(Ok(token));
}
public async Task <IActionResult> FacebookLoginAsync([FromBody] FacebookLoginRequest facebookLoginRequest)
{
var authorizationTokens = await _userService.FacebookLoginAsync(facebookLoginRequest);
if (authorizationTokens == null)
{
return(BadRequest(new { errors = "Invalid token!" }));
}
return(Ok(authorizationTokens));
}
public async Task <bool> Handle(FacebookLoginRequest message, IOutputPort <LoginResponse> outputPort)
{
var user = await _userRepository.FindByEmail(message.Email);
if (user == null)
{
user = await _userRepository.CreateUserFromFacebook(message, Convert.ToBase64String(Guid.NewGuid().ToByteArray()).Substring(0, 8));
if (user == null)
{
outputPort.Handle(new LoginResponse(new[] { new Error("facebook_login_failure", "Failed to create new user.") }));
return(false);
}
}
outputPort.Handle(new LoginResponse(await _jwtFactory.GenerateEncodedToken(user.Id, user.UserName), true));
return(true);
}
public async Task <IActionResult> FacebookLogin(FacebookLoginRequest request)
{
if (ModelState.IsValid)
{
var(token, whoLoggedIn, error) = await _acc.GetOrCreateExternalLoginUser(request.Provider, request.ProviderKey, request.Email,
request.FirstName, request.LastName, request.Role, true, request.Picture);
if (token != null)
{
UserViewModel dto = whoLoggedIn.Convert <ApplicationUser, UserViewModel>(_mapper);
dto.Token = token;
return(Ok(dto));
}
return(BadRequest(new { Message = error }));
}
return(BadRequest(new { Errors = ModelState.Values.SelectMany(e => e.Errors).ToList() }));
}
protected override void beforeEach()
{
theUrl = "login/test";
theRequest = new FacebookLoginRequest();
theSignIn = new FacebookSignIn();
MockFor <IFubuRequest>().Stub(x => x.Get <FacebookSignIn>()).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 <string> LoginWithFacebook(FacebookLoginRequest request)
{
var username = request.userId + "facebook";
var checkUserExist = await _userManager.FindByNameAsync(username);
//
if (checkUserExist != null && checkUserExist.status == ActionStatus.Deleted)
{
return("FAILED");
}
if (checkUserExist == null)
{
var user = new AppUser()
{
displayname = request.name,
Email = request.email,
avatar = request.avatar,
UserName = username,
//birthDay = DateTime.Now,
};
var result = await _userManager.CreateAsync(user, request.userId);
if (result.Succeeded)
{
var userRole = _context.Roles.FirstOrDefault(x => x.Name == "User");
await _userManager.AddToRoleAsync(user, userRole.Name);
var userTemp = await _userManager.FindByNameAsync(username);
return(await CreateToken(userTemp));
}
else
{
return("FAILED");
}
}
else
{
return(await CreateToken(checkUserExist));
}
}
private void FetchProfileCallback(IGraphResult result)
{
isLoggedIn = true;
firstName = result.ResultDictionary["first_name"].ToString();
lastName = result.ResultDictionary["last_name"].ToString();
email = result.ResultDictionary["email"].ToString();
id = result.ResultDictionary["id"].ToString();
profile_name.text = firstName;
PlayerPrefs.SetString(LocalStorageUtil.Keys.firstName.ToString(), result.ResultDictionary["first_name"].ToString());
PlayerPrefs.SetString(LocalStorageUtil.Keys.lastName.ToString(), result.ResultDictionary["last_name"].ToString());
PlayerPrefs.SetString(LocalStorageUtil.Keys.email.ToString(), result.ResultDictionary["email"].ToString());
DisplayProfilePanel();
FacebookLoginRequest facebookLoginRequest = new FacebookLoginRequest();
facebookLoginRequest.firstName = result.ResultDictionary["first_name"].ToString();
facebookLoginRequest.lastName = result.ResultDictionary["last_name"].ToString();
facebookLoginRequest.email = result.ResultDictionary["email"].ToString();
facebookLoginRequest.id = result.ResultDictionary["id"].ToString();
facebookLoginRequest.photoUrl = tempPhotoURL;
StartCoroutine(HttpUtil.Post(HttpUtil.facebookAuthUrl, JsonUtility.ToJson(facebookLoginRequest), (response) =>
{
ResponseModel responseModel = new ResponseModel();
responseModel = JsonUtility.FromJson <ResponseModel>(response.downloadHandler.text);
if (responseModel.isSuccessful || responseModel.successful)
{
LocalStorageUtil.saveAuthKey(responseModel.jtwToken);
}
else
{
}
}));
}
public IActionResult FacebookLogin([FromForm] FacebookLoginRequest request)
{
var user = _context.Users.Where(x => x.Email == request.Email.Trim()).FirstOrDefault();
//Email chưa được sử dụng trong hệ thống, đăng ký tài khoản mới
if (user == null)
{
var newUser = new AppUser()
{
NumberOfFiends = 0,
NumberOfImages = 0,
NumberOfLikes = 0,
Email = request.Email,
Role = ERole.User,
FullName = request.FullName,
UserName = request.Email,
AvatarPath = request.Avatar,
IsInfoUpdated = false,
TypeAccount = ETypeAccount.Facebook,
PassWord = Guid.NewGuid().ToString()
};
var mailchimp = new MailChimpModel()
{
Email = request.Email,
Name = request.FullName
};
_mailchimpService.Subscribe(mailchimp);
try
{
_context.Users.Add(newUser);
_context.SaveChanges();
var response = new UserResponse(newUser, _storageService);
response.Token = this.GenerateJSONWebToken(newUser);
return(Ok(response));
}
catch (Exception e)
{
return(BadRequest(new
{
Message = e.Message
}));
}
}
else // Email đã có trong hệ thống, tiến hành đăng nhập
{
if (user.Status == EUserStatus.Inactive)
{
return(BadRequest(new
{
Message = "Your account has been locked!"
}));
}
var userResponse = new UserResponse(user, _storageService);
userResponse.Token = this.GenerateJSONWebToken(user);
//_sessionService.SetSessionUser(user);
return(Ok(userResponse));
}
}
