public SecurityController(
SignInManager <ApplicationUser> signInManager,
RoleManager <Role> roleManager,
IPermissionsRegistrar permissionsProvider,
IUserSearchService userSearchService,
IRoleSearchService roleSearchService,
IOptions <Core.Security.AuthorizationOptions> securityOptions,
IOptions <UserOptionsExtended> userOptionsExtended,
IPasswordValidator <ApplicationUser> passwordValidator,
IEmailSender emailSender,
IEventPublisher eventPublisher,
IUserApiKeyService userApiKeyService)
{
_signInManager = signInManager;
_securityOptions = securityOptions.Value;
_userOptionsExtended = userOptionsExtended.Value;
_passwordValidator = passwordValidator;
_permissionsProvider = permissionsProvider;
_roleManager = roleManager;
_userSearchService = userSearchService;
_roleSearchService = roleSearchService;
_emailSender = emailSender;
_eventPublisher = eventPublisher;
_userApiKeyService = userApiKeyService;
}
public CustomUserManager(IUserStore <ApplicationUser> store, IOptions <IdentityOptions> optionsAccessor, IPasswordHasher <ApplicationUser> passwordHasher, IUserPasswordHasher userPasswordHasher,
IOptions <UserOptionsExtended> userOptionsExtended,
IEnumerable <IUserValidator <ApplicationUser> > userValidators, IEnumerable <IPasswordValidator <ApplicationUser> > passwordValidators,
ILookupNormalizer keyNormalizer, IdentityErrorDescriber errors, IServiceProvider services,
ILogger <UserManager <ApplicationUser> > logger, RoleManager <Role> roleManager, IPlatformMemoryCache memoryCache, IEventPublisher eventPublisher)
: base(store, optionsAccessor, passwordHasher, userValidators, passwordValidators, keyNormalizer, errors, services, logger)
{
_memoryCache = memoryCache;
_roleManager = roleManager;
_eventPublisher = eventPublisher;
_userPasswordHasher = userPasswordHasher;
_userOptionsExtended = userOptionsExtended.Value;
}
public static int ContDaysTillPasswordExpiry(ApplicationUser user, UserOptionsExtended userOptions)
{
var result = -1; // not a valid expiry days number
if (!user.PasswordExpired &&
userOptions.RemindPasswordExpiryInDays > 0 &&
userOptions.MaxPasswordAge != null &&
userOptions.MaxPasswordAge.Value > TimeSpan.Zero)
{
var lastPasswordChangeDate = user.LastPasswordChangedDate ?? user.CreatedDate;
var timeTillExpiry = lastPasswordChangeDate.Add(userOptions.MaxPasswordAge.Value) - DateTime.UtcNow;
if (timeTillExpiry > TimeSpan.Zero &&
timeTillExpiry < TimeSpan.FromDays(userOptions.RemindPasswordExpiryInDays))
{
result = timeTillExpiry.Days;
}
}
return(result);
}
public void TestPasswordExpiryCalculator(bool passwordExpired, int remindPasswordExpiryInDays, TimeSpan?maxPasswordAge, int expectedDays)
{
//Arrange
var user = new ApplicationUser
{
LastPasswordChangedDate = DateTime.UtcNow.AddDays(-20),
PasswordExpired = passwordExpired
};
var userOptionsExtended = new UserOptionsExtended
{
RemindPasswordExpiryInDays = remindPasswordExpiryInDays,
MaxPasswordAge = maxPasswordAge
};
//Act
var daysTillPasswordExpiry = PasswordExpiryHelper.ContDaysTillPasswordExpiry(user, userOptionsExtended);
//Assert
Assert.Equal(expectedDays, daysTillPasswordExpiry);
}
public static CustomUserManager TestCustomUserManager(Mock <IUserStore <ApplicationUser> > storeMock = null,
UserOptionsExtended userOptions = null, IdentityOptions identityOptions = null, PlatformMemoryCache platformMemoryCache = null, IEventPublisher eventPublisher = null, Func <ISecurityRepository> repositoryFactory = null, Mock <IUserPasswordHasher> passwordHasher = null)
{
storeMock ??= new Mock <IUserStore <ApplicationUser> >();
storeMock.As <IUserRoleStore <ApplicationUser> >()
.Setup(x => x.GetRolesAsync(It.IsAny <ApplicationUser>(), CancellationToken.None))
.ReturnsAsync(Array.Empty <string>());
storeMock.As <IUserLoginStore <ApplicationUser> >()
.Setup(x => x.GetLoginsAsync(It.IsAny <ApplicationUser>(), CancellationToken.None))
.ReturnsAsync(Array.Empty <UserLoginInfo>());
storeMock.Setup(x => x.UpdateAsync(It.IsAny <ApplicationUser>(), CancellationToken.None))
.ReturnsAsync(IdentityResult.Success);
var identityOptionsMock = new Mock <IOptions <IdentityOptions> >();
if (identityOptions != null)
{
identityOptionsMock.Setup(o => o.Value).Returns(identityOptions);
}
if (passwordHasher == null)
{
passwordHasher = new Mock <IUserPasswordHasher>();
passwordHasher.Setup(x => x.VerifyHashedPassword(It.IsAny <ApplicationUser>(), It.IsAny <string>(), It.IsAny <string>()))
.Returns(PasswordVerificationResult.Success);
}
userOptions ??= new UserOptionsExtended
{
MaxPasswordAge = new TimeSpan(0)
};
var userOptionsMock = new Mock <IOptions <UserOptionsExtended> >();
userOptionsMock.Setup(o => o.Value).Returns(userOptions);
var userValidators = new List <IUserValidator <ApplicationUser> >();
var validator = new Mock <IUserValidator <ApplicationUser> >();
userValidators.Add(validator.Object);
repositoryFactory ??= () => Mock.Of <ISecurityRepository>();
var passwordOptionsMock = new Mock <IOptions <PasswordOptionsExtended> >();
passwordOptionsMock.Setup(o => o.Value).Returns(new PasswordOptionsExtended());
var pwdValidators = new PasswordValidator <ApplicationUser>[] { new CustomPasswordValidator(new CustomIdentityErrorDescriber(), repositoryFactory, passwordHasher.Object, passwordOptionsMock.Object) };
var roleManagerMock = new Mock <RoleManager <Role> >(Mock.Of <IRoleStore <Role> >(),
new[] { Mock.Of <IRoleValidator <Role> >() },
Mock.Of <ILookupNormalizer>(),
Mock.Of <IdentityErrorDescriber>(),
Mock.Of <ILogger <RoleManager <Role> > >());
var userManager = new CustomUserManager(storeMock.Object,
identityOptionsMock.Object,
passwordHasher.Object,
passwordHasher.Object,
userOptionsMock.Object,
userValidators,
pwdValidators,
Mock.Of <ILookupNormalizer>(),
Mock.Of <IdentityErrorDescriber>(),
Mock.Of <IServiceProvider>(),
Mock.Of <ILogger <UserManager <ApplicationUser> > >(),
roleManagerMock.Object,
platformMemoryCache ?? Mock.Of <IPlatformMemoryCache>(),
eventPublisher,
repositoryFactory,
passwordOptionsMock.Object);
validator.Setup(x => x.ValidateAsync(userManager, It.IsAny <ApplicationUser>()))
.ReturnsAsync(IdentityResult.Success).Verifiable();
return(userManager);
}
