高翔 / ECS-ZJHX · Files

using HHECS.Application.Enums;
using HHECS.Application.Error;
using HHECS.BllModel;
using HHECS.Dal;
using HHECS.DAL.Repository;
using HHECS.Infrastructure.CommonHelper;
using HHECS.Model.Entities;
using HHECS.Model.Enums.Task;
using HHECS.Model.Enums.Truss;
using HHECS.Executor;
using System;
using System.Collections.Generic;
using System.Linq;
using HHECS.Communication;
using HHECS.Communication.PLC;

namespace HHECS.Executor.EquipmentHandler.Truss
{
    public abstract class TrussExcute : BaseEquipmentExecute
    {
        #region 属性
        /// <summary>
        /// 对应的设备类型
        /// </summary>
        public EquipmentType EquipmentType { get; set; }

        /// <summary>
        /// 用于可用存储设备列表
        /// </summary>
        public List<Equipment> Equipments { get; set; }



        #endregion

        protected TrussExcute(EquipmentType equipmentType)
        {
            EquipmentType = equipmentType;
        }


        /// <summary>
        /// 执行桁车处理逻辑
        /// </summary>
        /// <param name="srms"></param>
        /// <param name="plcs"></param>
        /// <returns></returns>
        public abstract BllResult Excute(List<Equipment> trusses, List<Equipment> allEquipments, PLCCore plc, User user);


        /// <summary>
        /// 下发数据到桁车
        /// </summary>
        /// <param name="truss"></param>
        /// <param name="plc"></param>
        /// <param name="taskFlag"></param>
        /// <param name="productId"></param>
        /// <param name="position"></param>
        /// <param name="taskNo"></param>
        /// <returns></returns>
        public BllResult SendTaskToTruss(Equipment truss, PLCCore plc, TrussTaskFlag taskFlag, int productType, int takeLocation, int putLocation, int moverLocation, int taskNo)
        {
            try
            {
                List<EquipmentProp> propsToWriter = new List<EquipmentProp>();
                var WCSTaskFlag = truss[TrussNormalProps.WCSTaskFlag.ToString()];
                WCSTaskFlag.Value = taskFlag.GetIndexString();
                var WCSProductType = truss[TrussNormalProps.WCSProductType.ToString()];
                WCSProductType.Value = productType.ToString();
                var WCSTakeLocation = truss[TrussNormalProps.WCSTakePosition.ToString()];
                WCSTakeLocation.Value = takeLocation.ToString();
                var WCSMoverPosition = truss[TrussNormalProps.WCSMoverPosition.ToString()];
                WCSMoverPosition.Value = moverLocation.ToString();
                var WCSPutLocation = truss[TrussNormalProps.WCSPutPosition.ToString()];
                WCSPutLocation.Value = putLocation.ToString();
                var WCSTaskCode = truss[TrussNormalProps.WCSTaskCode.ToString()];
                WCSTaskCode.Value = taskNo.ToString();
                propsToWriter.AddRange(new List<EquipmentProp>() { WCSProductType, WCSTakeLocation, WCSPutLocation, WCSMoverPosition, WCSTaskCode, WCSTaskFlag });
                return plc.Writes(propsToWriter);
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error($"写入plc失败，下发任务出现异常:{ex.Message}");
            }
        }

        /// <summary>
        /// 清理WCS交换区
        /// </summary>
        /// <param name="truss"></param>
        /// <param name="plc"></param>
        /// <returns></returns>
        public BllResult ClearWCSData(Equipment truss, PLCCore plc)
        {
            //表示桁车已经收到WCS发送给他的任务完成信号，此时WCS可以清除自己的交换区地址
            BllResult sendResult = SendTaskToTruss(truss, plc, TrussTaskFlag.NoTask, 0, 0, 0, 0, 0);
            if (sendResult.Success)
            {
                return BllResultFactory.Success($"任务完成后，清除桁车{truss.Name}交换区地址成功");
            }
            else
            {
                return BllResultFactory.Error($"任务完成后，清除桁车{truss.Name}交换区地址失败, 原因：${sendResult.Msg}");
            }
        }

