jinko.yikatong/Src/Dlhis.Basic/Places/Services/Implements/BusinessPlaceService.cs

using Dlhis.Basic.Places.Request;
using Dlhis.Basic.Places.Response;
using Dlhis.Entity.Basic.Entity;
using Dlhis.Entity.Canteen.Enums;
using Kurisu.AspNetCore.DataAccess.Dto;
using Kurisu.AspNetCore.DataAccess.SqlSugar.Extensions;
using Kurisu.AspNetCore.DataAccess.SqlSugar.Services;
using Kurisu.AspNetCore.Utils.Extensions;
using Mapster;

namespace Dlhis.Basic.Places.Services.Implements;

public class BusinessPlaceService : IBusinessPlaceService
{
    private readonly IDbContext _dbContext;
    private readonly IBusinessPlacePermissionsService _businessPlacePermissionsService;

    public BusinessPlaceService(IDbContext dbContext, IBusinessPlacePermissionsService businessPlacePermissionsService)
    {
        _dbContext = dbContext;
        _businessPlacePermissionsService = businessPlacePermissionsService;
    }

    public async Task<Pagination<BusinessPlaceResponse>> GetPageAsync(BusinessPlacePageRequest request)
    {
        var myCodes = await GetMyBusinessPlaceCodesAsync();

        var page = await _dbContext.Queryable<BusinessPlaceEntity>()
            .LeftJoin<BusinessPlaceShiftRelationshipEntity>((x, ps) => x.Code == ps.PlaceCode)
            .LeftJoin<BusinessShiftEntity>((x, ps, s) => s.Code == ps.ShiftCode)
            .WhereIF(request.Search.IsPresent(), x => x.CustomCode.Contains(request.Search)
                                                      || x.Code.ToString().Contains(request.Search)
                                                      || x.Name.Contains(request.Search))
            .WhereIF(request.Catalog.HasValue, x => x.Catalog == request.Catalog)
            .WhereIF(request.Status.HasValue, x => x.Status == request.Status)
            .WhereIF(request.Source.HasValue, x => x.Source == request.Source)
            .Where(x => myCodes.Contains(x.Code))
            .Select((x, ps, s) => new BusinessPlaceResponse
            {
                Id = x.Id,
                Code = x.Code,
                Status = x.Status,
                Name = x.Name,
                Catalog = x.Catalog,
                CustomCode = x.CustomCode,
                Source = x.Source,
                Supplier = x.Supplier,
                ShiftCode = s.Code,
                ShiftName = s.Name
            })
            .ToPageListAsync(request);

        return page;
    }


    public async Task<List<BusinessPlaceListResponse>> GetOpenedListAsync(Guid? placeCode = null, string tenant = null)
    {
        var list = await _dbContext.Queryable<BusinessPlaceEntity>()
            .LeftJoin<BusinessPlaceShiftRelationshipEntity>((x, ps) => x.Code == ps.PlaceCode)
            .LeftJoin<BusinessShiftEntity>((x, ps, s) => s.Code == ps.ShiftCode)
            .Where(x => x.Status == CanteenBusinessPlaceStatusEnumType.Opened)
            .WhereIF(placeCode.HasValue, x => x.Code == placeCode)
            .WhereIF(tenant.IsPresent(), x => x.TenantId == tenant)
            .Select((x, ps, s) => new BusinessPlaceListResponse
            {
                Id = x.Id,
                Code = x.Code,
                Status = x.Status,
                Name = x.Name,
                Catalog = x.Catalog,
                CustomCode = x.CustomCode,
                Source = x.Source,
                Supplier = x.Supplier,
                ShiftCode = s.Code,
                ShiftName = s.Name,
            })
            .ToListAsync();

        var shiftCodes = list.Where(x => x.ShiftCode.HasValue).Select(x => x.ShiftCode.Value).ToList();

        var shiftTypes = await _dbContext.Queryable<BusinessShiftMealRelationshipEntity>()
            .Where(x => shiftCodes.Contains(x.ShiftCode))
            .Select(x => new { x.ShiftCode, x.ShiftType })
            .ToListAsync();

        list.ForEach(item =>
        {
            if (item.ShiftCode.HasValue)
            {
                item.ShiftTypes = shiftTypes.Where(x => x.ShiftCode == item.ShiftCode.Value)
                    .Select(x => new Dictionary<int, string>() { [(int)x.ShiftType] = x.ShiftType.GetDescription() })
                    .ToList();
            }
        });

        return list;
    }


    public async Task SaveAsync(BusinessPlaceSaveRequest request)
    {
        await CheckExistsCustomCodeAsync(request);

        if (!request.Id.HasValue)
        {
            var entity = request.Adapt<BusinessPlaceEntity>();
            entity.CustomCode = request.CustomCode;
            entity.Code = Guid.NewGuid();
            await _dbContext.InsertAsync(entity);
        }
        else
        {
            var entity = await _dbContext.Queryable<BusinessPlaceEntity>().FirstAsync(x => x.Id == request.Id);
            request.Adapt(entity);

            await _dbContext.UpdateAsync(entity);
        }
    }


    public async Task SaveShiftAsync(BusinessPlaceSaveShiftRequest request)
    {
        var place = await _dbContext.Queryable<BusinessPlaceEntity>().Where(x => x.Id == request.Id).FirstAsync();
        place.ThrowIfNull("营业点不存在");

        var relationship = await _dbContext.Queryable<BusinessPlaceShiftRelationshipEntity>().Where(x => x.PlaceCode == place.Code).FirstAsync();
        if (relationship == null)
        {
            await _dbContext.InsertAsync(new BusinessPlaceShiftRelationshipEntity
            {
                PlaceCode = place.Code,
                ShiftCode = request.ShiftCode,
            });
        }
        else
        {
            relationship.ShiftCode = request.ShiftCode;
            await _dbContext.UpdateAsync(relationship);
        }
    }

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

    /// <summary>
    /// 检查重复手工号
    /// </summary>
    /// <param name="request"></param>
    /// <returns></returns>
    private async Task CheckExistsCustomCodeAsync(BusinessPlaceSaveRequest request)
    {
        var existsSameCustomCode = await _dbContext.Queryable<BusinessPlaceEntity>()
            .Where(x => x.CustomCode == request.CustomCode)
            .WhereIF(request.Id.HasValue, x => x.Id != request.Id)
            .AnyAsync();

        existsSameCustomCode.ThrowIfTrue($"自定义手工号[{request.CustomCode}]存在重复,请检查.");
    }

    /// <summary>
    /// 获取我的营业点
    /// </summary>
    /// <returns></returns>
    private async Task<List<Guid>> GetMyBusinessPlaceCodesAsync()
    {
        return (await _businessPlacePermissionsService.GetMyAsync()).Select(x => x.Code).ToList();
    }
}