jinko.yikatong/Src/Dlhis.Basic/Device/Services/Implements/DevicePermissionService.cs

using Dlhis.Basic.Device.Request;
using Dlhis.Entity.Basic.Entity;
using Dlhis.Entity.Device.Entities;
using Dlhis.Entity.Device.Enums;
using Dlhis.Entity.Sys.Entities;
using Dlhis.Entity.Sys.Enums;
using Kurisu.AspNetCore.Utils.Extensions;
using Kurisu.SqlSugar.Attributes;
using Kurisu.SqlSugar.Services;

namespace Dlhis.Basic.Device.Services.Implements;

public class DevicePermissionService : IDevicePermissionService
{
    private readonly IDbContext _dbContext;

    public DevicePermissionService(IDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    [Transactional]
    public async Task AssignmentAsync(List<DevicePermissionSaveReuqest> reuqests)
    {
        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)
                .ExecuteCommandAsync();

                var devicePermissions = data.Select(x => new DevicePermissionEntity
                {
                    UserNo = x.UserNo,
                    UniqueType = x.UniqueType,
                    UniqueValue = x.UniqueValue,

                }).ToList();

                await _dbContext.InsertAsync(devicePermissions);

            }, new List<string> { userNo });
        };
    }

    public async Task<List<Guid>> GetAssignmentsAsync(string userNo, DeviceAssignmentTypeEnumType? uniqueType)
    {
        var assignments = await _dbContext.Queryable<DevicePermissionEntity>()
                  .WhereIF(uniqueType.HasValue, x => x.UniqueType == uniqueType)
                  .Where(x => x.UserNo == userNo)
                  .Select(x => x.UniqueValue)
                  .ToListAsync();

        if (uniqueType.HasValue && 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));
            });
        }

        return assignments.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));
            }
        }
    }


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

        var beforeDic = new Dictionary<string, List<Guid>>(userNos.Count);
        foreach (var userNo in userNos)
        {
            beforeDic.TryAdd(userNo, await GetAssignDeviceCodesAsync(userNo));
        }

        //获取处理
        await func();

        //获取当前的权限code
        var currentDic = new Dictionary<string, List<Guid>>(userNos.Count);
        foreach (var userNo in userNos)
        {
            currentDic.TryAdd(userNo, await GetAssignDeviceCodesAsync(userNo));
        }

        foreach (var userNo in userNos)
        {
            var beforeCodes = beforeDic[userNo];
            var currentCodes = currentDic[userNo];

            //被删除
            var deletedItems = beforeCodes.Where(x => !currentCodes.Contains(x)).ToList();
            //新增
            var addItems = currentCodes.Where(x => !beforeCodes.Contains(x)).ToList();

            if (!deletedItems.Any() && !addItems.Any())
            {
                continue;
            }

            var deivces = await _dbContext.Queryable<DeviceEntity>().Where(x => deletedItems.Contains(x.Code) || addItems.Contains(x.Code)).ToListAsync();
            var deviceCodes = deivces.Select(x => x.Code).ToList();
            deletedItems = deletedItems.Where(x => deviceCodes.Contains(x)).ToList();
            addItems = addItems.Where(x => deviceCodes.Contains(x)).ToList();

            var userInfo = await _dbContext.Queryable<GainfoEntity>()
              .LeftJoin<DepartmentEntity>((ga, department) => department.No == ga.DepartmentNo)
              .Where(ga => ga.No == userNo)
              .Select(ga => new
              {
                  ga.Code
              })
              .SingleAsync();

            //下发任务创建
            var toDeleted = deletedItems.Select(x => new DeviceTaskEntity
            {
                DeviceUniqueNo = deivces.First(item => item.Code == x).UniqueNo,
                Status = DeviceTaskStatusEnumType.Wait,
                Type = DeviceTaskEnumType.Delete,
                UserNo = userNo,
                Version = 0,
                UserCode = userInfo.Code,
            }).ToList();

            var toAdd = addItems.Select(x => new DeviceTaskEntity
            {
                DeviceUniqueNo = deivces.First(item => item.Code == x).UniqueNo,
                Status = DeviceTaskStatusEnumType.Wait,
                Type = DeviceTaskEnumType.Add,
                UserNo = userNo,
                Version = 0,
                UserCode = userInfo.Code,
            }).ToList();

            var tasks = toDeleted.Concat(toAdd).ToList();
            await _dbContext.InsertAsync(tasks);
        }
    }


    //************************************************ help methods *******************************************************

    /// <summary>
    /// 获取用户所有设备权限
    /// </summary>
    /// <param name="userNo"></param>
    /// <returns></returns>
    private async Task<List<Guid>> GetAssignDeviceCodesAsync(string userNo)
    {
        var deviceCodes = await GetAssignmentsAsync(userNo, DeviceAssignmentTypeEnumType.Device);

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

        deviceCodes.AddRange(deviceCodeUnderGroups);


        return deviceCodes.Distinct().ToList();
    }
}