hn_zw_back_main/Service/Execute/Mgr/CommonMgr.cs

335 lines
12 KiB

using Autofac;
using AutoMapper;
using Common.Util;
using Entity.Constant;
using Entity.DbModel.Station;
using Entity.Dto;
using HybirdFrameworkCore.Autofac;
using HybirdFrameworkCore.Autofac.Attribute;
using log4net;
using NewLife.Serialization;
using Newtonsoft.Json;
using Repository.Station;
using Service.Execute.Api;
using Service.Execute.Model;
using Service.Init;
using Service.Plc.Client;
using Service.Station;
using SqlSugar;
namespace Service.Execute.Utils;
[Scope("SingleInstance")]
public class CommonMgr
{
private static readonly ILog _log = LogManager.GetLogger(typeof(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; }
public MoveBinRecordRepository MoveBinRecordRepository { get; set; }
/// <summary>
/// 新增小步状态
/// </summary>
public void InsertStep(InfoEnum.BusinessSwappingStep step, SwappingStateMachine machine)
{
var stepModel = new StepModel
{
StepName = BaseEnumExtensions.GetDescription(step),
StepNo = (int)step,
StartTime = DateTime.Now,
Status = 1
};
machine.StepModel[stepModel.StepNo.ToString()] = stepModel;
_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,
CreatedTime = DateTime.Now
};
_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);
_log.Info($"UpBin orderBatteryInfo={JsonConvert.SerializeObject(orderBatteryInfo)}");
if (orderBatteryInfo.CanSwap != InfoEnum.SelectBinStatusInfo.Success)
{
return orderBatteryInfo;
}
InBin(orderBatteryInfo, machine);
_log.Info($"InBin orderBatteryInfo={JsonConvert.SerializeObject(orderBatteryInfo)}");
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,
QueryMoveBinNo()[0]);
orderBatteryInfo.UpBinInfo = selectPack.BinInfo;
orderBatteryInfo.CanSwap = selectPack.Info;
}
private List<string> QueryMoveBinNo()
{
string moveUp = "";
string moveIn = "";
//当前有移仓任务
if (PlcMgr.PlcClient?.ReadTaskNo() == 2)
{
MoveBinRecord queryByClause = MoveBinRecordRepository.QueryByClause(i => i.Status == 0 || i.Status == 1,
i => i.CreatedTime,
OrderByType.Desc);
if (queryByClause != null)
{
moveUp = queryByClause?.UpBinNo;
moveIn = queryByClause?.InBinNo;
}
}
return new List<string>()
{
moveUp, moveIn
};
}
/// <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;
}
var value = QueryMoveBinNo()[1];
if (!string.IsNullOrWhiteSpace(value))
{
list = list.Where(i => i.No != value).ToList();
}
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),
});
}
}