public async Task <User> Handle(LoginUserQuery request, CancellationToken cancellationToken)
{
var user = await _userManager.FindByEmailAsync(request.Email);
if (user == null)
{
throw new RestException(HttpStatusCode.Unauthorized);
}
var userSignedIn = await _userManager.CheckPasswordAsync(user, request.Password);
if (!userSignedIn)
{
var errorMessage = ErrorMessages.UserLoginFailed;
_eventBus.Publish(new ErrorLogEvent(user.Id, errorMessage));
throw new RestException(HttpStatusCode.Unauthorized);
}
user.RefreshToken = _jwtGenerator.GenerateRefreshToken();
user.RefreshTokenExpiry = DateTime.Now.AddDays(30);
await _userManager.UpdateAsync(user);
_eventBus.Publish(new UserLoginEvent(user.Id));
return(new User
{
FirstName = user.FirstName,
Token = _jwtGenerator.CreateToken(user),
RefreshToken = user.RefreshToken,
Email = user.Email,
Image = null,
EmailConfirmed = user.EmailConfirmed
});
}
public async Task <User> Handle(Query request, CancellationToken cancellationToken)
{
var user = await _userManager.FindByEmailAsync(request.Email);
if (user == null)
{
throw new RestException(HttpStatusCode.Unauthorized);
}
var result = await _signInManager.CheckPasswordSignInAsync
(user, request.Password, false);
if (result.Succeeded)
{
var refreshToken = _jwtGenerator.GenerateRefreshToken();
user.RefreshTokens.Add(refreshToken);
//Update via _userManager since we are storing tokens in the db; it's saved automatically
await _userManager.UpdateAsync(user);
return(new User(user, _jwtGenerator, refreshToken.Token));
}
throw new RestException(HttpStatusCode.Unauthorized);
}
public async Task <User> Handle(Query request,
CancellationToken cancellationToken)
{
var user = await _userManager.FindByEmailAsync(request.Email);
if (user == null)
{
throw new RestException(HttpStatusCode.Unauthorized);
}
if (!user.EmailConfirmed)
{
throw new RestException(HttpStatusCode.BadRequest, new { Email = "Email is not Confirmed" });
}
var result = await _signInManager.CheckPasswordSignInAsync(user, request.Password, false);
if (result.Succeeded)
{
var refreshToken = _jwtGenerator.GenerateRefreshToken();
user.RefreshTokens.Add(refreshToken);
await _userManager.UpdateAsync(user);
return(new User(user, _jwtGenerator, refreshToken.Token));
}
throw new RestException(HttpStatusCode.Unauthorized);
}
public async Task <User> Handle(RefreshTokenQuery request, CancellationToken cancellationToken)
{
var user = await _userManager.FindByEmailAsync(request.Email);
if (user == null || user.RefreshToken != request.RefreshToken || user.RefreshTokenExpiry < DateTime.Now)
{
throw new RestException(HttpStatusCode.Unauthorized);
}
user.RefreshToken = _jwtGenerator.GenerateRefreshToken();
user.RefreshTokenExpiry = DateTime.Now.AddDays(30);
await _userManager.UpdateAsync(user);
_eventBus.Publish(new UpdatedRefreshTokenEvent(user.Id));
return(new User
{
FirstName = user.FirstName,
LastName = user.LastName,
Token = _jwtGenerator.CreateToken(user),
RefreshToken = user.RefreshToken,
Email = user.Email,
Image = null
});
}
//Implement interface
public async Task <User> Handle(Command request, CancellationToken cancellationToken)
{
//Logic
var user = await _userManager.FindByNameAsync(_userAccessor.GetCurrentUsername());
var oldToken = user.RefreshTokens.SingleOrDefault(w => w.Token == request.RefreshToken);
//Make sure oldToken is valid else return 401
if (oldToken != null && !oldToken.IsActive)
{
throw new RestException(HttpStatusCode.Unauthorized);
}
//Revoke the token
if (oldToken != null)
{
oldToken.Revoked = DateTime.Now;
}
//Create new token
var newRefreshToken = _jwtGenerator.GenerateRefreshToken();
user.RefreshTokens.Add(newRefreshToken);
await _userManager.UpdateAsync(user);
return(new User(user, _jwtGenerator, newRefreshToken.Token));
}
public async Task <UserViewModel> Handle(LoginQuery request, CancellationToken cancellationToken)
{
var user = await this.Context.Users
.Include(u => u.Photos)
.FirstOrDefaultAsync(u => u.Email == request.Email);
if (user != null)
{
var signInResult = await this.signInManager.CheckPasswordSignInAsync(user, request.Password, false);
if (signInResult.Succeeded)
{
user.RefreshToken = jwtGenerator.GenerateRefreshToken();
user.RefreshTokenExpiryDate = DateTime.Now.AddDays(ReactivitiesAppConstants.RefreshTokenExpiryInDays);
await this.userManager.UpdateAsync(user);
var loggedUser = mapper.Map <UserViewModel>(user);
loggedUser.Token = this.jwtGenerator.CreateToken(user);
loggedUser.Image = user.Photos?.FirstOrDefault(p => p.IsMain)?.Url;
return(loggedUser);
}
}
throw new RestException(HttpStatusCode.Unauthorized,
new { user = nameof(HttpStatusCode.Unauthorized) });
}
public async Task <User> Handle(Command request, CancellationToken cancellationToken)
{
if (await _context.Users.AnyAsync(x => x.Email == request.Email))
{
throw new RestException(HttpStatusCode.BadRequest, new { Email = "Email already exists" });
}
if (await _context.Users.AnyAsync(x => x.UserName == request.Username))
{
throw new RestException(HttpStatusCode.BadRequest, new { Username = "******" });
}
var user = new AppUser
{
DisplayName = request.DisplayName,
Email = request.Email,
UserName = request.Username
};
var refreshToken = _jwtGenerator.GenerateRefreshToken();
user.RefreshTokens.Add(refreshToken);
var result = await _userManager.CreateAsync(user, request.Password);
if (result.Succeeded)
{
return(new User(user, _jwtGenerator, refreshToken.Token));
}
throw new Exception("Problem creating user");
}
public async Task <User> Handle(Command request, CancellationToken cancellationToken)
{
var user = await _userManager.FindByNameAsync(_userAccessor.GetCurrentUsername());
var oldToken = user.RefreshTokens.SingleOrDefault(x =>
x.Token == request.RefreshToken);
if (oldToken != null && !oldToken.IsActive)
{
throw new RestException(HttpStatusCode.Unauthorized);
}
if (oldToken != null)
{
oldToken.Revoked = DateTime.UtcNow;
}
var newRefreshToken = _jwtGenerator.GenerateRefreshToken();
user.RefreshTokens.Add(newRefreshToken);
await _userManager.UpdateAsync(user);
return(new User(user, _jwtGenerator, newRefreshToken.Token));
}
public async Task <User> Handle(Query request, CancellationToken cancellationToken)
{
var user = await _userManager.FindByNameAsync(request.Username);
if (user == null)
{
throw new RestException(HttpStatusCode.BadRequest, ErrorType.DefaultValidationError);
}
if (user.RefreshToken != request.RefreshToken || user.RefreshTokenExpiry < DateTime.Now)
{
throw new RestException(HttpStatusCode.Unauthorized, ErrorType.RefreshTokenExpired);
}
user.RefreshToken = _jwtGenerator.GenerateRefreshToken();
user.RefreshTokenExpiry = DateTime.Now.AddDays(30);
await _userManager.UpdateAsync(user);
return(new User
{
DisplayName = user.DisplayName,
Email = user.Email,
Username = user.UserName,
Token = _jwtGenerator.CreateToken(user),
RefreshToken = user.RefreshToken,
TourCompleted = user.TourCompleted,
ItemsTourCompleted = user.ItemsTourCompleted,
NewItemTourCompleted = user.NewItemTourCompleted,
LearningTourCompleted = user.LearningTourCompleted
});
}
public async Task <Result <User> > Handle(Query request, CancellationToken cancellationToken)
{
try
{
var user = await _userManager.FindByEmailAsync(request.Email);
if (user == null)
{
return(null);
}
var result = await _signInManager.CheckPasswordSignInAsync(user, request.Password, false);
if (result.Succeeded)
{
var refreshToken = _jwtGenerator.GenerateRefreshToken();
user.RefreshTokens.Add(refreshToken);
await _userManager.UpdateAsync(user);
return(Result <User> .Success(new User(user, _jwtGenerator, refreshToken.Token)));
}
return(Result <User> .Failure("Failed to login that user."));
}
catch (Exception e)
{
Console.WriteLine($"Catched error in login: {e}");
return(null);
}
/*
* if (!user.EmailConfirmed)
* {
* throw new RestException(HttpStatusCode.BadRequest, new { Email = "Email is not confirmed" });
* }
*/
}
public async Task <User> Handle(Query request, CancellationToken cancellationToken)
{
var user = await _userManager.FindByEmailAsync(request.Email);
if (user == null)
{
throw new RestException(HttpStatusCode.Unauthorized);
}
var result = await _signinManager.CheckPasswordSignInAsync(user, request.Password, false);
if (result.Succeeded)
{
user.RefreshToken = _jwtGenerator.GenerateRefreshToken();
user.RefreshTokenExpiry = DateTime.Now.AddDays(30);
await _userManager.UpdateAsync(user);
return(new User {
DisplayName = user.DisplayName,
UserName = user.UserName,
Image = user.Photos.SingleOrDefault(x => x.IsMain)?.Url,
Token = _jwtGenerator.CreateToken(user),
RefreshToken = user.RefreshToken,
});
}
throw new RestException(HttpStatusCode.Unauthorized);
}
public async Task <User> Handle(LoginQuery request, CancellationToken cancellationToken)
{
var user = await _userManager.FindByEmailAsync(request.Email);
if (user == null)
{
throw new RestException(HttpStatusCode.Unauthorized);
}
// will put the logic for deleting the registration for unconfirmed users after 12 hours here.
if (!user.EmailConfirmed)
{
throw new RestException(HttpStatusCode.BadRequest, new { Login = "******" });
}
var result = await _signInManager.CheckPasswordSignInAsync(user, request.Password, false);
if (result.Succeeded)
{
user.RefreshToken = _jwtGenerator.GenerateRefreshToken();
user.RefreshTokenExpiry = DateTime.Now.AddDays(30);
await _userManager.UpdateAsync(user);
return(new User
{
DisplayName = user.DisplayName,
Token = _jwtGenerator.CreateToken(user),
RefreshToken = user.RefreshToken,
Id = user.Id,
Image = user.Photos.FirstOrDefault(x => x.IsMain)?.Url
});
}
throw new RestException(HttpStatusCode.Unauthorized);
}
public async Task <LoginResultModel> LoginAsync(LoginModel model)
{
// Check user existing
var user = await _userManager.FindByNameAsync(model.UserName);
if (user == null)
{
throw new Exception("Incorrect username.");
}
// Signin using username and password provided
var loginResult = await _signInManager.PasswordSignInAsync(model.UserName, model.Password, isPersistent : false, lockoutOnFailure : false);
if (loginResult.IsLockedOut)
{
throw new Exception("Your account was locked out.");
}
if (!loginResult.Succeeded)
{
throw new Exception("Invalid username or password.");
}
var newRefreshToken = _jwtGenerator.GenerateRefreshToken();
var userRefreshToken = _context.UserRefreshTokens.FirstOrDefault(urt => urt.Username == user.UserName);
if (userRefreshToken != null)
{
userRefreshToken.RefreshToken = newRefreshToken;
}
else
{
_context.UserRefreshTokens.Add(new UserRefreshToken
{
Username = user.UserName,
RefreshToken = newRefreshToken
});
}
await _context.SaveChangesAsync();
return(new LoginResultModel
{
UserName = user.UserName,
AccessToken = await GenerateToken(_jwtSettings, user),
RefreshToken = newRefreshToken
});
}
public async Task <User> Handle(Query request, CancellationToken cancellationToken)
{
// handler logic
var userInfo = await _facebookAccessor.FacebookLogin(request.AccessToken);
// if token is unverified or unsuccessful response from facebook
if (userInfo == null)
{
throw new RestException(HttpStatusCode.BadRequest, new { User = "******" });
}
// find the user by their email
var user = await _userManager.FindByEmailAsync(userInfo.Email);
var refreshToken = _jwtGenerator.GenerateRefreshToken();
if (user != null)
{
// they have loggen in before
user.RefreshTokens.Add(refreshToken);
await _userManager.UpdateAsync(user);
return(new User(user, _jwtGenerator, refreshToken.Token));
}
// if no user create them
user = new AppUser
{
DisplayName = userInfo.Name,
Id = userInfo.Id,
Email = userInfo.Email,
UserName = "******" + userInfo.Id,
EmailConfirmed = true // because facebook confirmed their email already
};
var photo = new Photo
{
Id = "fb_" + userInfo.Id,
// this is their main img in facebook
Url = userInfo.Picture.Data.Url,
IsMain = true
};
user.Photos.Add(photo);
user.RefreshTokens.Add(refreshToken);
var result = await _userManager.CreateAsync(user);
if (!result.Succeeded)
{
throw new RestException(HttpStatusCode.BadRequest, new { User = "******" });
}
return(new User(user, _jwtGenerator, refreshToken.Token));
}
public async Task <User> Handle(Query request, CancellationToken cancellationToken)
{
var userInfo = await _googleAccessor.GoogleLogin(request.AccessCode);
if (userInfo == null)
{
throw new RestException(HttpStatusCode.Unauthorized, ErrorType.GoogleAuthorizationFailed);
}
var user = await _userManager.FindByEmailAsync(userInfo.Email);
if (user != null && !user.UserName.Contains("_gg"))
{
throw new RestException(HttpStatusCode.BadRequest, ErrorType.DuplicateEmailFound);
}
if (user == null)
{
user = new AppUser
{
Id = userInfo.Sub,
DisplayName = userInfo.Name,
Email = userInfo.Email,
UserName = userInfo.Email.Split("@")[0] + "_gg",
Avatar = userInfo.Picture,
RefreshToken = _jwtGenerator.GenerateRefreshToken(),
RefreshTokenExpiry = DateTime.Now.AddDays(30),
};
var result = await _userManager.CreateAsync(user);
if (!result.Succeeded)
{
throw new RestException(HttpStatusCode.InternalServerError, ErrorType.SavingChangesError);
}
}
return(new User
{
DisplayName = user.DisplayName,
Email = user.Email,
Username = user.UserName,
Avatar = user.Avatar,
Token = _jwtGenerator.CreateToken(user),
RefreshToken = user.RefreshToken,
TourCompleted = user.TourCompleted,
ItemsTourCompleted = user.ItemsTourCompleted,
NewItemTourCompleted = user.NewItemTourCompleted,
LearningTourCompleted = user.LearningTourCompleted
});
}
public async Task <AppUserDto> Handle(Query request, CancellationToken cancellationToken)
{
var userInfo = await _facebookAccessor.FacebookLogin(request.AccessToken);
if (userInfo == null)
{
throw new RestException(HttpStatusCode.BadRequest,
new { User = "******" });
}
var user = await _userManager.FindByEmailAsync(userInfo.Email);
var refreshToken = _jwtGenerator.GenerateRefreshToken();
if (user != null)
{
user.RefreshTokens.Add(refreshToken);
await _userManager.UpdateAsync(user);
return(new AppUserDto(user, _jwtGenerator, refreshToken.Token));
}
// If no user exists - generate the new AppUser
user = new AppUser()
{
DisplayName = userInfo.Name,
Id = userInfo.Id,
Email = userInfo.Email,
UserName = "******" + userInfo.Id,
EmailConfirmed = true
};
if (userInfo.ImageData != null)
{
var photo = new Photo
{
Id = "fb_" + userInfo.Id,
Url = userInfo.ImageData?.Image?.Url,
IsAvatar = true
};
user.Photos.Add(photo);
}
user.RefreshTokens.Add(refreshToken);
var result = await _userManager.CreateAsync(user);
if (!result.Succeeded)
{
throw new RestException(HttpStatusCode.BadRequest);
}
return(new AppUserDto(user, _jwtGenerator, refreshToken.Token));
}
public async Task <UserDto> Handle(CurrentUserCommand request, CancellationToken cancellationToken)
{
var token = AppContext.Current.Request.Headers[HeaderNames.Authorization].ToString().Replace("Bearer ", "");
var refreshToken = AppContext.Current.Request.Cookies[Constants.RefreshToken];
var principal = _jwtGenerator.GetPrincipalFromExpiredToken(token);
var username = principal.Claims.FirstOrDefault(x => x.Type == ClaimTypes.NameIdentifier)?.Value;
var user = await _context.Users
.Where(x => x.UserName == username)
.Include(x => x.RefreshTokens)
.SingleOrDefaultAsync(x => x.RefreshTokens.Any(y => y.Token == refreshToken),
cancellationToken);
if (user == null)
{
ThrowUnauthorized();
}
var oldToken = user !.RefreshTokens.SingleOrDefault(x => x.Token == refreshToken);
if (oldToken != null && !oldToken.IsActive)
{
ThrowUnauthorized();
}
if (oldToken != null)
{
oldToken.Revoked = DateTime.UtcNow;
}
var newRefreshToken = _jwtGenerator.GenerateRefreshToken(user);
await _context.RefreshTokens.AddAsync(newRefreshToken, cancellationToken);
var revokedTokens = user.RefreshTokens.Where(x => x.IsExpired);
_context.RefreshTokens.RemoveRange(revokedTokens);
var success = await _context.SaveChangesAsync(cancellationToken) > 0;
if (success)
{
_cookieService.SetTokenCookie(newRefreshToken.Token);
return(new UserDto
{
UserName = user.UserName,
Token = _jwtGenerator.GenerateAccessToken(user),
RefreshToken = newRefreshToken.Token
});
}
throw new Exception(Constants.ServerSavingError);
}
public async Task <User> Handle(Command request, CancellationToken cancellationToken)
{
var userInfo = await _facebookAccessor.FacebookLogin(request.AccessToken);
if (userInfo == null)
{
throw new RestException(HttpStatusCode.BadGateway, new { User = "******" });
}
var user = await _userManager.FindByEmailAsync(userInfo.Email);
var token = "";
if (user == null)
{
user = new AppUser
{
DisplayName = userInfo.Name,
Id = userInfo.Id,
Email = userInfo.Email,
UserName = "******" + userInfo.Id,
RefreshToken = _jwtGenerator.GenerateRefreshToken(),
RefreshTokenExpiry = DateTime.UtcNow.AddDays(30)
};
//try create local user
token = _jwtGenerator.CreateToken(user);
var userCreated = await _userActivitiesApp.CreateUser(user.DisplayName, token);
if (!userCreated)
{
throw new RestException(HttpStatusCode.BadRequest, new { User = "******" });
}
var result = await _userManager.CreateAsync(user);
if (!result.Succeeded)
{
throw new RestException(HttpStatusCode.BadRequest, new { User = "******" });
}
}
if (token == "")
{
token = _jwtGenerator.CreateToken(user);
}
return(new User
{
Email = user.Email,
DisplayName = user.DisplayName,
Username = user.UserName,
Token = token,
RefreshToken = user.RefreshToken
});
}
public async Task <User> Handle(Query request, CancellationToken cancellationToken)
{
var user = await FindCurrentUser();
var refreshToken = _jwtGenerator.GenerateRefreshToken();
user.RefreshTokens.Add(refreshToken);
await _userManager.UpdateAsync(user);
return(new User(user, _jwtGenerator, refreshToken.Token));
}
public async Task <User> Handle(Query request, CancellationToken cancellationToken)
{
var userInfo = await _facebookAccessor.FacebookLogin(request.AccessToken);
if (userInfo == null)
{
throw new RestException(HttpStatusCode.BadRequest, new { User = "******" });
}
var user = await _userManager.FindByEmailAsync(userInfo.Email);
var refreshToken = _jwtGenerator.GenerateRefreshToken();
if (user != null)
{
user.RefreshTokens.Add(refreshToken);
await _userManager.UpdateAsync(user);
return(new User(user, _jwtGenerator, refreshToken.Token));
}
user = new AppUser
{
DisplayName = userInfo.Id,
Id = userInfo.Id,
Email = userInfo.Email,
UserName = "******" + userInfo.Id,
EmailConfirmed = true
};
var photo = new Photo
{
Id = "fb_" + userInfo.Id,
Url = userInfo.Picture.Data.Url,
IsMain = true
};
//To initialized photo collection
user.Photos.Add(photo);
user.RefreshTokens.Add(refreshToken);
var result = await _userManager.CreateAsync(user);
if (!result.Succeeded)
{
throw new RestException(HttpStatusCode.BadRequest, new { User = "******" });
}
// return new User(user, _jwtGenerator, refreshToken.Token);
return(new User(user, _jwtGenerator, refreshToken.Token));
}
public async Task <User> Handle(Query request, CancellationToken cancellationToken)
{
var user = await UserManager.FindByNameAsync(UserAccessor.GetCurrentUsername());
var refreshToken = JwtGenerator.GenerateRefreshToken();
user.RefreshTokens.Add(refreshToken);
await UserManager.UpdateAsync(user);
return(new User(user, JwtGenerator, refreshToken.Token));
}
public async Task <User> Handle(Query request, CancellationToken cancellationToken)
{
var user = await _userManager.FindByNameAsync(_userAccessor.GetCurrentUsername());
var refreshToken = _jwtGenerator.GenerateRefreshToken();
user.RefreshTokens.Add(refreshToken);
//Update via _userManager since we are storing tokens in the db; it's saved automatically
await _userManager.UpdateAsync(user);
return(new User(user, _jwtGenerator, refreshToken.Token));
}
public async Task <User> Handle(Query request, CancellationToken cancellationToken)
{
var userInfo = await _facebookAccessor.FacebookLogin(request.AccessToken);
if (userInfo == null)
{
throw new RestException(HttpStatusCode.BadRequest, new { User = "******" });
}
var user = await _userManager.FindByEmailAsync(userInfo.Email);
var refreshToken = _jwtGenerator.GenerateRefreshToken();
user.RefreshTokens.Add(refreshToken);
//Check user was logged in previously hence issue Refresh Token
if (user != null)
{
user.RefreshTokens.Add(refreshToken);
//Update via _userManager since we are storing tokens in the db; it's saved automatically
await _userManager.UpdateAsync(user);
return(new User(user, _jwtGenerator, refreshToken.Token));
}
//If user not logged in
user = new AppUser
{
DisplayName = userInfo.Name,
Id = userInfo.Id,
Email = userInfo.Email,
UserName = "******" + userInfo.Id //To differentiate from normal username
};
var photo = new Photo
{
Id = "fb_" + userInfo.Id,
Url = userInfo.Picture.Data.Url,
IsMain = true
};
user.RefreshTokens.Add(refreshToken);
user.Photos.Add(photo); //Had to modify AppUser.cs n create a constructor with Photos collection
var result = await _userManager.CreateAsync(user); //Password stored in FB
if (!result.Succeeded)
{
throw new RestException(HttpStatusCode.BadRequest, new { User = "******" });
}
return(new User(user, _jwtGenerator, refreshToken.Token));
}
public async Task <User> Handle(CurrentUserQuery request, CancellationToken cancellationToken)
{
var user = await _userManager.FindByEmailAsync(_userAccessor.GetEmail());
return(new User {
DisplayName = user.DisplayName,
Id = user.Id,
RefreshToken = _jwtGenerator.GenerateRefreshToken(),
Token = _jwtGenerator.CreateToken(user),
Image = user.Photos.FirstOrDefault(x => x.IsMain)?.Url
});
}
public async Task <User> Handle(Query request, CancellationToken cancellationToken)
{
//handler logic goes here.
var user = await _userManager.FindByNameAsync(_userAceessor.GetCurrentUsername());
var refreshToken = _jwtGenerator.GenerateRefreshToken();
user.RefreshToken.Add(refreshToken);
await _userManager.UpdateAsync(user);
return(new User(user, _jwtGenerator, refreshToken.Token));
}
public async Task <Result <User> > Handle(Query request, CancellationToken cancellationToken)
{
// Get user from DB
var user = await _userManager.FindByNameAsync(_userAccessor.GetCurrentUsername());
var refreshToken = _jwtGenerator.GenerateRefreshToken();
user.RefreshTokens.Add(refreshToken);
await _userManager.UpdateAsync(user);
return(Result <User> .Success(new User(user, _jwtGenerator, refreshToken.Token)));
}
public async Task <User> Handle(Query request,
CancellationToken cancellationToken)
{
var userInfo = await _facebookAccessor.FacebookLogin(request.AccessToken);
// Could be null if the token isn't verified, or if the response is unsuccessful when we get the UserInfo
if (userInfo == null)
{
throw new RestException(HttpStatusCode.BadRequest, new { User = "******" });
}
var user = await _userManager.FindByEmailAsync(userInfo.Email);
var refreshToken = _jwtGenerator.GenerateRefreshToken();
if (user != null)
{
user.RefreshTokens.Add(refreshToken);
await _userManager.UpdateAsync(user);
return(new User(user, _jwtGenerator, refreshToken.Token));
}
user = new AppUser
{
DisplayName = userInfo.Name,
Id = userInfo.Id,
Email = userInfo.Email,
UserName = "******" + userInfo.Id,
EmailConfirmed = true
};
var photo = new Photo
{
Id = "fb_" + userInfo.Id, // helps us recognize it's not a cloudinary photo
Url = userInfo.Picture.Data.Url,
IsMain = true
};
user.Photos.Add(photo);
user.RefreshTokens.Add(refreshToken);
var result = await _userManager.CreateAsync(user);
if (!result.Succeeded)
{
throw new RestException(HttpStatusCode.BadRequest, new { User = "******" });
}
return(new User(user, _jwtGenerator, refreshToken.Token));
}
public async Task <User> Handle(Query request, CancellationToken cancellationToken)
{
// get user info and verify token is valid
var userInfo = await _facebookAccessor.FacebookLogin(request.AccessToken);
// if user info is null then token could not be validated
if (userInfo == null)
{
throw new RestException(HttpStatusCode.BadRequest, new { User = "******" });
}
var user = await _userManager.FindByEmailAsync(userInfo.Email);
if (user == null)
{
user = new AppUser
{
DisplayName = userInfo.FirstName,
Id = userInfo.Id,
Email = userInfo.Email,
UserName = "******" + userInfo.Id,
RefreshToken = _jwtGenerator.GenerateRefreshToken(),
RefreshTokenExpiry = DateTime.Now.AddDays(30)
};
var photo = new Photo
{
Id = Guid.NewGuid().ToString(),
Url = userInfo.Picture.Data.Url,
IsMain = true
};
user.Photos.Add(photo);
var result = await _userManager.CreateAsync(user);
if (!result.Succeeded)
{
throw new RestException(HttpStatusCode.BadRequest, new { User = "******" });
}
}
return(new User
{
DisplayName = user.DisplayName,
Token = _jwtGenerator.CreateToken(user),
RefreshToken = user.RefreshToken,
Username = user.UserName,
Image = user.Photos.FirstOrDefault(x => x.IsMain)?.Url
});
}
public async Task <User> Handle(Command request, CancellationToken cancellationToken)
{
var normalizedEmail = request.Email.ToUpper();
var normalizedUsername = request.Username.ToUpper();
if (await _context.Users.AnyAsync(u => u.NormalizedEmail == normalizedEmail))
{
throw new RestException(HttpStatusCode.BadRequest, ErrorType.DuplicateEmailFound);
}
if (await _context.Users.AnyAsync(u => u.NormalizedUserName == normalizedUsername))
{
throw new RestException(HttpStatusCode.BadRequest, ErrorType.DuplicateUsernameFound);
}
var user = new AppUser
{
DisplayName = request.DisplayName,
Email = request.Email,
UserName = request.Username,
RefreshToken = _jwtGenerator.GenerateRefreshToken(),
RefreshTokenExpiry = DateTime.Now.AddDays(30),
NotificationsEmail = request.Email,
};
var result = await _userManager.CreateAsync(user, request.Password);
if (result.Succeeded)
{
return(new User
{
DisplayName = user.DisplayName,
Email = user.Email,
Username = user.UserName,
Token = _jwtGenerator.CreateToken(user),
RefreshToken = user.RefreshToken,
NotificationsEmail = user.NotificationsEmail,
NotifyAboutCertificateChange = user.NotifyAboutCertificateChange,
ExpiryNotificationThreshold = user.ExpiryNotificationThresholdDays,
NotifyAboutExpiryIfRenewalConfigured = user.NotifyAboutExpiryIfRenewalConfigured,
RenewalThresholdDays = user.RenewalThresholdDays
});
}
throw new RestException(HttpStatusCode.InternalServerError, ErrorType.SavingChangesError);
}
public async Task <User> Handle(Query request, CancellationToken cancellationToken)
{
var userInfo = await _facebookAccessor.FacebookLogin(request.AccessToken);
if (userInfo == null)
{
throw new RestException(HttpStatusCode.BadRequest, new { User = "******" });
}
var user = await _userManager.FindByEmailAsync(userInfo.Email);
if (user == null)
{
user = new AppUser
{
DisplayName = userInfo.Name,
Id = userInfo.Id,
Email = userInfo.Email,
UserName = "******" + userInfo.Id,
RefreshToken = _jwtGenerator.GenerateRefreshToken(),
RefreshTokenExpiry = DateTime.UtcNow.AddDays(30),
EmailConfirmed = true
};
var photo = new Photo
{
Id = "fb_" + userInfo.Id,
Url = userInfo.Picture.Data.Url,
IsMain = true
};
user.Photos.Add(photo); // Create initial collection of photos when adding new user
var result = await _userManager.CreateAsync(user);
if (!result.Succeeded)
{
throw new RestException(HttpStatusCode.BadRequest, new { User = "******" });
}
}
return(new User
{
DisplayName = user.DisplayName,
token = _jwtGenerator.CreateToken(user),
RefreshToken = user.RefreshToken,
Username = user.UserName,
Image = user.Photos.FirstOrDefault(x => x.IsMain)?.Url
});
}