        /// <summary>
        /// 发送到站台的任务
        /// </summary>
        /// <param name="truss"></param>
        /// <param name="plc"></param>
        /// <param name="truss"></param>
        /// <param name="taskEntityStatus"></param>
        /// <param name="taskFlag"></param>
        /// <param name="stationId"></param>
        /// <returns></returns>
        protected BllResult SendTaskToStation(Equipment truss, PLCCore plc, BusTaskTruss taskTruss, TaskTrussStatus taskTrussStatus, TrussTaskFlag taskFlag)
        {
            try
            {
                BaseWorkStation fromWorkStationCode = truss.WorkStationList.FirstOrDefault(t => t.WorkStationCode == taskTruss.FromStationCode);
                if (fromWorkStationCode == null)
                {
                    return BllResultFactory.Error($"从站台基础数据中找不到取货站台[{taskTruss.FromStationCode}]");
                }
                if (fromWorkStationCode.TakeLocation == 0)
                {
                    return BllResultFactory.Error($"站台[{fromWorkStationCode.Id}][{fromWorkStationCode.WorkStationName}]没有对应的取货位置，请补齐数据");
                }
                BaseWorkStation toWorkStationCode = truss.WorkStationList.FirstOrDefault(t => t.WorkStationCode == taskTruss.ToStationCode);
                if (toWorkStationCode == null)
                {
                    return BllResultFactory.Error($"从站台基础数据中找不到放货站台[{taskTruss.ToStationCode}]");
                }
                if (toWorkStationCode.PutLocation == 0)
                {
                    return BllResultFactory.Error($"站台[{toWorkStationCode.Id}][{toWorkStationCode.WorkStationName}]没有对应的放货位置，请补齐数据");
                }
                //记录下状态
                var tempStatus = taskTruss.Status;
                BusTaskTrussRepository taskTrussRepository = new BusTaskTrussRepository();
                taskTrussRepository.Attach(taskTruss);
                taskTruss.Status = taskTrussStatus.GetIndexInt();
                taskTruss.TrussCode = truss.Code;

                using (var uw = DALHelper.GetFreeSql().CreateUnitOfWork())
                {
                    try
                    {
                        taskTrussRepository.UnitOfWork = uw;
                        taskTrussRepository.Update(taskTruss);

                        BllResult sendResult = SendTaskToTruss(truss, plc, taskFlag, taskTruss.ProductType, fromWorkStationCode.TakeLocation, toWorkStationCode.PutLocation, 0, taskTruss.Id);
                        if (sendResult.Success)
                        {
                            uw?.Commit();
                            return BllResultFactory.Success($"桁车[{truss.Code}][{truss.Name}]下发任务[{taskTruss.Id}]成功，操作类型[{taskFlag}]，取货位置[{fromWorkStationCode.WorkStationCode}][{fromWorkStationCode.WorkStationName}][{fromWorkStationCode.TakeLocation}]，放货位置[{toWorkStationCode.WorkStationCode}][{toWorkStationCode.WorkStationName}][{toWorkStationCode.PutLocation}]");
                        }
                        else
                        {
                            uw?.Rollback();
                            taskTruss.Status = tempStatus;
                            return BllResultFactory.Error($"桁车[{truss.Code}][{truss.Name}]下发任务[{taskTruss.Id}]失败，操作类型[{taskFlag}]，取货位置[{fromWorkStationCode.WorkStationCode}][{fromWorkStationCode.WorkStationName}][{fromWorkStationCode.TakeLocation}]，放货位置[{toWorkStationCode.WorkStationCode}][{toWorkStationCode.WorkStationName}][{toWorkStationCode.PutLocation}]，原因：{sendResult.Msg}");
                        }
                    }
                    catch (Exception ex)
                    {
                        uw?.Rollback();
                        taskTruss.Status = tempStatus;
                        return BllResultFactory.Create(BllResultCode.Exception, ex, $"桁车[{truss.Code}][{truss.Name}]下发任务[{taskTruss.Id}]产生异常，操作类型[{taskFlag}]，取货位置[{fromWorkStationCode.WorkStationCode}][{fromWorkStationCode.WorkStationName}][{fromWorkStationCode.TakeLocation}]，放货位置[{toWorkStationCode.WorkStationCode}][{toWorkStationCode.WorkStationName}][{toWorkStationCode.PutLocation}]，原因：{ex.Message}", ErrorCodeConst.Exe_E0001.ToString());
                    }
                }
            }
            catch (Exception ex)
            {
                return BllResultFactory.Create(BllResultCode.Exception, ex, $"桁车[{truss.Code}][{truss.Name}]下发任务[{taskTruss.Id}]的时候产生异常，原因：{ex.Message}", ErrorCodeConst.Exe_E0001.ToString());
            }
        }


