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