jinko.yikatong/Src/Dlhis.Basic/Organization/Services/Implements/GainfoGroupService.cs

using Dlhis.Basic.Device.Services;
using Dlhis.Basic.Organization.Request;
using Dlhis.Basic.Organization.Response;
using Dlhis.Entity.Basic.Entity;
using Kurisu.AspNetCore.Authentication.Abstractions;
using Kurisu.AspNetCore.DataAccess.SqlSugar.Services;
using Kurisu.AspNetCore.Utils.Extensions;
using Mapster;

namespace Dlhis.Basic.Organization.Services.Implements;

public class GainfoGroupService : IGainfoGroupService
{
    private readonly IDbContext _dbContext;
    private readonly ICurrentUser _currentUser;
    private readonly IDevicePermissionService _devicePermissionService;

    public GainfoGroupService(IDbContext dbContext, ICurrentUser currentUser, IDevicePermissionService devicePermissionService)
    {
        _dbContext = dbContext;
        _currentUser = currentUser;
        _devicePermissionService = devicePermissionService;
    }

    public async Task<List<GainfoGroupTreeResponse>> GetTreeAsync()
    {
        var gainfoGroups = await _dbContext.Queryable<GainfoGroupEntity>()
            .Select<GainfoGroupTreeResponse>()
            .ToListAsync();

        var tops = gainfoGroups.Where(x => !x.PCode.HasValue).ToList();
        tops.ForEach(x => { RecursionGetNext(x, gainfoGroups); });

        return tops;
    }

    public async Task SaveAsync(GainfoGroupSaveRequest request)
    {
        await CheckDuplicateNameAsync(request);
        if (!request.Id.HasValue)
        {
            if (request.PCode.HasValue)
            {
                (await _dbContext.Queryable<GainfoGroupRelationshipEntity>().Where(x => x.GroupCode == request.PCode).AnyAsync()).ThrowIfTrue("上级已分配人员");
            }

            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)
    {
        if (request.UserNos.IsPresent())
        {
            var pGrp = await _dbContext.Queryable<GainfoGroupEntity>().Where(x => x.Code == request.GroupCode).FirstAsync();
            (pGrp?.Editable == false && pGrp?.IsDefault == true).ThrowIfTrue("不可分配人员到当前分组");
        }

        var existsNextGroup = await _dbContext.Queryable<GainfoGroupEntity>().Where(x => x.PCode == request.GroupCode).AnyAsync();
        existsNextGroup.ThrowIfTrue("存在下级分组,无法分配人员");

        await _devicePermissionService.GenerateDeviceTasksAsync(async () =>
        {
            var relations = await _dbContext.Queryable<GainfoGroupRelationshipEntity>()
                .Where(x => x.GroupCode == request.GroupCode)
                .ToListAsync();
            await _dbContext.DeleteAsync(relations);

            request.UserNos = await _dbContext.Queryable<GainfoEntity>()
                .Where(x => request.UserNos.Contains(x.No) || request.UserNos.Contains(x.Code))
                .Select(x => x.No)
                .ToListAsync();

            var entities = request.UserNos.Select(x => new GainfoGroupRelationshipEntity
            {
                GroupCode = request.GroupCode,
                UserNo = x
            }).ToList();

            await _dbContext.InsertAsync(entities);
        }, null);
    }


    public async Task<List<GainfoGroupTreeResponse>> GetGainfoGroupsByUserCodeAsync(string userCode)
    {
        var gainfo = await _dbContext.Queryable<GainfoEntity>().Where(x => x.Code == userCode).SingleAsync();
        var userNo = gainfo?.No;

        return await _dbContext.Queryable<GainfoGroupEntity>()
            .LeftJoin<GainfoGroupRelationshipEntity>((x, r) => x.Code == r.GroupCode)
            .Where((x, r) => r.UserNo == userNo)
            .Select(x => new GainfoGroupTreeResponse
            {
                Id = x.Id,
                PCode = x.PCode,
                Code = x.Code,
                Name = x.Name,
                Remark = x.Remark,
                Editable = x.Editable,
                IsDefault = x.IsDefault,
                TenantId = x.TenantId
            })
            .ToListAsync();
    }

    //******************************************************* 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}");
    }


    private void RecursionGetNext(GainfoGroupTreeResponse current, List<GainfoGroupTreeResponse> gainfoGroups)
    {
        var currentTenantId = _currentUser.GetStringTenantId();
        var next = gainfoGroups.Where(x =>
        {
            if (x.PCode == current.Code)
            {
                if (x.TenantId.IsEmpty())
                {
                    return true;
                }
                else
                {
                    return x.TenantId == currentTenantId;
                }
            }

            return false;
        }).ToList();
        current.Next = next;
        foreach (var item in next)
        {
            RecursionGetNext(item, gainfoGroups);
        }
    }
}