        /// <summary>
        /// 重新下发桁车任务
        /// 重新下发任务限制：
        /// 取货：货叉在中心、联机、无货
        /// 放货：货叉在中心、联机、有货
        /// </summary>
        /// <param name="truss">桁架</param>
        /// <param name="plc"></param>
        /// <param name="truss"></param>
        /// <param name="taskFlag">货叉标志</param>
        /// <param name="stationId">站台点位</param>
        /// <returns></returns>
        protected BllResult ReSendTask(Equipment truss, PLCCore plc, BusTaskTruss taskTruss, TrussTaskFlag taskFlag)
        {
            try
            {
                BaseWorkStation fromWorkStationCode = truss.WorkStationList.FirstOrDefault(t => t.WorkStationCode == taskTruss.FromStationCode);
                if (fromWorkStationCode == null)
                {
                    return BllResultFactory.Error($"从站台基础数据中找不到取货站台[{taskTruss.FromStationCode}]");
                }
                if (fromWorkStationCode.TakeLocation == 0)
                {
                    return BllResultFactory.Error($"站台[{fromWorkStationCode.Id}][{fromWorkStationCode.WorkStationName}]没有对应的取货位置，请补齐数据");
                }
                BaseWorkStation toWorkStationCode = truss.WorkStationList.FirstOrDefault(t => t.WorkStationCode == taskTruss.ToStationCode);
                if (toWorkStationCode == null)
                {
                    return BllResultFactory.Error($"从站台基础数据中找不到放货站台[{taskTruss.ToStationCode}]");
                }
                if (toWorkStationCode.PutLocation == 0)
                {
                    return BllResultFactory.Error($"站台[{toWorkStationCode.Id}][{toWorkStationCode.WorkStationName}]没有对应的放货位置，请补齐数据");
                }

                BusTaskTrussRepository taskTrussRepository = new BusTaskTrussRepository();
                taskTrussRepository.Attach(taskTruss);
                taskTruss.SendAgain = 2;
                taskTruss.TrussCode = truss.Code;

                using (var uw = DALHelper.GetFreeSql().CreateUnitOfWork())
                {
                    try
                    {
                        taskTrussRepository.UnitOfWork = uw;
                        taskTrussRepository.Update(taskTruss);

                        BllResult sendResult = SendTaskToTruss(truss, plc, taskFlag, taskTruss.ProductType, fromWorkStationCode.TakeLocation, toWorkStationCode.PutLocation, 0, taskTruss.Id);
                        if (sendResult.Success)
                        {
                            uw?.Commit();
                            return BllResultFactory.Success($"桁车[{truss.Code}][{truss.Name}]下发任务[{taskTruss.Id}]成功，操作类型[{taskFlag}]，取货位置[{fromWorkStationCode.WorkStationCode}][{fromWorkStationCode.WorkStationName}][{fromWorkStationCode.TakeLocation}]，放货位置[{toWorkStationCode.WorkStationCode}][{toWorkStationCode.WorkStationName}][{toWorkStationCode.PutLocation}]");
                        }
                        else
                        {
                            uw?.Rollback();
                            taskTruss.SendAgain = 1;
                            return BllResultFactory.Error($"桁车[{truss.Code}][{truss.Name}]下发任务[{taskTruss.Id}]失败，操作类型[{taskFlag}]，取货位置[{fromWorkStationCode.WorkStationCode}][{fromWorkStationCode.WorkStationName}][{fromWorkStationCode.TakeLocation}]，放货位置[{toWorkStationCode.WorkStationCode}][{toWorkStationCode.WorkStationName}][{toWorkStationCode.PutLocation}]，原因：{sendResult.Msg}");
                        }
                    }
                    catch (Exception ex)
                    {
                        uw?.Rollback();
                        taskTruss.SendAgain = 1;
                        return BllResultFactory.Create(BllResultCode.Exception, ex, $"桁车[{truss.Code}][{truss.Name}]下发任务[{taskTruss.Id}]产生异常，操作类型[{taskFlag}]，取货位置[{fromWorkStationCode.WorkStationCode}][{fromWorkStationCode.WorkStationName}][{fromWorkStationCode.TakeLocation}]，放货位置[{toWorkStationCode.WorkStationCode}][{toWorkStationCode.WorkStationName}][{toWorkStationCode.PutLocation}]，原因：{ex.Message}", ErrorCodeConst.Exe_E0001.ToString());
                    }
                }
            }
            catch (Exception ex)
            {
                return BllResultFactory.Create(BllResultCode.Exception, ex, $"桁车[{truss.Code}][{truss.Name}]下发任务[{taskTruss.Id}]产生异常，原因：{ex.Message}", ErrorCodeConst.Exe_E0001.ToString());
            }
        }



