/// <summary>
/// 删除模块信息
/// </summary>
/// <param name="id">要删除的模块信息编号</param>
/// <returns>业务操作结果</returns>
public virtual async Task <OperationResult> DeleteModule(TModuleKey id)
{
TModule entity = await _moduleRepository.GetAsync(id);
if (entity == null)
{
return(OperationResult.Success);
}
if (await _moduleRepository.CheckExistsAsync(m => m.ParentId.Equals(id)))
{
return(new OperationResult(OperationResultType.Error, $"模块“{entity.Name}”的子模块不为空，不能删除"));
}
//清除附属引用
await _moduleFunctionRepository.DeleteBatchAsync(m => m.ModuleId.Equals(id));
await _moduleRoleRepository.DeleteBatchAsync(m => m.ModuleId.Equals(id));
await _moduleUserRepository.DeleteBatchAsync(m => m.ModuleId.Equals(id));
OperationResult result = await _moduleRepository.DeleteAsync(entity) > 0
? new OperationResult(OperationResultType.Success, $"模块“{entity.Name}”删除成功")
: OperationResult.NoChanged;
if (result.Successed)
{
//功能权限缓存刷新事件
Guid[] functionIds = _moduleFunctionRepository.Query(m => m.Id.Equals(id)).Select(m => m.FunctionId).ToArray();
FunctionAuthCacheRefreshEventData removeEventData = new FunctionAuthCacheRefreshEventData()
{
FunctionIds = functionIds
};
_eventBus.Publish(removeEventData);
}
return(result);
}
/// <summary>
/// 更新功能信息
/// </summary>
/// <param name="dtos">包含更新信息的功能信息DTO信息</param>
/// <returns>业务操作结果</returns>
public virtual async Task <OperationResult> UpdateFunctions(params TFunctionInputDto[] dtos)
{
Check.Validate <TFunctionInputDto, Guid>(dtos, nameof(dtos));
OperationResult result = await _functionRepository.UpdateAsync(dtos,
(dto, entity) =>
{
if (dto.IsLocked && entity.Area == "Admin" && entity.Controller == "Function" &&
(entity.Action == "Update" || entity.Action == "Read"))
{
throw new HybridException($"功能信息“{entity.Name}”不能锁定");
}
if (dto.AuditEntityEnabled && !dto.AuditOperationEnabled && !entity.AuditOperationEnabled && !entity.AuditEntityEnabled)
{
dto.AuditOperationEnabled = true;
}
else if (!dto.AuditOperationEnabled && dto.AuditEntityEnabled && entity.AuditOperationEnabled && entity.AuditEntityEnabled)
{
dto.AuditEntityEnabled = false;
}
if (dto.AccessType != entity.AccessType)
{
entity.IsAccessTypeChanged = true;
}
return(Task.FromResult(0));
});
if (result.Successed)
{
//功能信息缓存刷新事件
FunctionCacheRefreshEventData clearEventData = new FunctionCacheRefreshEventData();
_eventBus.Publish(clearEventData);
//功能权限缓存刷新事件
FunctionAuthCacheRefreshEventData removeEventData = new FunctionAuthCacheRefreshEventData()
{
FunctionIds = dtos.Select(m => m.Id).ToArray()
};
_eventBus.Publish(removeEventData);
}
return(result);
}
/// <summary>
/// 使用账号登录
/// </summary>
/// <param name="dto">登录信息</param>
/// <returns>业务操作结果</returns>
public async Task <OperationResult <User> > Login(LoginDto dto)
{
Check.NotNull(dto, nameof(dto));
User user = await FindUserByAccount(dto.Account);
if (user == null)
{
return(new OperationResult <User>(OperationResultType.Error, "用户不存在"));
}
if (user.IsLocked)
{
return(new OperationResult <User>(OperationResultType.Error, "用户已被冻结，无法登录"));
}
SignInResult signInResult = await SignInManager.CheckPasswordSignInAsync(user, dto.Password, true);
OperationResult <User> result = ToOperationResult(signInResult, user);
if (!result.Succeeded)
{
return(result);
}
Logger.LogInformation(1, $"用户 {user.Id} 使用账号登录系统成功");
//触发登录成功事件
LoginEventData loginEventData = new LoginEventData()
{
LoginDto = dto, User = user
};
await EventBus.PublishAsync(loginEventData);
FunctionAuthCacheRefreshEventData functionAuthCacheRefreshEventData =
new FunctionAuthCacheRefreshEventData()
{
UserNames = new[] { user.UserName }
};
await EventBus.PublishAsync(functionAuthCacheRefreshEventData);
return(result);
}
/// <summary>
/// 设置用户的可访问模块
/// </summary>
/// <param name="userId">用户编号</param>
/// <param name="moduleIds">要赋给用户的模块编号集合</param>
/// <returns>业务操作结果</returns>
public virtual async Task <OperationResult> SetUserModules(TUserKey userId, TModuleKey[] moduleIds)
{
TUser user = await _userRepository.GetAsync(userId);
if (user == null)
{
return(new OperationResult(OperationResultType.QueryNull, $"编号为“{userId}”的用户信息不存在"));
}
TModuleKey[] existModuleIds = _moduleUserRepository.Query(m => m.UserId.Equals(userId)).Select(m => m.ModuleId).ToArray();
TModuleKey[] addModuleIds = moduleIds.Except(existModuleIds).ToArray();
TModuleKey[] removeModuleIds = existModuleIds.Except(moduleIds).ToArray();
List <string> addNames = new List <string>(), removeNames = new List <string>();
int count = 0;
foreach (TModuleKey moduleId in addModuleIds)
{
TModule module = await _moduleRepository.GetAsync(moduleId);
if (module == null)
{
return(new OperationResult(OperationResultType.QueryNull, $"编号为“{moduleId}”的模块信息不存在"));
}
TModuleUser moduleUser = new TModuleUser()
{
ModuleId = moduleId, UserId = userId
};
count += await _moduleUserRepository.InsertAsync(moduleUser);
addNames.Add(module.Name);
}
foreach (TModuleKey moduleId in removeModuleIds)
{
TModule module = await _moduleRepository.GetAsync(moduleId);
if (module == null)
{
return(new OperationResult(OperationResultType.QueryNull, $"编号为“{moduleId}”的模块信息不存在"));
}
TModuleUser moduleUser = _moduleUserRepository.Query().FirstOrDefault(m => m.ModuleId.Equals(moduleId) && m.UserId.Equals(userId));
if (moduleUser == null)
{
continue;
}
count += await _moduleUserRepository.DeleteAsync(moduleUser);
removeNames.Add(module.Name);
}
if (count > 0)
{
//功能权限缓存刷新事件
FunctionAuthCacheRefreshEventData removeEventData = new FunctionAuthCacheRefreshEventData()
{
UserNames = new[] { user.UserName }
};
_eventBus.Publish(removeEventData);
if (addNames.Count > 0 && removeNames.Count == 0)
{
return(new OperationResult(OperationResultType.Success, $"用户“{user.UserName}”添加模块“{addNames.ExpandAndToString()}”操作成功"));
}
if (addNames.Count == 0 && removeNames.Count > 0)
{
return(new OperationResult(OperationResultType.Success, $"用户“{user.UserName}”移除模块“{removeNames.ExpandAndToString()}”操作成功"));
}
return(new OperationResult(OperationResultType.Success,
$"用户“{user.UserName}”添加模块“{addNames.ExpandAndToString()}”，移除模块“{removeNames.ExpandAndToString()}”操作成功"));
}
return(OperationResult.NoChanged);
}
/// <summary>
/// 设置角色的可访问模块
/// </summary>
/// <param name="roleId">角色编号</param>
/// <param name="moduleIds">要赋予的模块编号集合</param>
/// <returns>业务操作结果</returns>
public virtual async Task <OperationResult> SetRoleModules(TRoleKey roleId, TModuleKey[] moduleIds)
{
TRole role = await _roleRepository.GetAsync(roleId);
if (role == null)
{
return(new OperationResult(OperationResultType.QueryNull, $"编号为“{roleId}”的角色信息不存在"));
}
TModuleKey[] existModuleIds = _moduleRoleRepository.Query(m => m.RoleId.Equals(roleId)).Select(m => m.ModuleId).ToArray();
TModuleKey[] addModuleIds = moduleIds.Except(existModuleIds).ToArray();
TModuleKey[] removeModuleIds = existModuleIds.Except(moduleIds).ToArray();
List <string> addNames = new List <string>(), removeNames = new List <string>();
int count = 0;
foreach (TModuleKey moduleId in addModuleIds)
{
TModule module = await _moduleRepository.GetAsync(moduleId);
if (module == null)
{
return(new OperationResult(OperationResultType.QueryNull, $"编号为“{moduleId}”的模块信息不存在"));
}
TModuleRole moduleRole = new TModuleRole()
{
ModuleId = moduleId, RoleId = roleId
};
count = count + await _moduleRoleRepository.InsertAsync(moduleRole);
addNames.Add(module.Name);
}
foreach (TModuleKey moduleId in removeModuleIds)
{
TModule module = await _moduleRepository.GetAsync(moduleId);
if (module == null)
{
return(new OperationResult(OperationResultType.QueryNull, $"编号为“{moduleId}”的模块信息不存在"));
}
TModuleRole moduleRole = _moduleRoleRepository.Query().FirstOrDefault(m => m.RoleId.Equals(roleId) && m.ModuleId.Equals(moduleId));
if (moduleRole == null)
{
continue;
}
count = count + await _moduleRoleRepository.DeleteAsync(moduleRole);
removeNames.Add(module.Name);
}
if (count > 0)
{
//功能权限缓存刷新事件
moduleIds = addModuleIds.Union(removeModuleIds).Distinct().ToArray();
Guid[] functionIds = _moduleFunctionRepository.Query(m => moduleIds.Contains(m.ModuleId))
.Select(m => m.FunctionId).Distinct().ToArray();
FunctionAuthCacheRefreshEventData removeEventData = new FunctionAuthCacheRefreshEventData()
{
FunctionIds = functionIds
};
_eventBus.Publish(removeEventData);
if (addNames.Count > 0 && removeNames.Count == 0)
{
return(new OperationResult(OperationResultType.Success, $"角色“{role.Name}”添加模块“{addNames.ExpandAndToString()}”操作成功"));
}
if (addNames.Count == 0 && removeNames.Count > 0)
{
return(new OperationResult(OperationResultType.Success, $"角色“{role.Name}”移除模块“{removeNames.ExpandAndToString()}”操作成功"));
}
return(new OperationResult(OperationResultType.Success,
$"角色“{role.Name}”添加模块“{addNames.ExpandAndToString()}”，移除模块“{removeNames.ExpandAndToString()}”操作成功"));
}
return(OperationResult.NoChanged);
}
/// <summary>
/// 设置模块的功能信息
/// </summary>
/// <param name="moduleId">模块编号</param>
/// <param name="functionIds">要设置的功能编号</param>
/// <returns>业务操作结果</returns>
public virtual async Task <OperationResult> SetModuleFunctions(TModuleKey moduleId, Guid[] functionIds)
{
TModule module = await _moduleRepository.GetAsync(moduleId);
if (module == null)
{
return(new OperationResult(OperationResultType.QueryNull, $"编号为“{moduleId}”的模块信息不存在"));
}
Guid[] existFunctionIds = _moduleFunctionRepository.Query(m => m.ModuleId.Equals(moduleId)).Select(m => m.FunctionId).ToArray();
Guid[] addFunctionIds = functionIds.Except(existFunctionIds).ToArray();
Guid[] removeFunctionIds = existFunctionIds.Except(functionIds).ToArray();
List <string> addNames = new List <string>(), removeNames = new List <string>();
int count = 0;
foreach (Guid functionId in addFunctionIds)
{
TFunction function = await _functionRepository.GetAsync(functionId);
if (function == null)
{
continue;
}
TModuleFunction moduleFunction = new TModuleFunction()
{
ModuleId = moduleId, FunctionId = functionId
};
count = count + await _moduleFunctionRepository.InsertAsync(moduleFunction);
addNames.Add(function.Name);
}
foreach (Guid functionId in removeFunctionIds)
{
TFunction function = await _functionRepository.GetAsync(functionId);
if (function == null)
{
continue;
}
TModuleFunction moduleFunction = _moduleFunctionRepository.Query()
.FirstOrDefault(m => m.ModuleId.Equals(moduleId) && m.FunctionId == functionId);
if (moduleFunction == null)
{
continue;
}
count = count + await _moduleFunctionRepository.DeleteAsync(moduleFunction);
removeNames.Add(function.Name);
}
if (count > 0)
{
//功能权限缓存刷新事件
FunctionAuthCacheRefreshEventData removeEventData = new FunctionAuthCacheRefreshEventData()
{
FunctionIds = addFunctionIds.Union(removeFunctionIds).Distinct().ToArray()
};
_eventBus.Publish(removeEventData);
return(new OperationResult(OperationResultType.Success,
$"模块“{module.Name}”添加功能“{addNames.ExpandAndToString()}”，移除功能“{removeNames.ExpandAndToString()}”操作成功"));
}
return(OperationResult.NoChanged);
}
