jinko.yikatong/Src/Dlhis.Basic/WorkGrids/Services/Implements/WorkGridService.cs

using Dlhis.Basic.Common.ApiLog.Services;
using Dlhis.Basic.WorkGrids.Request;
using Dlhis.Basic.WorkGrids.Response;
using Dlhis.Constants;
using Dlhis.Entity.Basic.Entity;
using Dlhis.Entity.Common.Enums;
using Kurisu.AspNetCore.Authentication.Abstractions;
using Kurisu.AspNetCore.DataAccess.Dto;
using Kurisu.AspNetCore.DataAccess.SqlSugar.Extensions;
using Kurisu.AspNetCore.DataAccess.SqlSugar.Services;
using Kurisu.AspNetCore.Utils.Extensions;
using Mapster;
using SqlSugar;

namespace Dlhis.Basic.WorkGrids.Services.Implements;

public class WorkGridService : IWorkGridService
{
    private readonly IDbContext _dbContext;
    private readonly ICurrentUser _currentUser;
    private readonly IOperateLog _operateLog;

    public WorkGridService(IDbContext dbContext, ICurrentUser currentUser, IOperateLog operateLog)
    {
        _dbContext = dbContext;
        _currentUser = currentUser;
        _operateLog = operateLog;
    }

    /// <inheritdoc />
    public async Task SaveAsync(List<WorkGridSaveRequest> requests)
    {
        var insertGrids = new List<string>();
        var updateGrids = new List<string>();

        foreach (var request in requests)
        {
            var exists = await _dbContext.Queryable<WorkGridEntity>()
                .Where(x => x.LeaderUserCode == request.LeaderUserCode)
                .WhereIF(request.Id.HasValue, x => x.Id != request.Id)
                .AnyAsync();

            if (!await _dbContext.Queryable<GainfoEntity>().Where(x => x.Code == request.LeaderUserCode).AnyAsync())
            {
                true.ThrowIfTrue($"工号:{request.LeaderUserCode}不存在");
            }

            if (await _dbContext.Queryable<WorkGridEntity>().Where(x => x.Name == request.Name)
                    .WhereIF(request.Id.HasValue, x => x.Id != request.Id)
                    .AnyAsync())
            {
                true.ThrowIfTrue($"网格区域名称[{request.Name}]重复");
            }

            exists.ThrowIfTrue($"{request.LeaderUserCode}已存在管理的网格");

            if (!request.Id.HasValue)
            {
                var entity = request.Adapt<WorkGridEntity>();
                entity.Code = Guid.NewGuid();

                await _dbContext.InsertAsync(entity);
                insertGrids.Add($"{entity.Name}({entity.LeaderUserCode})");
            }
            else
            {
                var entity = await _dbContext.Queryable<WorkGridEntity>().Where(x => x.Id == request.Id).SingleAsync();
                entity.ThrowIfNull("网格不存在");

                updateGrids.Add($"{entity.Name}->{request.Name}");
                request.Adapt(entity);

                await _dbContext.UpdateAsync(entity);
            }
        }

        await _operateLog.LogAsync(OperateLogType.WorkGrid, "创建网格:" + insertGrids.Join("\r\n"));
        await _operateLog.LogAsync(OperateLogType.WorkGrid, "修改网格:" + updateGrids.Join("\r\n"));
    }

    /// <inheritdoc />
    public async Task<Pagination<WorkGridPageResponse>> GetPageAsync(WorkGridPageRequest request)
    {
        var role = _currentUser.GetRole();
        var userCode = _currentUser.GetUserClaim(UserClaimConstants.JinkoCode);
        var isAll = role is "admin" or "tenant-admin";

        return await _dbContext.Queryable<WorkGridEntity>()
            .LeftJoin<GainfoEntity>((x, ga) => x.LeaderUserCode == ga.Code)
            .WhereIF(!isAll, x => x.LeaderUserCode == userCode)
            .WhereIF(request.Search.IsPresent(), x => x.Name.Contains(request.Search) || x.LeaderUserCode == request.Search)
            .Select((x, ga) => new WorkGridPageResponse
            {
                Id = x.Id,
                Code = x.Code,
                Name = x.Name,
                LeaderUserCode = x.LeaderUserCode,
                UserName = ga.Name,
                Remark = x.Remark,
                UserCount = SqlFunc.Subqueryable<WorkGridUserEntity>().Where(p => p.WorkGridCode == x.Code).Count()
            })
            .ToPageListAsync(request);
    }