        #region 共用

        ///// <summary>
        ///// 心跳
        ///// </summary>
        ///// <param name="truss"></param>
        ///// <param name="plc"></param>
        //public BllResult Heartbeat(Equipment truss, IPLC plc)
        //{
        //    var prop = truss[TrussNormalProps.WCSHeartBeat.ToString()];
        //    if (prop.Value == "1")
        //    {
        //        prop.Value = "0";
        //    }
        //    else
        //    {
        //        prop.Value = "1";
        //    }
        //    var result = plc.Writes(new List<EquipmentProp>() { prop });
        //    if (result.Success)
        //    {
        //        return BllResultFactory.Success();
        //    }
        //    else
        //    {
        //        return BllResultFactory.Error($"发送桁车{truss.Name}心跳数据失败:{result.Msg}");
        //    }
        //}

        /// <summary>
        /// 通用条件验证
        /// 验证桁车联机且无故障
        /// </summary>
        /// <param name="truss"></param>
        /// <returns></returns>
        public static BllResult Validate(Equipment truss)
        {
            //联机，无故障
            if (truss[TrussNormalProps.OperationModel.ToString()].Value != OperationModelFlag.Online.GetIndexString())
            {
                return BllResultFactory.Error($"桁车 {truss.Name} 不是联机");
            }
            if (truss[TrussNormalProps.TotalError.ToString()].Value == "True")
            {
                return BllResultFactory.Error($"桁车 {truss.Name} 有故障");
            }
            return BllResultFactory.Success();
        }

        /// <summary>
        /// 桁架是否可以执行任务
        /// </summary>
        /// <param name="truss"></param>
        /// <returns></returns>
        public static BllResult EnableExcute(Equipment truss)
        {
            if (truss[TrussNormalProps.OperationModel.ToString()].Value != OperationModelFlag.Online.GetIndexString())
            {
                return BllResultFactory.Error($"桁车 {truss.Name} 不是联机！");
            }
            if (truss[TrussNormalProps.TotalError.ToString()].Value == "True")
            {
                return BllResultFactory.Error($"桁车 {truss.Name} 有故障！");
            }
            if (truss[TrussNormalProps.ForkTaskExcuteStatus.ToString()].Value != TrussTaskExcuteStatus.Standby.GetIndexString())
            {
                return BllResultFactory.Error($"桁车 {truss.Name} 不是空闲！");
            }
            if (truss[TrussNormalProps.ForkHasPallet.ToString()].Value == "True")
            {
                return BllResultFactory.Error($"桁车 {truss.Name} 有货待执行！");
            }
            return BllResultFactory.Success();
        }

