You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
297 lines
13 KiB
297 lines
13 KiB
using BaseService.BaseData;
|
|
using BaseService.Systems.UserManagement.Dto;
|
|
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Identity;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Microsoft.Extensions.Configuration;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Runtime.InteropServices;
|
|
using System.Threading.Tasks;
|
|
using Volo.Abp.Application.Dtos;
|
|
using Volo.Abp.Application.Services;
|
|
using Volo.Abp.Authorization.Permissions;
|
|
using Volo.Abp.Domain.Repositories;
|
|
using Volo.Abp.Identity;
|
|
using Volo.Abp.ObjectExtending;
|
|
using Volo.Abp.PermissionManagement;
|
|
using Volo.Abp.Users;
|
|
|
|
namespace BaseService.Systems.UserManagement
|
|
{
|
|
[Authorize(IdentityPermissions.Users.Default)]
|
|
public class UserAppService : ApplicationService, IUserAppService
|
|
{
|
|
protected IdentityUserManager UserManager { get; }
|
|
protected IIdentityUserRepository UserRepository { get; }
|
|
|
|
/// <summary>
|
|
/// 权限列表
|
|
/// </summary>
|
|
protected IPermissionGrantRepository PermissionGrantRepository { get; }
|
|
public IIdentityRoleRepository RoleRepository { get; }
|
|
private readonly IRepository<Organization, Guid> _orgRepository;
|
|
private readonly IRepository<UserJob> _userJobsRepository;
|
|
private readonly IRepository<UserOrganization> _userOrgsRepository;
|
|
private readonly IConfiguration _config;
|
|
|
|
public UserAppService(
|
|
IdentityUserManager userManager,
|
|
IIdentityUserRepository userRepository,
|
|
IIdentityRoleRepository roleRepository,
|
|
IRepository<Organization, Guid> orgRepository,
|
|
IRepository<UserJob> userJobsRepository,
|
|
IConfiguration config,
|
|
IRepository<UserOrganization> userOrgsRepository
|
|
)
|
|
{
|
|
UserManager = userManager;
|
|
UserRepository = userRepository;
|
|
RoleRepository = roleRepository;
|
|
_orgRepository = orgRepository;
|
|
_userJobsRepository = userJobsRepository;
|
|
_userOrgsRepository = userOrgsRepository;
|
|
_config = config;
|
|
}
|
|
|
|
#region 新增方法
|
|
/// <summary>
|
|
/// 获取当前登录用户信息
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
[AllowAnonymous]
|
|
public async Task<IdentityUserDto> GetCurrentUserAsync()
|
|
{
|
|
var id = CurrentUser.GetId();
|
|
var currentUser = await UserManager.GetByIdAsync(id);
|
|
var dto = ObjectMapper.Map<IdentityUser, IdentityUserDto>(currentUser);
|
|
|
|
return dto;
|
|
}
|
|
/// <summary>
|
|
/// 重置密码功能
|
|
/// </summary>
|
|
/// <param name="userId"></param>
|
|
/// <returns></returns>
|
|
// [Authorize(IdentityPermissions.Users.Update)]
|
|
public async Task<IdentityUserDto> ResetPasswordAsync(Guid userId)
|
|
{
|
|
var user = await UserManager.FindByIdAsync(userId.ToString());
|
|
string repastword = _config["RePassword"];
|
|
//string token = await UserManager.GeneratePasswordResetTokenAsync(user);//err:No IUserTwoFactorTokenProvider<TUser> named 'Default' is registered.
|
|
//await UserManager.ResetPasswordAsync(user, token, "1q2w3E*");
|
|
await UserManager.RemovePasswordAsync(user);
|
|
if (user.PasswordHash == null)
|
|
{
|
|
(await UserManager.AddPasswordAsync(user, repastword)).CheckErrors();
|
|
}
|
|
var dto = ObjectMapper.Map<IdentityUser, IdentityUserDto>(user);
|
|
|
|
return dto;
|
|
}
|
|
/// <summary>
|
|
/// 根据用户ID，获取当前登录用户的所有权限信息，带角色名称
|
|
/// </summary>
|
|
/// <param name="userId"></param>
|
|
/// <returns></returns>
|
|
protected virtual async Task<List<PermissionGrant>> GetUserGrantedPermissionsAsync(Guid userId)
|
|
{
|
|
var listPermiss = new List<PermissionGrant>();
|
|
var listRolesName = await UserRepository.GetRoleNamesAsync(userId);
|
|
if (listRolesName != null)
|
|
{
|
|
foreach (var rolename in listRolesName)
|
|
{
|
|
var permissionGrantsInRole = await PermissionGrantRepository.GetListAsync(RolePermissionValueProvider.ProviderName, rolename);
|
|
if (permissionGrantsInRole != null)
|
|
{
|
|
foreach (var permiss in permissionGrantsInRole)
|
|
{
|
|
listPermiss.Add(permiss);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return listPermiss;
|
|
}
|
|
|
|
#endregion
|
|
|
|
public async Task<BaseIdentityUserDto> Get(Guid id)
|
|
{
|
|
var dto = ObjectMapper.Map<IdentityUser, BaseIdentityUserDto>(await UserManager.GetByIdAsync(id));
|
|
var jobIds = await (await _userJobsRepository.GetQueryableAsync()).Where(_ => _.UserId == id).Select(_ => _.JobId).ToListAsync();
|
|
var orgIds = await (await _userOrgsRepository.GetQueryableAsync()).Where(_ => _.UserId == id).Select(_ => _.OrganizationId).ToListAsync();
|
|
dto.JobIds = jobIds;
|
|
dto.OrganizationIds = orgIds;
|
|
dto.RoleNames = await UserRepository.GetRoleNamesAsync(id);
|
|
|
|
return dto;
|
|
}
|
|
|
|
[Authorize(IdentityPermissions.Users.Create)]
|
|
public async Task<IdentityUserDto> Create(BaseIdentityUserCreateDto input)
|
|
{
|
|
var user = new IdentityUser(
|
|
GuidGenerator.Create(),
|
|
input.UserName,
|
|
input.Email,
|
|
CurrentTenant.Id
|
|
);
|
|
|
|
input.MapExtraPropertiesTo(user);
|
|
|
|
(await UserManager.CreateAsync(user, input.Password)).CheckErrors();
|
|
await UpdateUserByInput(user, input);
|
|
|
|
var dto = ObjectMapper.Map<IdentityUser, IdentityUserDto>(user);
|
|
|
|
if (input.JobIds != null && input.JobIds.Count > 0)
|
|
{
|
|
foreach (var id in input.JobIds)
|
|
{
|
|
await _userJobsRepository.InsertAsync(new UserJob(CurrentTenant.Id, user.Id, id));
|
|
}
|
|
}
|
|
|
|
if(input.OrganizationIds!=null&& input.OrganizationIds.Count>0)
|
|
{
|
|
foreach (var id in input.OrganizationIds)
|
|
{
|
|
await _userOrgsRepository.InsertAsync(new UserOrganization(CurrentTenant.Id, user.Id, id));
|
|
}
|
|
}
|
|
|
|
await CurrentUnitOfWork.SaveChangesAsync();
|
|
|
|
return dto;
|
|
}
|
|
|
|
[Authorize(IdentityPermissions.Users.Update)]
|
|
public async Task<IdentityUserDto> UpdateAsync(Guid id, BaseIdentityUserUpdateDto input)
|
|
{
|
|
var user = await UserManager.GetByIdAsync(id);
|
|
user.ConcurrencyStamp = input.ConcurrencyStamp;
|
|
|
|
(await UserManager.SetUserNameAsync(user, input.UserName)).CheckErrors();
|
|
|
|
await UpdateUserByInput(user, input);
|
|
input.MapExtraPropertiesTo(user);
|
|
|
|
(await UserManager.UpdateAsync(user)).CheckErrors();
|
|
|
|
if (!input.Password.IsNullOrEmpty())
|
|
{
|
|
(await UserManager.RemovePasswordAsync(user)).CheckErrors();
|
|
(await UserManager.AddPasswordAsync(user, input.Password)).CheckErrors();
|
|
}
|
|
|
|
var dto = ObjectMapper.Map<IdentityUser, IdentityUserDto>(user);
|
|
|
|
await _userJobsRepository.DeleteAsync(_ => _.UserId == id);
|
|
if (input.JobIds != null && input.JobIds.Count > 0)
|
|
{
|
|
foreach (var jid in input.JobIds)
|
|
{
|
|
await _userJobsRepository.InsertAsync(new UserJob(CurrentTenant.Id, id, jid));
|
|
}
|
|
}
|
|
|
|
|
|
await _userOrgsRepository.DeleteAsync(_ => _.UserId == id);
|
|
if (input.OrganizationIds != null && input.OrganizationIds.Count > 0)
|
|
{
|
|
foreach (var oid in input.OrganizationIds)
|
|
{
|
|
await _userOrgsRepository.InsertAsync(new UserOrganization(CurrentTenant.Id, id, oid));
|
|
}
|
|
}
|
|
|
|
await CurrentUnitOfWork.SaveChangesAsync();
|
|
|
|
return dto;
|
|
}
|
|
|
|
public async Task<PagedResultDto<BaseIdentityUserDto>> GetAll(GetBaseIdentityUsersInput input)
|
|
{
|
|
var orgQueryable = await _orgRepository.GetQueryableAsync();
|
|
var userOrgQueryable = await _userOrgsRepository.GetQueryableAsync();
|
|
if (input.OrganizationId.HasValue)
|
|
{
|
|
var userDbSet = await UserRepository.GetDbSetAsync();
|
|
var org = await _orgRepository.GetAsync(input.OrganizationId.Value);
|
|
var orgs = await (await _orgRepository.GetQueryableAsync()).Where(_ => _.CascadeId.Contains(org.CascadeId)).ToListAsync();
|
|
|
|
var totalCount = await userOrgQueryable.Where(_ => orgs.Select(o => o.Id).Contains(_.OrganizationId))
|
|
.GroupBy(_ => _.UserId)
|
|
.LongCountAsync();
|
|
|
|
//TODO: Redis Query
|
|
var userIds = await userOrgQueryable.Where(_ => orgs.Select(o => o.Id).Contains(_.OrganizationId))
|
|
.Select(_ => _.UserId)
|
|
.Distinct()
|
|
.Skip(input.SkipCount)
|
|
.Take(input.MaxResultCount)
|
|
.ToListAsync();
|
|
|
|
var items = await userDbSet.WhereIf(!string.IsNullOrWhiteSpace(input.Filter), _ => _.UserName.Contains(input.Filter))
|
|
.Where(_ => userIds.Contains(_.Id)).ToListAsync();
|
|
var userOrgs = await userOrgQueryable.Where(_ => items.Select(i => i.Id).Contains(_.UserId))
|
|
.ToListAsync();
|
|
var allOrg = await orgQueryable.Where(_ => userOrgs.Select(uo => uo.OrganizationId).Contains(_.Id))
|
|
.OrderBy(_ => _.CascadeId)
|
|
.ToListAsync();
|
|
var dtos = ObjectMapper.Map<List<IdentityUser>, List<BaseIdentityUserDto>>(items);
|
|
|
|
foreach (var dto in dtos)
|
|
{
|
|
var oids = userOrgs.Where(_ => _.UserId == dto.Id).Select(_ => _.OrganizationId);
|
|
dto.OrganizationNames = string.Join(", ", allOrg.Where(_ => oids.Contains(_.Id)).Select(_ => _.Name).ToArray());
|
|
}
|
|
return new PagedResultDto<BaseIdentityUserDto>(totalCount, dtos);
|
|
}
|
|
else
|
|
{
|
|
var totalCount = await UserRepository.GetCountAsync(input.Filter);
|
|
var items = await UserRepository.GetListAsync(input.Sorting, input.MaxResultCount, input.SkipCount, input.Filter);
|
|
//TODO: Redis Query
|
|
var userOrgs = await userOrgQueryable.Where(_ => items.Select(i => i.Id).Contains(_.UserId))
|
|
.ToListAsync();
|
|
var orgs = await orgQueryable.Where(_ => userOrgs.Select(uo => uo.OrganizationId).Contains(_.Id))
|
|
.OrderBy(_ => _.CascadeId)
|
|
.ToListAsync();
|
|
var dtos = ObjectMapper.Map<List<IdentityUser>, List<BaseIdentityUserDto>>(items);
|
|
foreach (var dto in dtos)
|
|
{
|
|
var oids = userOrgs.Where(_ => _.UserId == dto.Id).Select(_ => _.OrganizationId);
|
|
dto.OrganizationNames = string.Join(", ", orgs.Where(_ => oids.Contains(_.Id)).Select(_ => _.Name).ToArray());
|
|
}
|
|
return new PagedResultDto<BaseIdentityUserDto>(totalCount, dtos);
|
|
}
|
|
}
|
|
|
|
protected virtual async Task UpdateUserByInput(IdentityUser user, IdentityUserCreateOrUpdateDtoBase input)
|
|
{
|
|
if (!string.Equals(user.Email, input.Email, StringComparison.InvariantCultureIgnoreCase))
|
|
{
|
|
(await UserManager.SetEmailAsync(user, input.Email)).CheckErrors();
|
|
}
|
|
|
|
if (!string.Equals(user.PhoneNumber, input.PhoneNumber, StringComparison.InvariantCultureIgnoreCase))
|
|
{
|
|
(await UserManager.SetPhoneNumberAsync(user, input.PhoneNumber)).CheckErrors();
|
|
}
|
|
|
|
(await UserManager.SetLockoutEnabledAsync(user, input.LockoutEnabled)).CheckErrors();
|
|
|
|
user.Name = input.Name;
|
|
user.Surname = input.Surname;
|
|
|
|
if (input.RoleNames != null)
|
|
{
|
|
(await UserManager.SetRolesAsync(user, input.RoleNames)).CheckErrors();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|