using com.hnshituo.core.webapp.vo;
using Common;
using System;
using System.Collections.Generic;
using System.Linq;
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 JISCO.SaveMethod saveMethod = new JISCO.SaveMethod();

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

            string ResultMessage = "";
            bool isError = false;


            mwaf.carNo = PbCache.lockCarNo;
            mwaf.weightType = "";  // 默认重量类型为空
            mwaf.actualFirstNo = DateTime.Now.ToString("yyyyMMdd");//10
            mwaf.meterWeight = PbCache.lockWgt;//计量重量
            mwaf.addWeight = PbCache.addWgt;//附加重量
            mwaf.createManNo = PbCache.sportInfo.baseSpotNo;
            mwaf.createManName = PbCache.sportInfo.baseSpotName;
            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";

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

                // 根据车号查询委托表中未使用和使用中的委托
                // 状态（0：未配车；1：未使用；2：已使用；3：已作废；4：正使用）
                RESTfulResult<List<PreTrackScale>> rmPre = preTrackScaleService.doQueryByFlag(new PreTrackScale { carNo = PbCache.lockCarNo });
                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)    
                        {
                            rt = saveMethod.doAddFirst(null, mwaf);
                        }
                        // 存在一条使用中的委托
                        else if (listPreScale.Count == 1 && listPreScale[0].valueFlag == "4")
                        {
                            rt = saveMethod.doError("不存在一次计量数据却存在一条使用中的委托");
                        }
                        // 只存在一条未使用的委托
                        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);

                            // 查询上一次结净数据
                            MeterWorkCarActualService meterWorkCarActualService = new MeterWorkCarActualService();
                            //计量实绩
                            CommonPage<MeterWorkCarActual> cpc = new CommonPage<MeterWorkCarActual>();
                            MeterWorkCarActual mwca = new MeterWorkCarActual();
                            mwca.carNo = PbCache.lockCarNo;
                            cpc.param = mwca;
                            cpc.pageSize = 1;

                            RESTfulResult<List<MeterWorkCarActual>> rm = meterWorkCarActualService.doQueryOneWf(cpc);

                            if (rm.Succeed)
                            {
                                // 之前没有净重记录
                                if (rm.Data.Count == 0)
                                {
                                    /*
                                     * a. 正常保存重量(重量类型为空)
                                     * b. 匹配委托
                                     * c. 将委托状态变更为已使用
                                     * d. 提示称重完成
                                     */
                                    // 把委托编号复制给一次计量记录
                                    rt = saveMethod.doAddFirst(listPreScale[0] , mwaf);
                                }
                                else
                                {
                                    MeterWorkCarActual lastMeterWorkCarActual = rm.Data[0];

                                    
                                    // 上次净重记录未匹配委托
                                    if (lastMeterWorkCarActual.isPreScale == "0")
                                    {
                                        rt = saveMethod.doAddFirst(null, mwaf);
                                        rt = saveMethod.doError("称重完成，上次净重数据未匹配委托，请联系计量大厅");
                                    }
                                    // 上次净重已匹配委托 
                                    else if (lastMeterWorkCarActual.isPreScale == "1")
                                    {
                                        /* 委托和当次存在委托满足一车多卸逻辑 && 当次重量值小于上次净重记录中的皮重值
                                         * 一车多卸判断逻辑1
                                         * 存在判断依据(委托类型为一车多卸，且上次洁净数据中匹配委托类型也是一车多卸)
                                         *
                                         * 一车多卸判断逻辑2
                                         * 委托不存在判断依据，则根据签发时间排序
                                         * 如果两条数据发货单位一致，收货单位不一致，且签发时间在10分钟内，则可判定为一车多卸业务
                                         */
                                        bool isYCDX = false;

                                        // 签发时间比较
                                        // 通过上次洁净记录，找到该委托的签发时间
                                        RESTfulResult<List<PreTrackScale>> lastPre = preTrackScaleService.doQueryWf(new PreTrackScale { predictionNo = lastMeterWorkCarActual.predictionNo });
                                        //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 (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";

                                            // 复制对象，将档次委托信息复制给一次记录
                                            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个小时之内
                                         */

                                        bool isHZ = false;

                                        // 签发时间比较
                                        // 通过上次洁净记录，找到该委托的签发时间
                                        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;
                                        }

                                        if (isHZ == true)
                                        {
                                            /*
                                             * a. 取上次净重记录中的毛重值为当次皮重
                                             * b. 洁净匹配委托
                                             */
                                            // 新增一条皮重数据
                                            MeterWorkCarActualFirst newActualFirst = new MeterWorkCarActualFirst();
                                            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";

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

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

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

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

                                        // 把委托编号复制给一次计量记录
                                        EntityBase<PreTrackScale> entityBase = new EntityBase<PreTrackScale>();
                                        mwaf = entityBase.format<MeterWorkCarActualFirst>(listPreScale[0], mwaf);

                                        rt = saveMethod.doAddFirst(listPreScale[0], mwaf);
                                    }
                                }

                            }
                        }
                        // 存在多条委托
                        else if (listPreScale.Count > 1)
                        {
                            /*
                            * a. 正常保存重量(重量类型为空)
                            * b. 提示称重完成
                            */
                            PreTrackScale pre = null;
                            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 == "7" && listPreScale[1].predictionType == "7")
                            {
                                pre = listPreScale[0];
                            }
                            rt = saveMethod.doAddFirst(pre, mwaf);
                        }
                    }

                }
                // 存在一次计量数据
                else
                {
                    // 读结净最小值配置
                    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)
                    {
                        if (rmPre.Succeed)
                        {
                            // 存在的一次计量数据未匹配委托
                            if (rmX.Data[0].isPreScale == "0")
                            {
                                // 不存在委托数据
                                if (listPreScale == null || listPreScale.Count == 0)
                                {
                                    /*
                                     * a. 正常产生洁净数据(状态为未发布)
                                     * b. 提示司机当前计量数据未匹配委托，请联系计量打印进行处理
                                     */

                                    rt = saveMethod.doNet(scale, rmX.Data[0], mwaf);

                                }
                                // 只存在一条使用中的委托
                                else if (listPreScale.Count == 1 && listPreScale[0].valueFlag == "4")
                                {
                                    /*
                                     * a. 程序报警
                                     * b. 提示司机存在一条使用中的委托，请联系计量大厅进行确认
                                     * c. 自动进行语音求助
                                     */

                                    rt = saveMethod.doError("存在一条使用中的委托，请联系计量大厅进行确认");
                                }
                                // 只存在一条未使用的委托数据
                                else if (listPreScale.Count == 1 && (listPreScale[0].valueFlag == "0" || listPreScale[0].valueFlag == "1"))
                                {
                                    /*
                                     * a. 程序根据大减小的原则，保存净重并正确设置一次计量数据中的重量类型
                                     * b. 播放称重完成的语音提示
                                     */
                                    rt = saveMethod.doNetAndScale(scale, rmX.Data[0], mwaf);
                                }
                                // 如果存在两条未使用的委托
                                else if (listPreScale.Count == 2 && listPreScale[1].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);
                                    }
                                    /*
                                     * 委托关系满足一车多卸逻辑
                                     * 分两种情况：
                                     * 1、委托数据中没有委托类型标识，则根据签发时间排序，如果两条数据发货单位一致，收货单位不一致，且签发时间在10分钟内，则可判定为一车多卸业务，根据时间顺序选择第一条委托产生净重数据，然后使用第二条委托产生一个毛重数据。
                                     * 2、委托数据中存在委托类型标识，且类型都为一车多卸。
                                     */
                                    else if (listPreScale[0].predictionType == "6" && listPreScale[1].predictionType == "6" || listPreScale[0].predictionType == "7" && listPreScale[1].predictionType == "7")
                                    {
                                        /*
                                         * a. 正常洁净产生一条净重记录
                                         * b. 自动生成一条一次毛重计量数据，重量值值为当次计量数据中的毛重
                                         */
                                        MeterWorkCarActualFirst mwca = new MeterWorkCarActualFirst();
                                        mwca = rmX.Data[0];
                                        mwca.isPreScale = "1";

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

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

                                        rt = saveMethod.doNet(listPreScale[0], mwca, mwaf);
                                    }
                                    // 不满足以上逻辑
                                    else
                                    {
                                        /*
                                         * a. 正常洁净产生一条净重记录(状态为未发布)
                                         * b. 提示司机当前存计量数据未匹配委托
                                         * c. 进行大厅报警，请联系计量大厅进行处理
                                         * d. 自动进行语音求助(但是原有的语音求助逻辑是重量归零相应秤点的求助信息也会清空)
                                         */

                                        rt = saveMethod.doNet(scale, rmX.Data[0], mwaf);
                                        rt = saveMethod.doError("称重完成，当前所存计量数据未匹配委托，请联系计量大厅进行处理");
                                    }
                                }
                                // 存在多条未使用的委托数据
                                else if (listPreScale.Count > 2 && (listPreScale[0].valueFlag == "0" || listPreScale[0].valueFlag == "1"))
                                {
                                    ///* 委托关系满足多委托逻辑
                                    // * 多委托判定逻辑：
                                    // * 多条委托数据都存在委托类型依据，且类型都是多委托。
                                    // */
                                    //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("称重完成，当前所存计量数据未匹配委托，请联系计量大厅进行处理");
                                    //}
                                    rt = saveMethod.doNet(scale, rmX.Data[0], mwaf);
                                    rt = saveMethod.doError("称重完成，当前所存计量数据未匹配委托，请联系计量大厅进行处理");
                                }
                            }
                            // 存在的一次计量数据已匹配委托
                            else if (rmX.Data[0].isPreScale == "1")
                            {
                                /*
                                 * a. 程序根据大减小的原则，保存净重并正确设置一次计量数据中的重量类型
                                 * b. 播放称重完成的语音提示
                                 */
                                // 原数据大于新数据，原数据是毛重，新数据是皮重
                                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";

                                rt = saveMethod.doNet(pts, oldCarActural, mwaf);

                                rt.result = true;
                                rt.resultInfo = "称重完成";
                            }
                        }
                        
                    }
                    // 不满足
                    else
                    {
                        rt = saveMethod.doError("第一次计量重量【" + rmX.Data[0].meterWeight.Value / 1000 + "T】和第二次计量重量【" + PbCache.lockWgt / 1000 + "T】接近，小于结净最小值【" + diffrentWgt / 1000 + " T】");
                    }
                }
            }
            else
            {
                rt = saveMethod.doError("接口调用错误：无法读取车辆最近一次计量数据");
            }

            return rt;
        }

        
    }
}