maersai_heavy_back_main/Service/Execute/Mgr/CommonMgr.cs

using Autofac;
using AutoMapper;
using Entity.Constant;
using Entity.DbModel.Station;
using Entity.Dto;
using HybirdFrameworkCore.Autofac;
using HybirdFrameworkCore.Autofac.Attribute;
using Repository.Station;
using Service.Execute.Model;
using Service.Init;
using Service.Station;

namespace Service.Execute.Utils;

[Scope("SingleInstance")]
public class CommonMgr
{
    public SwapOrderStepService _swapOrderStepService { get; set; }
    public SwapOrderRepository _swapOrderRepository { get; set; }

    public BinInfoRepository _binInfoRepository { get; set; }
    public SwapAmtOrderRepository _amtOrderRepository { get; set; }
    public SwapOrderBatteryRepository _swapOrderBatteryRepository { get; set; }

    public SwapOrderReportCloudRepository _swapOrderReportCloudRepository { get; set; }

    /// <summary>
    /// 新增小步状态
    /// </summary>
    public void InsertStep(InfoEnum.BusinessSwappingStep step, SwappingStateMachine machine)
    {
        machine.StepModel.Add(new()
        {
            StepName = BaseEnumExtensions.GetDescription(step),
            StepNo = (int)step,
            StartTime = DateTime.Now
        });
        _swapOrderStepService.InsertSwapStepForSwapMain(step,
            machine.StepSort++, machine.SwapOrder.Sn);
    }


    /// <summary>
    /// 新增换电订单
    /// </summary>
    /// <param name="swapOrder"></param>
    /// <returns></returns>
    public SwapOrder SaveOrder(SwapOrder swapOrder)
    {
        swapOrder.SwapWay = (int)StationConstant.StationWay.Auto;
        swapOrder.CloudReportStatus = 0;
        swapOrder.SwapWay = 1;
        swapOrder.CreatedTime = DateTime.Now;
        _swapOrderRepository.Insert(swapOrder);
        return swapOrder;
    }


    public void SaveSwapBattery(SwappingStateMachine machine)
    {
        BinInfo upBin = machine.SwapOrderBatteryInfo.UpBinInfo;
        BinInfo inBin = machine.SwapOrderBatteryInfo.InBinInfo;
        SwapOrderBattery swapOrderBattery = new SwapOrderBattery()
        {
            SwapOrderSn = machine.SwapOrder.Sn,
            UpBatterySoc = upBin.Soc,
            UpBatteryNo = upBin.BatteryNo,
            UpBatterySoe = upBin.Soe,
            UpBatteryBinNo = int.Parse(upBin.No),
            DownBatteryBinNo = int.Parse(inBin.No),
            DownBatteryNo = inBin.BatteryNo,
            DownBatterySoc = inBin.Soc,
            DownBatterySoe = inBin.Soe,
        };

        _swapOrderBatteryRepository.Insert(swapOrderBattery);
    }

    /// <summary>
    /// 1.锁仓
    /// 2.更改预约单
    /// </summary>
    public void LockBinAndUpdateAmt(SwapOrderBatteryInfo orderBatteryInfo)
    {
        var configBinInfo =
            new MapperConfiguration(cfg => cfg.CreateMap<BinInfo, BinInfo>().ReverseMap());
        IMapper mapperBinInfo = configBinInfo.CreateMapper();
        BinInfo dbBinInfo = mapperBinInfo.Map<BinInfo>(orderBatteryInfo.UpBinInfo);

        dbBinInfo.AmtLock = (int)InfoEnum.AmtBatLockStatus.Lock;
        _binInfoRepository.Update(dbBinInfo);
        if (!orderBatteryInfo.isAmt)
        {
            return;
        }

        var configAmt =
            new MapperConfiguration(cfg => cfg.CreateMap<SwapAmtOrder, SwapAmtOrder>().ReverseMap());
        IMapper mapperAmt = configAmt.CreateMapper();
        SwapAmtOrder swapAmtOrder = mapperAmt.Map<SwapAmtOrder>(orderBatteryInfo.swapAmtOrder);
        swapAmtOrder.Status = (int)InfoEnum.AmtOrderStatus.Swapping;
        _amtOrderRepository.Update(swapAmtOrder);
    }

