public virtual bool IsTokenValidityKeyValid(
TUser user,
string tokenValidityKey,
CancellationToken cancellationToken = default(CancellationToken))
{
return(AbpUserStore.IsTokenValidityKeyValid(user, tokenValidityKey, cancellationToken));
}
// Microsoft.AspNetCore.Identity.UserManager doesn't have required sync version for method calls in this function
//public override IdentityResult Delete(TUser user)
//{
// if (user.UserName == AbpUserBase.AdminUserName)
// {
// throw new UserFriendlyException(string.Format(L("CanNotDeleteAdminUser"), AbpUserBase.AdminUserName));
// }
// return base.Delete(user);
//}
public virtual async Task <IdentityResult> ChangePasswordAsync(TUser user, string newPassword)
{
var errors = new List <IdentityError>();
foreach (var validator in PasswordValidators)
{
var validationResult = await validator.ValidateAsync(this, user, newPassword);
if (!validationResult.Succeeded)
{
errors.AddRange(validationResult.Errors);
}
}
if (errors.Any())
{
return(IdentityResult.Failed(errors.ToArray()));
}
await AbpUserStore.SetPasswordHashAsync(user, PasswordHasher.HashPassword(user, newPassword));
await UpdateSecurityStampAsync(user);
return(IdentityResult.Success);
}
public virtual void RemoveTokenValidityKey(
TUser user,
string tokenValidityKey,
CancellationToken cancellationToken = default(CancellationToken))
{
AbpUserStore.RemoveTokenValidityKey(user, tokenValidityKey, cancellationToken);
}
private UserPermissionCacheItem GetUserPermissionCacheItem(long userId)
{
var cacheKey = userId + "@" + (GetCurrentTenantId() ?? 0);
return(_cacheManager.GetUserPermissionCache().Get(cacheKey, () =>
{
var user = AbpUserStore.FindById(userId.ToString());
if (user == null)
{
return null;
}
var newCacheItem = new UserPermissionCacheItem(userId);
foreach (var roleName in AbpUserStore.GetRoles(user))
{
newCacheItem.RoleIds.Add((RoleManager.GetRoleByName(roleName)).Id);
}
foreach (var permissionInfo in UserPermissionStore.GetPermissions(userId))
{
if (permissionInfo.IsGranted)
{
newCacheItem.GrantedPermissions.Add(permissionInfo.Name);
}
else
{
newCacheItem.ProhibitedPermissions.Add(permissionInfo.Name);
}
}
return newCacheItem;
}));
}
public virtual async Task <bool> IsTokenValidityKeyValidAsync(
TUser user,
string tokenValidityKey,
CancellationToken cancellationToken = default(CancellationToken))
{
return(await AbpUserStore.IsTokenValidityKeyValidAsync(user, tokenValidityKey, cancellationToken));
}
public virtual async Task RemoveTokenValidityKeyAsync(
TUser user,
string tokenValidityKey,
CancellationToken cancellationToken = default(CancellationToken))
{
await AbpUserStore.RemoveTokenValidityKeyAsync(user, tokenValidityKey, cancellationToken);
}
protected AbpUserManager(
AbpUserStore <TRole, TUser> userStore,
AbpRoleManager <TRole, TUser> roleManager,
IRepository <TTenant> tenantRepository,
IMultiTenancyConfig multiTenancyConfig,
IPermissionManager permissionManager,
IUnitOfWorkManager unitOfWorkManager,
ISettingManager settingManager,
IUserManagementConfig userManagementConfig,
IIocResolver iocResolver,
ICacheManager cacheManager,
IRepository <OrganizationUnit, long> organizationUnitRepository,
IRepository <UserOrganizationUnit, long> userOrganizationUnitRepository,
IOrganizationUnitSettings organizationUnitSettings,
IRepository <UserLoginAttempt, long> userLoginAttemptRepository)
: base(userStore)
{
AbpStore = userStore;
RoleManager = roleManager;
SettingManager = settingManager;
_tenantRepository = tenantRepository;
_multiTenancyConfig = multiTenancyConfig;
_permissionManager = permissionManager;
_unitOfWorkManager = unitOfWorkManager;
_userManagementConfig = userManagementConfig;
_iocResolver = iocResolver;
_cacheManager = cacheManager;
_organizationUnitRepository = organizationUnitRepository;
_userOrganizationUnitRepository = userOrganizationUnitRepository;
_organizationUnitSettings = organizationUnitSettings;
_userLoginAttemptRepository = userLoginAttemptRepository;
LocalizationManager = NullLocalizationManager.Instance;
AbpSession = NullAbpSession.Instance;
}
public async Task <UserPermissionCacheItem> GetUserPermissionCacheItemAsync(long userId, long?branchId)
{
var cacheKey = userId + "@" + (GetCurrentTenantId() ?? 0) + "@" + (branchId ?? 0);
return(await _cacheManager.GetUserPermissionCache().GetAsync(cacheKey, async() =>
{
var user = await FindByIdAsync(userId.ToString());
if (user == null)
{
return null;
}
var newCacheItem = new UserPermissionCacheItem(userId, branchId);
foreach (var roleName in await AbpUserStore.GetRolesAsync(user, branchId))
{
newCacheItem.RoleIds.Add((await RoleManager.GetRoleByNameAsync(roleName)).Id);
}
foreach (var permissionInfo in await UserPermissionStore.GetPermissionsAsync(userId, branchId))
{
if (permissionInfo.IsGranted)
{
newCacheItem.GrantedPermissions.Add(permissionInfo.Name);
}
else
{
newCacheItem.ProhibitedPermissions.Add(permissionInfo.Name);
}
}
return newCacheItem;
}));
}
protected AbpUserManager(
AbpUserStore <TTenant, TRole, TUser> userStore,
AbpRoleManager <TTenant, TRole, TUser> roleManager,
IRepository <TTenant> tenantRepository,
IMultiTenancyConfig multiTenancyConfig,
IPermissionManager permissionManager,
IUnitOfWorkManager unitOfWorkManager,
ISettingManager settingManager,
IUserManagementConfig userManagementConfig,
IIocResolver iocResolver,
ICacheManager cacheManager)
: base(userStore)
{
AbpStore = userStore;
RoleManager = roleManager;
SettingManager = settingManager;
_tenantRepository = tenantRepository;
_multiTenancyConfig = multiTenancyConfig;
_permissionManager = permissionManager;
_unitOfWorkManager = unitOfWorkManager;
_userManagementConfig = userManagementConfig;
_iocResolver = iocResolver;
_cacheManager = cacheManager;
LocalizationManager = NullLocalizationManager.Instance;
}
public virtual void AddTokenValidityKey(
TUser user,
string tokenValidityKey,
DateTime expireDate,
CancellationToken cancellationToken = default(CancellationToken))
{
AbpUserStore.AddTokenValidityKey(user, tokenValidityKey, expireDate, cancellationToken);
}
public virtual async Task AddTokenValidityKeyAsync(
TUser user,
string tokenValidityKey,
DateTime expireDate,
CancellationToken cancellationToken = default(CancellationToken))
{
await AbpUserStore.AddTokenValidityKeyAsync(user, tokenValidityKey, expireDate, cancellationToken);
}
/// <summary>
/// Gets a user by given id.
/// Throws exception if no user found with given id.
/// </summary>
/// <param name="userId">User id</param>
/// <returns>User</returns>
/// <exception cref="AbpException">Throws exception if no user found with given id</exception>
public virtual TUser GetUserById(long userId)
{
var user = AbpUserStore.FindById(userId.ToString());
if (user == null)
{
throw new AbpException("There is no user with id: " + userId);
}
return(user);
}
public bool IsLockedOut(string userId)
{
var user = AbpUserStore.FindById(userId);
if (user == null)
{
throw new AbpException("There is no user with id: " + userId);
}
var lockoutEndDateUtc = AbpUserStore.GetLockoutEndDate(user);
return(lockoutEndDateUtc > DateTimeOffset.UtcNow);
}
public AbpUserManager(
AbpRoleManager <TRole, TUser> roleManager,
AbpUserStore <TRole, TUser> userStore,
IOptions <IdentityOptions> optionsAccessor,
IPasswordHasher <TUser> passwordHasher,
IEnumerable <IUserValidator <TUser> > userValidators,
IEnumerable <IPasswordValidator <TUser> > passwordValidators,
ILookupNormalizer keyNormalizer,
IdentityErrorDescriber errors,
IServiceProvider services,
ILogger <UserManager <TUser> > logger,
IPermissionManager permissionManager,
IUnitOfWorkManager unitOfWorkManager,
ICacheManager cacheManager,
IRepository <OrganizationUnit, long> organizationUnitRepository,
IRepository <UserOrganizationUnit, long> userOrganizationUnitRepository,
IOrganizationUnitSettings organizationUnitSettings,
ISettingManager settingManager,
IRepository <UserLogin, long> userLoginRepository)
: base(
userStore,
optionsAccessor,
passwordHasher,
userValidators,
passwordValidators,
keyNormalizer,
errors,
services,
logger)
{
_permissionManager = permissionManager;
_unitOfWorkManager = unitOfWorkManager;
_cacheManager = cacheManager;
_organizationUnitRepository = organizationUnitRepository;
_userOrganizationUnitRepository = userOrganizationUnitRepository;
_organizationUnitSettings = organizationUnitSettings;
_settingManager = settingManager;
_userLoginRepository = userLoginRepository;
_optionsAccessor = optionsAccessor;
AbpUserStore = userStore;
RoleManager = roleManager;
LocalizationManager = NullLocalizationManager.Instance;
LocalizationSourceName = AbpZeroConsts.LocalizationSourceName;
}
protected AbpUserManager(
AbpRoleManager <TRole, TUser> roleManager,
AbpUserStore <TRole, TUser> store,
IOptions <IdentityOptions> optionsAccessor,
IPasswordHasher <TUser> passwordHasher,
IEnumerable <IUserValidator <TUser> > userValidators,
IEnumerable <IPasswordValidator <TUser> > passwordValidators,
ILookupNormalizer keyNormalizer,
IdentityErrorDescriber errors,
IServiceProvider services,
ILogger <UserManager <TUser> > logger,
IPermissionManager permissionManager,
IUnitOfWorkManager unitOfWorkManager,
ICacheManager cacheManager,
IRepository <OrganizationUnit, long> organizationUnitRepository,
IRepository <UserOrganizationUnit, long> userOrganizationUnitRepository,
IOrganizationUnitSettings organizationUnitSettings,
ISettingManager settingManager)
: base(
store,
optionsAccessor,
passwordHasher,
userValidators,
passwordValidators,
keyNormalizer,
errors,
services,
logger)
{
_permissionManager = permissionManager;
_unitOfWorkManager = unitOfWorkManager;
_cacheManager = cacheManager;
_organizationUnitRepository = organizationUnitRepository;
_userOrganizationUnitRepository = userOrganizationUnitRepository;
_organizationUnitSettings = organizationUnitSettings;
_settingManager = settingManager;
AbpStore = store;
RoleManager = roleManager;
}
protected AbpUserManager(
AbpUserStore <TRole, TUser> userStore,
AbpRoleManager <TRole, TUser> roleManager,
IPermissionManager permissionManager,
IUnitOfWorkManager unitOfWorkManager,
ICacheManager cacheManager,
IRepository <OrganizationUnit, long> organizationUnitRepository,
IRepository <UserOrganizationUnit, long> userOrganizationUnitRepository,
IOrganizationUnitSettings organizationUnitSettings,
ILocalizationManager localizationManager,
IdentityEmailMessageService emailService,
ISettingManager settingManager,
IUserTokenProviderAccessor userTokenProviderAccessor,
IRepository <UserLogin, long> userLoginRepository)
: base(userStore)
{
AbpStore = userStore;
RoleManager = roleManager;
LocalizationManager = localizationManager;
LocalizationSourceName = AbpZeroConsts.LocalizationSourceName;
_settingManager = settingManager;
_userLoginRepository = userLoginRepository;
_permissionManager = permissionManager;
_unitOfWorkManager = unitOfWorkManager;
_cacheManager = cacheManager;
_organizationUnitRepository = organizationUnitRepository;
_userOrganizationUnitRepository = userOrganizationUnitRepository;
_organizationUnitSettings = organizationUnitSettings;
AbpSession = NullAbpSession.Instance;
UserLockoutEnabledByDefault = true;
DefaultAccountLockoutTimeSpan = TimeSpan.FromMinutes(5);
MaxFailedAccessAttemptsBeforeLockout = 5;
EmailService = emailService;
UserTokenProvider = userTokenProviderAccessor.GetUserTokenProviderOrNull <TUser>();
}
// Microsoft.AspNetCore.Identity doesn't have a sync version of FindByName(...), FindByEmail(...)
//public virtual IdentityResult CheckDuplicateUsernameOrEmailAddress(long? expectedUserId, string userName, string emailAddress)
//{
// var user = (FindByName(userName));
// if (user != null && user.Id != expectedUserId)
// {
// throw new UserFriendlyException(string.Format(L("Identity.DuplicateUserName"), userName));
// }
// user = (FindByEmail(emailAddress));
// if (user != null && user.Id != expectedUserId)
// {
// throw new UserFriendlyException(string.Format(L("Identity.DuplicateEmail"), emailAddress));
// }
// return IdentityResult.Success;
//}
public virtual async Task <IdentityResult> SetRolesAsync(TUser user, string[] roleNames, long?branchId)
{
await AbpUserStore.UserRepository.EnsureCollectionLoadedAsync(user, u => u.Roles);
//Remove from removed roles
foreach (var userRole in user.Roles.Where(e => e.BranchId == branchId).ToList())
{
var role = await RoleManager.FindByIdAsync(userRole.RoleId.ToString());
if (role != null && roleNames.All(roleName => role.NormalizedName != roleName))
{
//var result = await RemoveFromRoleAsync(user, role.Name);
//if (!result.Succeeded)
//{
// return result;
//}
await AbpUserStore.RemoveFromRoleAsync(user, role.NormalizedName, branchId);
}
}
//Add to added roles
foreach (var roleName in roleNames)
{
var roleByName = await RoleManager.GetRoleByNameAsync(roleName);
if (user.Roles.Where(e => e.BranchId == branchId).All(ur => ur.RoleId != roleByName.Id))
{
//var result = await AddToRoleAsync(user, roleName);
//if (!result.Succeeded)
//{
// return result;
//}
await AbpUserStore.AddToRoleAsync(user, roleName, branchId);
}
}
return(IdentityResult.Success);
}
public virtual List <TUser> FindAll(UserLoginInfo login)
{
return(AbpUserStore.FindAll(login));
}
public virtual TUser FindByNameOrEmail(long?tenantId, string userNameOrEmailAddress)
{
return(AbpUserStore.FindByNameOrEmail(tenantId, userNameOrEmailAddress));
}
protected virtual string GetOldUserName(long userId)
{
return(AbpUserStore.GetUserNameFromDatabase(userId));
}
protected AbpUserManager(AbpUserStore <TTenant, TRole, TUser> store)
: base(store)
{
}
public virtual Task <TUser> FindByNameOrEmailAsync(int?tenantId, string userNameOrEmailAddress)
{
return(AbpUserStore.FindByNameOrEmailAsync(tenantId, userNameOrEmailAddress));
}
protected virtual Task <string> GetOldUserNameAsync(long userId)
{
return(AbpUserStore.GetUserNameFromDatabaseAsync(userId));
}
public virtual Task <List <TUser> > FindAllAsync(UserLoginInfo login)
{
return(AbpUserStore.FindAllAsync(login));
}
public virtual Task <TUser> FindAsync(int?tenantId, UserLoginInfo login)
{
return(AbpUserStore.FindAsync(tenantId, login));
}
public virtual Task <TUser> FindByNameOrEmailAsync(string userNameOrEmailAddress)
{
return(AbpUserStore.FindByNameOrEmailAsync(userNameOrEmailAddress));
}
public bool IsLockedOut(TUser user)
{
var lockoutEndDateUtc = AbpUserStore.GetLockoutEndDate(user);
return(lockoutEndDateUtc > DateTimeOffset.UtcNow);
}
public void ResetAccessFailedCount(TUser user)
{
AbpUserStore.ResetAccessFailedCount(user);
}
public virtual TUser Find(int?tenantId, UserLoginInfo login)
{
return(AbpUserStore.Find(tenantId, login));
}
public virtual TUser FindByNameOrEmail(string userNameOrEmailAddress)
{
return(AbpUserStore.FindByNameOrEmail(userNameOrEmailAddress));
}