    /// <inheritdoc />
    public async Task ChangeAsync(string from, string to)
    {
        var workGrid = await _dbContext.Queryable<WorkGridEntity>().Where(x => x.LeaderUserCode == from).SingleAsync();
        workGrid.ThrowIfNull("网格不存在");

        var gainfo = await _dbContext.Queryable<GainfoEntity>().Where(x => x.Code == to).SingleAsync();
        gainfo.ThrowIfNull($"{to}人员不存在");

        workGrid.LeaderUserCode = to;
        await _dbContext.UpdateAsync(workGrid);

        await _operateLog.LogAsync(OperateLogType.WorkGrid, $"网格({workGrid.Name})修改负责人{from}->{to}");
    }

    /// <inheritdoc />
    public async Task<WorkGridUserPageResponse> GetMyWorkGridAsync(WorkGridPageRequest request)
    {
        var currentUserCode = _currentUser.GetUserClaim("jinko-code");
        var myWorkGrid = await _dbContext.Queryable<WorkGridEntity>()
            .WhereIF(request.WorkGridCode.HasValue == false, x => x.LeaderUserCode == currentUserCode)
            .WhereIF(request.WorkGridCode.HasValue, x => x.Code == request.WorkGridCode)
            .Select(x => new WorkGridUserPageResponse
            {
                Id = x.Id,
                Code = x.Code,
                Name = x.Name,
                Remark = x.Remark,
                UserInfos = SqlFunc.Subqueryable<WorkGridUserEntity>()
                    .LeftJoin<GainfoEntity>((p, ga) => p.UserCode == ga.Code)
                    .Where((p, ga) => p.WorkGridCode == x.Code)
                    .WhereIF(request.Search.IsPresent(), (p, ga) => p.UserCode == request.Search || ga.Name.Contains(request.Search))
                    .ToList((p, ga) => new WorkGridUserPageDetailResponse
                    {
                        Code = p.UserCode,
                        Name = ga.Name
                    })
            })
            .SingleAsync();

        return myWorkGrid;
    }

    /// <inheritdoc />
    public async Task AssignAsync(WorkGridUserAssignRequest request)
    {
        var currentFactory = _currentUser.GetStringTenantId();
        var currentUserCode = _currentUser.GetUserClaim("jinko-code");

        var myWorkGrid = await _dbContext.Queryable<WorkGridEntity>().Where(x => x.LeaderUserCode == currentUserCode).SingleAsync();
        myWorkGrid.ThrowIfNull("工作网格尚未配置,请联系管理员");

        //检查配置的人员
        var count = await _dbContext.Queryable<GainfoEntity>()
            .Where(x => x.Factory == currentFactory)
            .Where(x => request.UserCodes.Contains(x.Code))
            .CountAsync();

        (count != request.UserCodes.Count).ThrowIfTrue("存在非当前厂区人员,请检查");

        var existsAssigned = await _dbContext.Queryable<WorkGridUserEntity>().Where(x => x.WorkGridCode == myWorkGrid.Code)
            .Where(x => request.UserCodes.Contains(x.UserCode))
            .AnyAsync();
        existsAssigned.ThrowIfTrue("存在已经分配人员,请勿重复分配");

        var dataToInserts = request.UserCodes.Select(x => new WorkGridUserEntity
        {
            WorkGridCode = myWorkGrid.Code,
            UserCode = x
        }).ToList();

        await _dbContext.InsertAsync(dataToInserts);
        await _operateLog.LogAsync(OperateLogType.WorkGrid, $"分配人员到网格({myWorkGrid.Name}),人员:{dataToInserts.Select(x => x.UserCode).Join(",")}");
    }

    /// <inheritdoc />
    public async Task RemoveAsync(WorkGridUserRemoveRequest request)
    {
        var currentUserCode = _currentUser.GetUserClaim("jinko-code");
        var myWorkGrid = await _dbContext.Queryable<WorkGridEntity>().Where(x => x.LeaderUserCode == currentUserCode).SingleAsync();
        myWorkGrid.ThrowIfNull("工作网格尚未配置,请联系管理员");

        var workGridUsers = await _dbContext.Queryable<WorkGridUserEntity>().Where(x => x.WorkGridCode == myWorkGrid.Code)
            .Where(x => request.UserCodes.Contains(x.UserCode))
            .ToListAsync();

        var workGridSchedules = await _dbContext.Queryable<WorkGridScheduleEntity>().Where(x => x.WorkGridCode == myWorkGrid.Code)
            .Where(x => request.UserCodes.Contains(x.UserCode))
            .ToListAsync();

        await _dbContext.DeleteReallyAsync(workGridUsers);
        await _dbContext.DeleteReallyAsync(workGridSchedules);

        await _operateLog.LogAsync(OperateLogType.WorkGrid, $"从网格({myWorkGrid.Name})移除人员:{request.UserCodes.Join(",")}");
    }
}