    ///     1.仓位状态：启动
    ///     2.电池在位
    ///     3.充电状态：不在充电中
    ///     4.未锁定
    ///     5.最后一次结束充电时间> ()
    ///     6.soc >()
    /**
     * && i.ChargeStatus == 2
            && i.AmtLock == "0"
            && new TimeSpan(DateTime.Now.Ticks -
                            i.LastChargeFinishTime.ToDateTime().Ticks)
                .TotalMinutes > StaticStationInfo.SwapFinishChargeTime
            && i.Soc > StaticStationInfo.Soc
     */
    public SwapOrderBatteryInfo SelectPackNotArm(SwappingStateMachine machine)
    {
        SwapOrderBatteryInfo orderBatteryInfo = new SwapOrderBatteryInfo();
        UpBin(orderBatteryInfo);
        if (orderBatteryInfo.CanSwap != InfoEnum.SelectBinStatusInfo.Success)
        {
            return orderBatteryInfo;
        }

        InBin(orderBatteryInfo, machine);

        return orderBatteryInfo;
    }

    public SwapOrderBatteryInfo SelectPackArm(SwapAmtOrder swapAmtOrder, SwappingStateMachine machine)
    {
        SwapOrderBatteryInfo orderBatteryInfo = new SwapOrderBatteryInfo();
        orderBatteryInfo.swapAmtOrder = swapAmtOrder;
        orderBatteryInfo.isAmt = true;
        BinInfo UpBin = _binInfoRepository.QueryByClause(i => i.No.Equals(swapAmtOrder.AmtBinNoList));
        bool CanSwap = UpBin.Exists == 1 && UpBin.Status == 1 && UpBin.ChargeStatus == 2
                       && UpBin.AmtLock == (int)InfoEnum.AmtBatLockStatus.Lock && new TimeSpan(DateTime.Now.Ticks -
                               UpBin.LastChargeFinishTime.ToDateTime()
                                   .Ticks)
                           .TotalMinutes > StaticStationInfo.SwapFinishChargeTime &&
                       UpBin.Soc > StaticStationInfo.SwapSoc;
        if (!CanSwap)
        {
            orderBatteryInfo.CanSwap = InfoEnum.SelectBinStatusInfo.AmtError;

            return orderBatteryInfo;
        }

        orderBatteryInfo.UpBinInfo = UpBin;
        InBin(orderBatteryInfo, machine);
        return orderBatteryInfo;
    }

    /// <summary>
    /// 取电池判断
    /// </summary>
    /// <param name="orderBatteryInfo"></param>
    public void UpBin(SwapOrderBatteryInfo orderBatteryInfo)
    {
        SelectPackDto selectPack =
            _binInfoRepository.SelectPack(StaticStationInfo.SwapSoc, StaticStationInfo.SwapFinishChargeTime);

        orderBatteryInfo.UpBinInfo = selectPack.BinInfo;
        orderBatteryInfo.CanSwap = selectPack.Info;
    }

