yuangb/jinko.yikatong
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix 档案组,设备权限分配

Browse Source
This commit is contained in:
liguoyang
2024-01-15 14:55:26 +08:00
parent 7d2c041bb9
commit ea5761d9b4
18 changed files with 408 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
Src/Dlhis.Basic/Device/Controllers/DevicePermissionsController.cs
View File

@@ -20,12 +20,12 @@ public class DevicePermissionsController : ControllerBase
/// <summary>
/// 分配权限
/// </summary>
/// <param name="requests"></param>
/// <param name="request"></param>
/// <returns></returns>
[HttpPost("assign")]
public async Task AssignmentAsync(List<DevicePermissionSaveReuqest> requests)
public async Task AssignAsync(DevicePermissionSaveReuqest request)
{
await _devicePermissionService.AssignmentAsync(requests);
await _devicePermissionService.AssignAsync(request);
}
/// <summary>
@@ -36,18 +36,6 @@ public class DevicePermissionsController : ControllerBase
[HttpGet("assignments")]
public async Task<List<Guid>> GetAssignmentsAsync([FromQuery] DeviceGetAssignmentsRequest request)
{
return await _devicePermissionService.GetAssignmentsAsync(request.UserNo, request.UniqueType);
}
/// <summary>
/// 重置
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
[HttpPost("reset")]
public async Task ResetAssignmentsAsync(DeviceResetAssignmentsRequest request)
{
await _devicePermissionService.ResetAssignmentsAsync(request);
return await _devicePermissionService.GetAssignmentsAsync(request.UniqueType, request.AssignType, request.AssignValue);
}
}

19
Src/Dlhis.Basic/Device/Request/DeviceGetAssignmentsRequest.cs
View File

@@ -6,14 +6,19 @@ namespace Dlhis.Basic.Device.Request;
public class DeviceGetAssignmentsRequest
{
/// <summary>
/// 用户档案号
/// </summary>
[Required]
public string UserNo { get; set; }
/// <summary>
/// 权限分配类型 MenuAssignmentTypeEnumType
/// 权限分配类型 DeviceAssignmentTypeEnumType
/// </summary>
[EnumDataType(typeof(DeviceAssignmentTypeEnumType))]
public DeviceAssignmentTypeEnumType UniqueType { get; set; }
/// <summary>
/// 分配类型 AssignTypeEnumType
/// </summary>
[EnumDataType(typeof(AssignTypeEnumType))]
public AssignTypeEnumType AssignType { get; set; }
/// <summary>
/// 分配值
/// </summary>
public string AssignValue { get; set; }
}

13
Src/Dlhis.Basic/Device/Request/DevicePermissionSaveReuqest.cs
View File

@@ -5,14 +5,20 @@ namespace Dlhis.Basic.Device.Request;
public class DevicePermissionSaveReuqest
{
/// <summary>
/// 分配类型 AssignTypeEnumType
/// </summary>
[EnumDataType(typeof(AssignTypeEnumType), ErrorMessage = "枚举类型错误")]
public AssignTypeEnumType AssignType { get; set; }
/// <summary>
/// 人员档案号
/// </summary>
[Required(ErrorMessage = "人员档案号不能为空")]
public string UserNo { get; set; }
public string AssignValue { get; set; }
/// <summary>
/// 分配权限类型 DevicePermissionTypeEnumType
/// 来源分配权限类型 DevicePermissionTypeEnumType
/// </summary>
[EnumDataType(typeof(DeviceAssignmentTypeEnumType), ErrorMessage = "枚举类型错误")]
public DeviceAssignmentTypeEnumType UniqueType { get; set; }
@@ -20,6 +26,5 @@ public class DevicePermissionSaveReuqest
/// <summary>
/// 分配权限值不能为空
/// </summary>
[Required(ErrorMessage = "分配权限值不能为空")]
public Guid UniqueValue { get; set; }
public List<Guid> Codes { get; set; } = new List<Guid>();
}