        /// <summary>
        /// 生成桁车任务
        /// </summary>
        /// <param name="allEquipments"></param>
        /// <param name="fromStation"></param>
        /// <param name="toStationList"></param>
        /// <param name="material"></param>
        /// <param name="stepTrace"></param>
        /// <param name="user"></param>
        /// <returns></returns>
        public static BllResult<BusTaskTruss> CreateTask(List<Equipment> allEquipments, BaseWorkStation fromStation, List<BaseWorkStation> toStationList, int productType, BusWorkOrderHead busWorkOrderHead, User user)
        {
            BusTaskTruss taskTrussEntity = new BusTaskTruss();
            try
            {
                if (fromStation == null)
                {
                    return BllResultFactory.Error<BusTaskTruss>(taskTrussEntity, $"源站台为空，不能生成桁车任务！");
                }
                if (toStationList == null || toStationList.Count == 0)
                {
                    return BllResultFactory.Error<BusTaskTruss>(taskTrussEntity, $"目标站台为空，不能生成桁车任务！");
                }
                var truss = allEquipments.FirstOrDefault(t => t.Code == fromStation.TransportNormal);
                if (truss == null)
                {
                    truss = allEquipments.FirstOrDefault(t => t.Code == fromStation.TransportCompatible);
                    if (truss == null)
                    {
                        return BllResultFactory.Error<BusTaskTruss>(taskTrussEntity, $"站台正常模式对应的桁车[{fromStation.TransportNormal}]不存在，兼容模式对应的桁车[{fromStation.TransportCompatible}]也不存在，无法生成桁车任务！");
                    }
                    var compatibleMode = truss[TrussNormalProps.CompatibleMode.ToString()];
                    if (compatibleMode.Value != TrussCompatible.Compatible.GetIndexString())
                    {
                        return BllResultFactory.Error<BusTaskTruss>(taskTrussEntity, $"站台正常模式对应的桁车[{fromStation.TransportNormal}]不存在，兼容模式对应的桁车[{fromStation.TransportCompatible}]不是兼容模式，无法生成桁车任务！");
                    }
                }
                var trussValidate = EnableExcute(truss);
                if (!trussValidate.Success)
                {
                    return BllResultFactory.Create<BusTaskTruss>(BllResultCode.Warning, taskTrussEntity, trussValidate.Msg);
                }
                //var baseProductHeader = DALHelper.GetFreeSql().GetRepository<BaseProductHeader>().Where(u => u.ProductCode == busWorkOrderHead.ProductHeaderCode).First();
                //if (baseProductHeader == null)
                //{
                //    return BllResultFactory.Error<TaskTrussEntity>(taskTrussEntity, $"根据在制品[{busWorkOrderHead.Id}]的产品编码[{busWorkOrderHead.ProductHeaderCode}]找不到对应的产品，无法生成桁架任务！");
                //}
                var manageSmallDistance = Int64.Parse(truss[TrussNormalProps.ManageSmallDistance.ToString()].Value);
                var manageBigDistance = Int64.Parse(truss[TrussNormalProps.ManageBigDistance.ToString()].Value);

                // 筛选在桁车移动范围之内的设备
                var toStation = toStationList.FirstOrDefault(t => t.Distance >= manageSmallDistance && t.Distance <= manageBigDistance && t.TransportNormal == truss.WorkStationCode);
                if (toStation == null)
                {
                    return BllResultFactory.Error<BusTaskTruss>(taskTrussEntity, $"站台正常模式对应的桁车[{truss.Name}]无法找到能去的站台，请检查桁架点位");
                }

                taskTrussEntity.LineCode = fromStation.LineCode;
                taskTrussEntity.TrussCode = truss.Code;
                taskTrussEntity.Type = TrussTaskFlag.Take.GetIndexInt();
                taskTrussEntity.FromStationCode = fromStation.WorkStationCode;
                taskTrussEntity.ToStationCode = toStation.WorkStationCode;
                taskTrussEntity.SendAgain = 0;
                taskTrussEntity.Status = TaskTrussStatus.TaskCreate.GetIndexInt();
                taskTrussEntity.MaterialCode = "0";
                taskTrussEntity.Barcode = busWorkOrderHead.Id.ToString();
                taskTrussEntity.ProductType = productType;
                taskTrussEntity.StepTraceId = busWorkOrderHead.Id;
                taskTrussEntity.StartTime = DateTime.Now;
                taskTrussEntity.CreateTime = DateTime.Now;
                taskTrussEntity.CreateBy = user.UserCode;
                taskTrussEntity.UpdateTime = DateTime.Now;
                taskTrussEntity.UpdateBy = user.UserCode;

                return BllResultFactory.Success<BusTaskTruss>(taskTrussEntity);
            }
            catch (Exception ex)
            {
                return BllResultFactory.Create<BusTaskTruss>(BllResultCode.Exception, taskTrussEntity, $"生成站台[{fromStation.WorkStationCode}][{fromStation.WorkStationName}]的桁车任务时候，发生异常：{ex.Message}", ErrorCodeConst.Exe_E0001.ToString());
            }
        }

