tsai
/
abp
mirror of https://github.com/abpframework/abp.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Fixed space and tab issue

pull/14580/head
malik masis 4 years ago
parent
3dd7ba9537
commit
070dc79480
2 changed files with 237 additions and 237 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 468
      modules/identity/src/Volo.Abp.Identity.Domain/Volo/Abp/Identity/IdentityUserManager.cs
  2. 6
      modules/users/src/Volo.Abp.Users.Abstractions/Volo/Abp/Users/UserPasswordChangeRequestedEto.cs

468
modules/identity/src/Volo.Abp.Identity.Domain/Volo/Abp/Identity/IdentityUserManager.cs
View File

@ -19,238 +19,238 @@ namespace Volo.Abp.Identity;
public class IdentityUserManager : UserManager<IdentityUser>, IDomainService public class IdentityUserManager : UserManager<IdentityUser>, IDomainService
{ {
protected IIdentityRoleRepository RoleRepository { get; } protected IIdentityRoleRepository RoleRepository { get; }
protected IIdentityUserRepository UserRepository { get; } protected IIdentityUserRepository UserRepository { get; }
protected IOrganizationUnitRepository OrganizationUnitRepository { get; } protected IOrganizationUnitRepository OrganizationUnitRepository { get; }
protected ISettingProvider SettingProvider { get; } protected ISettingProvider SettingProvider { get; }
protected ICancellationTokenProvider CancellationTokenProvider { get; } protected ICancellationTokenProvider CancellationTokenProvider { get; }
protected override CancellationToken CancellationToken => CancellationTokenProvider.Token; protected override CancellationToken CancellationToken => CancellationTokenProvider.Token;
public IdentityUserManager( public IdentityUserManager(
IdentityUserStore store, IdentityUserStore store,
IIdentityRoleRepository roleRepository, IIdentityRoleRepository roleRepository,
IIdentityUserRepository userRepository, IIdentityUserRepository userRepository,
IOptions<IdentityOptions> optionsAccessor, IOptions<IdentityOptions> optionsAccessor,
IPasswordHasher<IdentityUser> passwordHasher, IPasswordHasher<IdentityUser> passwordHasher,
IEnumerable<IUserValidator<IdentityUser>> userValidators, IEnumerable<IUserValidator<IdentityUser>> userValidators,
IEnumerable<IPasswordValidator<IdentityUser>> passwordValidators, IEnumerable<IPasswordValidator<IdentityUser>> passwordValidators,
ILookupNormalizer keyNormalizer, ILookupNormalizer keyNormalizer,
IdentityErrorDescriber errors, IdentityErrorDescriber errors,
IServiceProvider services, IServiceProvider services,
ILogger<IdentityUserManager> logger, ILogger<IdentityUserManager> logger,
ICancellationTokenProvider cancellationTokenProvider, ICancellationTokenProvider cancellationTokenProvider,
IOrganizationUnitRepository organizationUnitRepository, IOrganizationUnitRepository organizationUnitRepository,
ISettingProvider settingProvider) ISettingProvider settingProvider)
: base( : base(
store, store,
optionsAccessor, optionsAccessor,
passwordHasher, passwordHasher,
userValidators, userValidators,
passwordValidators, passwordValidators,
keyNormalizer, keyNormalizer,
errors, errors,
services, services,
logger) logger)
{ {
OrganizationUnitRepository = organizationUnitRepository; OrganizationUnitRepository = organizationUnitRepository;
SettingProvider = settingProvider; SettingProvider = settingProvider;
RoleRepository = roleRepository; RoleRepository = roleRepository;
UserRepository = userRepository; UserRepository = userRepository;
CancellationTokenProvider = cancellationTokenProvider; CancellationTokenProvider = cancellationTokenProvider;
} }
public virtual async Task<IdentityResult> CreateAsync(IdentityUser user, string password, bool validatePassword) public virtual async Task<IdentityResult> CreateAsync(IdentityUser user, string password, bool validatePassword)
{ {
var result = await UpdatePasswordHash(user, password, validatePassword); var result = await UpdatePasswordHash(user, password, validatePassword);
if (!result.Succeeded) if (!result.Succeeded)
{ {
return result; return result;
} }
return await CreateAsync(user); return await CreateAsync(user);
} }
public virtual async Task<IdentityUser> GetByIdAsync(Guid id) public virtual async Task<IdentityUser> GetByIdAsync(Guid id)
{ {
var user = await Store.FindByIdAsync(id.ToString(), CancellationToken); var user = await Store.FindByIdAsync(id.ToString(), CancellationToken);
if (user == null) if (user == null)
{ {
throw new EntityNotFoundException(typeof(IdentityUser), id); throw new EntityNotFoundException(typeof(IdentityUser), id);
} }
return user; return user;
} }
public virtual async Task<IdentityResult> SetRolesAsync([NotNull] IdentityUser user, public virtual async Task<IdentityResult> SetRolesAsync([NotNull] IdentityUser user,
[NotNull] IEnumerable<string> roleNames) [NotNull] IEnumerable<string> roleNames)
{ {
Check.NotNull(user, nameof(user)); Check.NotNull(user, nameof(user));
Check.NotNull(roleNames, nameof(roleNames)); Check.NotNull(roleNames, nameof(roleNames));
var currentRoleNames = await GetRolesAsync(user); var currentRoleNames = await GetRolesAsync(user);
var result = await RemoveFromRolesAsync(user, currentRoleNames.Except(roleNames).Distinct()); var result = await RemoveFromRolesAsync(user, currentRoleNames.Except(roleNames).Distinct());
if (!result.Succeeded) if (!result.Succeeded)
{ {
return result; return result;
} }
result = await AddToRolesAsync(user, roleNames.Except(currentRoleNames).Distinct()); result = await AddToRolesAsync(user, roleNames.Except(currentRoleNames).Distinct());
if (!result.Succeeded) if (!result.Succeeded)
{ {
return result; return result;
} }
return IdentityResult.Success; return IdentityResult.Success;
} }
public virtual async Task<bool> IsInOrganizationUnitAsync(Guid userId, Guid ouId) public virtual async Task<bool> IsInOrganizationUnitAsync(Guid userId, Guid ouId)
{ {
var user = await UserRepository.GetAsync(userId, cancellationToken: CancellationToken); var user = await UserRepository.GetAsync(userId, cancellationToken: CancellationToken);
return user.IsInOrganizationUnit(ouId); return user.IsInOrganizationUnit(ouId);
} }
public virtual async Task<bool> IsInOrganizationUnitAsync(IdentityUser user, OrganizationUnit ou) public virtual async Task<bool> IsInOrganizationUnitAsync(IdentityUser user, OrganizationUnit ou)
{ {
await UserRepository.EnsureCollectionLoadedAsync(user, u => u.OrganizationUnits, await UserRepository.EnsureCollectionLoadedAsync(user, u => u.OrganizationUnits,
CancellationTokenProvider.Token); CancellationTokenProvider.Token);
return user.IsInOrganizationUnit(ou.Id); return user.IsInOrganizationUnit(ou.Id);
} }
public virtual async Task AddToOrganizationUnitAsync(Guid userId, Guid ouId) public virtual async Task AddToOrganizationUnitAsync(Guid userId, Guid ouId)
{ {
await AddToOrganizationUnitAsync( await AddToOrganizationUnitAsync(
await UserRepository.GetAsync(userId, cancellationToken: CancellationToken), await UserRepository.GetAsync(userId, cancellationToken: CancellationToken),
await OrganizationUnitRepository.GetAsync(ouId, cancellationToken: CancellationToken) await OrganizationUnitRepository.GetAsync(ouId, cancellationToken: CancellationToken)
); );
} }
public virtual async Task AddToOrganizationUnitAsync(IdentityUser user, OrganizationUnit ou) public virtual async Task AddToOrganizationUnitAsync(IdentityUser user, OrganizationUnit ou)
{ {
await UserRepository.EnsureCollectionLoadedAsync(user, u => u.OrganizationUnits, await UserRepository.EnsureCollectionLoadedAsync(user, u => u.OrganizationUnits,
CancellationTokenProvider.Token); CancellationTokenProvider.Token);
if (user.OrganizationUnits.Any(cou => cou.OrganizationUnitId == ou.Id)) if (user.OrganizationUnits.Any(cou => cou.OrganizationUnitId == ou.Id))
{ {
return; return;
} }
await CheckMaxUserOrganizationUnitMembershipCountAsync(user.OrganizationUnits.Count + 1); await CheckMaxUserOrganizationUnitMembershipCountAsync(user.OrganizationUnits.Count + 1);
user.AddOrganizationUnit(ou.Id); user.AddOrganizationUnit(ou.Id);
await UserRepository.UpdateAsync(user, cancellationToken: CancellationToken); await UserRepository.UpdateAsync(user, cancellationToken: CancellationToken);
} }
public virtual async Task RemoveFromOrganizationUnitAsync(Guid userId, Guid ouId) public virtual async Task RemoveFromOrganizationUnitAsync(Guid userId, Guid ouId)
{ {
var user = await UserRepository.GetAsync(userId, cancellationToken: CancellationToken); var user = await UserRepository.GetAsync(userId, cancellationToken: CancellationToken);
user.RemoveOrganizationUnit(ouId); user.RemoveOrganizationUnit(ouId);
await UserRepository.UpdateAsync(user, cancellationToken: CancellationToken); await UserRepository.UpdateAsync(user, cancellationToken: CancellationToken);
} }
public virtual async Task RemoveFromOrganizationUnitAsync(IdentityUser user, OrganizationUnit ou) public virtual async Task RemoveFromOrganizationUnitAsync(IdentityUser user, OrganizationUnit ou)
{ {
await UserRepository.EnsureCollectionLoadedAsync(user, u => u.OrganizationUnits, await UserRepository.EnsureCollectionLoadedAsync(user, u => u.OrganizationUnits,
CancellationTokenProvider.Token); CancellationTokenProvider.Token);
user.RemoveOrganizationUnit(ou.Id); user.RemoveOrganizationUnit(ou.Id);
await UserRepository.UpdateAsync(user, cancellationToken: CancellationToken); await UserRepository.UpdateAsync(user, cancellationToken: CancellationToken);
} }
public virtual async Task SetOrganizationUnitsAsync(Guid userId, params Guid[] organizationUnitIds) public virtual async Task SetOrganizationUnitsAsync(Guid userId, params Guid[] organizationUnitIds)
{ {
await SetOrganizationUnitsAsync( await SetOrganizationUnitsAsync(
await UserRepository.GetAsync(userId, cancellationToken: CancellationToken), await UserRepository.GetAsync(userId, cancellationToken: CancellationToken),
organizationUnitIds organizationUnitIds
); );
} }
public virtual async Task SetOrganizationUnitsAsync(IdentityUser user, params Guid[] organizationUnitIds) public virtual async Task SetOrganizationUnitsAsync(IdentityUser user, params Guid[] organizationUnitIds)
{ {
Check.NotNull(user, nameof(user)); Check.NotNull(user, nameof(user));
Check.NotNull(organizationUnitIds, nameof(organizationUnitIds)); Check.NotNull(organizationUnitIds, nameof(organizationUnitIds));
await CheckMaxUserOrganizationUnitMembershipCountAsync(organizationUnitIds.Length); await CheckMaxUserOrganizationUnitMembershipCountAsync(organizationUnitIds.Length);
await UserRepository.EnsureCollectionLoadedAsync(user, u => u.OrganizationUnits, await UserRepository.EnsureCollectionLoadedAsync(user, u => u.OrganizationUnits,
CancellationTokenProvider.Token); CancellationTokenProvider.Token);
//Remove from removed OUs //Remove from removed OUs
foreach (var ouId in user.OrganizationUnits.Select(uou => uou.OrganizationUnitId).ToArray()) foreach (var ouId in user.OrganizationUnits.Select(uou => uou.OrganizationUnitId).ToArray())
{ {
if (!organizationUnitIds.Contains(ouId)) if (!organizationUnitIds.Contains(ouId))
{ {
user.RemoveOrganizationUnit(ouId); user.RemoveOrganizationUnit(ouId);
} }
} }
//Add to added OUs //Add to added OUs
foreach (var organizationUnitId in organizationUnitIds) foreach (var organizationUnitId in organizationUnitIds)
{ {
if (!user.IsInOrganizationUnit(organizationUnitId)) if (!user.IsInOrganizationUnit(organizationUnitId))
{ {
user.AddOrganizationUnit(organizationUnitId); user.AddOrganizationUnit(organizationUnitId);
} }
} }
await UserRepository.UpdateAsync(user, cancellationToken: CancellationToken); await UserRepository.UpdateAsync(user, cancellationToken: CancellationToken);
} }
private async Task CheckMaxUserOrganizationUnitMembershipCountAsync(int requestedCount) private async Task CheckMaxUserOrganizationUnitMembershipCountAsync(int requestedCount)
{ {
var maxCount = var maxCount =
await SettingProvider.GetAsync<int>(IdentitySettingNames.OrganizationUnit.MaxUserMembershipCount); await SettingProvider.GetAsync<int>(IdentitySettingNames.OrganizationUnit.MaxUserMembershipCount);
if (requestedCount > maxCount) if (requestedCount > maxCount)
{ {
throw new BusinessException(IdentityErrorCodes.MaxAllowedOuMembership) throw new BusinessException(IdentityErrorCodes.MaxAllowedOuMembership)
.WithData("MaxUserMembershipCount", maxCount); .WithData("MaxUserMembershipCount", maxCount);
} }
} }
[UnitOfWork] [UnitOfWork]
public virtual async Task<List<OrganizationUnit>> GetOrganizationUnitsAsync(IdentityUser user, public virtual async Task<List<OrganizationUnit>> GetOrganizationUnitsAsync(IdentityUser user,
bool includeDetails = false) bool includeDetails = false)
{ {
await UserRepository.EnsureCollectionLoadedAsync(user, u => u.OrganizationUnits, await UserRepository.EnsureCollectionLoadedAsync(user, u => u.OrganizationUnits,
CancellationTokenProvider.Token); CancellationTokenProvider.Token);
return await OrganizationUnitRepository.GetListAsync( return await OrganizationUnitRepository.GetListAsync(
user.OrganizationUnits.Select(t => t.OrganizationUnitId), user.OrganizationUnits.Select(t => t.OrganizationUnitId),
includeDetails, includeDetails,
cancellationToken: CancellationToken cancellationToken: CancellationToken
); );
} }
[UnitOfWork] [UnitOfWork]
public virtual async Task<List<IdentityUser>> GetUsersInOrganizationUnitAsync( public virtual async Task<List<IdentityUser>> GetUsersInOrganizationUnitAsync(
OrganizationUnit organizationUnit, OrganizationUnit organizationUnit,
bool includeChildren = false) bool includeChildren = false)
{ {
if (includeChildren) if (includeChildren)
{ {
return await UserRepository return await UserRepository
.GetUsersInOrganizationUnitWithChildrenAsync(organizationUnit.Code, CancellationToken); .GetUsersInOrganizationUnitWithChildrenAsync(organizationUnit.Code, CancellationToken);
} }
else else
{ {
return await UserRepository return await UserRepository
.GetUsersInOrganizationUnitAsync(organizationUnit.Id, CancellationToken); .GetUsersInOrganizationUnitAsync(organizationUnit.Id, CancellationToken);
} }
} }
public virtual async Task<IdentityResult> AddDefaultRolesAsync([NotNull] IdentityUser user) public virtual async Task<IdentityResult> AddDefaultRolesAsync([NotNull] IdentityUser user)
{ {
await UserRepository.EnsureCollectionLoadedAsync(user, u => u.Roles, CancellationToken); await UserRepository.EnsureCollectionLoadedAsync(user, u => u.Roles, CancellationToken);
foreach (var role in await RoleRepository.GetDefaultOnesAsync(cancellationToken: CancellationToken)) foreach (var role in await RoleRepository.GetDefaultOnesAsync(cancellationToken: CancellationToken))
{ {
if (!user.IsInRole(role.Id)) if (!user.IsInRole(role.Id))
{ {
user.AddRole(role.Id); user.AddRole(role.Id);
} }
} }
return await UpdateUserAsync(user); return await UpdateUserAsync(user);
} }
} }

6
modules/users/src/Volo.Abp.Users.Abstractions/Volo/Abp/Users/UserPasswordChangeRequestedEto.cs
View File

@ -8,9 +8,9 @@ namespace Volo.Abp.Users;
[EventName("Volo.Abp.Users.UserPasswordChangeRequested")] [EventName("Volo.Abp.Users.UserPasswordChangeRequested")]
public class UserPasswordChangeRequestedEto : IMultiTenant public class UserPasswordChangeRequestedEto : IMultiTenant
{ {
public Guid? TenantId { get; set; } public Guid? TenantId { get; set; }
public string UserName { get; set; } public string UserName { get; set; }
public string Password { get; set; } public string Password { get; set; }
} }

Write Preview
Loading…
Cancel
Save