jinko.yikatong/Src/Dlhis.Canteen/Order/Services/Implements/MiniProgramOrderDetailService.cs

using Dlhis.Canteen.Order.Request;
using Dlhis.Canteen.Order.Response;
using Dlhis.Entity.Basic.Entity;
using Dlhis.Entity.Canteen.Entities;
using Dlhis.Entity.Canteen.Enums;
using Dlhis.Sys.Api;
using Kurisu.AspNetCore.Utils;
using Kurisu.AspNetCore.Utils.Extensions;
using Kurisu.Core.DataAccess.Dto;
using Kurisu.SqlSugar.Extensions;
using Kurisu.SqlSugar.Services;
using Mapster;
using SqlSugar;

namespace Dlhis.Canteen.Order.Services.Implements;

public class MiniProgramOrderDetailService : IMiniProgramOrderDetailService
{
    private readonly IDbContext _dbContext;
    private readonly ITenantApi _tenantApi;
    public MiniProgramOrderDetailService(IDbContext dbContext, ITenantApi tenantApi)
    {
        _dbContext = dbContext;
        _tenantApi = tenantApi;
    }

    public async Task<Pagination<GetMiniProgramOrderResponse>> GetMiniProgramOrderAsync(GetMiniProgramOrderRequest request)
    {
        var page = await _dbContext.Queryable<MiniProgramOrderEntity>()
            .LeftJoin<BusinessPlaceEntity>((order, place) => order.PlaceCode == place.Code)
            .LeftJoin<CanteenDishesEntity>((order, place, dishers) => order.DishesCode == dishers.CustomCode)
            .LeftJoin<DepartmentEntity>((order, place, dishers, depart) => order.DepartmentNo == depart.No)
            .WhereIF(!request.Search.IsEmpty(), order => order.Name == request.Search || order.Code == request.Search)
            .WhereIF(request.SysDate.HasValue, order => order.SysDate == request.SysDate)
            .OrderBy(order => order.CostDate, OrderByType.Desc)
            .Select((order, place, dishers, depart) => new GetMiniProgramOrderResponse
            {
                PlaceName = place.Name,
                DepartmentName = depart.Name,
                DishesName = dishers.Name,
            }, true)
            .ToPageListAsync(request);
        return page;
    }

    public async Task SaveDetailAsync(SaveDetailRequest request)
    {
        if (!request.Id.HasValue)
        {
            var entity = request.Adapt<OrderDetailsEntity>();
            await _dbContext.InsertAsync(entity);
        }
        else
        {
            var entity = await _dbContext.Queryable<OrderDetailsEntity>()
                .Where(x => x.Id == request.Id)
                .FirstAsync();
            request.Adapt(entity);
            await _dbContext.UpdateAsync(entity);
        }
    }

    public async Task<Pagination<GetDetailResponse>> GetDetailAsync(GetDetailRequest request)
    {
        var page = await _dbContext.Queryable<OrderDetailsEntity>()
            .WhereIF(!request.Search.IsEmpty(), x => x.ThirdNo == request.Search)
            .Select<GetDetailResponse>()
            .ToPageListAsync(request);

        return page;
    }

