jinko.yikatong/Src/Dlhis.Basic/BusinessShift/Services/Implements/BusinessPlaceShiftService.cs

using Dlhis.Basic.Places.Request;
using Dlhis.Basic.BusinessPlace.Response;
using Dlhis.Basic.BusinessShift.Request;
using Dlhis.Basic.BusinessShift.Response;
using Dlhis.Entity.Basic.Entity;
using Dlhis.Entity.Device.Entities;
using Dlhis.Sys.Api;
using Kurisu.AspNetCore.Utils.Extensions;
using Kurisu.Core.CustomClass;
using Kurisu.Core.DataAccess.Dto;
using Kurisu.Core.Result;
using Kurisu.SqlSugar.Extensions;
using Kurisu.SqlSugar.Services;
using Mapster;
using System.Collections.Generic;

namespace Dlhis.Basic.BusinessShift.Services.Implements;

public class BusinessPlaceShiftService : IBusinessPlaceShiftService
{
    private readonly IDbContext _dbContext;
    private readonly ITenantApi _tenantApi;

    public BusinessPlaceShiftService(IDbContext dbContext, ITenantApi tenantApi)
    {
        _dbContext = dbContext;
        _tenantApi = tenantApi;
    }

    public async Task<Pagination<BusinessPlaceShiftResponse>> GetPageAsync(BusinessPlaceShiftPageRequest request)
    {
        var page = await _dbContext.Queryable<BusinessShiftEntity>()
                .WhereIF(request.Search.IsPresent(), (shift) => shift.CustomCode.Contains(request.Search) || shift.Name.Contains(request.Search))
                .Select<BusinessPlaceShiftResponse>()
               .ToPageListAsync(request);

        var shiftCodes = page.Data.Select(x => x.Code).ToList();

        //下级就餐时间段
        var mealShifts = await _dbContext.Queryable<BusinessShiftMealRelationshipEntity>()
                .Where(x => shiftCodes.Contains(x.ShiftCode))
                .Select((x) => new MealShiftResponse
                {
                    Id = x.Id,
                    ShiftCode = x.ShiftCode,
                    ShiftType = x.ShiftType,
                    Start = x.Start,
                    End = x.End,
                })
                .ToListAsync();

        page.Data.ForEach(x =>
        {
            x.MealShifts = mealShifts.Where(item => item.ShiftCode == x.Code).ToList();
        });

        return page;
    }

    public async Task<List<BusinessPlaceShiftResponse>> GetListAsync()
    {
        var result = await _dbContext.Queryable<BusinessShiftEntity>()
            .Select<BusinessPlaceShiftResponse>()
            .ToListAsync();

        return result;
    }

    public async Task<Guid> SaveAsync(BusinessPlaceShiftSaveRequest request)
    {
        await CheckExistsAsync(request);

        if (!request.Id.HasValue)
        {
            var entity = request.Adapt<BusinessShiftEntity>();
            entity.CustomCode = request.CustomCode;
            entity.Code = Guid.NewGuid();
            await _dbContext.InsertAsync(entity);

            return entity.Code;
        }
        else
        {
            var entity = await _dbContext.Queryable<BusinessShiftEntity>().FirstAsync(x => x.Id == request.Id);
            entity.ThrowIfNull("餐次不存在");

            request.Adapt(entity);
            await _dbContext.UpdateAsync(entity);

            return entity.Code;
        }
    }