        /// <summary>
        /// 任务删除
        /// hack:这里不做任务校验，直接发送任务删除，考虑权限控制
        /// </summary>
        /// <param name="truss"></param>
        /// <returns></returns>
        public static BllResult TrussDeleteTask(PLCCore PLC, Equipment truss)
        {
            if (PLC == null || PLC.GetConnectStatus(truss.IP).Success == false)
            {
                return BllResultFactory.Error("地址读取失败,请检查通讯连接");
            }

            if (truss.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == TrussNormalProps.OperationModel.ToString()).Value != OperationModelFlag.Online.GetIndexString())
            {
                return BllResultFactory.Error($"桁车{truss.Name}未处于联机状态下");
            }
            var stepTraceId = truss.EquipmentProps.FirstOrDefault(t => t.EquipmentTypePropTemplateCode == TrussNormalProps.ForkTaskCode.ToString()).Value;
            if (stepTraceId == null)
            {
                //Logger.Log($"桁车{truss.Name}的任务ID为空，没有任务", LogLevel.Error);
                return BllResultFactory.Error($"桁车{truss.Name}的任务ID为空，没有任务");
            }
            EquipmentRepository equipmentRespository = new EquipmentRepository();
            long rowIndex1 = truss.RowIndex1;
            long rowIndex2 = truss.RowIndex2;
            truss.RowIndex1 = 0;
            truss.RowIndex2 = 0;
            var result = equipmentRespository.Update(truss);
            if (result > 0)
            {
                var prop = truss.EquipmentProps.FirstOrDefault(t => t.EquipmentTypePropTemplateCode == TrussNormalProps.WCSTaskFlag.ToString());
                if (prop.Value != TrussForTaskFlag.移车任务.GetIndexString())
                {
                    BusTaskTrussRepository taskEntityRespository = new BusTaskTrussRepository();
                    var taskResult = taskEntityRespository.Where(t => t.Id.ToString() == stepTraceId).ToList();
                    if (taskResult.Count <= 0)
                    {
                        return BllResultFactory.Error($"删除失败");
                    }
                    if (taskResult.Count == 0)
                    {
                        return BllResultFactory.Error($"未找到{truss.Name}对应的任务Id：{stepTraceId}");
                    }
                    var task = taskResult[0];
                    task.Status = TaskTrussStatus.TaskErrorCompleted.GetIndexInt();
                    task.UpdateTime = DateTime.Now;
                    result = taskEntityRespository.Update(task);
                    if (result <= 0)
                    {
                        return BllResultFactory.Error($"通知{truss}删除任务{task.Id}失败！");
                    }
                }
                prop.Value = TrussForTaskFlag.删除任务.GetIndexString();
                var plcResult = PLC.Writes(prop);
                if (plcResult.Success)
                {

                    //Logger.Log($"删除{truss.Name}任务{stepTraceId}成功", LogLevel.Success);
                    return BllResultFactory.Success($"删除{truss.Name}任务{stepTraceId}成功");
                }
                else
                {
                    truss.RowIndex1 = (int)rowIndex1;
                    truss.RowIndex2 = (int)rowIndex2;
                    equipmentRespository.Update(truss);
                    //Logger.Log($"删除{truss.Name}任务{stepTraceId}的时候，写入PLC失败：{plcResult.Msg}", LogLevel.Error);
                    return BllResultFactory.Error($"删除{truss.Name}任务{stepTraceId}的时候，写入PLC失败：{plcResult.Msg}");
                }
            }
            else
            {
                //Logger.Log($"删除{truss.Code}任务{stepTraceId}的时候，修改桁车路劲，修改数据库失败：{result.Msg}", LogLevel.Error);
                return BllResultFactory.Error($"删除{truss.Code}任务{stepTraceId}的时候，修改桁车路劲，修改数据库失败");
            }
        }

