YG-OPP-WCS-Client/WCS.PLC/Common/ConveyorHelper.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using WCS.Data;
using WCS.Data.Models;
using WCS.Data.Utils;
using WCS.PLC.Model.Equipment;
using static WCS.PLC.Base_Conv;

namespace WCS.PLC
{
    public class ConveyorHelper
    {
        /// <summary>
        /// 获取输送线信号
        /// </summary>
        /// <param name="plc_name"></param>
        /// <param name="conveyorNo"></param>
        /// <returns></returns>
        public static ConvSignal GetConveyorSignal(string plc_name, string conveyorNo)
        {
            var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == plc_name);

            var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == conveyorNo);
            if (conveyor == null)
            {
                Log4netHelper.Logger_Info.InfoFormat("plc:" + plc_name + "输送线：" + conveyorNo);
                return null;
            }
            return conveyor.EquSignal_Conv;
        }

        private static List<string> QuerySrmList(List<string> srms)
        {
            var result = new List<string>();
            Dictionary<string, int> dicsrm = new Dictionary<string, int>();
            foreach (var item in srms)
            {
                string srm = string.Format("srm0{0}", item);
                int taskcount = Current.TaskSet.Where(v => v.TASK_COMTYPE == 1 && v.TASK_WKSTATUS == 2 && v.TASK_SRMNO == srm).Count();
                dicsrm.Add(srm, taskcount);
            }
            result = dicsrm.OrderBy(v => v.Value).Select(t => t.Key).ToList();
            return result;
        }
        private static Dictionary<string, int> QueryDicList(List<string> srms)
        {
            Dictionary<string, int> dicsrm = new Dictionary<string, int>();
            foreach (var item in srms)
            {
                string srm = string.Format("srm0{0}", item);
                int taskcount = Current.TaskSet.Where(v => v.TASK_COMTYPE == 1 && v.TASK_WKSTATUS == 2 && v.TASK_SRMNO == srm).Count();
                dicsrm.Add(srm, taskcount);
            }
            return dicsrm;
        }

        /// <summary>
        /// 看板提示
        /// </summary>
        /// <param name="equipmentNo"></param>
        /// <param name="alaram"></param>
        /// <param name="writeCount"></param>
        public static void AddLedAlarmsMsg(string equipmentNo, string alaram, int writeCount = 100)
        {
            var time = SugarBase.DB.GetDate();//获取当前时间
            var alarmsmsgSet = SugarBase.DB.Queryable<WCS_LEDALARMSMSG>().Where(v => v.LED_CONVYORNO == equipmentNo).ToList();
            if (alarmsmsgSet.Count() < writeCount)
            {
                WCS_LEDALARMSMSG updateAlaram = null;
                var alarams = alarmsmsgSet.OrderByDescending(v => v.LED_UPDATETIME).ToList();
                if (alarams.Count > 0)
                {
                    if (alarams[0].LED_ALARMSMSG == alaram)
                    {
                        updateAlaram = alarams[0];
                    }
                }

                if (updateAlaram == null)
                {
                    //添加
                    var alarmsmsg = new WCS_LEDALARMSMSG();
                    alarmsmsg.LED_ID = Guid.NewGuid().ToString();
                    alarmsmsg.LED_ADDRESS = string.Empty;
                    alarmsmsg.LED_CONVYORNO = equipmentNo;
                    alarmsmsg.LED_NO = "1";
                    alarmsmsg.LED_ALARMSMSG = alaram;
                    alarmsmsg.LED_DEFAULTMESSAGE = Current.LED_DEFAULTMESSAGE;
                    alarmsmsg.LED_UPDATETIME = time;
                    alarmsmsg.LED_NOTES = string.Empty;
                    SugarBase.DB.Insertable(alarmsmsg).ExecuteCommand();
                }
                else if (updateAlaram.LED_UPDATETIME.AddMilliseconds(3) < time)
                {
                    //更新时间大于3秒，更新最新提示
                    SugarBase.DB.Updateable<WCS_LEDALARMSMSG>(it => new WCS_LEDALARMSMSG() { LED_UPDATETIME = time })
                             .Where(it => it.LED_ID == updateAlaram.LED_ID)
                             .ExecuteCommand();
                }
            }
            else
            {
                var alaitem = alarmsmsgSet.OrderByDescending(v => v.LED_UPDATETIME).ToList()[0];
                if (alaitem.LED_ALARMSMSG != alaram)
                {
                    var alaramsmsgitem = alarmsmsgSet.OrderBy(v => v.LED_UPDATETIME).ToList()[0];
                    //更新最新提示
                    SugarBase.DB.Updateable<WCS_LEDALARMSMSG>(it => new WCS_LEDALARMSMSG() { LED_ALARMSMSG = alaram, LED_UPDATETIME = time })
                             .Where(it => it.LED_ID == alaramsmsgitem.LED_ID)
                             .ExecuteCommand();
                }
            }
        }

        /// <summary>
        /// 入口是否报警
        /// </summary>
        public static bool ConvGoodsAlarms(string convNo, ConvSignal cs)
        {
            var alarmsMsg = new StringBuilder();
            if (cs.DB521_Goods_Err)
            {
                alarmsMsg.Append(string.Format("外形/条码等故障"));
            }
            if (cs.DB521_F_Outside)
            {
                if (alarmsMsg.Length > 0)
                {
                    alarmsMsg.Append(";");
                }
                alarmsMsg.Append(string.Format("前超长故障"));
            }
            if (cs.DB521_B_Outside)
            {
                if (alarmsMsg.Length > 0)
                {
                    alarmsMsg.Append(";");
                }
                alarmsMsg.Append(string.Format("后超长故障"));
            }
            if (cs.DB521_L_Outside)
            {
                if (alarmsMsg.Length > 0)
                {
                    alarmsMsg.Append(";");
                }
                alarmsMsg.Append(string.Format("左超长故障"));
            }
            if (cs.DB521_R_Outside)
            {
                if (alarmsMsg.Length > 0)
                {
                    alarmsMsg.Append(";");
                }
                alarmsMsg.Append(string.Format("右超长故障"));
            }
            if (cs.DB521_H_Outside)
            {
                if (alarmsMsg.Length > 0)
                {
                    alarmsMsg.Append(";");
                }
                alarmsMsg.Append(string.Format("超高故障"));
            }
            if (cs.DB521_BCR_Noread)
            {
                if (alarmsMsg.Length > 0)
                {
                    alarmsMsg.Append(";");
                }
                alarmsMsg.Append(string.Format("条码未读出"));
            }
            if (cs.DB521_Overload)
            {
                if (alarmsMsg.Length > 0)
                {
                    alarmsMsg.Append(";");
                }
                alarmsMsg.Append(string.Format("超重"));
            }

            if (alarmsMsg.Length > 0)
            {
                string result = string.Format("输送线[{0}]货物[{1}]", convNo, alarmsMsg.ToString());
                Log4netHelper.Logger_Error.ErrorFormat(result);
                return true;
            }
            else
            {
                return false;
            }
        }

        internal static string QueryTunnel(string wmstaskno, string tunnelNum,out string srmNo)
        {
            string tunnelNo = string.Empty;
            srmNo = string.Empty;
            var tunnelList = tunnelNum.Split(',').ToList();

            //根据物料缓存状态统计堆垛机入库任务数量
            var SrmCacheInfoSet = QuerySrmInConvCacheInfoList(tunnelList);

            foreach (var item in tunnelList)
            {
                var srmitem = SrmCacheInfoSet.FirstOrDefault(v => v.SrmTunnel == item);
                if (srmitem.ConvCacheIsAvailable)
                {
                    //var plctemp = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == srmitem.SrmNo);
                    //if (plctemp.WCS_StackerDataSet[0].SrmSignalItem.DB521_Auto_status != (int)SrmModeEnum.远程) continue;
                    //if (plctemp.WCS_StackerDataSet[0].SrmSignalItem.SrmDB541_Alarm) continue;
                    tunnelNo = srmitem.SrmTunnel;
                    srmNo = srmitem.SrmNo;
                    break;
                }
            }
            if (string.IsNullOrWhiteSpace(tunnelNo))
            {
                var SrmCacheInfoList = SrmCacheInfoSet.OrderBy(v => v.ConvCacheInTaskCount).ToList();
                foreach (var tunnelInfo in SrmCacheInfoList)
                {
                    //var plctemp = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == srm);
                    //if (plctemp.WCS_StackerDataSet[0].SrmSignalItem.DB521_Auto_status != (int)SrmModeEnum.远程) continue;
                    //if (plctemp.WCS_StackerDataSet[0].SrmSignalItem.SrmDB541_Alarm) continue;
                    tunnelNo = tunnelInfo.SrmTunnel;
                    srmNo = tunnelInfo.SrmNo;
                    break;
                }
            }

            if (string.IsNullOrWhiteSpace(tunnelNo))
            {
                throw new Exception(string.Format("WMS任务[{0}]分配巷道失败,WMS返回的巷道[{1}]在WCS系统中未找到。", wmstaskno, tunnelNum));
            }
            return tunnelNo;
        }
        internal static string AssignSrm(string convNo, string tunnelNum)
        {
            string srmno = string.Empty;
            var routeSet = EquRouteHelper.QueryRoute(convNo, "srm");
            var srmList = tunnelNum.Split(',').ToList();

            //根据物料缓存状态统计堆垛机入库任务数量
            //var dicsrm = QueryDicList(srmList);
            var SrmCacheInfoSet = QuerySrmInConvCacheInfoList(srmList);
            foreach (var item in srmList)
            {
                //if (srm == "srm03" || srm == "srm01" || srm == "srm04")
                //{
                var srmitem = SrmCacheInfoSet.FirstOrDefault(v => v.SrmTunnel == item);
                if (srmitem.ConvCacheIsAvailable)
                {
                    var plctemp = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == srmitem.SrmNo);
                    //if (plctemp.WCS_StackerDataSet[0].SrmSignalItem.DB521_Auto_status != (int)SrmModeEnum.远程) continue;
                    //if (plctemp.WCS_StackerDataSet[0].SrmSignalItem.SrmDB541_Alarm) continue;
                    var touteTo = routeSet.FirstOrDefault(v => v.ROUTE_SONPOS == srmitem.SrmNo);
                    if (touteTo == null) continue;
                    srmno = srmitem.SrmNo;
                    break;
                }
                //}
            }
            if (string.IsNullOrWhiteSpace(srmno))
            {
                var result = SrmCacheInfoSet.OrderBy(v => v.ConvCacheInTaskCount).Select(t => t.SrmNo).ToList();
                foreach (var srm in result)
                {
                    //if (srm == "srm03" || srm == "srm01" || srm == "srm04")
                    //{
                    var plctemp = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == srm);
                    //if (plctemp.WCS_StackerDataSet[0].SrmSignalItem.DB521_Auto_status != (int)SrmModeEnum.远程) continue;
                    //if (plctemp.WCS_StackerDataSet[0].SrmSignalItem.SrmDB541_Alarm) continue;
                    var touteTo = routeSet.FirstOrDefault(v => v.ROUTE_SONPOS == srm);
                    if (touteTo == null) continue;
                    srmno = srm;
                    break;
                    //}
                }
            }
            return srmno;
        }
        internal static List<SrmInConvCacheInfo> QuerySrmInConvCacheInfoList(List<string> tunnels)
        {
            var srmList = new List<SrmInConvCacheInfo>();

            foreach (var tunnel in tunnels)
            {
                var syssetitem = Current.SysSets.Where(v => v.SET_ID.Contains("Tunnel")).FirstOrDefault(v => v.SET_VALUE == tunnel);

                int taskcount = Current.TaskSet.Where(v => v.TASK_COMTYPE == 1 && (v.TASK_WKSTATUS == 2 || v.TASK_WKSTATUS == 5) && v.TASK_EndTunnelNum == tunnel).Count();
                if (syssetitem.SET_TYPE == "srm01")
                {
                    srmList.Add(new SrmInConvCacheInfo { SrmTunnel = tunnel, SrmNo = syssetitem.SET_TYPE, ConvCacheCount = 100, ConvCacheInTaskCount = taskcount });
                }
                else
                {
                    srmList.Add(new SrmInConvCacheInfo { SrmTunnel = tunnel, SrmNo = syssetitem.SET_TYPE, ConvCacheCount = 2, ConvCacheInTaskCount = taskcount });
                }
            }
            return srmList;
        }

        /// <summary>
        /// 分配堆垛机(分配巷道)
        /// </summary>
        /// <param name="routeSet">路由轨迹清单</param>
        /// <param name="converywrite">要写入plc的信息</param>
        /// <param name="task_no">任务号</param>
        public static void AssignSrm(List<WCS_EQUIPMENTROUTE> routeSet, WCSWriteToConveyorSignal converywrite, int wmstaskNum)
        {
            var param = new GetTunnelListParam();
            param.WMSTaskNum = wmstaskNum.ToString();
            //分配巷道
            var tunnelListReply = Current.WmsInterface.I_WCS_GetTunnelList(param);
            if (tunnelListReply == null)
            {
                throw new Exception(string.Format("WMS任务[{0}]分配巷道失败,原因[接口返回对象不正确，解析失败]", wmstaskNum));
            }
            else if (tunnelListReply.ResType)
            {
                if (string.IsNullOrWhiteSpace(tunnelListReply.TunnelNum))
                {
                    throw new Exception(string.Format("WMS任务[{0}]分配巷道失败,原因[没有返回巷道列表]", wmstaskNum));
                }
                var srmList = tunnelListReply.TunnelNum.Split(',').ToList();
                //根据物料缓存状态统计堆垛机入库任务数量
                //var dicsrm = QueryDicList(srmList);

                var SrmCacheInfoSet = QuerySrmInConvCacheInfoList(srmList);
                foreach (var item in srmList)
                {
                    //string srm = string.Empty;
                    //if (item.Length == 2)
                    //{
                    //    srm = string.Format("srm{0}", item);
                    //}
                    //else
                    //{
                    //    srm = string.Format("srm0{0}", item);
                    //}

                    //if (srm == "srm03" || srm == "srm01" || srm == "srm04")
                    //{
                    var srmitem = SrmCacheInfoSet.FirstOrDefault(v => v.SrmTunnel == item);
                    if (srmitem.ConvCacheIsAvailable)
                    {
                        var plctemp = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == srmitem.SrmNo);
                        //if (plctemp.WCS_StackerDataSet[0].SrmSignalItem.DB521_Auto_status != (int)SrmModeEnum.远程) continue;
                        //if (plctemp.WCS_StackerDataSet[0].SrmSignalItem.SrmDB541_Alarm) continue;
                        var touteTo = routeSet.FirstOrDefault(v => v.ROUTE_SONPOS == srmitem.SrmNo);
                        if (touteTo == null) continue;

                        converywrite.Goodsend = Convert.ToInt32(touteTo.ROUTE_STARTPOS);
                        converywrite.Srmno = srmitem.SrmNo;
                        break;
                    }
                    //}
                }
                if (converywrite.Goodsend <= 0)
                {
                    var result = SrmCacheInfoSet.OrderBy(v => v.ConvCacheInTaskCount).Select(t => t.SrmNo).ToList();
                    foreach (var srm in result)
                    {
                        //if (srm == "srm03" || srm == "srm01" || srm == "srm04")
                        //{
                        var plctemp = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == srm);
                        //if (plctemp.WCS_StackerDataSet[0].SrmSignalItem.DB521_Auto_status != (int)SrmModeEnum.远程) continue;
                        //if (plctemp.WCS_StackerDataSet[0].SrmSignalItem.SrmDB541_Alarm) continue;
                        var touteTo = routeSet.FirstOrDefault(v => v.ROUTE_SONPOS == srm);
                        if (touteTo == null) continue;

                        converywrite.Goodsend = Convert.ToInt32(touteTo.ROUTE_STARTPOS);
                        converywrite.Srmno = srm;
                        break;
                        //}
                    }
                }
            }

            if (converywrite.Goodsend <= 0)
            {
                if (tunnelListReply.ResType)
                {
                    throw new Exception(string.Format("WMS任务[{0}]分配巷道失败,原因[WMS接口返回成功，设备信号因素导致失败]", wmstaskNum));
                }
                else
                {
                    throw new Exception(string.Format("WMS任务[{0}]分配巷道失败,原因[{1}]", wmstaskNum, tunnelListReply.ResMessage));
                }
            }
            else
            {
                var result = TryCachHelper.TryExecute((db) =>
                {
                    var task = db.Queryable<WCS_TASK>().First(v => v.TASK_NO == converywrite.Tasknum);

                    db.Updateable<WCS_TASK>(it => new WCS_TASK()
                    {
                        TASK_POSIDTO = converywrite.Srmno,
                        TASK_SRMNO = converywrite.Srmno,
                        TASK_EDITUSERNO = "WCS",
                        TASK_EDITDATETIME = DateTime.Now
                    })
                     .Where(it => it.TASK_NO == task.TASK_NO)
                     .ExecuteCommand();
                });
                if (!string.IsNullOrWhiteSpace(result))
                {
                    throw new Exception(string.Format("WMS任务[{0}]分配巷道更新任务失败,原因[{1}]", wmstaskNum, result));
                }
            }
        }

        public static void AssignSrm(WCS_TASK task)
        {
            try
            {
                var param = new GetTunnelListParam();
                param.WMSTaskNum = task.TASK_WMSNO;
                if (task.TASK_POSIDCUR == "1023" || task.TASK_POSIDNEXT == "1023")
                {
                    var plctemp = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == "srm01");
                    var srm = plctemp.WCS_EquipmentInfoSet.FirstOrDefault().EquSignal_Srm;

                    if (srm.DB521_ToRowPos == 1 || srm.DB521_ToRowPos == 2)
                    {
                        param.Memo1 = "1";
                    }
                    else
                    {
                        param.Memo1 = "2";
                    }
                }
                //分配巷道
                var tunnelListReply = Current.WmsInterface.I_WCS_GetTunnelList(param);
                if (tunnelListReply == null)
                {
                    throw new Exception(string.Format("WMS任务[{0}]分配巷道失败,原因[接口返回对象不正确，解析失败]", task.TASK_WMSNO));
                }
                if (tunnelListReply.ResType)
                {
                    if (string.IsNullOrWhiteSpace(tunnelListReply.TunnelNum))
                    {
                        throw new Exception(string.Format("WMS任务[{0}]分配巷道失败,原因[没有返回巷道列表]", task.TASK_WMSNO));
                    }
                }
                else
                {
                    throw new Exception(string.Format("WMS任务[{0}]分配巷道失败,原因[{1}]", task.TASK_WMSNO, tunnelListReply.ResMessage));
                }

                string tunnelNo = string.Empty;
                string tunnelSrmNo = string.Empty;
                var srmList = tunnelListReply.TunnelNum.Split(',').ToList();
                //根据物料缓存状态统计堆垛机入库任务数量
                var SrmCacheInfoSet = QuerySrmInConvCacheInfoList(srmList);

                foreach (var item in srmList)
                {
                    var srmitem = SrmCacheInfoSet.FirstOrDefault(v => v.SrmTunnel == item);
                    if (srmitem.ConvCacheIsAvailable)
                    {
                        //var plctemp = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == srmitem.SrmNo);
                        //if (plctemp.WCS_StackerDataSet[0].SrmSignalItem.DB521_Auto_status != (int)SrmModeEnum.远程) continue;
                        //if (plctemp.WCS_StackerDataSet[0].SrmSignalItem.SrmDB541_Alarm) continue;

                        tunnelNo = srmitem.SrmTunnel;
                        tunnelSrmNo = srmitem.SrmNo;
                        break;
                    }
                }
                if (string.IsNullOrWhiteSpace(tunnelSrmNo))
                {
                    var SrmCacheInfoList = SrmCacheInfoSet.OrderBy(v => v.ConvCacheInTaskCount).ToList();
                    foreach (var tunnelInfo in SrmCacheInfoList)
                    {
                        //var plctemp = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == srm);
                        //if (plctemp.WCS_StackerDataSet[0].SrmSignalItem.DB521_Auto_status != (int)SrmModeEnum.远程) continue;
                        //if (plctemp.WCS_StackerDataSet[0].SrmSignalItem.SrmDB541_Alarm) continue;

                        tunnelNo = tunnelInfo.SrmTunnel;
                        tunnelSrmNo = tunnelInfo.SrmNo;
                        break;
                    }
                }

                if (string.IsNullOrWhiteSpace(tunnelSrmNo))
                {
                    throw new Exception(string.Format("WMS任务[{0}]分配巷道失败,WMS返回的巷道[{1}]在WCS系统中未找到。", task.TASK_WMSNO, tunnelListReply.TunnelNum));
                }

                if (task.TASK_POSIDFROM == "1004")
                {
                    tunnelNo = "1";
                }
                else if (task.TASK_POSIDFROM == "1013")
                {
                    tunnelNo = "2";
                }
                var result = TryCachHelper.TryExecute((db) =>
                {

                    db.Updateable<WCS_TASK>(it => new WCS_TASK()
                    {
                        TASK_EndTunnelNum = tunnelNo,
                        TASK_POSIDTO = tunnelSrmNo,
                        TASK_SRMNO = tunnelSrmNo,
                        TASK_EDITUSERNO = "WCS",
                        TASK_EDITDATETIME = DateTime.Now
                    })
                     .Where(it => it.TASK_NO == task.TASK_NO)
                     .ExecuteCommand();
                });
                if (string.IsNullOrWhiteSpace(result))
                {
                    task.TASK_POSIDTO = tunnelSrmNo;
                    task.TASK_EndTunnelNum = tunnelNo;
                    task.TASK_SRMNO = tunnelSrmNo;
                }
                else
                {
                    throw new Exception(string.Format("WMS任务[{0}]分配巷道更新任务失败,原因[{1}]", task.TASK_WMSNO, result));
                }
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        /// <summary>
        /// 预分配巷道
        /// </summary>
        public static void PreparatoryAssignSrmTunnel(WCS_TASK task)
        {
            try
            {
                var param = new GetTunnelListParam();
                param.WMSTaskNum = task.TASK_WMSNO;
                //分配巷道
                var tunnelListReply = Current.WmsInterface.I_WCS_GetTunnelList(param);
                if (tunnelListReply == null)
                {
                    throw new Exception(string.Format("WMS任务[{0}]分配巷道失败,原因[接口返回对象不正确，解析失败]", task.TASK_WMSNO));
                }
                if (tunnelListReply.ResType)
                {
                    if (string.IsNullOrWhiteSpace(tunnelListReply.TunnelNum))
                    {
                        throw new Exception(string.Format("WMS任务[{0}]分配巷道失败,原因[没有返回巷道列表]", task.TASK_WMSNO));
                    }
                }
                else
                {
                    throw new Exception(string.Format("WMS任务[{0}]分配巷道失败,原因[{1}]", task.TASK_WMSNO, tunnelListReply.ResMessage));
                }

                var result = TryCachHelper.TryExecute((db) =>
                {

                    db.Updateable<WCS_TASK>(it => new WCS_TASK()
                    {
                        TASK_ITEM7 = tunnelListReply.TunnelNum,
                        TASK_EDITUSERNO = "WCS",
                        TASK_EDITDATETIME = DateTime.Now
                    })
                     .Where(it => it.TASK_NO == task.TASK_NO)
                     .ExecuteCommand();
                });

                if (!string.IsNullOrWhiteSpace(result))
                {
                    throw new Exception(string.Format("WMS任务[{0}]分配巷道更新任务失败,原因[{1}]", task.TASK_WMSNO, result));
                }
                else
                {
                    task.TASK_ITEM7 = tunnelListReply.TunnelNum;
                }
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }
    }

    public struct SrmInConvCacheInfo
    {
        /// <summary>
        /// 巷道
        /// </summary>
        public string SrmTunnel { get; set; }
        /// <summary>
        /// 堆垛机
        /// </summary>
        public string SrmNo { get; set; }
        /// <summary>
        /// 输送线缓存数量
        /// </summary>
        public int ConvCacheCount { get; set;}
        /// <summary>
        /// 缓存中的入库任务数量
        /// </summary>
        public int ConvCacheInTaskCount { get; set; }
        /// <summary>
        /// 输送线缓存区是否够用
        /// </summary>
        public bool ConvCacheIsAvailable
        {
            get
            {
                return ConvCacheCount > ConvCacheInTaskCount;
            }
        }
    }
}