16
Src/Dlhis.Basic/Device/Services/IDevicePermissionService.cs
View File

@@ -8,24 +8,18 @@ public interface IDevicePermissionService : IScopeDependency
/// <summary>
/// 保存设备权限
/// </summary>
/// <param name="reuqests"></param>
/// <param name="reuqest"></param>
/// <returns></returns>
Task AssignmentAsync(List<DevicePermissionSaveReuqest> reuqests);
Task AssignAsync(DevicePermissionSaveReuqest reuqest);
/// <summary>
/// 获取分配的权限
/// </summary>
/// <param name="userNo"></param>
/// <param name="uniqueType"></param>
/// <param name="assignValue"></param>
/// <param name="assignType"></param>
/// <returns></returns>
Task<List<Guid>> GetAssignmentsAsync(string userNo, DeviceAssignmentTypeEnumType? uniqueType);
/// <summary>
/// 重置分配
/// </summary>
/// <returns></returns>
Task ResetAssignmentsAsync(DeviceResetAssignmentsRequest request);
Task<List<Guid>> GetAssignmentsAsync(DeviceAssignmentTypeEnumType uniqueType, AssignTypeEnumType assignType, string assignValue);
/// <summary>

125
Src/Dlhis.Basic/Device/Services/Implements/DevicePermissionService.cs
View File