        /// <summary>
        /// 重新下发
        /// </summary>
        /// <param name="srm"></param>
        /// <returns></returns>
        public static BllResult TrussOverrideHandle(Equipment srm, PLCCore PLC)
        {

            if (PLC == null || PLC.GetConnectStatus(srm.IP).Success == false)
            {
                return BllResultFactory.Error("地址读取失败,请检查通讯连接");
            }
            if (srm[$"{ TrussNormalProps.OperationModel}"].Value != OperationModelFlag.Online.GetIndexString())
            {
                return BllResultFactory.Error($"桁车{srm.Code}未处于联机状态下");
            }
            if (srm[$"{ TrussNormalProps.ForkCenter}"].Value == "False")
            {
                return BllResultFactory.Error($"桁车{srm.Code}的货叉1未处于中心");
            }
            var taskProp = srm[$"{ TrussNormalProps.ForkTaskCode}"];
            if (taskProp == null)
            {
                return BllResultFactory.Error($"未找到桁车{srm.Name}的任务属性");
            }

            BusTaskTrussRepository taskEntityRespository = new BusTaskTrussRepository();
            var taskResult = taskEntityRespository.Where(t => t.Id.ToString() == taskProp.Value).ToList();
            if (taskResult.Count <= 0)
            {
                return BllResultFactory.Error($"重新下发失败");
            }
            if (taskResult.Count == 0)
            {
                return BllResultFactory.Error($"未找到{srm.Name}对应的任务Id：{taskProp.Value}");
            }
            var task = taskResult[0];
            if (task.Status == TaskTrussStatus.SendTake.GetIndexInt() || task.Status == TaskTrussStatus.SendPut.GetIndexInt())//|| task.TaskStatus == TaskEntityStatus.SendSRMOutsideGet.GetIndexInt() || task.TaskStatus == TaskEntityStatus.SendSRMOutsidePut.GetIndexInt()
            {
                var hasPallet = srm[$"{ TrussNormalProps.ForkHasPallet}"];
                if (task.Status == TaskTrussStatus.SendTake.GetIndexInt())
                {
                    //取货要货叉无货
                    if (hasPallet?.Value == "True")
                    {
                        return BllResultFactory.Error($"重新下发取货性质的任务时，货叉必须无货");
                    }
                }
                else
                {
                    //放货要货叉有货
                    if (hasPallet?.Value == "False")
                    {
                        return BllResultFactory.Error($"重新下发放货性质的任务时，货叉必须有货");
                    }
                }

                var prop = srm[$"{TrussNormalProps.WCSTaskFlag}"];
                prop.Value = TrussTaskFlag.TaskDelete.GetIndexString();
                var result = PLC.Write(prop);
                if (result.Success)
                {
                    task.SendAgain = 1;
                    task.UpdateTime = DateTime.Now;
                    var upResult = taskEntityRespository.Update(task);
                    if (upResult > 0)
                    {
                        return BllResultFactory.Success("成功");
                    }
                    else
                    {
                        return BllResultFactory.Error($"通知{srm}删除任务{task.Id}成功，但是更新任务重新下发的表示失败！");
                    }
                }
                else
                {
                    return BllResultFactory.Error($"通知{srm}删除任务{task.Id}失败");
                }
            }
            else
            {
                return BllResultFactory.Error($"{srm.Name}对应的任务Id：{taskProp.Value}任务状态不能重新下发");
            }

        }