    public async Task OrderAsync(OrderRequest request)
    {
        //判断时间
        DateTime currentTime = DateTime.Now;
        TimeSpan ninePM = new TimeSpan(20, 30, 0);
        if (currentTime.TimeOfDay > ninePM)
        {
            true.ThrowIfTrue("20:30之后无法订餐!");
        }
        //判断营业日
        var dishes = await _dbContext.Queryable<CanteenDishesEntity>().Where(x => x.CustomCode == request.DishesCode).FirstAsync();
        dishes.Enable.ThrowIfFalse($"{dishes.Name}没启用!");

        var menu = await _dbContext.Queryable<CanteenMenuEntity>().Where(x => x.Code == request.MenuCode).FirstAsync();
        menu.Enable.ThrowIfFalse($"{dishes.Name}没启用!");

        // 获取用餐日期
        DateOnly tomorrow = DateOnly.FromDateTime(DateTime.Today.AddDays(1));
        if (tomorrow != menu.StartDate)
        {
            true.ThrowIfTrue($"菜品:{dishes.Name}对应的菜单:{menu.Name}不在营业日!");
        }

        var restricted = await _dbContext.Queryable<CanteenMenuDishersRelationshipEntity>()
            .Where(x => x.MenuCode == request.MenuCode && x.DishersCode == request.DishesCode).FirstAsync();
        restricted.ThrowIfNull($"每日菜单:{menu.Name} 还没有配置菜品:{dishes.Name} 的限售数量!");
        if (restricted.RestrictedNum < 0)
        {
            true.ThrowIfTrue($"菜品:{dishes.Name}已售罄!");
        }

        var gainfo = await _dbContext.Queryable<GainfoEntity>()
            .Where(x => x.Code == request.UserCode)
            .FirstAsync();
        gainfo.ThrowIfNull($"用户{request.UserCode}无档案信息，无法订餐!");

        //判断是否订过餐
        var flag = await _dbContext.Queryable<MiniProgramOrderEntity>()
            .Where(x => x.SysDate == tomorrow && x.ShiftType == request.ShiftType && x.Code == request.UserCode && x.OrderStatus == MiniProgramOrderStatusEnumType.I)
            .AnyAsync();
        flag.ThrowIfTrue($"工号:{request.UserCode} 姓名:{gainfo.Name} 已经定过{tomorrow}的{request.ShiftType.GetDescription()}!");

        //支付方式
        /* var result = await _tenantApi.GetTenantTreeAsync();
         var tree = result.Data;
         var shanxi = tree.Where(x => x.Name == "山西基地").FirstOrDefault();
         var codes = shanxi.Next.Select(x => x.Code).ToList();
         if (!codes.Contains(gainfo.Factory))
         {
             if (request.PayType == CanteenPayEnumType.Repair)
             {
                 true.ThrowIfTrue($"非山西，支付方式不能为{request.PayType.GetDescription()}");
             }
         }*/

        //生成订单
        var order = new MiniProgramOrderEntity
        {
            No = "O" + SnowFlakeHelper.Instance.NextId(),
            Name = gainfo.Name,
            Code = gainfo.Code,
            Werks = gainfo.Werks,
            DepartmentNo = gainfo.DepartmentNo,
            CostId = gainfo.CostId,
            Workplace = gainfo.Workplace,
            Factory = gainfo.Factory,
            PlaceCode = request.PlaceCode,
            ShiftType = request.ShiftType,
            DishesCode = request.DishesCode,
            Phone = gainfo.Phone,
            SysDate = tomorrow,
            CostDate = DateTime.Now,
            PayType = request.PayType,
            OrderStatus = MiniProgramOrderStatusEnumType.I,
            OrderType = dishes.Type,
        };
        //生成订单明细
        var detail = new OrderDetailsEntity
        {
            ThirdNo = order.No,
            SysDate = tomorrow,
            ShiftType = request.ShiftType,
            DishesCode = request.DishesCode,
            DishesName = dishes.Name,
            Price = dishes.Price,
            Unit = dishes.Unit,
            Number = request.DishesNum,
            Amount = request.DishesNum * dishes.Price,
            Status = OrderDetailsStatusEnumType.I,
        };
        order.Amount = detail.Amount;
        await _dbContext.InsertAsync(order);
        await _dbContext.InsertAsync(detail);

        //扣减份数
        var effect = await _dbContext.Updateable<CanteenMenuDishersRelationshipEntity>()
             .SetColumns(x => x.RestrictedNum == restricted.RestrictedNum - request.DishesNum)
             .SetColumns(x => x.Version == x.Version + 1)
             .Where(x => x.MenuCode == request.MenuCode && x.DishersCode == request.DishesCode && x.Version == restricted.Version)
             .ExecuteCommandAsync();

        if (effect <= 0) throw new VersionExceptions("更新版本冲突");
    }

}