eaxing_back_africa_main/Service/Execute/Step/SwapDoneState.cs

using log4net;
using Repository.Station;
using Service.Execute.Api;
using Service.Execute.Enum;
using Service.Execute.Model;
using Service.Execute.StaticTools;
using Service.Execute.SwapException;
using Service.Station;
using Swapping.Business.Tech;

namespace Service.Execute.Step;

public class SwapDoneState : IState
{
    private SwapOrderRepository SwapOrderRepository { get; set; }
    public SwapOrderStepService SwapOrderStepService { get; set; }
    private SwapAmtOrderRepository SwapAmtOrderRepository { get; set; }

    private readonly ILog _log = LogManager.GetLogger(typeof(SwapDoneState));

    /// <summary>
    /// 修改换电订单
    /// 查看是否有预约单 更新预约单的状态
    /// </summary>
    /// <param name="machine"></param>
    /// <returns></returns>
    public StateResult Handle(SwappingStateMachine machine)
    {
        //更新换电订单
        machine.SwapOrder.SwapResult = machine.SwapStatus;
        machine.SwapOrder.SwapEndTime = DateTime.Now;
        machine.SwapOrder.FailReason = machine.SwapFailReason;
        SwapOrderRepository.Update(machine.SwapOrder);


        if (machine.SwapStatus == (int)InfoEnum.SwapOrderResult.Success)
        {
            //上传云平台换电状态
            machine.BusinessSwappingForCloudState = InfoEnum.BusinessSwappingForCloudState.SwapDoneWithVel;
            CloudApi.SendStateLog(machine.SwapOrder, machine.BusinessSwappingForCloudState);
        }

        //云平台没有匹配的失败状态
        //车辆上锁 ,提示请驶离
        InvokeStatus lockCar = LockCar(machine);

        if (lockCar != InvokeStatus.Done)
        {
            return SwappingStateMachine.ReturnWithInvokeErr(lockCar, ExceptionReason.None);
        }

        //出口雷达监测
        InvokeStatus existRadar = ExistRadar(machine);
        if (existRadar != InvokeStatus.Done)
        {
            return SwappingStateMachine.ReturnWithInvokeErr(existRadar, ExceptionReason.None);
        }

        return new StateResult()
        {
            SwappingState = SwappingState.StationReady
        };
    }

    /// <summary>
    /// 车辆上锁
    /// </summary>
    /// <returns></returns>
    public InvokeStatus LockCar(SwappingStateMachine machine)
    {
        return Invoker.Invoke("LockCar", 500, 100, machine.IsCanceled,
            () => machine.VelLockFlag, () =>
            {
                Task<bool> result = TBoxApi.LockCar();
                bool unLock = result.Result;
                if (unLock)
                {
                    //查询车辆锁止状态
                    Task<TboxCarInfoModel> carInfo = TBoxApi.GetCarInfo();
                    if (carInfo.Result.HeartBeatMsg.LockStatus == 2)
                    {
                        //设置出口的是绿灯
                        if (PlcApi.WriteExistLamp(1000))
                        {
                            machine.LedTool?.WriteProgramContent(
                                machine.SwapStatus == (int)InfoEnum.SwapOrderResult.Success
                                    ? InfoEnum.SwapInfo.InfoCarLeave.GetLed()
                                    : InfoEnum.SwapInfo.ErrInfoCarLeave.GetLed());
                            SoundTool.PlayOneSound(machine.SwapStatus == (int)InfoEnum.SwapOrderResult.Success
                                ? (int)InfoEnum.SwapInfo.InfoCarLeave
                                : (int)InfoEnum.SwapInfo.ErrInfoCarLeave);
                            machine.VelLockFlag = true;


                            SwapOrderStepService.InsertSwapStepForSwapMain(InfoEnum.BusinessSwappingStep.VelLockFlag,
                                machine.StepSort++, machine.SwapOrder.Sn);
                        }
                    }
                }
            }, () =>
            {
                machine.LedTool?.WriteProgramContent(InfoEnum.SwapInfo.ErrLockCar.GetLed());
                SoundTool.PlayOneSound((int)InfoEnum.SwapInfo.ErrLockCar);
            }, false, () => { machine.ExceptionReason = ExceptionReason.LockCarError; }
            , 10, InvokeStatus.None);
    }


    public InvokeStatus ExistRadar(SwappingStateMachine machine)
    {
        return Invoker.Invoke("wait exist radar", 1000, 5, machine.IsCanceled,
            () => machine.RadarOutFlag, () =>
            {
                if (!PlcApi.EntranceRadar())
                {
                    _log.Info("exist radar false");
                }
                else
                {
                    machine.ExceptionReason = ExceptionReason.None;
                    _log.Info("exist radar true");


                    if (PlcApi.WriteExistLamp(1020))
                    {
                        //出口写红灯
                        //更新车辆离场时间，上报云平台
                        machine.BusinessSwappingForCloudState =
                            InfoEnum.BusinessSwappingForCloudState.SwapDoneWithoutVel;
                        machine.SwapOrder!.VehicleLeaveTime = DateTime.Now;
                        SwapOrderRepository.Update(machine.SwapOrder);
                        if (machine.SwapOrderBatteryInfo!.swapAmtOrder != null)
                        {
                            machine.SwapOrderBatteryInfo.swapAmtOrder.Status =
                                machine.SwapStatus == (int)InfoEnum.SwapOrderResult.Success
                                    ? (int)InfoEnum.AmtOrderStatus.SwapFinish
                                    : (int)InfoEnum.AmtOrderStatus.SwapFail;
                            SwapAmtOrderRepository.Update(machine.SwapOrderBatteryInfo.swapAmtOrder);
                        }

                        machine.RadarOutFlag = true;

                        SwapOrderStepService.InsertSwapStepForSwapMain(
                            machine.SwapStatus == (int)InfoEnum.SwapOrderResult.Success
                                ? InfoEnum.BusinessSwappingStep.RadarOutFlag
                                : InfoEnum.BusinessSwappingStep.RadarOutFailFlag,
                            machine.StepSort++, machine.SwapOrder.Sn);
                    }
                }
            });
    }
}