        /// <summary>
        /// 移车
        /// </summary>
        /// <param name="workStationId">工位ID</param>
        /// <param name="truss"></param>
        /// <param name="plc"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public static BllResult TrussMoveTrussHandle(string workStationId, Equipment truss, PLCCore plc)
        {
            if (plc == null || plc.GetConnectStatus(truss.IP).Success == false)
            {
                return BllResultFactory.Error("地址读取失败,请检查通讯连接");
            }
            //if (truss[$"{TrussNormalProps.OperationModel}"].Value != SRMOperationModel.Online.GetIndexString())
            //{
            //    return BllResultFactory.Error($"桁车{truss.Code}未处于联机状态下");
            //}
            //return BllResultFactory.Error("该功能暂未实现！");
            if (plc == null || plc.GetConnectStatus(truss.IP).Success == false)
            {
                return BllResultFactory.Error("地址读取失败,请检查通讯连接");
            }

            if (truss.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == TrussNormalProps.OperationModel.ToString()).Value != OperationModelFlag.Online.GetIndexString())
            {
                return BllResultFactory.Error($"桁车{truss.Code}未处于联机状态下");
            }
            List<EquipmentProp> propsToWriter = new List<EquipmentProp>();
            var props = truss.EquipmentProps;
            var WCSTaskFlag = props.Find(t => t.EquipmentTypePropTemplateCode == TrussNormalProps.WCSTaskFlag.ToString());

            if (WCSTaskFlag.Value != "0")
            {
                return BllResultFactory.Error($"移走{truss}行架失败，{truss}正在执行任务中");
            }
            WCSTaskFlag.Value = TrussTaskFlag.Walk.GetIndexString();
            var WCSProductId = props.Find(t => t.EquipmentTypePropTemplateCode == TrussNormalProps.WCSProductType.ToString());
            WCSProductId.Value = "0";
            var WCSStationId = props.Find(t => t.EquipmentTypePropTemplateCode == TrussNormalProps.WCSMoverPosition.ToString());
            var takeLocation = DALHelper.GetFreeSql().Select<BaseWorkStation>().Where(u => u.Id == Convert.ToInt32(workStationId)).First().TakeLocation;
            WCSStationId.Value = takeLocation.ToString();
            //var WCSTaskNo = props.Find(t => t.EquipmentTypePropTemplateCode == TrussNormalProps.WCSTaskCode.ToString());
            var WCSTaskNo = truss[TrussNormalProps.WCSTaskCode.ToString()];
            WCSTaskNo.Value = Int32.MaxValue.ToString();
            propsToWriter.AddRange(new List<EquipmentProp>() { WCSTaskFlag, WCSProductId, WCSStationId, WCSTaskNo });
            var result = plc.Writes(propsToWriter);
            if (result.Success)
            {
                return BllResultFactory.Success("成功");
            }
            else
            {
                //Logger.Log($"通知{truss.Name}移走任务失败：{result.Msg}", LogLevel.Error);
                return BllResultFactory.Error($"通知{truss.Name}移走任务失败");
            }
        }
        #endregion

    }
}