jinko.yikatong/Src/Dlhis.Visitor/Appointment/Services/Implements/AppointmentAreaService.cs

using Dlhis.Entity.Basic.Entity;
using Dlhis.Entity.Device.Entities;
using Dlhis.Entity.Device.Enums;
using Dlhis.Entity.Visitor.Entity;
using Dlhis.Entity.Visitor.Enums;
using Dlhis.Visitor.Appointment.Request;
using Dlhis.Visitor.Appointment.Response;
using Kurisu.AspNetCore.Utils.Extensions;
using Kurisu.Core.DataAccess.Dto;
using Kurisu.SqlSugar.Extensions;
using Kurisu.SqlSugar.Services;
using Mapster;

namespace Dlhis.Visitor.Appointment.Services.Implements;

public class AppointmentAreaService : IAppointmentAreaService
{
    private readonly IDbContext _dbContext;

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

    public async Task<Pagination<ApponintmentAreaPageResponse>> GetPageAsync(PageDto request)
    {
        return await _dbContext.Queryable<AppointmentAreaEntity>()
            .Select<ApponintmentAreaPageResponse>()
            .ToPageListAsync(request);
    }


    public async Task SaveAsync(AppointmentAreaSaveRequest request)
    {
        await CheckCustomCodeDuplicateAsync(request);

        if (!request.Id.HasValue)
        {
            var entity = request.Adapt<AppointmentAreaEntity>();
            entity.Type = request.Type;
            entity.CustomCode = request.CustomCode;

            await _dbContext.InsertAsync(entity);
        }
        else
        {
            var entity = await _dbContext.Queryable<AppointmentAreaEntity>().Where(x => x.Id == request.Id).SingleAsync();
            entity.ThrowIfNull("预约区域不存在");

            request.Adapt(entity);

            await _dbContext.UpdateAsync(entity);
        }
    }


    public async Task DeleteAsync(long id)
    {
        var entity = await _dbContext.Queryable<AppointmentAreaEntity>().Where(x => x.Id == id).SingleAsync();
        await _dbContext.DeleteAsync(entity);
    }


    public async Task AssignAsync(AppointmentAreaAssignRequest request)
    {
        var userNos = await _dbContext.Queryable<VisitorAppointmentDetailEntity>()
            .LeftJoin<VisitorAppointmentEntity>((x, y) => x.FlowId == y.FlowId)
            .Where(x => x.Status == AppointmentDetailEnumType.Arrived)
            .Where((x, y) => y.AreaCustomCode == request.CustomCode)
            .Select(x => x.UserNo)
            .ToListAsync();

        //通过人
        var deviceCodes = await _dbContext.Queryable<AppointmentAreaAssignmentEntity>()
            .Where(x => x.CustomCode == request.CustomCode).Select(x => x.DeviceCode).ToListAsync();

        var userPermissions = userNos.ToDictionary(x => x, _ => deviceCodes.ToList());

        await _dbContext.Client.Deleteable<AppointmentAreaAssignmentEntity>()
            .Where(x => x.CustomCode == request.CustomCode)
            .ExecuteCommandAsync();

        var data = request.DeviceCodes.Select(x => new AppointmentAreaAssignmentEntity
        {
            CustomCode = request.CustomCode,
            DeviceCode = x
        }).ToList();

        await _dbContext.InsertAsync(data);


        deviceCodes = await _dbContext.Queryable<AppointmentAreaAssignmentEntity>()
            .Where(x => x.CustomCode == request.CustomCode).Select(x => x.DeviceCode).ToListAsync();

        var devices = await _dbContext.Queryable<DeviceEntity>().Where(x => deviceCodes.Contains(x.Code)).ToListAsync();

        var userCurrentPermissions = userNos.ToDictionary(x => x, _ => deviceCodes.ToList());

        var tasks = new List<DeviceTaskEntity>();
        foreach (var userNo in userNos)
        {
            var before = userPermissions[userNo];
            var current = userCurrentPermissions[userNo];

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

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

            tasks.AddRange(deletedItems.Select(x => new DeviceTaskEntity
            {
                Type = DeviceTaskEnumType.Delete,
                DeviceType = DeviceTypeEnumType.Door,
                UserNo = userNo,
                DeviceUniqueNo = devices.First(item => item.Code == x).UniqueNo,
                Status = DeviceTaskStatusEnumType.Wait,
                Version = 0,
                CancellationId = 0,
                Source = DeviceTaskSourceEnumType.Appointment,
                Priority = 99
            }));

            tasks.AddRange(addItems.Select(x => new DeviceTaskEntity
            {
                Type = DeviceTaskEnumType.Add,
                DeviceType = DeviceTypeEnumType.Door,
                UserNo = userNo,
                DeviceUniqueNo = devices.First(item => item.Code == x).UniqueNo,
                Status = DeviceTaskStatusEnumType.Wait,
                Version = 0,
                CancellationId = 0,
                Source = DeviceTaskSourceEnumType.Appointment,
                Priority = 99
            }));
        }

        await _dbContext.InsertAsync(tasks);
    }


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


    /// <summary>
    /// 检查编码重复
    /// </summary>
    /// <param name="request"></param>
    /// <returns></returns>
    private async Task CheckCustomCodeDuplicateAsync(AppointmentAreaSaveRequest request)
    {
        var exists = await _dbContext.Queryable<AppointmentAreaEntity>()
            .Where(x => x.CustomCode == request.CustomCode)
            .WhereIF(request.Id.HasValue, x => x.Id == request.Id)
            .AnyAsync();

        exists.ThrowIfTrue("重复区域编码,请检查");
    }
}