    public async Task SaveMealShiftsAsync(List<BusinessPlaceShiftSaveMealShiftRequest> requests)
    {
        foreach (var request in requests)
        {
            var shift = await CheckExistsShiftAsync(request.ShiftCode);
            await CheckExistsMealShiftAsync(request);
            await DuplicateTimePeriodAsync(request);

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

                entity.ShiftCode = shift.Code;
                entity.ShiftCustomCode = shift.CustomCode;
                entity.Start = request.TimePeriod.Start.Value;
                entity.End = request.TimePeriod.End.Value;

                await _dbContext.InsertAsync(entity);
            }
            else
            {
                var entity = await _dbContext.Queryable<BusinessShiftMealRelationshipEntity>().FirstAsync(x => x.Id == request.Id);
                entity.ThrowIfNull("餐次段不存在");

                request.Adapt(entity);
                await _dbContext.UpdateAsync(entity);
            }
        }
    }


    public async Task<BusinessPlaceWithShiftResponse> GetShiftsByPlaceCustomCodeAsync(string placeCustomCode)
    {
        var place = await _dbContext.Queryable<BusinessPlaceEntity>().Where(x => x.CustomCode == placeCustomCode).FirstAsync();
        if (place == null)
        {
            return new BusinessPlaceWithShiftResponse()
            {
                Shifts = new List<BusinessPlaceShiftTinyResponse>()
            };
        }

        var tenantResult = await _tenantApi.GetTenantByCodeAsync(place.TenantId);
        (tenantResult.Code == ApiStateCode.Success).ThrowIfFalse(tenantResult.Msg);
        var tenantInfo = tenantResult.Data;

        var relationship = await _dbContext.Queryable<BusinessPlaceShiftRelationshipEntity>().Where(x => x.PlaceCode == place.Code).FirstAsync();
        if (relationship == null)
        {
            return new BusinessPlaceWithShiftResponse()
            {
                CustomCode = placeCustomCode,
                Name = place.Name,
                TenantCode = tenantInfo.Code,
                TenantName = tenantInfo.Name,
                Shifts = new List<BusinessPlaceShiftTinyResponse>()
            };
        }

        var shifts = await _dbContext.Queryable<BusinessShiftMealRelationshipEntity>()
            .Where(x => x.ShiftCode == relationship.ShiftCode)
            .OrderBy(x => x.Sequence) //排序
            .ToListAsync();

        var list = new List<BusinessPlaceShiftTinyResponse>();

        foreach (BusinessShiftMealRelationshipEntity shiftinfo in shifts)
        {
            var name = _dbContext.Queryable<BasicTypeEntity>()
                    .Where(x => x.Code == shiftinfo.ShiftType.ToString())
                    .Select(x => x.Display)
                    .First();

            var shift = new BusinessPlaceShiftTinyResponse
            {
                CustomCode = shiftinfo.Id.ToString(),
                Name = name,
                Start = shiftinfo.Start,
                End = shiftinfo.End
            };

            list.Add(shift);
        }
        return new BusinessPlaceWithShiftResponse
        {
            CustomCode = placeCustomCode,
            Name = place.Name,
            TenantCode = tenantInfo.Code,
            TenantName = tenantInfo.Name,
            Shifts = list
        };
    }

    public async Task<Pagination<DeviceCodeNameDetail>> GetDevicesByCode(BusinessPlaceGetByCodeRequest request)
    {
        var regiss = await _dbContext.Queryable<DeviceRegistryEntity>()
            .Where(x => x.BusinessPlaceCode.ToString() == request.Code)
            .ToListAsync();

        var devices = await _dbContext.Queryable<DeviceEntity>().ToListAsync();

        var list = new List<DeviceCodeNameDetail>();
        if (regiss.Count > 0)
        {
            foreach (var regis in regiss)
            {
                var device = devices.Where(x => x.UniqueNo == regis.DeviceUniqueNo)
                    .FirstOrDefault();
                if (device != null)
                {
                    var detail = new DeviceCodeNameDetail
                    {
                        UniqueNo = regis.DeviceUniqueNo,
                        UniqueName = device.Supplier
                    };
                    list.Add(detail);
                }
            }
        }
        //分页
        var startIndex = (request.PageIndex - 1) * request.PageSize;
        var pagedData = list.Skip(startIndex).Take(request.PageSize).ToList();

        var pagination = new Pagination<DeviceCodeNameDetail>
        {
            PageIndex = request.PageIndex,
            PageSize = request.PageSize,
            Total = list.Count, // 使用原始列表的总数进行分页
            Data = pagedData
        };

        return pagination;
    }


    public async Task DispositionDeviceAsync(DispositionDeviceRequest request)
    {
        var places = await _dbContext.Queryable<BusinessPlaceEntity>().ToListAsync();
        var place = places.Where(x => x.Code.ToString() == request.PlaceCode).First();
        place.ThrowIfNull($"{request.PlaceCode}:该营业点不存在");

        var devices = await _dbContext.Queryable<DeviceEntity>().ToListAsync();

        if (request.UniqueNos != null && request.UniqueNos.Count > 0)
        {
            foreach (var no in request.UniqueNos)
            {
                var device = devices.Where(x => x.UniqueNo == no).FirstOrDefault();
                device.ThrowIfNull($"{no}:设备不存在");
            }
        }

        var regiss = await _dbContext.Queryable<DeviceRegistryEntity>()
            .Where(x => request.UniqueNos.Contains(x.DeviceUniqueNo))
            .ToListAsync();

        var list = new List<DeviceRegistryEntity>();

        foreach (var regis in regiss)
        {
            regis.BusinessPlaceCode = place.Code;
            regis.BusinessPlaceCustomCode = place.CustomCode;
            list.Add(regis);
        }
        await _dbContext.UpdateAsync(list);
    }

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

    /// <summary>
    /// 时间段重合检查
    /// </summary>
    /// <param name="request"></param>
    /// <returns></returns>
    private async Task DuplicateTimePeriodAsync(BusinessPlaceShiftSaveMealShiftRequest request)
    {
        var periods = await _dbContext.Queryable<BusinessShiftMealRelationshipEntity>()
              .Where(x => x.ShiftCode == request.ShiftCode)
              .WhereIF(request.Id.HasValue, x => x.Id != request.Id)
              .Select(x => new TimePeriod
              {
                  Start = x.Start,
                  End = x.End,
              })
              .ToListAsync();

        foreach (var period in periods)
        {
            period.IsDuplicate1(request.TimePeriod).ThrowIfTrue($"存在时间段重合[{period.Start}-{period.End}]");
        }
    }


    /// <summary>
    /// 检查重复
    /// </summary>
    /// <param name="request"></param>
    /// <returns></returns>
    private async Task CheckExistsAsync(BusinessPlaceShiftSaveRequest request)
    {
        var existsSameCustomCode = await _dbContext.Queryable<BusinessShiftEntity>()
               .Where(x => x.CustomCode == request.CustomCode || x.Name == request.Name)
               .WhereIF(request.Id.HasValue, x => x.Id != request.Id)
               .AnyAsync();

        existsSameCustomCode.ThrowIfTrue($"自定义手工号或者名称存在重复,请检查.");
    }

    private async Task<BusinessShiftEntity> CheckExistsShiftAsync(Guid shiftCode)
    {
        var shift = await _dbContext.Queryable<BusinessShiftEntity>().Where(x => x.Code == shiftCode).FirstAsync();
        shift.ThrowIfNull("餐次不存在");

        return shift;
    }

    private async Task CheckExistsMealShiftAsync(BusinessPlaceShiftSaveMealShiftRequest request)
    {
        var exists = await _dbContext.Queryable<BusinessShiftMealRelationshipEntity>()
                .Where(x => x.ShiftCode == request.ShiftCode)
                .Where(x => x.ShiftType == request.ShiftType)
                .WhereIF(request.Id.HasValue, x => x.Id != request.Id)
                .AnyAsync();

        exists.ThrowIfTrue("重复设置!");
    }
}