    /// <summary>
    /// 放电池判断：取出来的电池仓位能不能放
    /// </summary>
    /// <param name="orderBatteryInfo"></param>
    public void InBin(SwapOrderBatteryInfo orderBatteryInfo, SwappingStateMachine machine)
    {
        List<BinInfo> list =
            _binInfoRepository.QueryListByClause(i =>
                i.CacheBinFlag == 0 &&
                i.Status == 1 && i.AmtLock == (int)InfoEnum.AmtBatLockStatus.UnLock
                && i.Exists == 0);

        if (list.Count <= 0)
        {
            orderBatteryInfo.CanSwap = InfoEnum.SelectBinStatusInfo.LessOfEmptyBin;
            return;
        }

        orderBatteryInfo.InBinInfo = list[0];
        orderBatteryInfo.InBinInfo.BatteryNo = "-1";
        orderBatteryInfo.InBinInfo.Soc = -1;
        orderBatteryInfo.InBinInfo.Soe = -1;
        orderBatteryInfo.InBinInfo.Soh = -1;
        var carInfoBatteryInfos = machine.BoxCarInfoModel?.CarInfo?.BatteryInfos;
        if (carInfoBatteryInfos != null && carInfoBatteryInfos.Count > 0)
        {
            orderBatteryInfo.InBinInfo.BatteryNo = carInfoBatteryInfos[0].BatteryNo;
            orderBatteryInfo.InBinInfo.Soc = carInfoBatteryInfos[0].Soc;
            orderBatteryInfo.InBinInfo.Soe = carInfoBatteryInfos[0].Soe;
            orderBatteryInfo.InBinInfo.Soh = carInfoBatteryInfos[0].Soh;
        }

        orderBatteryInfo.CanSwap = InfoEnum.SelectBinStatusInfo.Success;
    }

    /// <summary>
    /// 查询预约单
    /// </summary>
    /// <param name="machine"></param>
    /// <returns></returns>
    public SwapAmtOrder? QueryAmtOrder(SwappingStateMachine machine)
    {
        return
            _amtOrderRepository.QueryByClause(i =>
                i.Status == (int)InfoEnum.AmtOrderStatus.Success && i.CarNo.Equals(machine.BoxCarInfoModel.CarNo));
    }

    /// <summary>
    /// 更新订单
    /// </summary>
    /// <param name="machine"></param>
    public void UpdateSwapOrder(SwappingStateMachine machine)
    {
        SwapOrder swapOrder = _swapOrderRepository.QueryById(machine.SwapOrder.Id);
        machine.SwapOrder.CloudReportStatus = swapOrder.CloudReportStatus;
        _swapOrderRepository.Update(machine.SwapOrder);
    }

    /// <summary>
    /// 更新预约订单
    /// </summary>
    /// <param name="machine"></param>
    public void UpdateAmtOrder(SwappingStateMachine machine)
    {
        _amtOrderRepository.Update(machine.SwapOrderBatteryInfo.swapAmtOrder);
    }


    /// <summary>
    /// 换电成功关于binInfo表的处理
    /// </summary>
    public void UpdateBinInfoForSwapSuccess(SwappingStateMachine machine)
    {
        SwapOrderBatteryInfo? machineSwapOrderBatteryInfo = machine.SwapOrderBatteryInfo;

        if (machineSwapOrderBatteryInfo != null)
        {
            var inBinInfo = machineSwapOrderBatteryInfo.InBinInfo;
            //修改入仓顺序
            BinInfo binInfo = _binInfoRepository
                .QueryListByClause(i => i.BatteryEnterSeq != null, "battery_enter_seq desc").First();
            inBinInfo.BatteryEnterSeq = binInfo.BatteryEnterSeq + 1;
            inBinInfo.InTime = DateTime.Now;
            _binInfoRepository.Update(inBinInfo);
            var upBinInfo = machineSwapOrderBatteryInfo.UpBinInfo;
            upBinInfo.Soc = -1;
            upBinInfo.Soe = -1;
            upBinInfo.BatteryNo = "-1";
            _binInfoRepository.Update(upBinInfo);
        }
    }


    /// <summary>
    /// 换电完成新增上报云平台记录
    /// </summary>
    /// <param name="machine"></param>
    public void InsertCloudReportForSwapSuccess(SwappingStateMachine machine)
    {
        SwapOrder? machineSwapOrder = machine.SwapOrder;

        _swapOrderReportCloudRepository.Insert(new SwapOrderReportCloud()
        {
            SwapOrderSn = machineSwapOrder.Sn,
            SwapOrderId = machineSwapOrder.Id,
            CloudReportStatus = 0,
            Vin = machineSwapOrder.VehicleVin,
            Vtm = Convert.ToSingle(machine.BoxCarInfoModel?.ElecMsg?.TotalMile),
        });
    }
}