@@ -20,81 +20,66 @@ public class DevicePermissionService : IDevicePermissionService
}
[Transactional]
public async Task AssignmentAsync(List<DevicePermissionSaveReuqest> reuqests)
public async Task AssignAsync(DevicePermissionSaveReuqest reuqest)
{
foreach (var grp in reuqests.GroupBy(x => x.UserNo))
{
var userNo = grp.Key;
var data = grp.AsEnumerable().DistinctBy(x => x.UniqueValue).ToList();
await GenerateDeviceTasksAsync(async () =>
{
await _dbContext.Client.Deleteable<DevicePermissionEntity>()
.Where(x => x.UserNo == userNo)
.Where(x => x.AssignType == reuqest.AssignType)
.Where(x => x.AssignValue == reuqest.AssignValue)
.ExecuteCommandAsync();
var devicePermissions = data.Select(x => new DevicePermissionEntity
var devicePermissions = reuqest.Codes.Select(x => new DevicePermissionEntity
{
UserNo = x.UserNo,
UniqueType = x.UniqueType,
UniqueValue = x.UniqueValue,
AssignType = reuqest.AssignType,
AssignValue = reuqest.AssignValue,
UniqueType = reuqest.UniqueType,
UniqueValue = x,
}).ToList();
await _dbContext.InsertAsync(devicePermissions);
}, new List<string> { userNo });
};
}, null);
}
public async Task<List<Guid>> GetAssignmentsAsync(string userNo, DeviceAssignmentTypeEnumType? uniqueType)
public async Task<List<Guid>> GetAssignmentsAsync(DeviceAssignmentTypeEnumType uniqueType, AssignTypeEnumType assignType, string assignValue)
{
var assignments = await _dbContext.Queryable<DevicePermissionEntity>()
.WhereIF(uniqueType.HasValue, x => x.UniqueType == uniqueType)
.Where(x => x.UserNo == userNo)
var devicePermissions = await _dbContext.Queryable<DevicePermissionEntity>()
.Where(x => x.UniqueType == uniqueType)
.Where(x => x.AssignType == assignType)
.Where(x => x.AssignValue == assignValue)
.Select(x => x.UniqueValue)
.ToListAsync();
if (uniqueType.HasValue && uniqueType == DeviceAssignmentTypeEnumType.Group)
if (uniqueType == DeviceAssignmentTypeEnumType.Group)
{
var deviceGroups = await _dbContext.Queryable<DeviceGroupEntity>().ToListAsync();
var tops = deviceGroups.Where(x => !x.PCode.HasValue).ToList();
tops.ForEach(x =>
{
RecursionGetNext(x, deviceGroups, assignments, assignments.Contains(x.Code));
RecursionGetNext(x, deviceGroups, devicePermissions, devicePermissions.Contains(x.Code));
});
}
return assignments.Distinct().ToList();
return devicePermissions.Distinct().ToList();
void RecursionGetNext(DeviceGroupEntity current, List<DeviceGroupEntity> deviceGroups, List<Guid> result, bool add)
{
var next = deviceGroups.Where(x => x.PCode == current.Code).ToList();
foreach (var item in next)
{
if (add) assignments.Add(item.Code);
RecursionGetNext(item, deviceGroups, result, assignments.Contains(item.Code));
if (add) result.Add(item.Code);
RecursionGetNext(item, deviceGroups, result, result.Contains(item.Code));
}
}
}
public async Task ResetAssignmentsAsync(DeviceResetAssignmentsRequest request)
{
await GenerateDeviceTasksAsync(async () =>
{
await _dbContext.Client.Deleteable<DevicePermissionEntity>()
.Where(x => x.UserNo == request.UserNo)
.ExecuteCommandAsync();
}, new List<string> { request.UserNo });
}
public async Task GenerateDeviceTasksAsync(Func<Task> func, List<string> userNos)
{
if (userNos.IsEmpty())
{
userNos = await _dbContext.Queryable<DevicePermissionEntity>().Select(x => x.UserNo).Distinct().ToListAsync();
userNos = await GetPermissionUserNosAsync();
}
var beforeDic = new Dictionary<string, List<Guid>>(userNos.Count);
@@ -108,6 +93,7 @@ public class DevicePermissionService : IDevicePermissionService
//获取当前的权限code
var currentDic = new Dictionary<string, List<Guid>>(userNos.Count);
userNos = await GetPermissionUserNosAsync();
foreach (var userNo in userNos)
{
currentDic.TryAdd(userNo, await GetAssignDeviceCodesAsync(userNo));
@@ -115,8 +101,11 @@ public class DevicePermissionService : IDevicePermissionService
foreach (var userNo in userNos)
{
var beforeCodes = beforeDic[userNo];
var currentCodes = currentDic[userNo];
beforeDic.TryGetValue(userNo, out var beforeCodes);
if (beforeCodes == null) beforeCodes = new List<Guid>();
currentDic.TryGetValue(userNo, out var currentCodes);
if (currentCodes == null) currentCodes = new List<Guid>();
//被删除
var deletedItems = beforeCodes.Where(x => !currentCodes.Contains(x)).ToList();
@@ -171,6 +160,32 @@ public class DevicePermissionService : IDevicePermissionService
//************************************************ help methods *******************************************************
private async Task<List<string>> GetPermissionUserNosAsync()
{
var permissions = await _dbContext.Queryable<DevicePermissionEntity>().ToListAsync();
//User
var userNos = permissions.Where(x => x.AssignType == AssignTypeEnumType.User).Select(x => x.AssignValue).ToList();
//Group
var groupCode = permissions.Where(x => x.AssignType == AssignTypeEnumType.Group).Select(x => Guid.Parse(x.AssignValue)).ToList();
var userNosByGroup = await _dbContext.Queryable<GainfoGroupRelationshipEntity>()
.Where(x => groupCode.Contains(x.GroupCode))
.Select(x => x.UserNo)
.ToListAsync();
//Department
var departmentNos = permissions.Where(x => x.AssignType == AssignTypeEnumType.Department).Select(x => x.AssignValue).ToList();
var userNosByDepartment = await _dbContext.Queryable<GainfoEntity>().Where(x => departmentNos.Contains(x.DepartmentNo)).Select(x => x.No).ToListAsync();
//Tenant
var tenants = permissions.Where(x => x.AssignType == AssignTypeEnumType.Tenant).Select(x => x.AssignValue).ToList();
var userNosByWerk = await _dbContext.Queryable<GainfoEntity>().Where(x => tenants.Contains(x.Werks)).Select(x => x.No).ToListAsync();
return userNos.Concat(userNosByGroup).Concat(userNosByDepartment).Concat(userNosByWerk).ToList();
}
/// <summary>
/// 获取用户所有设备权限
/// </summary>
@@ -178,17 +193,37 @@ public class DevicePermissionService : IDevicePermissionService
/// <returns></returns>
private async Task<List<Guid>> GetAssignDeviceCodesAsync(string userNo)
{
var deviceCodes = await GetAssignmentsAsync(userNo, DeviceAssignmentTypeEnumType.Device);
var gainfo = await _dbContext.Queryable<GainfoEntity>().Where(x => x.No == userNo).SingleAsync();
var gainfoGroups = await _dbContext.Queryable<GainfoGroupRelationshipEntity>().Where(x => x.UserNo == userNo).Select(x => x.GroupCode).ToListAsync();
var groupCodes = await GetAssignmentsAsync(userNo, DeviceAssignmentTypeEnumType.Group);
var deviceCodeUnderGroups = await _dbContext.Queryable<DeviceGroupRelationshipEntity>()
.Where(x => groupCodes.Contains(x.GroupCode))
.Select(x => x.DeviceCode)
.Distinct()
.ToListAsync();
var deviceCodes = new List<Guid>();
var deviceGroupCodes = new List<Guid>();
deviceCodes.AddRange(deviceCodeUnderGroups);
var du = await GetAssignmentsAsync(DeviceAssignmentTypeEnumType.Device, AssignTypeEnumType.User, userNo);
var gu = await GetAssignmentsAsync(DeviceAssignmentTypeEnumType.Group, AssignTypeEnumType.User, userNo);
deviceCodes.AddRange(du);
deviceGroupCodes.AddRange(gu);
foreach (var group in gainfoGroups)
{
var dg = await GetAssignmentsAsync(DeviceAssignmentTypeEnumType.Device, AssignTypeEnumType.Group, group.ToString());
var gg = await GetAssignmentsAsync(DeviceAssignmentTypeEnumType.Group, AssignTypeEnumType.Group, group.ToString());
deviceCodes.AddRange(dg);
deviceGroupCodes.AddRange(gg);
}
var dd = await GetAssignmentsAsync(DeviceAssignmentTypeEnumType.Device, AssignTypeEnumType.Department, gainfo.DepartmentNo);
var gd = await GetAssignmentsAsync(DeviceAssignmentTypeEnumType.Group, AssignTypeEnumType.Department, gainfo.DepartmentNo);
deviceCodes.AddRange(dd);
deviceGroupCodes.AddRange(gd);
var dt = await GetAssignmentsAsync(DeviceAssignmentTypeEnumType.Device, AssignTypeEnumType.Tenant, gainfo.Werks);
var gt = await GetAssignmentsAsync(DeviceAssignmentTypeEnumType.Group, AssignTypeEnumType.Tenant, gainfo.Werks);
deviceCodes.AddRange(du);
deviceGroupCodes.AddRange(gu);
var deveiceCodesByGroup = await _dbContext.Queryable<DeviceGroupRelationshipEntity>().Where(x => deviceGroupCodes.Contains(x.GroupCode)).Select(x => x.DeviceCode).ToListAsync();
deviceCodes.AddRange(deveiceCodesByGroup);
return deviceCodes.Distinct().ToList();
}

2
Src/Dlhis.Basic/Dlhis.Basic.csproj
View File

@@ -17,7 +17,7 @@
</ItemGroup>
<ItemGroup>
<PackageReference Include="Kurisu.AspNetCore" Version="0.4.8" />
<PackageReference Include="Kurisu.AspNetCore" Version="0.4.9" />
<PackageReference Include="Microsoft.AspNetCore.DataProtection.StackExchangeRedis" Version="6.0.26" />
</ItemGroup>

80
Src/Dlhis.Basic/Organization/Controllers/GainfoGroupsController.cs Normal file
View File

@@ -0,0 +1,80 @@
using Dlhis.Basic.Organization.Request;
using Dlhis.Basic.Organization.Response;
using Dlhis.Basic.Organization.Services;
using Kurisu.AspNetCore.MVC;
using Kurisu.Core.DataAccess.Dto;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
namespace Dlhis.Basic.Organization.Controllers;
/// <summary>
/// 档案分组
/// </summary>
[Authorize]
[ApiDefinition("SAP", Description = "晶科sap组织架构信息")]
[Route("api/[controller]")]
[ApiController]
public class GainfoGroupsController : ControllerBase
{
private readonly IGainfoGroupService _gainfoGroupService;
public GainfoGroupsController(IGainfoGroupService gainfoGroupService)
{
_gainfoGroupService = gainfoGroupService;
}
/// <summary>
/// 获取档案组分页
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
[HttpGet("page")]
public async Task<Pagination<GainfoGroupResponse>> GetPageAsync([FromQuery] GainfoGroupPageRequest request)
{
return await _gainfoGroupService.GetPageAsync(request);
}
/// <summary>
/// 获取所有档案组
/// </summary>
/// <returns></returns>
[HttpGet("list")]
public async Task<List<GainfoGroupResponse>> GetListAsync()
{
return await _gainfoGroupService.GetListAsync();
}
/// <summary>
/// 保存档案组
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
[HttpPost]
public async Task SaveAsync(GainfoGroupSaveRequest request)
{
await _gainfoGroupService.SaveAsync(request);
}
/// <summary>
/// 根据分组code获取人员档案
/// </summary>
/// <param name="code"></param>
/// <returns></returns>
[HttpGet("gainfos")]
public async Task<List<GainfoPageResponse>> GetGainfosByGroupAsync(Guid code)
{
return await _gainfoGroupService.GetGainfosByGroupAsync(code);
}
/// <summary>
/// 分配人员
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
[HttpPost("assign")]
public async Task AssignGainfosAsync(GainfoAssignRequest request)
{
await _gainfoGroupService.AssignGainfosAsync(request);
}
}

7
Src/Dlhis.Basic/Organization/Controllers/GainfosController.cs
View File

@@ -1,5 +1,4 @@
using System.ComponentModel.DataAnnotations;
using Dlhis.Basic.Organization.Filters;
using Dlhis.Basic.Organization.Filters;
using Dlhis.Basic.Organization.Request;
using Dlhis.Basic.Organization.Response;
using Dlhis.Basic.Organization.Services;
@@ -65,7 +64,7 @@ public class GainfosController : ControllerBase
/// <param name="request"></param>
/// <returns></returns>
[HttpPost("dimission")]
public async Task DimissionAsync(GainfoDImissionRequest request)
public async Task DimissionAsync(GainfoDimissionRequest request)
{
await _gainfoService.DimissionAsync(request);
}
@@ -76,7 +75,7 @@ public class GainfosController : ControllerBase
/// <param name="request"></param>
/// <returns></returns>
[HttpPost("onboarding")]
public async Task OnboardingAsync(GainfoDImissionRequest request)
public async Task OnboardingAsync(GainfoDimissionRequest request)
{
await _gainfoService.OnboardingAsync(request);
}

17
Src/Dlhis.Basic/Organization/Request/GainfoAssignRequest.cs Normal file
View File

@@ -0,0 +1,17 @@
using System.ComponentModel.DataAnnotations;
namespace Dlhis.Basic.Organization.Request;
public class GainfoAssignRequest
{
/// <summary>
/// 分组code
/// </summary>
[Required(ErrorMessage = "档案组code")]
public Guid GroupCode { get; set; }
/// <summary>
/// 档案号
/// </summary>
public List<string> UserNos { get; set; } = new List<string>();
}

7
Src/Dlhis.Basic/Organization/Request/GainfoDImissionRequest.cs
View File

@@ -1,13 +1,12 @@
using System.ComponentModel.DataAnnotations;
namespace Dlhis.Basic.Organization.Request
namespace Dlhis.Basic.Organization.Request;
public class GainfoDimissionRequest
{
public class GainfoDImissionRequest
{
/// <summary>
/// 档案号
/// </summary>
[Required(ErrorMessage = "档案号不能为空")]
public string UserNo { get; set; }
}
}

7
Src/Dlhis.Basic/Organization/Request/GainfoGroupPageRequest.cs Normal file
View File

@@ -0,0 +1,7 @@
using Kurisu.Core.DataAccess.Dto;
namespace Dlhis.Basic.Organization.Request;
public class GainfoGroupPageRequest: PageDto
{
}

16
Src/Dlhis.Basic/Organization/Request/GainfoGroupSaveRequest.cs Normal file
View File

@@ -0,0 +1,16 @@
namespace Dlhis.Basic.Organization.Request;
public class GainfoGroupSaveRequest
{
public long? Id { get; set; }
/// <summary>
/// 名称
/// </summary>
public string Name { get; set; }
/// <summary>
/// 备注
/// </summary>
public string Remark { get; set; }
}

20
Src/Dlhis.Basic/Organization/Request/GainfoUploadFaceRequest.cs
View File

@@ -2,7 +2,7 @@
namespace Dlhis.Basic.Organization.Request;
public class GainfoUploadFaceRequest
public class GainfoUploadFaceRequest : IValidatableObject
{
/// <summary>
/// 用户档案号
@@ -15,4 +15,22 @@ public class GainfoUploadFaceRequest
/// </summary>
[Required(ErrorMessage = "人脸照片不能为空")]
public string Face { get; set; }
public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
{
bool v = true;
try
{
Convert.FromBase64String(Face);
}
catch (Exception)
{
v = false;
}
if (!v)
{
yield return new ValidationResult("人脸照片需要为Base64格式", new[] { nameof(Face) });
}
}
}

19
Src/Dlhis.Basic/Organization/Response/GainfoGroupResponse.cs Normal file
View File

@@ -0,0 +1,19 @@
namespace Dlhis.Basic.Organization.Response;
public class GainfoGroupResponse
{
/// <summary>
/// 分组code
/// </summary>
public Guid Code { get; set; }
/// <summary>
/// 名称
/// </summary>
public string Name { get; set; }
/// <summary>
/// 备注
/// </summary>
public string Remark { get; set; }
}

18
Src/Dlhis.Basic/Organization/Services/IGainfoGroupService.cs Normal file
View File

@@ -0,0 +1,18 @@
using Dlhis.Basic.Organization.Request;
using Dlhis.Basic.Organization.Response;
using Kurisu.Core.DataAccess.Dto;
namespace Dlhis.Basic.Organization.Services;
public interface IGainfoGroupService : IScopeDependency
{
Task<Pagination<GainfoGroupResponse>> GetPageAsync(GainfoGroupPageRequest request);
Task<List<GainfoGroupResponse>> GetListAsync();
Task SaveAsync(GainfoGroupSaveRequest request);
Task<List<GainfoPageResponse>> GetGainfosByGroupAsync(Guid code);
Task AssignGainfosAsync(GainfoAssignRequest request);
}

4
Src/Dlhis.Basic/Organization/Services/IGainfoService.cs
View File

@@ -13,9 +13,9 @@ public interface IGainfoService : IScopeDependency
Task UpdateAsync(GainfoSaveRequest request);
Task DimissionAsync(GainfoDImissionRequest request);
Task DimissionAsync(GainfoDimissionRequest request);
Task OnboardingAsync(GainfoDImissionRequest request);
Task OnboardingAsync(GainfoDimissionRequest request);
Task<GainfoCurrentResponse> CurrentUserInfoAsync();

101
Src/Dlhis.Basic/Organization/Services/Implements/GainfoGroupService.cs Normal file
View File

@@ -0,0 +1,101 @@
using Dlhis.Basic.Organization.Request;
using Dlhis.Basic.Organization.Response;
using Dlhis.Entity.Basic.Entity;
using Kurisu.AspNetCore.Utils.Extensions;
using Kurisu.Core.DataAccess.Dto;
using Kurisu.SqlSugar.Extensions;
using Kurisu.SqlSugar.Services;
using Mapster;
namespace Dlhis.Basic.Organization.Services.Implements;
public class GainfoGroupService : IGainfoGroupService
{
private readonly IDbContext _dbContext;
public GainfoGroupService(IDbContext dbContext)
{
_dbContext = dbContext;
}
public async Task<Pagination<GainfoGroupResponse>> GetPageAsync(GainfoGroupPageRequest request)
{
return await _dbContext.Queryable<GainfoGroupEntity>()
.Select<GainfoGroupResponse>()
.ToPageListAsync(request);
}
public async Task<List<GainfoGroupResponse>> GetListAsync()
{
return await _dbContext.Queryable<GainfoGroupEntity>()
.Select<GainfoGroupResponse>()
.ToListAsync();
}
public async Task SaveAsync(GainfoGroupSaveRequest request)
{
await CheckDuplicateNameAsync(request);
if (!request.Id.HasValue)
{
var entity = request.Adapt<GainfoGroupEntity>();
entity.Code = Guid.NewGuid();
await _dbContext.InsertAsync(entity);
}
else
{
var entity = await _dbContext.Queryable<GainfoGroupEntity>().Where(x => x.Id == request.Id).SingleAsync();
request.Adapt(entity);
await _dbContext.UpdateAsync(entity);
}
}
public async Task<List<GainfoPageResponse>> GetGainfosByGroupAsync(Guid code)
{
var userNos = await _dbContext.Queryable<GainfoGroupRelationshipEntity>()
.Where(x => x.GroupCode == code)
.Select(x => x.UserNo)
.ToListAsync();
var list = await _dbContext.Queryable<GainfoEntity>()
.Where(x => userNos.Contains(x.No))
.Select<GainfoPageResponse>()
.ToListAsync();
return list;
}
public async Task AssignGainfosAsync(GainfoAssignRequest request)
{
var relations = await _dbContext.Queryable<GainfoGroupRelationshipEntity>().Where(x => x.GroupCode == request.GroupCode).ToListAsync();
await _dbContext.DeleteReallyAsync(relations);
var entities = request.UserNos.Select(x => new GainfoGroupRelationshipEntity
{
GroupCode = request.GroupCode,
UserNo = x
}).ToList();
await _dbContext.InsertAsync(entities);
}
//******************************************************* help methods ***********************************************************
/// <summary>
/// 检查重名
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
private async Task CheckDuplicateNameAsync(GainfoGroupSaveRequest request)
{
var exists = await _dbContext.Queryable<GainfoGroupEntity>()
.Where(x => x.Name == request.Name)
.WhereIF(request.Id.HasValue, x => x.Id != request.Id)
.AnyAsync();
exists.ThrowIfTrue($"重复组名{request.Name}");
}
}

4
Src/Dlhis.Basic/Organization/Services/Implements/GainfoService.cs
View File

@@ -87,7 +87,7 @@ public class GainfoService : IGainfoService
/// <param name="request"></param>
/// <returns></returns>
[Transactional]
public async Task DimissionAsync(GainfoDImissionRequest request)
public async Task DimissionAsync(GainfoDimissionRequest request)
{
var gainfo = await _gainfoStore.Queryable(GainfoStatusEnumType.Working)
.Where(x => x.No == request.UserNo)
@@ -107,7 +107,7 @@ public class GainfoService : IGainfoService
/// <param name="request"></param>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
public async Task OnboardingAsync(GainfoDImissionRequest request)
public async Task OnboardingAsync(GainfoDimissionRequest request)
{
var gainfo = await _gainfoStore.Queryable(GainfoStatusEnumType.External)
.Where(x => x.No == request.UserNo)