jisco_winform_wzjl/MeterSceneLibrary/JISCO/OuterCarJISCO.cs

using com.hnshituo.core.webapp.vo;
using Common;
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;

namespace MeterSceneLibrary
{
    /// <summary>
    /// 酒钢厂外车辆计量业务
    /// </summary>
    public class OuterCarJISCO
    {
        // 一次计量数据
        private MeterWorkCarActualFirstService mwcfs = new MeterWorkCarActualFirstService();
        // 车辆委托表
        private PreTrackScaleService preTrackScaleService = new PreTrackScaleService();

        private rtInfo rt = new rtInfo();

        // 构建一次计量数据
        private MeterWorkCarActualFirst mwaf = new MeterWorkCarActualFirst();

        // 结净最小值，默认取配置文件
        private double diffrentWgt = AppConfigCache.differenceWgt;

        // 根据车号查询委托表中未使用和使用中的委托
        private List<PreTrackScale> listPreScale;

        // 根据称点查询监控信息
        private RESTfulResult<List<MeterWorkMonitor>> listMonitor;

        // 查询上一次结净数据
        private MeterWorkCarActualService meterWorkCarActualService = new MeterWorkCarActualService();

        private JISCO.SaveMethod saveMethod = new JISCO.SaveMethod();

        public rtInfo MeterMethod(PreTrackScale scale)
        {
            Log lg = Log.GetInstance();
            rt.isError = false;

            string ResultMessage = "";
            bool isError = false;

            #region 数据查询
            //根据称点查询监控信息
            MeterWorkMonitorService meterWorkMonitorService = new MeterWorkMonitorService();
            listMonitor = meterWorkMonitorService.doQueryOneWf(new MeterWorkMonitor { pointNo = PbCache.sportInfo.baseSpotNo });

            // VALUE_FLAG 状态（0=作废，1=有效(已匹配)，2=结净，3=未匹配）
            // 根据车号查询最近的一次计量数据
            RESTfulResult<List<MeterWorkCarActualFirst>> rmX = mwcfs.doQueryByFlag(new MeterWorkCarActualFirst { carNo = PbCache.lockCarNo });

            // 根据车号查询委托表中未使用和使用中的委托
            // 状态（0：未配车；1：未使用；2：已使用；3：已作废；4：正使用）
            RESTfulResult<List<PreTrackScale>> rmPre = preTrackScaleService.doQueryByFlag(new PreTrackScale { carNo = PbCache.lockCarNo });


            //计量实绩
            MeterWorkCarActual mwca = new MeterWorkCarActual();
            mwca.carNo = PbCache.lockCarNo;
            RESTfulResult<List<MeterWorkCarActual>> rm = meterWorkCarActualService.doQueryActaulWf(mwca);

            // 签发时间比较
            // 通过上次结净记录，找到该委托的签发时间
            MeterWorkCarActual lastMeterWorkCarActual = rm.Data[0];
            RESTfulResult<List<PreTrackScale>> lastPre = preTrackScaleService.doQueryWf(new PreTrackScale { predictionNo = lastMeterWorkCarActual.predictionNo });
            #endregion

            mwaf.carNo = PbCache.lockCarNo;
            mwaf.weightType = "";  // 默认重量类型为空
            mwaf.actualFirstNo = DateTime.Now.ToString("yyyyMMdd");//10
            mwaf.meterWeight = PbCache.lockWgt;//计量重量
            mwaf.addWeight = PbCache.addWgt;//附加重量
            mwaf.createManNo = "admin";
            mwaf.createManName = "admin";
            mwaf.meterGroup = "";
            mwaf.meterClass = "";
            mwaf.createTime = DateTime.Now;
            mwaf.baseSpotNo = PbCache.sportInfo.baseSpotNo;//计量点编号
            mwaf.baseSpotName = PbCache.sportInfo.baseSpotName;
            //mwaf.memo = "";
            mwaf.valueFlag = "1"; //状态（0 = 作废，1 = 有效(已匹配)，2 = 结净，3 = 未匹配）
            mwaf.updateManName = "";
            mwaf.updateManNo = "";
            mwaf.updateTime = null;
            mwaf.checkFlag = "1"; //0未审核,1已审核
            mwaf.meterMode = "2"; //1：远程计量；2：智能计量；3：手工录入；4：放行智能计量；5：滞后匹配
            mwaf.addWeight = PbCache.addWgt;
            mwaf.dataSource = "1"; //数据来源(1=智能终端，2=本地计量，3=应急计量，4=手动录入(计量票据录入))
            mwaf.isPreScale = "0";
            PbCache.isActual = false;
            PbCache.isInnerCar = false;
            PbCache.ResultMessage = "";
            PbCache.monitorResultMessage = "";
            PbCache.LEDResultMessage = "";

            PbCache.yardActual = null;
            PbCache.yardFirst = null;

            if (rmX.Succeed)
            {
                List<MeterWorkCarActualFirst> list = rmX.Data;

                listPreScale = rmPre.Data;

                // 不存在一次计量数据
                if (list == null || list.Count == 0)
                {
                    //// 根据车号查询委托表中未使用和使用中的委托
                    //// 状态（0：未配车；1：未使用；2：已使用；3：已作废；4：正使用）
                    //RESTfulResult<List<PreTrackScale>> rmPre = preTrackScaleService.doQueryByFlag(new PreTrackScale { carNo = PbCache.lockCarNo});

                    if (rmPre.Succeed)
                    {
                        //listPreScale = rmPre.Data;
                        // 不存在委托
                        if (listPreScale == null || listPreScale.Count == 0)
                        {
                            PbCache.isActual = true;
                            PbCache.isInnerCar = true;
                            rt = saveMethod.doAddFirst(null, mwaf);
                            PbCache.voiceType = 1;
                            PbCache.LEDResultMessage = string.Format("车号{0}，1次重量{1}吨，计量完成", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2));
                        }
                        // 存在一条使用中的委托
                        else if (listPreScale.Count == 1 && listPreScale[0].valueFlag == "4")
                        {
                            PbCache.isActual = true;
                            PbCache.isInnerCar = true;
                            rt = saveMethod.doAddFirst(null, mwaf);
                            rt.resultInfo += "，不存在一次计量数据，存在一条使用中的委托";
                            PbCache.voiceType = 18;
                            PbCache.LEDResultMessage = "不存在一次计量数据却存在一条使用中的委托";
                            PbCache.monitorResultMessage = string.Format("车号:{0}，不存在一次计量数据却存在一条使用中的委托",PbCache.lockCarNo);
                            return rt;
                        }
                        // 只存在一条未使用的委托
                        else if (listPreScale.Count == 1 && (listPreScale[0].valueFlag == "0" || listPreScale[0].valueFlag == "1"))
                        {
                            //相同名称的均赋值一次
                            //EntityBase<PreTrackScale> entityBase = new EntityBase<PreTrackScale>();
                            //mwaf = entityBase.format<MeterWorkCarActualFirst>(scale, mwaf);

                            

                            if (rm.Succeed)
                            {
                                // 之前没有净重记录
                                if (rm.Data == null || rm.Data.Count == 0)
                                {
                                    /*
                                     * a. 正常保存重量(重量类型为空)
                                     * b. 匹配委托
                                     * c. 将委托状态变更为已使用
                                     * d. 提示称重完成
                                     */
                                    // 把委托编号复制给一次计量记录
                                    PbCache.isActual = true;
                                    PbCache.isInnerCar = true;
                                    PbCache.voiceType = 1;
                                    rt = saveMethod.doAddFirst(listPreScale[0], mwaf);
                                    PbCache.LEDResultMessage = string.Format("车号{0}，1次重量{1}吨，计量完成", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2));
                                }
                                else
                                {
                                    


                                    // 上次净重记录未匹配委托
                                    if (lastMeterWorkCarActual.isPreScale == "0")
                                    {
                                        PbCache.isActual = true;
                                        PbCache.isInnerCar = true;
                                        PbCache.voiceType = 1;
                                        rt = saveMethod.doAddFirst(listPreScale[0], mwaf);
                                        PbCache.LEDResultMessage = string.Format("车号{0}，1次重量{1}吨，计量完成", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2));
                                    }
                                    // 上次净重已匹配委托 
                                    else if (lastMeterWorkCarActual.isPreScale == "1")
                                    {
                                        /* 委托和当次存在委托满足一车多卸逻辑 && 当次重量值小于上次净重记录中的皮重值
                                         * 一车多卸判断逻辑1
                                         * 存在判断依据(委托类型为一车多卸，且上次结净数据中匹配委托类型也是一车多卸)
                                         *
                                         * 一车多卸判断逻辑2
                                         * 委托不存在判断依据，则根据签发时间排序
                                         * 如果两条数据发货单位一致，收货单位不一致，且签发时间在10分钟内，则可判定为一车多卸业务
                                         */
                                        bool isYCDX = false;

                                        bool isHZ = false;
                                        
                                        //int min = 999;

                                        //if (lastPre.Succeed && lastPre.Data.Count == 1)
                                        //{
                                        //    TimeSpan ts = new TimeSpan();
                                        //    ts = DateTime.Parse(listPreScale[0].trustDateTime.ToString()) - DateTime.Parse(lastPre.Data[0].trustDateTime.ToString());

                                        //    min = ts.Minutes; //此为相差分钟
                                        //}

                                        //// 一车多卸 && 当次重量值小于上次净重记录中的皮重值
                                        //if (listPreScale[0].meterTypeNo.Equals("xxxx"))
                                        //{
                                        //    isYCDX = true;
                                        //}
                                        //// 如果两条数据发货单位一致，收货单位不一致，且签发时间在10分钟内，则可判定为一车多卸业务
                                        //else if (listPreScale[0].forwardingUnitNo.Equals(lastMeterWorkCarActual.forwardingUnitNo) && !listPreScale[0].receivingUintNo.Equals(lastMeterWorkCarActual.receivingUintNo) && min <= 10)
                                        //{
                                        //    isYCDX = true;
                                        //}

                                        //if (lastPre.Data[0].predictionCombination == listPreScale[0].predictionCombination && lastPre.Data[0].predictionType == "6" && listPreScale[0].predictionType == "6")
                                        //{
                                        //    isYCDX = true;
                                        //}
                                        
                                        if (!string.IsNullOrEmpty(lastPre.Data[0].receiverRemark) && !string.IsNullOrEmpty(listPreScale[0].receiverRemark) && listPreScale[0].tempConveyance == lastPre.Data[0].tempConveyance && !string.IsNullOrEmpty(listPreScale[0].tempConveyance) && !string.IsNullOrEmpty(lastPre.Data[0].tempConveyance))
                                        {
                                            isHZ = true;
                                        }

                                        if (isYCDX == true)
                                        {
                                            /*
                                             * a. 取上次净重记录的皮重为当次毛重
                                             * b. 结净匹配委托
                                             */
                                            // 新增一条毛重数据
                                            MeterWorkCarActualFirst tempCarActualFirst = new MeterWorkCarActualFirst();
                                            tempCarActualFirst.carNo = PbCache.lockCarNo;
                                            tempCarActualFirst.weightType = "0";  // 重量类型（0=毛重；1=常规皮重；2=期限皮重；3=历史皮重；4=标识皮重；5=自重皮重）
                                            tempCarActualFirst.actualFirstNo = DateTime.Now.ToString("yyyyMMdd");//10
                                            tempCarActualFirst.meterWeight = lastMeterWorkCarActual.tareWeight;//计量重量
                                            tempCarActualFirst.addWeight = PbCache.addWgt;//附加重量
                                            tempCarActualFirst.createManNo = PbCache.sportInfo.baseSpotNo;
                                            tempCarActualFirst.createManName = PbCache.sportInfo.baseSpotName;
                                            tempCarActualFirst.meterGroup = "";
                                            tempCarActualFirst.meterClass = "";
                                            tempCarActualFirst.createTime = DateTime.Now;
                                            tempCarActualFirst.baseSpotNo = PbCache.sportInfo.baseSpotNo;//计量点编号
                                            tempCarActualFirst.baseSpotName = PbCache.sportInfo.baseSpotName;
                                            //mwaf.memo = "";
                                            tempCarActualFirst.valueFlag = "1"; //状态（0 = 作废，1 = 有效(已匹配)，2 = 结净，3 = 未匹配）
                                            tempCarActualFirst.updateManName = "";
                                            tempCarActualFirst.updateManNo = "";
                                            tempCarActualFirst.updateTime = null;
                                            tempCarActualFirst.checkFlag = "1"; //0未审核,1已审核
                                            tempCarActualFirst.meterMode = "2"; //1：远程计量；2：智能计量；3：手工录入；4：放行智能计量；5：滞后匹配
                                            tempCarActualFirst.addWeight = PbCache.addWgt;
                                            tempCarActualFirst.dataSource = "1"; //数据来源(1=智能终端，2=本地计量，3=应急计量，4=手动录入(计量票据录入))
                                            tempCarActualFirst.isPreScale = "1";
                                            tempCarActualFirst.valueFlag = "2";

                                            // 复制对象，将档次委托信息复制给一次记录
                                            EntityBase<PreTrackScale> entityBase = new EntityBase<PreTrackScale>();
                                            tempCarActualFirst = entityBase.format<MeterWorkCarActualFirst>(listPreScale[0], tempCarActualFirst);

                                            EntityBase<PreTrackScale> entityBase1 = new EntityBase<PreTrackScale>();
                                            mwaf = entityBase1.format<MeterWorkCarActualFirst>(listPreScale[0], mwaf);

                                            // 将当次一次计量数据重量类型改为皮重
                                            mwaf.weightType = "1"; // 常规皮重
                                            mwaf.isPreScale = "1";
                                            // 混装卸逻辑，并结净匹配委托
                                            rt = saveMethod.doNetHZHX(listPreScale[0], tempCarActualFirst, mwaf);
                                        }

                                        /* 匹配委托和当次委托满足混装逻辑 && 当次重量大于上次净重记录中的毛重值
                                         * 混装判断逻辑1
                                         * 存在判断依据(委托类型为混装，且上次结净数据中匹配委托类型也是混装)
                                         *
                                         * 混装判断逻辑2
                                         * 两次委托发货单位一致，净重时间在4个小时之内
                                         */



                                        // 签发时间比较
                                        // 通过上次结净记录，找到该委托的签发时间
                                        //int hour = 999;

                                        //if (lastPre.Succeed && lastPre.Data.Count == 1)
                                        //{
                                        //    TimeSpan ts = new TimeSpan();
                                        //    ts = DateTime.Parse(DateTime.Now.ToString()) - DateTime.Parse(lastMeterWorkCarActual.netTime.ToString());

                                        //    hour = ts.Hours; //此为相差小时
                                        //}

                                        //// 混装逻辑 && 当次重量大于上次净重记录中的毛重值
                                        //if (listPreScale[0].meterTypeNo.Equals("yyyy") && PbCache.lockWgt > lastMeterWorkCarActual.tareWeight)
                                        //{
                                        //    isHZ = true;
                                        //}
                                        //// 两次委托发货单位一致，净重时间在4个小时之内
                                        //else if (listPreScale[0].forwardingUnitNo.Equals(lastMeterWorkCarActual.forwardingUnitNo) && hour <= 4)
                                        //{
                                        //    isHZ = true;
                                        //}



                                        else if (isHZ == true)
                                        {
                                            /*
                                             * a. 取上次净重记录中的毛重值为当次皮重
                                             * b. 结净匹配委托
                                             */
                                            // 新增一条皮重数据
                                            MeterWorkCarActualFirst newActualFirst = new MeterWorkCarActualFirst();

                                            // 复制对象，将档次委托信息复制给一次记录
                                            EntityBase<PreTrackScale> entityBase = new EntityBase<PreTrackScale>();
                                            newActualFirst = entityBase.format<MeterWorkCarActualFirst>(listPreScale[0], newActualFirst);


                                            newActualFirst.carNo = PbCache.lockCarNo;
                                            newActualFirst.weightType = "1";  // 默认重量类型为皮重
                                            newActualFirst.actualFirstNo = DateTime.Now.ToString("yyyyMMdd");//10
                                            newActualFirst.meterWeight = lastMeterWorkCarActual.grossWeight;//取上次净重记录中的毛重值为当次皮重
                                            newActualFirst.addWeight = PbCache.addWgt;//附加重量
                                            newActualFirst.createManNo = PbCache.sportInfo.baseSpotNo;
                                            newActualFirst.createManName = PbCache.sportInfo.baseSpotName;
                                            newActualFirst.meterGroup = "";
                                            newActualFirst.meterClass = "";
                                            newActualFirst.createTime = DateTime.Now;
                                            newActualFirst.baseSpotNo = PbCache.sportInfo.baseSpotNo;//计量点编号
                                            newActualFirst.baseSpotName = PbCache.sportInfo.baseSpotName;
                                            //mwaf.memo = "";
                                            newActualFirst.valueFlag = "1"; //状态（0 = 作废，1 = 有效(已匹配)，2 = 结净，3 = 未匹配）
                                            newActualFirst.updateManName = "";
                                            newActualFirst.updateManNo = "";
                                            newActualFirst.updateTime = null;
                                            newActualFirst.checkFlag = "1"; //0未审核,1已审核
                                            newActualFirst.meterMode = "2"; //1：远程计量；2：智能计量；3：手工录入；4：放行智能计量；5：滞后匹配
                                            newActualFirst.addWeight = PbCache.addWgt;
                                            newActualFirst.dataSource = "1"; //数据来源(1=智能终端，2=本地计量，3=应急计量，4=手动录入(计量票据录入))
                                            newActualFirst.isPreScale = "1";
                                            newActualFirst.valueFlag = "2";

                                            
                                            EntityBase<PreTrackScale> entityBase1 = new EntityBase<PreTrackScale>();
                                            mwaf = entityBase1.format<MeterWorkCarActualFirst>(listPreScale[0], mwaf);

                                            // 读结净最小值配置
                                            ComBaseInfoService cbis = new ComBaseInfoService();
                                            RESTfulResult<List<ComBaseInfo>> res = cbis.doQueryBaseList(new ComBaseInfo { baseCode = "001031001" });
                                            if (res.Succeed)
                                            {
                                                if (res.Data != null && res.Data.Count == 1)
                                                {
                                                    try
                                                    {
                                                        diffrentWgt = Double.Parse(res.Data[0].baseName);
                                                    }
                                                    finally
                                                    {

                                                    }
                                                }
                                            }

                                            if (Math.Abs(newActualFirst.meterWeight.Value - PbCache.lockWgt) > diffrentWgt || listMonitor.Data[0].validPredictionDiff == "0")
                                            {
                                                // 将当次一次计量数据重量类型改为毛重
                                                mwaf.weightType = "0"; // 毛重
                                                mwaf.isPreScale = "1";
                                                // 混装逻辑，并结净匹配委托
                                                rt = saveMethod.doAddNetNewHZHX(listPreScale[0], newActualFirst, mwaf);
                                                rt.resultInfo += "，混装业务";
                                                double? netWeight = PbCache.lockWgt - lastMeterWorkCarActual.grossWeight;
                                                PbCache.voiceType = 1;
                                                PbCache.LEDResultMessage = string.Format("车号{0}，2次重量{1}吨，净重{2}吨，混装业务", PbCache.lockCarNo, Math.Round(PbCache.lockWgt / 1000, 2), Math.Abs(Math.Round((double)netWeight / 1000, 2)));
                                            }
                                            else
                                            {
                                                rt = saveMethod.doError("第一次计量重量【" + newActualFirst.meterWeight.Value / 1000 + "T】和第二次计量重量【" + PbCache.lockWgt / 1000 + "T】接近，小于结净最小值【" + diffrentWgt / 1000 + " T】");
                                                rt.isWarn = true;
                                                rt.WarnContent = "validWgt";
                                                PbCache.voiceType = 4;
                                                PbCache.LEDResultMessage = "计量失败，小于结净最小值，请联系计量大厅";
                                                return rt;
                                            }
                                        }
                                        else
                                        {
                                            EntityBase<PreTrackScale> entityBase2 = new EntityBase<PreTrackScale>();
                                            mwaf = entityBase2.format<MeterWorkCarActualFirst>(listPreScale[0], mwaf);
                                            PbCache.isActual = true;
                                            PbCache.isInnerCar = true;
                                            PbCache.voiceType = 1;
                                            rt = saveMethod.doAddFirst(listPreScale[0], mwaf);
                                            PbCache.LEDResultMessage = string.Format("车号{0}，1次重量{1}吨，计量完成", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2));
                                        }

                                    }
                                    // 存在结净记录，不满足以上逻辑
                                    else {
                                        /*
                                         * a. 正常保存重量(重量类型为空)
                                         * b. 匹配委托
                                         * c. 提示称重完成
                                         */

                                        // 把委托编号复制给一次计量记录
                                        EntityBase<PreTrackScale> entityBase = new EntityBase<PreTrackScale>();
                                        mwaf = entityBase.format<MeterWorkCarActualFirst>(listPreScale[0], mwaf);
                                        PbCache.isActual = true;
                                        PbCache.isInnerCar = true;
                                        PbCache.voiceType = 1;
                                        rt = saveMethod.doAddFirst(listPreScale[0], mwaf);
                                        PbCache.LEDResultMessage = string.Format("车号{0}，1次重量{1}吨，计量完成", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2));
                                    }
                                }

                            }
                            else
                            {
                                rt = saveMethod.doError("接口调用错误：无法读取车辆最近一次结净数据");
                                return rt;
                            }
                        }
                        else if (listPreScale.Count == 2 && listPreScale[0].valueFlag == "4" && listPreScale[1].valueFlag == "4")
                        {
                            rt = saveMethod.doAddFirst(null, mwaf);
                            PbCache.voiceType = 1;
                            PbCache.LEDResultMessage = string.Format("车号{0}，1次重量{1}吨，计量完成", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2));
                        }
                        // 存在多条委托
                        else if (listPreScale.Count > 1)
                        {
                            bool isHZ = false;

                            if (rm.Succeed) 
                            {
                                if (rm.Data == null || rm.Data.Count == 0)
                                {
                                    isHZ = true;
                                }
                                else
                                {
                                    if (rm.Data[0].isPreScale == "1")
                                    {
                                        isHZ = true;
                                    }
                                }
                            }

                            /*
                            * a. 正常保存重量(重量类型为空)
                            * b. 提示称重完成
                            */
                            PreTrackScale pre = null;
                            string res = "";
                            string matter = "";
                            string forwarding = "";
                            string receiving = "";
                            bool flag = true;
                            foreach (var item in listPreScale)
                            {
                                if (matter == "" && forwarding == "" && receiving == "")
                                {
                                    matter = item.matterNo;
                                    forwarding = item.forwardingUnitNo;
                                    receiving = item.receivingUintNo;
                                }
                                else
                                {
                                    if (matter == item.matterNo && forwarding == item.forwardingUnitNo && receiving == item.receivingUintNo)
                                    { }
                                    else
                                    {
                                        flag = false;
                                        break;
                                    }
                                }
                            }
                            if (flag)
                            {
                                pre = listPreScale[0];
                                PbCache.voiceType = 1;
                                PbCache.monitorResultMessage = string.Format("计量完成，车号{0}多个完全相同委托自动匹配最新委托", PbCache.lockCarNo);
                                PbCache.LEDResultMessage = string.Format("车号{0}，1次重量{1}吨，计量完成", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2));
                            }
                            if (listPreScale.Count == 2 && listPreScale[0].valueFlag == "1" && listPreScale[1].valueFlag == "1" && listPreScale[0].predictionType == "6" && listPreScale[1].predictionType == "6")
                            {
                                pre = listPreScale[0];
                            }
                            if (listPreScale.Count == 2 && listPreScale[0].valueFlag == "1" && listPreScale[1].valueFlag == "1" && listPreScale[0].predictionType == "5" && listPreScale[1].predictionType == "5")
                            {
                                pre = listPreScale[0];
                            }
                            if (listPreScale.Count == 2 && listPreScale[0].matterNo == listPreScale[1].matterNo && (listPreScale[0].receivingUintNo == listPreScale[1].forwardingUnitNo || listPreScale[0].forwardingUnitNo == listPreScale[1].receivingUintNo))
                            {
                                // 正常结净并生成两条净重数据
                                pre = listPreScale[1];
                                res = "，双委托业务";
                                PbCache.voiceType = 1;
                                PbCache.LEDResultMessage = string.Format("车号{0}，1次重量{1}吨，计量完成，双委托业务", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2));
                            }
                            if (listPreScale.Count == 2 && !string.IsNullOrEmpty(listPreScale[0].receiverRemark) && !string.IsNullOrEmpty(listPreScale[1].receiverRemark) && listPreScale[0].tempConveyance == listPreScale[1].tempConveyance && !string.IsNullOrEmpty(listPreScale[0].tempConveyance) && !string.IsNullOrEmpty(listPreScale[1].tempConveyance) && isHZ)
                            {
                                pre = listPreScale[1]; 
                                res = "，混装业务";
                                PbCache.voiceType = 1;
                                PbCache.LEDResultMessage = string.Format("车号{0}，1次重量{1}吨，计量完成，混装业务", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2));
                            }
                            if (pre == null)
                            {
                                res = "，存在多个委托，无法自动匹配";
                                PbCache.voiceType = 8;
                                PbCache.LEDResultMessage = string.Format("车号{0}，1次重量{1}吨，计量完成，多委托无法自动匹配请联系", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2));
                                PbCache.monitorResultMessage = string.Format("计量完成，车号{0}存在{1}个委托，无法自动匹配", PbCache.lockCarNo, listPreScale.Count);
                            }
                            PbCache.isActual = true;
                            PbCache.isInnerCar = true;
                            rt = saveMethod.doAddFirst(pre, mwaf);
                            if (res != "")
                            {
                                rt.resultInfo += res;
                            }
                        }
                        //不符合上述条件且有一次记录，不匹配委托直接保存一次
                        else
                        {
                            rt = saveMethod.doAddFirst(null, mwaf);
                            rt.resultInfo += "，存在多个委托，无法自动匹配";
                            PbCache.voiceType = 8;
                            PbCache.LEDResultMessage = string.Format("车号{0}，1次重量{1}吨，计量完成，多委托无法自动匹配请联系", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2));
                            PbCache.monitorResultMessage = string.Format("计量完成，车号{0}存在{1}个委托，无法自动匹配", PbCache.lockCarNo, listPreScale.Count);
                            PbCache.isActual = true;
                            PbCache.isInnerCar = true;
                        }
                    }

                }
                // 存在一次计量数据
                else if(list.Count == 1)
                {
                    // 读结净最小值配置
                    ComBaseInfoService cbis = new ComBaseInfoService();
                    RESTfulResult<List<ComBaseInfo>> res = cbis.doQueryBaseList(new ComBaseInfo { baseCode = "001031001" });
                    if (res.Succeed)
                    {
                        if (res.Data != null && res.Data.Count == 1)
                        {
                            try
                            {
                                diffrentWgt = Double.Parse(res.Data[0].baseName);
                            }
                            finally
                            {
                                
                            }
                        }
                    }

                    // 校验上次计量数据和当次计量数据是否满足基础配置表中的结净最小值条件
                    if (Math.Abs(rmX.Data[0].meterWeight.Value - PbCache.lockWgt) > diffrentWgt || listMonitor.Data[0].validPredictionDiff == "0")
                    {
                        if (rmPre.Succeed)
                        {
                            // 存在的一次计量数据未匹配委托
                            if (string.IsNullOrEmpty(rmX.Data[0].isPreScale) || rmX.Data[0].isPreScale == "0")
                            {
                                // 不存在委托数据
                                if (listPreScale == null || listPreScale.Count == 0)
                                {
                                    /*
                                     * a. 正常产生结净数据(状态为未发布)
                                     * b. 提示司机当前计量数据未匹配委托，请联系计量打印进行处理
                                     */
                                    rt = saveMethod.doNet(null, rmX.Data[0], mwaf);
                                    rt.isWarn = true;
                                    rt.WarnContent = "validIsPre";
                                    rt.resultInfo += "，无委托结净";
                                    PbCache.voiceType = 1;
                                    PbCache.LEDResultMessage = string.Format("车号{0}，2次重量{1}吨，净重{2}吨，无委托结净", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2), Math.Round((Math.Abs(rmX.Data[0].meterWeight.Value - PbCache.lockWgt) / 1000), 2));
                                    PbCache.monitorResultMessage = string.Format("计量完成，车号{0}无委托结净", PbCache.lockCarNo, listPreScale.Count);

                                }
                                // 只存在一条使用中的委托
                                else if (listPreScale.Count == 1 && listPreScale[0].valueFlag == "4")
                                {
                                    /*
                                     * a. 程序报警
                                     * b. 提示司机存在一条使用中的委托，请联系计量大厅进行确认
                                     * c. 自动进行语音求助
                                     */
                                    rt = saveMethod.doNet(null, rmX.Data[0], mwaf);
                                    rt.resultInfo += "，存在一条使用中的委托，请联系计量大厅进行确认";
                                    PbCache.voiceType = 18;
                                    PbCache.LEDResultMessage = "存在一条使用中的委托，请联系计量大厅进行确认";
                                    PbCache.monitorResultMessage = string.Format("车号:{0}，存在一条使用中的委托，请联系计量大厅进行确认", PbCache.lockCarNo);
                                    return rt;
                                }
                                // 只存在一条未使用的委托数据
                                else if (listPreScale.Count == 1 && listPreScale[0].valueFlag == "1")
                                {
                                    /*
                                     * a. 程序根据大减小的原则，保存净重并正确设置一次计量数据中的重量类型
                                     * b. 播放称重完成的语音提示
                                     */
                                    EntityBase<PreTrackScale> entityBase = new EntityBase<PreTrackScale>();
                                    mwaf = entityBase.format<MeterWorkCarActualFirst>(listPreScale[0], mwaf);
                                    mwaf.isPreScale = "1";
                                    PbCache.voiceType = 1;
                                    rt = saveMethod.doNet(listPreScale[0], rmX.Data[0], mwaf);
                                    PbCache.LEDResultMessage = string.Format("车号{0}，2次重量{1}吨，净重{2}吨，计量完成", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2), Math.Round((Math.Abs(rmX.Data[0].meterWeight.Value - PbCache.lockWgt) / 1000), 2));
                                }
                                // 如果存在两条未使用的委托
                                else if (listPreScale.Count == 2 && listPreScale[0].valueFlag == "1" && listPreScale[1].valueFlag == "1")
                                {
                                    /* 委托关系满足双委托逻辑
                                     * 分两种情况：
                                     * 1、委托数据货源字段中带有委托标识，且两条委托类型都是双委托。
                                     * 2、委托数据中没有带有委托标识，则根据签发时间排序，如果第一条委托的物料和第二条委托数据的相同，且第一条委托的收货单位是第二条委托的发货单位。
                                     */
                                    if (listPreScale[0].predictionType == "5" && listPreScale[1].predictionType == "5" && listPreScale[0].predictionCombination == listPreScale[1].predictionCombination)
                                    {
                                        // 正常结净并生成两条净重数据
                                        rt = saveMethod.doNetAddTwo(listPreScale, rmX.Data[0], mwaf);
                                        PbCache.voiceType = 1;
                                        PbCache.LEDResultMessage = string.Format("车号{0}，2次重量{1}吨，净重{2}吨，双委托结净", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2), Math.Round((Math.Abs(rmX.Data[0].meterWeight.Value - PbCache.lockWgt) / 1000), 2));
                                    }
                                    else if (listPreScale[0].matterNo == listPreScale[1].matterNo && (listPreScale[0].receivingUintNo == listPreScale[1].forwardingUnitNo || listPreScale[0].forwardingUnitNo == listPreScale[1].receivingUintNo))
                                    {
                                        // 正常结净并生成两条净重数据
                                        rt = saveMethod.doNetAddTwo(listPreScale, rmX.Data[0], mwaf);
                                        PbCache.voiceType = 1;
                                        PbCache.LEDResultMessage = string.Format("车号{0}，2次重量{1}吨，净重{2}吨，双委托结净", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2), Math.Round((Math.Abs(rmX.Data[0].meterWeight.Value - PbCache.lockWgt) / 1000), 2));
                                    }
                                    /*
                                     * 委托关系满足混装逻辑
                                     */
                                    else if (listPreScale.Count == 2 && !string.IsNullOrEmpty(listPreScale[0].receiverRemark) && !string.IsNullOrEmpty(listPreScale[1].receiverRemark) && listPreScale[0].tempConveyance == listPreScale[1].tempConveyance && !string.IsNullOrEmpty(listPreScale[0].tempConveyance) && !string.IsNullOrEmpty(listPreScale[1].tempConveyance))
                                    {
                                        /*
                                         * a. 正常结净产生一条净重记录
                                         * b. 自动生成一条一次毛重计量数据，重量值值为当次计量数据中的毛重
                                         */
                                        PreTrackScale ptss = new PreTrackScale();
                                        foreach (var item in listPreScale)
                                        {
                                            if (item.receiverRemark == "HO1")
                                            {
                                                ptss = item;
                                            }
                                        }


                                        MeterWorkCarActualFirst mwca2 = new MeterWorkCarActualFirst();
                                        mwca2 = rmX.Data[0];
                                        mwca2.isPreScale = "1";

                                        EntityBase<PreTrackScale> entityBase = new EntityBase<PreTrackScale>();
                                        mwca2 = entityBase.format<MeterWorkCarActualFirst>(ptss, mwca2);

                                        //EntityBase<PreTrackScale> entityBase1 = new EntityBase<PreTrackScale>();
                                        //mwaf = entityBase1.format<MeterWorkCarActualFirst>(listPreScale[0], mwaf);
                                        //mwaf.isPreScale = "1";
                                        
                                        PbCache.voiceType = 1;
                                        rt = saveMethod.doNetHZHX(ptss, mwca2, mwaf);
                                        PbCache.LEDResultMessage = string.Format("车号{0}，2次重量{1}吨，净重{2}吨，混装业务", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2), Math.Round((Math.Abs(rmX.Data[0].meterWeight.Value - PbCache.lockWgt) / 1000), 2));
                                        rt.resultInfo += "，混装业务";
                                    }
                                    // 不满足以上逻辑
                                    else
                                    {
                                        /*
                                         * a. 正常结净产生一条净重记录(状态为未发布)
                                         * b. 提示司机当前存计量数据未匹配委托
                                         * c. 进行大厅报警，请联系计量大厅进行处理
                                         * d. 自动进行语音求助(但是原有的语音求助逻辑是重量归零相应秤点的求助信息也会清空)
                                         */
                                        rt = saveMethod.doNet(null, rmX.Data[0], mwaf);
                                        rt.isWarn = true;
                                        rt.WarnContent = "validIsPre";
                                        rt.resultInfo += "，存在多个委托，无法自动匹配";
                                        PbCache.voiceType = 8;
                                        PbCache.LEDResultMessage = string.Format("车号{0}，2次重量{1}吨，净重{2}吨，多委托请联系大厅", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2), Math.Round((Math.Abs(rmX.Data[0].meterWeight.Value - PbCache.lockWgt) / 1000), 2));
                                        PbCache.monitorResultMessage = string.Format("计量完成，车号{0}存在{1}个委托，无法自动匹配", PbCache.lockCarNo, listPreScale.Count);
                                    }
                                }
                                // 存在多条未使用的委托数据
                                else if (listPreScale.Count > 2)
                                {
                                    ///* 委托关系满足多委托逻辑
                                    // * 多委托判定逻辑：
                                    // * 多条委托数据都存在委托类型依据，且类型都是多委托。
                                    // */
                                    //if (1 == 1)
                                    //{
                                    //    // 正常结净并生成两条净重数据
                                    //    rt = saveMethod.doNetAddTwo(listPreScale, rmX.Data[0], mwaf);
                                    //}
                                    ///*
                                    // * 委托关系满足一车多卸逻辑
                                    // * 一车多卸逻辑：多条委托都存在委托判断依据，且类型都是一车多卸委托。
                                    // */
                                    //else if (2 == 2)
                                    //{
                                    //    /*
                                    //     * a. 正常结净产生一条净重记录
                                    //     * b. 自动生成一条一次毛重计量数据，重量值值为当次计量数据中的毛重
                                    //     */

                                    //    // 将当次一次计量数据重量类型改为毛重
                                    //    mwaf.weightType = "0"; // 毛重
                                    //                           // 结净匹配委托
                                    //    rt = saveMethod.doNetMass(scale, mwaf);
                                    //}
                                    //// 不满足以上逻辑
                                    //else
                                    //{
                                    //    /*
                                    //     * a. 正常结净产生一条净重记录(状态为未发布)
                                    //     * b. 提示司机当前计量数据未匹配委托，请联系计量大厅进行委托匹配
                                    //     * c. 自动进行语音求助(但是原有的语音求助逻辑是重量归零相应秤点的求助信息也会清空)
                                    //     */
                                    //    rt = saveMethod.doNet(scale, rmX.Data[0], mwaf);
                                    //    rt = saveMethod.doError("称重完成，当前所存计量数据未匹配委托，请联系计量大厅进行处理");
                                    //}
                                    PreTrackScale pre = null;
                                    string matter = "";
                                    string forwarding = "";
                                    string receiving = "";
                                    bool flag = true;
                                    foreach (var item in listPreScale)
                                    {
                                        if (matter == "" && forwarding == "" && receiving == "")
                                        {
                                            matter = item.matterNo;
                                            forwarding = item.forwardingUnitNo;
                                            receiving = item.receivingUintNo;
                                        }
                                        else
                                        {
                                            if (matter == item.matterNo && forwarding == item.forwardingUnitNo && receiving == item.receivingUintNo)
                                            { }
                                            else
                                            {
                                                flag = false;
                                            }
                                        }
                                    }
                                    if (flag)
                                    {
                                        pre = listPreScale[0];

                                        EntityBase<PreTrackScale> entityBase = new EntityBase<PreTrackScale>();
                                        mwaf = entityBase.format<MeterWorkCarActualFirst>(pre, mwaf);
                                        mwaf.isPreScale = "1";

                                        PbCache.monitorResultMessage = string.Format("计量完成，车号{0}多个完全相同委托自动匹配最新委托", PbCache.lockCarNo);
                                        PbCache.LEDResultMessage = string.Format("车号{0}，2次重量{1}吨，净重{2}吨，计量完成", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2), Math.Round((Math.Abs(rmX.Data[0].meterWeight.Value - PbCache.lockWgt) / 1000), 2));
                                    }
                                    PbCache.voiceType = 1;
                                    rt = saveMethod.doNet(pre, rmX.Data[0], mwaf);
                                    rt.isWarn = true;
                                    rt.WarnContent = "validIsPre";
                                    if (pre == null)
                                    {
                                        PbCache.voiceType = 8;
                                        PbCache.LEDResultMessage = string.Format("车号{0}，2次重量{1}吨，净重{2}吨，多委托请联系大厅", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2), Math.Round((Math.Abs(rmX.Data[0].meterWeight.Value - PbCache.lockWgt) / 1000), 2));
                                        PbCache.monitorResultMessage = string.Format("计量完成，车号{0}存在{1}个委托，无法自动匹配", PbCache.lockCarNo, listPreScale.Count);
                                        rt.resultInfo += "，存在多个委托，无法自动匹配";
                                    }
                                }
                                //不符合上述条件且有一次记录，不匹配委托直接结净
                                else
                                {
                                    rt = saveMethod.doNet(null, rmX.Data[0], mwaf);
                                    rt.isWarn = true;
                                    rt.WarnContent = "validIsPre";
                                    PbCache.voiceType = 8;
                                    rt.resultInfo += "，存在多个委托，无法自动匹配";
                                    PbCache.LEDResultMessage = string.Format("车号{0}，2次重量{1}吨，净重{2}吨，多委托请联系大厅", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2), Math.Round((Math.Abs(rmX.Data[0].meterWeight.Value - PbCache.lockWgt) / 1000), 2));
                                    PbCache.monitorResultMessage = string.Format("计量完成，车号{0}存在{1}个委托，无法自动匹配", PbCache.lockCarNo, listPreScale.Count);
                                }
                            }
                            // 存在的一次计量数据已匹配委托
                            else if ((!string.IsNullOrEmpty(rmX.Data[0].isPreScale)) && rmX.Data[0].isPreScale == "1")
                            {
                                // 只存在一条使用中的委托
                                if (listPreScale.Count == 1 && listPreScale[0].valueFlag == "4")
                                {
                                    MeterWorkCarActualFirst oldCarActural = rmX.Data[0];
                                    if (rmX.Data[0].meterWeight.Value > PbCache.lockWgt)
                                    {
                                        mwaf.weightType = "1";

                                        oldCarActural.weightType = "0";

                                    }
                                    else
                                    {
                                        mwaf.weightType = "0";

                                        oldCarActural.weightType = "1";
                                    }
                                    PreTrackScale pts = listPreScale[0];

                                    EntityBase<PreTrackScale> entityBase = new EntityBase<PreTrackScale>();
                                    mwaf = entityBase.format<MeterWorkCarActualFirst>(pts, mwaf);
                                    mwaf.isPreScale = "1";
                                    PbCache.voiceType = 1;
                                    rt = saveMethod.doNet(pts, oldCarActural, mwaf);
                                    PbCache.LEDResultMessage = string.Format("车号{0}，2次重量{1}吨，净重{2}吨，计量完成", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2), Math.Round((Math.Abs(rmX.Data[0].meterWeight.Value - PbCache.lockWgt) / 1000), 2));

                                    rt.resultInfo = "计量完成";
                                }
                                // 如果存在一条未使用的委托和一条使用中的委托
                                else if (listPreScale.Count == 2 && (listPreScale[0].valueFlag == "4" && listPreScale[1].valueFlag == "1" || listPreScale[0].valueFlag == "1" && listPreScale[1].valueFlag == "4"))
                                {
                                    /* 委托关系满足双委托逻辑
                                     * 分两种情况：
                                     * 1、委托数据货源字段中带有委托标识，且两条委托类型都是双委托。
                                     * 2、委托数据中没有带有委托标识，则根据签发时间排序，如果第一条委托的物料和第二条委托数据的相同，且第一条委托的收货单位是第二条委托的发货单位。
                                     */
                                    if (listPreScale[0].predictionType == "5" && listPreScale[1].predictionType == "5" && listPreScale[0].predictionCombination == listPreScale[1].predictionCombination)
                                    {
                                        // 正常结净并生成两条净重数据
                                        rt = saveMethod.doNetAddTwo(listPreScale, rmX.Data[0], mwaf);
                                        PbCache.voiceType = 1;
                                        PbCache.LEDResultMessage = string.Format("车号{0}，2次重量{1}吨，净重{2}吨，双委托结净", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2), Math.Round((Math.Abs(rmX.Data[0].meterWeight.Value - PbCache.lockWgt) / 1000), 2));
                                    }
                                    else if (listPreScale[0].matterNo == listPreScale[1].matterNo && (listPreScale[0].receivingUintNo == listPreScale[1].forwardingUnitNo || listPreScale[0].forwardingUnitNo == listPreScale[1].receivingUintNo))
                                    {
                                        // 正常结净并生成两条净重数据
                                        rt = saveMethod.doNetAddTwo(listPreScale, rmX.Data[0], mwaf);
                                        PbCache.voiceType = 1;
                                        PbCache.LEDResultMessage = string.Format("车号{0}，2次重量{1}吨，净重{2}吨，双委托结净", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2), Math.Round((Math.Abs(rmX.Data[0].meterWeight.Value - PbCache.lockWgt) / 1000), 2));
                                    }
                                    /*
                                     * 委托关系满足混装混卸逻辑
                                     */
                                    else if (listPreScale.Count == 2 && !string.IsNullOrEmpty(listPreScale[0].receiverRemark) && !string.IsNullOrEmpty(listPreScale[1].receiverRemark) && listPreScale[0].tempConveyance == listPreScale[1].tempConveyance && !string.IsNullOrEmpty(listPreScale[0].tempConveyance) && !string.IsNullOrEmpty(listPreScale[1].tempConveyance))
                                    {
                                        /*
                                         * a. 正常结净产生一条净重记录
                                         * b. 自动生成一条一次毛重计量数据，重量值值为当次计量数据中的毛重
                                         */
                                        MeterWorkCarActualFirst mwca3 = new MeterWorkCarActualFirst();
                                        mwca3 = rmX.Data[0];
                                        mwca3.isPreScale = "1";

                                        PreTrackScale pts = null;

                                        foreach (var item in listPreScale)
                                        {
                                            if (item.predictionNo == rmX.Data[0].predictionNo)
                                            {
                                                pts = item;
                                            }
                                        }

                                        EntityBase<PreTrackScale> entityBase = new EntityBase<PreTrackScale>();
                                        mwca3 = entityBase.format<MeterWorkCarActualFirst>(pts, mwca3);

                                        //EntityBase<PreTrackScale> entityBase1 = new EntityBase<PreTrackScale>();
                                        //mwaf = entityBase1.format<MeterWorkCarActualFirst>(pts, mwaf);
                                        //mwaf.isPreScale = "1";

                                        rt = saveMethod.doNetHZHX(pts, mwca3, mwaf);
                                        rt.resultInfo += "，混装业务";
                                        PbCache.voiceType = 1;
                                        PbCache.LEDResultMessage = string.Format("车号{0}，2次重量{1}吨，净重{2}吨，混装业务", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2), Math.Round((Math.Abs(rmX.Data[0].meterWeight.Value - PbCache.lockWgt) / 1000), 2));
                                    }
                                    // 不满足以上逻辑
                                    else
                                    {
                                        /*
                                         * a. 正常结净产生一条净重记录(状态为未发布)
                                         * b. 提示司机当前存计量数据未匹配委托
                                         * c. 进行大厅报警，请联系计量大厅进行处理
                                         * d. 自动进行语音求助(但是原有的语音求助逻辑是重量归零相应秤点的求助信息也会清空)
                                         */
                                        MeterWorkCarActualFirst oldCarActural = rmX.Data[0];
                                        if (rmX.Data[0].meterWeight.Value > PbCache.lockWgt)
                                        {
                                            mwaf.weightType = "1";

                                            oldCarActural.weightType = "0";

                                        }
                                        else
                                        {
                                            mwaf.weightType = "0";

                                            oldCarActural.weightType = "1";
                                        }
                                        PreTrackScale pts = null;

                                        foreach (var item in listPreScale)
                                        {
                                            if (item.predictionNo == rmX.Data[0].predictionNo)
                                            {
                                                pts = item;
                                            }
                                        }

                                        EntityBase<PreTrackScale> entityBase = new EntityBase<PreTrackScale>();
                                        mwaf = entityBase.format<MeterWorkCarActualFirst>(pts, mwaf);
                                        mwaf.isPreScale = "1";
                                        PbCache.voiceType = 1;
                                        rt = saveMethod.doNet(pts, oldCarActural, mwaf);
                                        PbCache.LEDResultMessage = string.Format("车号{0}，2次重量{1}吨，净重{2}吨，计量完成", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2), Math.Round((Math.Abs(rmX.Data[0].meterWeight.Value - PbCache.lockWgt) / 1000), 2));
                                        PbCache.monitorResultMessage = string.Format("计量完成，在结净时仍然存在{1}个委托）", PbCache.lockCarNo, listPreScale.Count-1);

                                        rt.resultInfo = "计量完成";
                                    }
                                }
                                else if (listPreScale.Count == 2 && listPreScale[0].valueFlag == "4" && listPreScale[1].valueFlag == "4")
                                {
                                    rt = saveMethod.doNet(null, rmX.Data[0], mwaf);
                                    rt.isWarn = true;
                                    rt.WarnContent = "validIsPre";
                                    PbCache.voiceType = 8;
                                    rt.resultInfo += "，存在多个委托，无法自动匹配";
                                    PbCache.LEDResultMessage = string.Format("车号{0}，2次重量{1}吨，净重{2}吨，多委托请联系大厅", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2), Math.Round((Math.Abs(rmX.Data[0].meterWeight.Value - PbCache.lockWgt) / 1000), 2));
                                    PbCache.monitorResultMessage = string.Format("计量完成，车号{0}存在{1}个委托，无法自动匹配", PbCache.lockCarNo, listPreScale.Count);
                                }
                                // 存在多条未使用的委托数据
                                else if (listPreScale.Count > 2)
                                {
                                    PreTrackScale pts = null;

                                    foreach (var item in listPreScale)
                                    {
                                        if (item.predictionNo == rmX.Data[0].predictionNo)
                                        {
                                            pts = item;
                                        }
                                    }

                                    EntityBase<PreTrackScale> entityBase = new EntityBase<PreTrackScale>();
                                    mwaf = entityBase.format<MeterWorkCarActualFirst>(pts, mwaf);
                                    mwaf.isPreScale = "1";

                                    rt = saveMethod.doNet(pts, rmX.Data[0], mwaf);
                                    if (pts == null)
                                    {
                                        rt.isWarn = true;
                                        rt.WarnContent = "validIsPre";
                                        PbCache.voiceType = 8;
                                        rt.resultInfo += "，存在多个委托，无法自动匹配";
                                        PbCache.LEDResultMessage = string.Format("车号{0}，2次重量{1}吨，净重{2}吨，多委托请联系大厅", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2), Math.Round((Math.Abs(rmX.Data[0].meterWeight.Value - PbCache.lockWgt) / 1000), 2));
                                        PbCache.monitorResultMessage = string.Format("计量完成，车号{0}存在{1}个委托，无法自动匹配", PbCache.lockCarNo, listPreScale.Count);
                                    }
                                    else
                                    {
                                        PbCache.LEDResultMessage = string.Format("车号{0}，2次重量{1}吨，净重{2}吨，计量完成", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2), Math.Round((Math.Abs(rmX.Data[0].meterWeight.Value - PbCache.lockWgt) / 1000), 2));
                                    }
                                }
                                else
                                {
                                    PreTrackScale pts = null;

                                    foreach (var item in listPreScale)
                                    {
                                        if (item.predictionNo == rmX.Data[0].predictionNo)
                                        {
                                            pts = item;
                                        }
                                    }

                                    EntityBase<PreTrackScale> entityBase = new EntityBase<PreTrackScale>();
                                    mwaf = entityBase.format<MeterWorkCarActualFirst>(pts, mwaf);
                                    mwaf.isPreScale = "1";

                                    rt = saveMethod.doNet(pts, rmX.Data[0], mwaf);
                                    if (pts == null)
                                    {
                                        rt.isWarn = true;
                                        rt.WarnContent = "validIsPre";
                                        PbCache.voiceType = 8;
                                        rt.resultInfo += "，存在多个委托，无法自动匹配";
                                        PbCache.LEDResultMessage = string.Format("车号{0}，2次重量{1}吨，净重{2}吨，多委托请联系大厅", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2), Math.Round((Math.Abs(rmX.Data[0].meterWeight.Value - PbCache.lockWgt) / 1000), 2));
                                        PbCache.monitorResultMessage = string.Format("计量完成，车号{0}存在{1}个委托，无法自动匹配", PbCache.lockCarNo, listPreScale.Count);
                                    }
                                    else
                                    {
                                        PbCache.LEDResultMessage = string.Format("车号{0}，重量{1}吨，净重{2}吨，计量完成", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2), Math.Round((Math.Abs(rmX.Data[0].meterWeight.Value - PbCache.lockWgt) / 1000), 2));
                                    }
                                }
                            }
                        }
                    }
                    // 不满足
                    else
                    {
                        rt = saveMethod.doError("第一次计量重量【" + rmX.Data[0].meterWeight.Value / 1000 + "T】和第二次计量重量【" + PbCache.lockWgt / 1000 + "T】接近，小于结净最小值【" + diffrentWgt / 1000 + " T】");
                        rt.isWarn = true;
                        rt.WarnContent = "validWgt";
                        PbCache.voiceType = 4;
                        PbCache.LEDResultMessage = "计量失败，小于结净最小值，请联系计量大厅";
                        return rt;
                    }
                }
                else
                {
                    PbCache.isActual = true;
                    PbCache.isInnerCar = true;
                    rt = saveMethod.doAddFirst(null, mwaf);
                    rt.resultInfo += "，存在"+ list.Count + "条一次数据";
                    PbCache.voiceType = 24;
                    PbCache.LEDResultMessage = string.Format("车号{0}，重量{1}吨，存在{2}条一次数据，请联系大厅", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2),list.Count);
                    PbCache.monitorResultMessage = string.Format("车号{0}，重量{1}吨，存在{2}条一次数据，请联系大厅", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2), list.Count);
                    rt.isWarn = true;
                    rt.WarnContent = "validWgt";
                }
            }
            else
            {
                rt = saveMethod.doError("接口调用错误：无法读取车辆最近一次计量数据");
                return rt;
            }

            // 后台失败处理
            if (!rt.result)
            {
                rt.resultInfo = "称重数据保存失败";
                PbCache.voiceType = 25;
                PbCache.LEDResultMessage = "计量失败，请联系计量大厅";
                PbCache.monitorResultMessage = "";
            }
            return rt;
         }

        
    }
}