winfrom提交

CarMeterSystem/App.config

@@ -8,10 +8,10 @@
     <!--<add key="ServiceUrl" value="http://10.104.4.105:9004/v1" />-->
     <!--<add key="ServiceUrl" value="http://192.168.216.143:9004/v1" />-->
     <!--<add key="ServiceUrl" value="http://192.168.137.136:9004/v1" />-->
-    <!--<add key="ServiceUrl" value="http://10.104.0.1:9004/v1" />-->
+    <add key="ServiceUrl" value="http://10.104.0.1:9004/v1" />
     <!--<add key="ServiceUrl" value="http://192.168.107.60:8888/icore.icp.winform/pass/jlcar"/>-->
     <!--<add key="ServiceUrl" value="http://192.168.185.29/icore.icp.winform/pass/jlcar"/>-->
-    <add key="ServiceUrl" value="http://10.99.81.20/icore.icp.web/pass/systemBase/v1"/>
+    <!--<add key="ServiceUrl" value="http://10.99.81.20/icore.icp.web/pass/systemBase/v1"/>-->
     <!--<add key="ServiceUrl" value="http://jgwzjl.jiugang.com/icore.icp.web/pass/systemBase/v1"/>-->
     <!--<add key="ServiceUrl" value="http://10.130.1.2/icore.icp.web/pass/systemBase/v1"/>-->
     <!--实时库地址-->

CarMeterSystem/frmMain.cs

@@ -93,6 +93,8 @@ namespace CarMeterSystem
 
         private bool isOpened = false;//是否已经打开了扫码计量界面
 
+        private bool noteCode = false;
+
         //扫码器
         private SerialPortES sweepCodeClass = new SerialPortES();
 
@@ -864,8 +866,9 @@ namespace CarMeterSystem
                             PbCache.collect.carno = sCarNo;
                         }
 
-                        if (codeFlag)
+                        if (codeFlag && !noteCode)
                         {
+                            noteCode = true;
                             meterWorkScheduledHelp1.baseSpotNo = PbCache.sportInfo.baseSpotNo;
                             meterWorkScheduledHelp1.baseSpotName = PbCache.sportInfo.baseSpotName;
                             meterWorkScheduledHelp1.carNo = string.IsNullOrEmpty(PbCache.collect.carno) ? PbCache.resultCarNo : PbCache.collect.carno;
@@ -968,7 +971,11 @@ namespace CarMeterSystem
                             uc.setControlEnable(false);
                         }
                     }
-                    
+
+
+                    noteCode = false;
+
+
                     meterWorkMonitorEventDataI.pointNo = PbCache.sportInfo.baseSpotNo;
                     meterWorkMonitorEventDataI.validWgt = "1";
                     meterWorkMonitorEventDataI.validCarno = "1";

CarMeterSystem/frmOneYardToEnd.cs

@@ -15,6 +15,7 @@ using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Windows.Forms;
+using Common.DbOption.work;
 
 namespace CarMeterSystem
 {
@@ -41,7 +42,10 @@ namespace CarMeterSystem
         private MeterWorkScheduledHelpService meterWorkScheduledHelpService = new MeterWorkScheduledHelpService();
         private MeterWorkCompareSpotScaleService meterWorkCompareSpotScaleService = new MeterWorkCompareSpotScaleService();
         private MeterBaseSpecialUnitService meterBaseSpecialUnitService = new MeterBaseSpecialUnitService();
+        private ComBaseInfoService comBaseInfoService = new ComBaseInfoService();
         private MyTest myTest = new MyTest();
+        // 重量类型预处理表
+        private MeterWorkPreWgttypeService wgttypeService = new MeterWorkPreWgttypeService();
 
 
         private validTermTareCar termTareCar = new validTermTareCar();//验证是否可留期限皮
@@ -567,46 +571,94 @@ namespace CarMeterSystem
                                 // 厂内车辆
                                 if (car.carTypeNo == "001004003")
                                 {
-                                    try
+                                    RESTfulResult<PreTrackScale> isDoublePre = PreTrackScaleService.isDoublePre(tempCarNo);
+                                    if (isDoublePre.Succeed && isDoublePre.Data != null)
                                     {
-                                        btnSave.Enabled = false;
-                                        strRm = em.GetAndExecuteMethod<rtInfo>("MeterSceneLibrary", "InnerCarJISCO", "MeterMethod", new object[] { new PreTrackScale { } });
-                                        if (!string.IsNullOrEmpty(strRm.ResultMessage))
-                                        {
-                                            setMsg(strRm.ResultMessage);
-                                            strMsg = strRm.ResultMessage;
-                                            PbCache.ResultMessage = strRm.ResultMessage;
-                                        }
-                                        else
+                                        try
                                         {
-                                            setMsg(strRm.Data.resultInfo);
-                                            strMsg = strRm.Data.resultInfo;
-                                            PbCache.ResultMessage = strRm.Data.resultInfo;
-                                        }
-                                        if (!string.IsNullOrEmpty(PbCache.LEDResultMessage))
-                                        {
-                                            led_controler.setStaticLineMsg(PbCache.sportInfo.ledIp, PbCache.LEDResultMessage);
+                                            btnSave.Enabled = false;
+                                            strRm = em.GetAndExecuteMethod<rtInfo>("MeterSceneLibrary", "InnerDoubleJISCO", "MeterMethod", new object[] { isDoublePre.Data });
+                                            if (!string.IsNullOrEmpty(strRm.ResultMessage))
+                                            {
+                                                setMsg(strRm.ResultMessage);
+                                                strMsg = strRm.ResultMessage;
+                                                PbCache.ResultMessage = strRm.ResultMessage;
+                                            }
+                                            else
+                                            {
+                                                setMsg(strRm.Data.resultInfo);
+                                                strMsg = strRm.Data.resultInfo;
+                                                PbCache.ResultMessage = strRm.Data.resultInfo;
+                                            }
+                                            if (!string.IsNullOrEmpty(PbCache.LEDResultMessage))
+                                            {
+                                                led_controler.setStaticLineMsg(PbCache.sportInfo.ledIp, PbCache.LEDResultMessage);
+                                            } 
+                                            RESTfulResult<string> rms = monitor.doUpdateWf(new MeterWorkMonitor { pointNo = PbCache.sportInfo.baseSpotNo, ferroalloyResult = "1" });
+                                            if (!rms.Succeed)
+                                            {
+                                                lg.WriteLog(3, PbCache.lockCarNo + "求助写入失败");
+                                            }
+                                            isStop = false;
                                         }
-                                        RESTfulResult<string> rms = monitor.doUpdateWf(new MeterWorkMonitor { pointNo = PbCache.sportInfo.baseSpotNo, ferroalloyResult = "1" });
-                                        if (!rms.Succeed)
+                                        catch (Exception exp)
                                         {
-                                            lg.WriteLog(3, PbCache.lockCarNo + "求助写入失败");
+                                            PbCache.ResultMessage = "获取计量场景信息失败，请点击语音求助";
+                                            //这里是未找到方法的情况
+                                            lg.WriteLog(3, "获取场景失败！" + strRm.ResultMessage);
+                                            setMsg(PbCache.ResultMessage);
+                                            if (!string.IsNullOrEmpty(PbCache.LEDResultMessage))
+                                            {
+                                                led_controler.setStaticLineMsg(PbCache.sportInfo.ledIp, PbCache.LEDResultMessage);
+                                            }
+                                            isStop = false;
+                                            //break;
+                                            return;
                                         }
-                                        isStop = false;
                                     }
-                                    catch (Exception exp)
+                                    else
                                     {
-                                        PbCache.ResultMessage = "获取计量场景信息失败，请点击语音求助";
-                                        //这里是未找到方法的情况
-                                        lg.WriteLog(3, "获取场景失败！" + strRm.ResultMessage);
-                                        setMsg(PbCache.ResultMessage);
-                                        if (!string.IsNullOrEmpty(PbCache.LEDResultMessage))
+                                        try
                                         {
-                                            led_controler.setStaticLineMsg(PbCache.sportInfo.ledIp, PbCache.LEDResultMessage);
+                                            btnSave.Enabled = false;
+                                            strRm = em.GetAndExecuteMethod<rtInfo>("MeterSceneLibrary", "InnerCarJISCO", "MeterMethod", new object[] { new PreTrackScale { } });
+                                            if (!string.IsNullOrEmpty(strRm.ResultMessage))
+                                            {
+                                                setMsg(strRm.ResultMessage);
+                                                strMsg = strRm.ResultMessage;
+                                                PbCache.ResultMessage = strRm.ResultMessage;
+                                            }
+                                            else
+                                            {
+                                                setMsg(strRm.Data.resultInfo);
+                                                strMsg = strRm.Data.resultInfo;
+                                                PbCache.ResultMessage = strRm.Data.resultInfo;
+                                            }
+                                            if (!string.IsNullOrEmpty(PbCache.LEDResultMessage))
+                                            {
+                                                led_controler.setStaticLineMsg(PbCache.sportInfo.ledIp, PbCache.LEDResultMessage);
+                                            }
+                                            RESTfulResult<string> rms = monitor.doUpdateWf(new MeterWorkMonitor { pointNo = PbCache.sportInfo.baseSpotNo, ferroalloyResult = "1" });
+                                            if (!rms.Succeed)
+                                            {
+                                                lg.WriteLog(3, PbCache.lockCarNo + "求助写入失败");
+                                            }
+                                            isStop = false;
+                                        }
+                                        catch (Exception exp)
+                                        {
+                                            PbCache.ResultMessage = "获取计量场景信息失败，请点击语音求助";
+                                            //这里是未找到方法的情况
+                                            lg.WriteLog(3, "获取场景失败！" + strRm.ResultMessage);
+                                            setMsg(PbCache.ResultMessage);
+                                            if (!string.IsNullOrEmpty(PbCache.LEDResultMessage))
+                                            {
+                                                led_controler.setStaticLineMsg(PbCache.sportInfo.ledIp, PbCache.LEDResultMessage);
+                                            }
+                                            isStop = false;
+                                            //break;
+                                            return;
                                         }
-                                        isStop = false;
-                                        //break;
-                                        return;
                                     }
                                 }
                                 // 厂外车辆

Common/DbOption/scale/PreTrackScaleService.cs

@@ -70,6 +70,14 @@ namespace Common
 
             return rm;
         }
+
+        public RESTfulResult<PreTrackScale> isDoublePre(string carNo)
+        {
+            DbHelper db = new DbHelper();
+            RESTfulResult<PreTrackScale> rm = db.doOption<PreTrackScale>("meterbasemattermaps", "/isDoublePre", new object[] { new MeterBaseCar() { carNo = carNo } }, 1);
+
+            return rm;
+        }
         #endregion
     }
 }

Common/DbOption/work/MeterWorkCarActualFirstService.cs

@@ -29,6 +29,26 @@ namespace Common
             return rm;
         }
 
+        /// <summary>
+        /// 直接新增一次计量数据（无业务）
+        /// </summary>
+        /// <param name="info">MeterWorkCarActualFirst</param>
+        /// <returns></returns>
+        public RESTfulResult<string> doDoubleAdd(PbSomeModel<MeterWorkCarActualFirst, PreTrackScale, PreTrackScale, MeterMonitorNote> info)
+        {
+            DbHelper db = new DbHelper();
+
+            RESTfulResult<string> rm = db.doOption<string>("meterworkcaractualfirsts", "/doDoubleAdd", new object[] { info }, 1);
+            RESTfulResult<string> result = new RESTfulResult<string>();
+            result.Succeed = rm.Succeed;
+            result.Status = rm.Status;
+            result.Message = rm.Message;
+            result.ResultMessage = rm.ResultMessage;
+            result.Code = rm.Code;
+            result.Data = rm.Data;
+            return rm;
+        }
+
         /// <summary>
         /// 加密车号获取
         /// </summary>

Common/DbOption/work/MeterWorkCarActualService.cs

@@ -166,6 +166,46 @@ namespace Common
             return rm;
         }
 
+        /// <summary>
+        /// 期限皮结净
+        /// </summary>
+        /// <param name="scale">PreTrackScale</param>
+        /// <param name="actualFirst">MeterWorkCarActualFirst</param>
+        /// <returns></returns>
+        public RESTfulResult<string> doTermTareNetDouble(PreTrackScale scale, PreTrackScale scale1, MeterWorkCarActualFirst actualFirst)
+        {
+            DbHelper db = new DbHelper();
+            PbSomeModel<MeterWorkCarActualFirst, PreTrackScale, PreTrackScale, MeterMonitorNote> pbSomeModel = new PbSomeModel<MeterWorkCarActualFirst, PreTrackScale, PreTrackScale, MeterMonitorNote>();
+            pbSomeModel.one = actualFirst;
+            pbSomeModel.two = scale1;
+            pbSomeModel.three = scale;
+
+            //RESTfulResult<string> rm = db.doOption<string>("meterworkcaractualfirsts", "doAddNetInnerWf", new object[] { secondDb, netDb, saveTare }, 1);
+            RESTfulResult<string> rm = db.doOption<string>("meterworkcaractualfirsts", "/doTermTareNetDouble", new object[] { pbSomeModel }, 1);
+            return rm;
+        }
+
+        /// <summary>
+        /// 期限皮结净，留存期限皮
+        /// </summary>
+        /// <param name="scale">PreTrackScale</param>
+        /// <param name="TareactualFirst">MeterWorkCarActualFirst</param>
+        /// <param name="GrossactualFirst">MeterWorkCarActualFirst</param>
+        /// <returns></returns>
+        public RESTfulResult<string> doTermTareNetDoubleRetain(PreTrackScale scale, PreTrackScale scale1, MeterWorkCarActualFirst TareactualFirst, MeterWorkCarActualFirst GrossactualFirst)
+        {
+            DbHelper db = new DbHelper();
+            PbSomeModel<MeterWorkCarActualFirst, MeterWorkCarActualFirst, PreTrackScale, PreTrackScale> pbSomeModel = new PbSomeModel<MeterWorkCarActualFirst, MeterWorkCarActualFirst, PreTrackScale, PreTrackScale>();
+            pbSomeModel.one = TareactualFirst;
+            pbSomeModel.two = GrossactualFirst;
+            pbSomeModel.three = scale;
+            pbSomeModel.four = scale1;
+
+            //RESTfulResult<string> rm = db.doOption<string>("meterworkcaractualfirsts", "doAddNetInnerWf", new object[] { secondDb, netDb, saveTare }, 1);
+            RESTfulResult<string> rm = db.doOption<string>("meterworkcaractualfirsts", "doTermTareNetDoubleRetain", new object[] { pbSomeModel }, 1);
+            return rm;
+        }
+
         /// <summary>
         /// 多毛一皮结净
         /// </summary>
@@ -192,6 +232,72 @@ namespace Common
             return rm;
         }
 
+        /// <summary>
+        /// 多毛一皮结净
+        /// </summary>
+        /// <param name="secondDb">MeterWorkCarActualFirst</param>
+        /// <param name="netDb">MeterWorkCarActual</param>
+        /// <param name="saveTare">0 不保存历史皮，1保存历史皮</param>
+        /// <returns></returns>
+        public RESTfulResult<string> doNetAddMuchGrossDouble(List<MeterWorkCarActualFirst> actualFirst, MeterWorkCarActualFirst actualFirst1, MeterMonitorNote note)
+        {
+            DbHelper db = new DbHelper();
+            PbSomeModel<List<MeterWorkCarActualFirst>, MeterWorkCarActualFirst, PreTrackScale, MeterMonitorNote> pbSomeModel = new PbSomeModel<List<MeterWorkCarActualFirst>, MeterWorkCarActualFirst, PreTrackScale, MeterMonitorNote>();
+            pbSomeModel.one = actualFirst;
+            pbSomeModel.two = actualFirst1;
+            pbSomeModel.four = note;
+
+            if (actualFirst1 != null && string.IsNullOrEmpty(actualFirst1.createManNo))
+            {
+                actualFirst1.createManNo = actualFirst1.baseSpotNo;
+                actualFirst1.createManName = actualFirst1.baseSpotName;
+            }
+
+            //RESTfulResult<string> rm = db.doOption<string>("meterworkcaractualfirsts", "doAddNetInnerWf", new object[] { secondDb, netDb, saveTare }, 1);
+            RESTfulResult<string> rm = db.doOption<string>("meterworkcaractualfirsts", "doNetAddMuchGrossDouble", new object[] { pbSomeModel }, 1);
+            return rm;
+        }
+
+        /// <summary>
+        /// 内倒双委托多毛一皮结净存期限皮
+        /// </summary>
+        /// <param name="actualFirsts">List<MeterWorkCarActualFirst></param>
+        /// <param name="TareactualFirst">MeterWorkCarActualFirst</param>
+        /// <param name="note">MeterMonitorNote</param>
+        /// <returns></returns>
+        public RESTfulResult<string> doAddDoubleMuchNet(List<MeterWorkCarActualFirst> actualFirsts, MeterWorkCarActualFirst TareactualFirst, MeterMonitorNote note)
+        {
+            DbHelper db = new DbHelper();
+            PbSomeModel<List<MeterWorkCarActualFirst>, MeterWorkCarActualFirst, PreTrackScale, MeterMonitorNote> pbSomeModel = new PbSomeModel<List<MeterWorkCarActualFirst>, MeterWorkCarActualFirst, PreTrackScale, MeterMonitorNote>();
+            pbSomeModel.one = actualFirsts;
+            pbSomeModel.two = TareactualFirst;
+            pbSomeModel.four = note;
+
+            //RESTfulResult<string> rm = db.doOption<string>("meterworkcaractualfirsts", "doAddNetInnerWf", new object[] { secondDb, netDb, saveTare }, 1);
+            RESTfulResult<string> rm = db.doOption<string>("meterworkcaractualfirsts", "/doAddDoubleMuchNet", new object[] { pbSomeModel }, 1);
+            return rm;
+        }
+
+        /// <summary>
+        /// 内倒双委托多毛一皮结净存期限皮
+        /// </summary>
+        /// <param name="actualFirsts">List<MeterWorkCarActualFirst></param>
+        /// <param name="TareactualFirst">MeterWorkCarActualFirst</param>
+        /// <param name="note">MeterMonitorNote</param>
+        /// <returns></returns>
+        public RESTfulResult<string> doAddDoubleMuchNetRetain(List<MeterWorkCarActualFirst> actualFirsts, MeterWorkCarActualFirst TareactualFirst, MeterMonitorNote note)
+        {
+            DbHelper db = new DbHelper();
+            PbSomeModel<List<MeterWorkCarActualFirst>, MeterWorkCarActualFirst, PreTrackScale, MeterMonitorNote> pbSomeModel = new PbSomeModel<List<MeterWorkCarActualFirst>, MeterWorkCarActualFirst, PreTrackScale, MeterMonitorNote>();
+            pbSomeModel.one = actualFirsts;
+            pbSomeModel.two = TareactualFirst;
+            pbSomeModel.four = note;
+
+            //RESTfulResult<string> rm = db.doOption<string>("meterworkcaractualfirsts", "doAddNetInnerWf", new object[] { secondDb, netDb, saveTare }, 1);
+            RESTfulResult<string> rm = db.doOption<string>("meterworkcaractualfirsts", "/doAddDoubleMuchNetRetain", new object[] { pbSomeModel }, 1);
+            return rm;
+        }
+
         /// <summary>
         /// 错误结净
         /// </summary>
@@ -304,6 +410,27 @@ namespace Common
             return rm;
         }
 
+        /// <summary>
+        /// 内倒双委托结净逻辑
+        /// </summary>
+        /// <param name="scale">List<PreTrackScale></param>
+        /// <param name="TareactualFirst">MeterWorkCarActualFirst</param>
+        /// <param name="GorssactualFirst">MeterWorkCarActualFirst</param>
+        /// <returns></returns>
+        public RESTfulResult<string> doAddDoubleNet(PreTrackScale scale, PreTrackScale scale1, MeterWorkCarActualFirst TareactualFirst, MeterWorkCarActualFirst GorssactualFirst)
+        {
+            DbHelper db = new DbHelper();
+            PbSomeModel<MeterWorkCarActualFirst, MeterWorkCarActualFirst, PreTrackScale, PreTrackScale> pbSomeModel = new PbSomeModel<MeterWorkCarActualFirst, MeterWorkCarActualFirst, PreTrackScale, PreTrackScale>();
+            pbSomeModel.one = TareactualFirst;
+            pbSomeModel.two = GorssactualFirst;
+            pbSomeModel.three = scale;
+            pbSomeModel.four = scale1;
+
+            //RESTfulResult<string> rm = db.doOption<string>("meterworkcaractualfirsts", "doAddNetInnerWf", new object[] { secondDb, netDb, saveTare }, 1);
+            RESTfulResult<string> rm = db.doOption<string>("meterworkcaractualfirsts", "/doAddDoubleNet", new object[] { pbSomeModel }, 1);
+            return rm;
+        }
+
         /// <summary>
         /// 期限皮逻辑
         /// </summary>

MeterSceneLibrary/JISCO/InnerCarJISCO.cs

@@ -1002,8 +1002,8 @@ namespace MeterSceneLibrary
                                 }
                                 else
                                 {
-                                    rt = saveMethod.doError("委托匹配异常，无法计量，请联系处理");
-                                    PbCache.LEDResultMessage = "委托匹配异常，无法计量，请联系处理";
+                                    rt = saveMethod.doError("选择的委托不存在，请重新选择");
+                                    PbCache.LEDResultMessage = "选择的委托不存在，请重新选择";
                                     PbCache.voiceType = 6;
                                     rt.isWarn = true;
                                     rt.WarnContent = "validIsPre";

MeterSceneLibrary/JISCO/InnerDoubleJISCO.cs

@@ -0,0 +1,466 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using com.hnshituo.core.webapp.vo;
+using Common;
+using Common.DbOption.work;
+
+namespace MeterSceneLibrary
+{
+    public class InnerDoubleJISCO
+    {
+        // 一次计量数据
+        private MeterWorkCarActualFirstService mwcfs = new MeterWorkCarActualFirstService();
+
+        // 重量类型预处理表
+        private MeterWorkPreWgttypeService wgttypeService = new MeterWorkPreWgttypeService();
+
+        // 车辆委托表
+        private PreTrackScaleService preTrackScaleService = new PreTrackScaleService();
+
+        // 留期限皮操作
+        private MeterBaseTermTareDataService termTareDate = new MeterBaseTermTareDataService();
+
+        private MeterBaseSpotInfoService meterBaseSpotInfoService = new MeterBaseSpotInfoService();
+
+        private rtInfo rt = new rtInfo();
+
+        // 构建一次计量数据
+        private MeterWorkCarActualFirst mwaf = new MeterWorkCarActualFirst();
+
+        private MeterBaseCarService carService = new MeterBaseCarService();
+
+        private MeterBaseSpecialUnitService meterBaseSpecialUnitService = new MeterBaseSpecialUnitService();
+
+        // 结净最小值，默认取配置文件
+        private double diffrentWgt = AppConfigCache.differenceWgt;
+
+        // 根据称点查询监控信息
+        private RESTfulResult<List<MeterWorkMonitor>> listMonitor;
+
+        // 根据车号查询委托表中未使用和使用中的委托
+        private List<PreTrackScale> listPreScale;
+
+        private JISCO.SaveMethod saveMethod = new JISCO.SaveMethod();
+
+        private ComBaseInfoService comBaseInfoService = new ComBaseInfoService();
+
+        private MeterBaseTermTareDataService meterBaseTermTareDataService = new MeterBaseTermTareDataService();
+
+        public rtInfo MeterMethod(PreTrackScale scale)
+        {
+            Log lg = Log.GetInstance();
+            rt.isError = false;
+
+            string ResultMessage = "";
+            bool isError = false;
+
+            //根据称点查询监控信息
+            MeterWorkMonitorService meterWorkMonitorService = new MeterWorkMonitorService();
+            listMonitor = meterWorkMonitorService.doQueryOneWf(new MeterWorkMonitor { pointNo = PbCache.sportInfo.baseSpotNo });
+
+            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.createManNo = "SYSTEM";
+            mwaf.createManName = "system";
+            mwaf.createTime = DateTime.Now;
+            mwaf.baseSpotNo = PbCache.sportInfo.baseSpotNo;//计量点编号
+            mwaf.baseSpotName = PbCache.sportInfo.baseSpotName;
+            //mwaf.memo = "";
+            mwaf.valueFlag = "1"; //状态（0 = 作废，1 = 有效(已匹配)，2 = 结净）
+            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=手动录入(计量票据录入))
+            PbCache.isActual = false;
+            PbCache.isInnerCar = false;
+            PbCache.ResultMessage = "";
+            PbCache.monitorResultMessage = "";
+            PbCache.LEDResultMessage = "";
+
+            // 根据车号查询重量类型预处理表
+            RESTfulResult<List<MeterWorkPreWgttype>> rmX = wgttypeService.doQueryWf(new MeterWorkPreWgttype { carNo = PbCache.lockCarNo, valueFlag = "1" });
+
+            if (rmX.Succeed)
+            {
+                List<MeterWorkPreWgttype> list = rmX.Data;
+
+                // 不存在一次预处理数据
+                if (list == null || list.Count == 0)
+                {
+                    /* a. 程序报警
+                     * b. 自动进行语音求助
+                     */
+                    rt = saveMethod.doError("未选择称重类型，请选择后开始计量");
+                    PbCache.voiceType = 21;
+                    PbCache.monitorResultMessage = "未选择称重类型，请选择后开始计量";
+                    PbCache.LEDResultMessage = "未选择称重类型，请选择后开始计量";
+                    PbCache.ResultMessage = "未选择称重类型，请选择后开始计量";
+                    return rt;
+                }
+                else if (list == null || list.Count == 1)
+                {
+                    // 历史皮重验证
+                    // 001033002：皮重
+                    rt = saveMethod.validHisTare2(list[0].weightTypeNo);
+                    if (list[0].weightTypeNo == "001033002" && PbCache.monitorResult.valid_wgt == false && listMonitor.Data[0].validWgt == "1")
+                    {
+                        PbCache.ResultMessage = "毛皮类型选错，请重新选择";
+                        PbCache.LEDResultMessage = "计量失败，毛皮类型选错，请重新选择";
+                        PbCache.voiceType = 26;
+                        rt = saveMethod.doError(PbCache.ResultMessage);
+                        rt.isWarn = true;
+                        rt.WarnContent = "validWgt";
+                        return rt;
+                    }
+                    // 001033001：毛重
+                    if (list[0].weightTypeNo == "001033001" && PbCache.monitorResult.valid_wgt == true && listMonitor.Data[0].validWgt == "1")
+                    {
+                        PbCache.ResultMessage = "毛皮类型选错，请重新选择";
+                        PbCache.LEDResultMessage = "计量失败，毛皮类型选错，请重新选择";
+                        PbCache.voiceType = 23;
+                        rt = saveMethod.doError(PbCache.ResultMessage);
+                        rt.isWarn = true;
+                        rt.WarnContent = "validWgt";
+                        return rt;
+                    }
+
+                    // 查已选择的委托
+                    RESTfulResult<List<PreTrackScale>> rmScale = preTrackScaleService.doQueryByFlag(new PreTrackScale { carNo = PbCache.lockCarNo, lineDesc = "1" });
+
+                    // 查询一次计量数据表
+                    RESTfulResult<List<MeterWorkCarActualFirst>> rmFirst = mwcfs.doQueryByFlag(new MeterWorkCarActualFirst { carNo = PbCache.lockCarNo });
+
+                    //查询车辆是否存在配置
+                    RESTfulResult<List<ComBaseInfo>> comBaseInfos = comBaseInfoService.doQueryBaseList(new ComBaseInfo { pBaseCode = "001048", validFlag = "1",baseName = PbCache.lockCarNo });
+
+                    //查询车辆是否存在期限皮重信息
+                    RESTfulResult<MeterBaseTermTareData> termTareData = meterBaseTermTareDataService.doQueryPageWf(new MeterBaseTermTareData { carNo = PbCache.lockCarNo, valueFlag = "0" });
+
+                    List<MeterWorkCarActualFirst> firstList = rmFirst.Data;
+                    //判断已选择的委托是否为1条
+                    if (rmScale.Succeed && rmScale.Data.Count == 1)
+                    {
+                        mwaf.weightType = "0";
+
+                        if (rmFirst.Succeed)
+                        {
+                            //不存在一次计量数据
+                            if (firstList == null || firstList.Count == 0)
+                            {
+                                if (comBaseInfos.Succeed)
+                                {
+                                    //判断车辆是否满足期限皮
+                                    if (comBaseInfos.Data != null && comBaseInfos.Data.Count == 1)
+                                    {
+                                        if (termTareData.Succeed)
+                                        {
+                                            //判断车辆是否存在期限皮重
+                                            if (termTareData.Data == null)
+                                            {
+                                                // 只保存一次计量数据
+                                                rt = saveMethod.doAddDoubleFirst(rmScale.Data[0], scale, mwaf);
+                                                PbCache.voiceType = 15;
+                                                rt.resultInfo = "计量成功，期限皮过期，请留存期限皮";
+                                                PbCache.ResultMessage = "计量成功，期限皮过期，请留存期限皮";
+                                                PbCache.monitorResultMessage = "计量成功，期限皮过期，请留存期限皮";
+                                                PbCache.LEDResultMessage = string.Format("车号{0}，毛重{1}吨，计量完成，期限皮过期", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2));
+                                            }
+                                            else
+                                            {
+                                                // 存在期限皮重，并使用期限皮重结净
+                                                EntityBase<PreTrackScale> entityBase1 = new EntityBase<PreTrackScale>();
+                                                mwaf = entityBase1.format<MeterWorkCarActualFirst>(rmScale.Data[0], mwaf);
+                                                rt = saveMethod.doTermTareNetDouble(rmScale.Data[0], scale, mwaf, "0");
+                                                rt.resultInfo += "，期限皮结净";
+                                                PbCache.voiceType = 16;
+                                                PbCache.ResultMessage = "计量完成，期限皮结净";
+                                                PbCache.LEDResultMessage = string.Format("车号{0}，毛重{1}吨，净重{2}吨，期限皮结净", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2), Math.Round((Math.Abs(PbCache.lockWgt - termTareData.Data.meterWeight.Value) / 1000), 2));
+                                            }
+                                        }
+                                    }
+                                    else
+                                    {
+                                        // 只保存一次计量数据
+                                        rt = saveMethod.doAddDoubleFirst(rmScale.Data[0], scale, mwaf);
+                                        PbCache.voiceType = 1;
+                                        PbCache.LEDResultMessage = string.Format("车号{0}，毛重{1}吨，计量完成", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2));
+                                    }
+                                }
+                            }
+                            //存在一条一次计量数据
+                            else if (firstList.Count == 1)
+                            {
+                                //存在的一次数据为毛重
+                                if (firstList[0].weightType == "0")
+                                {
+                                    if (comBaseInfos.Succeed)
+                                    {
+                                        //判断车辆是否满足期限皮
+                                        if (comBaseInfos.Data != null && comBaseInfos.Data.Count == 1)
+                                        {
+                                            if (termTareData.Succeed)
+                                            {
+                                                //判断车辆是否存在期限皮重
+                                                if (termTareData.Data == null)
+                                                {
+                                                    // 只保存一次计量数据
+                                                    rt = saveMethod.doAddDoubleFirst(rmScale.Data[0], scale, mwaf);
+                                                    PbCache.voiceType = 17;
+                                                    rt.resultInfo = "计量成功，期限皮过期，存在未结净毛重";
+                                                    PbCache.ResultMessage = "计量成功，期限皮过期，存在未结净毛重";
+                                                    PbCache.monitorResultMessage = "计量成功，期限皮过期，存在未结净毛重";
+                                                    PbCache.LEDResultMessage = string.Format("车号{0}，毛重{1}吨，计量完成，期限皮过期", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2));
+                                                }
+                                                else
+                                                {
+                                                    // 存在期限皮重，并使用期限皮重结净
+                                                    EntityBase<PreTrackScale> entityBase1 = new EntityBase<PreTrackScale>();
+                                                    mwaf = entityBase1.format<MeterWorkCarActualFirst>(rmScale.Data[0], mwaf);
+                                                    rt = saveMethod.doTermTareNetDouble(rmScale.Data[0], scale, mwaf, "0");
+                                                    rt.resultInfo += "，期限皮结净";
+                                                    PbCache.voiceType = 16;
+                                                    PbCache.ResultMessage = "计量完成，期限皮结净";
+                                                    PbCache.LEDResultMessage = string.Format("车号{0}，毛重{1}吨，净重{2}吨，期限皮结净", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2), Math.Round((Math.Abs(PbCache.lockWgt - termTareData.Data.meterWeight.Value) / 1000), 2));
+                                                }
+                                            }
+                                        }
+                                        else
+                                        {
+                                            // 只保存一次计量数据
+                                            rt = saveMethod.doAddDoubleFirst(rmScale.Data[0], scale, mwaf);
+                                            rt.resultInfo += "，存在未结净毛重";
+                                            PbCache.voiceType = 17;
+                                            PbCache.ResultMessage = "存在未结净毛重";
+                                            PbCache.LEDResultMessage = string.Format("车号{0}，毛重{1}吨，存在未结净毛重，请联系", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2));
+                                            PbCache.monitorResultMessage = "存在未结净毛重";
+                                            rt.isWarn = true;
+                                            rt.WarnContent = "validWgt";
+                                        }
+                                    }
+                                }
+                                //存在的一次数据为皮重
+                                else
+                                {
+                                    if (comBaseInfos.Succeed)
+                                    {
+                                        //判断车辆是否满足期限皮
+                                        if (comBaseInfos.Data != null && comBaseInfos.Data.Count == 1)
+                                        {
+                                            if (termTareData.Succeed)
+                                            {
+                                                // 存在期限皮重，并使用期限皮重结净
+                                                EntityBase<PreTrackScale> entityBase1 = new EntityBase<PreTrackScale>();
+                                                mwaf = entityBase1.format<MeterWorkCarActualFirst>(rmScale.Data[0], mwaf);
+                                                rt = saveMethod.doTermTareNetDoubleRetain(rmScale.Data[0], scale, firstList[0], mwaf, "0");
+                                                rt.resultInfo += "，留存期限皮成功";
+                                                PbCache.voiceType = 16;
+                                                PbCache.ResultMessage = "计量完成，留存期限皮成功";
+                                                PbCache.LEDResultMessage = string.Format("车号{0}，毛重{1}吨，净重{2}吨，留存期限皮成功", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2), Math.Round((Math.Abs(PbCache.lockWgt - firstList[0].meterWeight.Value) / 1000), 2));
+                                            }
+                                        }
+                                        else
+                                        {
+                                            // 只保存一次计量数据
+                                            rt = saveMethod.doAddDoubleNet(rmScale.Data[0], scale, firstList[0], mwaf,"0");
+                                            PbCache.voiceType = 1;
+                                            PbCache.LEDResultMessage = string.Format("车号{0}，毛重{1}吨，净重{2}吨，双委托结净", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2),Math.Round((Math.Abs(PbCache.lockWgt - firstList[0].meterWeight.Value) / 1000), 2));
+                                        }
+                                    }
+                                }
+                            }
+                            //存在多条一次计量数据
+                            else
+                            {
+                                if (comBaseInfos.Succeed)
+                                {
+                                    //判断车辆是否满足期限皮
+                                    if (comBaseInfos.Data != null && comBaseInfos.Data.Count == 1)
+                                    {
+                                        if (termTareData.Succeed)
+                                        {
+                                            //判断车辆是否存在期限皮重
+                                            if (termTareData.Data == null)
+                                            {
+                                                // 只保存一次计量数据
+                                                rt = saveMethod.doAddDoubleFirst(rmScale.Data[0], scale, mwaf);
+                                                PbCache.voiceType = 15;
+                                                rt.resultInfo = "计量成功，期限皮过期，存在多条未结净数据";
+                                                PbCache.ResultMessage = "计量成功，期限皮过期，存在多条未结净数据";
+                                                PbCache.monitorResultMessage = "计量成功，期限皮过期，存在多条未结净数据";
+                                                PbCache.LEDResultMessage = string.Format("车号{0}，毛重{1}吨，计量完成，期限皮过期", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2));
+                                            }
+                                            else
+                                            {
+                                                // 存在期限皮重，并使用期限皮重结净
+                                                EntityBase<PreTrackScale> entityBase1 = new EntityBase<PreTrackScale>();
+                                                mwaf = entityBase1.format<MeterWorkCarActualFirst>(rmScale.Data[0], mwaf);
+                                                rt = saveMethod.doTermTareNetDouble(rmScale.Data[0], scale, mwaf, "0");
+                                                rt.resultInfo += "，期限皮结净";
+                                                PbCache.voiceType = 16;
+                                                PbCache.ResultMessage = "计量完成，期限皮结净";
+                                                PbCache.LEDResultMessage = string.Format("车号{0}，毛重{1}吨，净重{2}吨，期限皮结净", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2), Math.Round((Math.Abs(PbCache.lockWgt - termTareData.Data.meterWeight.Value) / 1000), 2));
+                                            }
+                                        }
+                                    }
+                                    else
+                                    {
+                                        // 只保存一次计量数据
+                                        rt = saveMethod.doAddDoubleFirst(rmScale.Data[0], scale, mwaf);
+                                        rt.resultInfo += "，存在多条未结净数据";
+                                        PbCache.voiceType = 11;
+                                        PbCache.ResultMessage = "存在多条未结净数据";
+                                        PbCache.LEDResultMessage = string.Format("车号{0}，毛重{1}吨，存在多条未结净数据，请联系", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2));
+                                        PbCache.monitorResultMessage = "存在未结净毛重";
+                                        rt.isWarn = true;
+                                        rt.WarnContent = "validWgt";
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    //判断已选择的委托是否为0条
+                    else if (rmScale.Succeed && rmScale.Data.Count == 0)
+                    {
+                        mwaf.weightType = "1";
+                        //不存在一次计量数据
+                        if (firstList == null || firstList.Count == 0)
+                        {
+                            // 只保存一次计量数据
+                            rt = saveMethod.doAddFirst(null, mwaf);
+                            PbCache.voiceType = 1;
+                            PbCache.LEDResultMessage = string.Format("车号{0}，皮重{1}吨，计量完成", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2));
+                        }
+                        //存在一条一次计量数据
+                        else if (firstList.Count == 1)
+                        {
+                            //存在的一次数据为毛重
+                            if (firstList[0].weightType == "0")
+                            {
+                                if (comBaseInfos.Succeed)
+                                {
+                                    //判断车辆是否满足期限皮
+                                    if (comBaseInfos.Data != null && comBaseInfos.Data.Count == 1)
+                                    {
+                                        RESTfulResult<List<PreTrackScale>> scales = preTrackScaleService.doQueryWf(new PreTrackScale { predictionNo = firstList[0].predictionNo });
+                                        // 存在期限皮重，并使用期限皮重结净
+                                        EntityBase<PreTrackScale> entityBase1 = new EntityBase<PreTrackScale>();
+                                        mwaf = entityBase1.format<MeterWorkCarActualFirst>(scales.Data[0], mwaf);
+                                        rt = saveMethod.doTermTareNetDoubleRetain(scales.Data[0], scale, mwaf, firstList[0], "1");
+                                        rt.resultInfo += "，留存期限皮成功";
+                                        PbCache.voiceType = 16;
+                                        PbCache.ResultMessage = "计量完成，留存期限皮成功";
+                                        PbCache.LEDResultMessage = string.Format("车号{0}，皮重{1}吨，净重{2}吨，留存期限皮成功", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2), Math.Round((Math.Abs(PbCache.lockWgt - termTareData.Data.meterWeight.Value) / 1000), 2));
+                                    }
+                                    else
+                                    {
+                                        // 只保存一次计量数据
+                                        rt = saveMethod.doAddDoubleNet(rmScale.Data[0], scale, mwaf, firstList[0], "1");
+                                        PbCache.voiceType = 1;
+                                        PbCache.LEDResultMessage = string.Format("车号{0}，皮重{1}吨，净重{2}吨，双委托结净", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2), Math.Round((Math.Abs(firstList[0].meterWeight.Value - PbCache.lockWgt) / 1000), 2));
+                                    }
+                                }
+                            }
+                            //存在的一次数据为皮重
+                            else
+                            {
+                                //保存一条作废的皮重数据
+                                mwaf.weightType = "1";
+                                mwaf.valueFlag = "0";
+                                PbCache.voiceType = 1;
+                                rt = saveMethod.doAddFirst(null, mwaf);
+                                PbCache.LEDResultMessage = string.Format("车号{0}，皮重{1}吨，计量完成", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2));
+                            }
+                        }
+                        //存在多条一次计量数据
+                        else
+                        {
+                            List<MeterWorkCarActualFirst> mwcafListDouble = new List<MeterWorkCarActualFirst>();
+                            foreach (var item in firstList)
+                            {
+                                if (!string.IsNullOrEmpty(item.predictionCombination))
+                                {
+                                    mwcafListDouble.Add(item);
+                                }
+                            }
+                            List<MeterWorkCarActualFirst> mwcafList = new List<MeterWorkCarActualFirst>();
+                            MeterWorkCarActualFirst meterWorkCarActualFirst = mwcafListDouble[0];
+                            mwcafList.Add(meterWorkCarActualFirst);
+                            foreach (var item in mwcafListDouble)
+                            {
+                                if (!string.IsNullOrEmpty(item.predictionCombination))
+                                {
+                                    if (meterWorkCarActualFirst.predictionCombination == item.predictionCombination && meterWorkCarActualFirst.actualFirstNo != item.actualFirstNo) 
+                                    {
+                                        mwcafList.Add(item);
+                                        break;
+                                    };
+                                }
+                            }
+                            if (comBaseInfos.Succeed)
+                            {
+                                //判断车辆是否满足期限皮
+                                if (comBaseInfos.Data != null && comBaseInfos.Data.Count == 1)
+                                {
+                                    // 存在期限皮重，并使用期限皮重结净
+                                    rt = saveMethod.doNetAddMuchGrossDouble(mwcafListDouble, mwaf);
+                                    rt.resultInfo += "，留存期限皮成功";
+                                    PbCache.voiceType = 16;
+                                    PbCache.ResultMessage = "计量完成，留存期限皮成功";
+                                    PbCache.LEDResultMessage = string.Format("车号{0}，皮重{1}吨，留存期限皮成功", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2));
+                                }
+                                else
+                                {
+                                    // 双委托不使用期限皮结净
+                                    rt = saveMethod.doAddDoubleMuchNet(mwcafList, mwaf);
+                                    PbCache.voiceType = 1;
+                                    PbCache.LEDResultMessage = string.Format("车号{0}，皮重{1}吨，计量完成", PbCache.lockCarNo, Math.Round((PbCache.lockWgt / 1000), 2));
+
+                                }
+                            }
+                        }
+                    }
+                    //判断已选择的委托是否为多条
+                    else
+                    {
+                        rt = saveMethod.doError("存在多条已选择的委托，请联系计量大厅");
+                        PbCache.LEDResultMessage = "存在多条已选择的委托，请联系计量大厅";
+                        rt.isWarn = true;
+                        PbCache.voiceType = 19;
+                        rt.WarnContent = "validIsPre";
+                        return rt;
+                    }
+                }
+                else
+                {
+                    rt = saveMethod.doError("存在多条上称申请数据，请联系计量大厅");
+                    PbCache.voiceType = 20;
+                    PbCache.LEDResultMessage = "存在多条上称申请数据，请联系计量大厅";
+                    return rt;
+                }
+            }
+
+            // 后台失败处理
+            if (!rt.result)
+            {
+                rt.resultInfo = "称重数据保存失败";
+                PbCache.voiceType = 25;
+                PbCache.LEDResultMessage = "计量失败，请联系计量大厅";
+                PbCache.monitorResultMessage = "";
+            }
+            return rt;
+        }
+    }
+}

MeterSceneLibrary/JISCO/private/SaveMethod.cs

@@ -1050,6 +1050,45 @@ namespace MeterSceneLibrary.JISCO
             return rt;
         }
 
+        /// <summary>
+        /// 多毛一皮
+        /// </summary>
+        /// <param name="scale"></param>
+        /// <param name="actualFirst"></param>
+        /// <param name="actualFirst1"></param>
+        /// <returns></returns>
+        public rtInfo doNetAddMuchGrossDouble(List<MeterWorkCarActualFirst> actualFirst, MeterWorkCarActualFirst actualFirst1)
+        {
+            //操作日志
+            MeterMonitorNote monitorNote = new MeterMonitorNote();
+            monitorNote.baseSpotNo = actualFirst1.baseSpotNo;
+            monitorNote.baseSpotName = actualFirst1.baseSpotName;
+            monitorNote.operationContent = string.Format("保存期限皮重");
+            monitorNote.operationTime = actualFirst1.createTime.Value.ToString("yyyy-MM-dd HH:mm:ss");
+            monitorNote.carNo = actualFirst1.carNo;
+            monitorNote.meterNoteSource = "0";
+
+            //期限皮重数据保存
+            MeterWorkCarActualService actualService = new MeterWorkCarActualService();
+            RESTfulResult<string> rmI = actualService.doNetAddMuchGrossDouble(actualFirst, actualFirst1, monitorNote);
+
+            if (rmI.Succeed)
+            {
+                rt.result = true;
+                rt.resultInfo = "计量完成";
+                PbCache.actualFirstNo = rmI.Data;
+                PbCache.strQRCode = rmI.Message;
+                PbCache.isTareWeight = true;//皮重
+            }
+            else
+            {
+                rt.result = false;
+                rt.isError = true;
+                rt.resultInfo = "称重数据保存失败";
+            }
+            return rt;
+        }
+
         /// <summary>
         /// 多毛一重
         /// </summary>
@@ -1311,6 +1350,229 @@ namespace MeterSceneLibrary.JISCO
                 }
             }
         }
+
+        /// <summary>
+        /// 保存一次内倒双委托计量数据
+        /// </summary>
+        public rtInfo doAddDoubleFirst(PreTrackScale scale, PreTrackScale scale1, MeterWorkCarActualFirst model)
+        {
+            //操作日志
+            MeterMonitorNote monitorNote = new MeterMonitorNote();
+            monitorNote.baseSpotNo = model.baseSpotNo;
+            monitorNote.baseSpotName = model.baseSpotName;
+            monitorNote.operationContent = string.Format("产生一次计量数据");
+            monitorNote.operationTime = model.createTime.Value.ToString("yyyy-MM-dd HH:mm:ss");
+            monitorNote.carNo = model.carNo;
+            monitorNote.meterNoteSource = "0";
+
+            PbSomeModel<MeterWorkCarActualFirst, PreTrackScale, PreTrackScale, MeterMonitorNote> pbSomeModel = new PbSomeModel<MeterWorkCarActualFirst, PreTrackScale, PreTrackScale, MeterMonitorNote>();
+            pbSomeModel.one = model;
+            pbSomeModel.two = scale;
+            pbSomeModel.three = scale1;
+            pbSomeModel.four = monitorNote;
+
+            RESTfulResult<string> rmI = mwcfs.doDoubleAdd(pbSomeModel);
+
+            PbCache.yardFirst = model;
+
+            if (rmI.Succeed)
+            {
+                rt.result = true;
+                rt.resultInfo = "计量完成";
+                PbCache.actualFirstNo = rmI.Data;
+                PbCache.strQRCode = rmI.Message;
+                if (model.weightType == "0")
+                {
+                    PbCache.isTareWeight = false;//毛重
+                }
+                else
+                {
+                    PbCache.isTareWeight = true;//皮重
+                }
+            }
+            else
+            {
+                rt.result = false;
+                rt.isError = true;
+                rt.resultInfo = "称重数据保存失败";
+            }
+
+            return rt;
+        }
+
+        /// <summary>
+        /// 产生一次计量数据，同时结净并匹配委托（多委托）
+        /// </summary>
+        /// <param name="scale"></param>
+        /// <param name="actualFirst"></param>
+        /// <param name="actualFirst1"></param>
+        public rtInfo doAddDoubleNet(PreTrackScale scale, PreTrackScale scale1, MeterWorkCarActualFirst TareactualFirst, MeterWorkCarActualFirst GorssactualFirst, string flag)
+        {
+
+            MeterWorkCarActualService actualService = new MeterWorkCarActualService();
+            RESTfulResult<string> rmI = actualService.doAddDoubleNet(scale, scale1, TareactualFirst, GorssactualFirst);
+
+            if (rmI.Succeed)
+            {
+                rt.result = true;
+                rt.resultInfo = "计量完成，双委托洁净";
+                PbCache.actualFirstNo = rmI.Data;
+                PbCache.strQRCode = rmI.Message;
+                if (flag == "0")
+                {
+                    PbCache.isTareWeight = false;//毛重
+                }
+                else
+                {
+                    PbCache.isTareWeight = true;//皮重
+                }
+            }
+            else
+            {
+                rt.result = false;
+                rt.isError = true;
+                rt.resultInfo = "称重数据保存失败";
+            }
+            return rt;
+        }
+
+        public rtInfo doTermTareNetDouble(PreTrackScale scale, PreTrackScale scale1, MeterWorkCarActualFirst actualFirst,string flag)
+        {
+            //期限皮重数据保存
+            MeterWorkCarActualService actualService = new MeterWorkCarActualService();
+            RESTfulResult<string> rmI = actualService.doTermTareNetDouble(scale, scale1, actualFirst);
+
+            if (rmI.Succeed)
+            {
+                rt.result = true;
+                rt.resultInfo = "计量完成";
+                PbCache.actualFirstNo = rmI.Data;
+                PbCache.strQRCode = rmI.Message;
+                if (flag == "1")
+                {
+                    PbCache.isTareWeight = true;//皮重
+                }
+                else
+                {
+                    PbCache.isTareWeight = false;//毛重
+                }
+            }
+            else
+            {
+                rt.result = false;
+                rt.isError = true;
+                rt.resultInfo = "称重数据保存失败";
+            }
+            return rt;
+        }
+
+        /// <summary>
+        /// 不存期限皮多毛一皮
+        /// </summary>
+        /// <param name="scale"></param>
+        /// <param name="actualFirst"></param>
+        /// <param name="actualFirst1"></param>
+        /// <returns></returns>
+        public rtInfo doAddDoubleMuchNet(List<MeterWorkCarActualFirst> actualFirsts, MeterWorkCarActualFirst TareactualFirst)
+        {
+            //操作日志
+            MeterMonitorNote monitorNote = new MeterMonitorNote();
+            monitorNote.baseSpotNo = TareactualFirst.baseSpotNo;
+            monitorNote.baseSpotName = TareactualFirst.baseSpotName;
+            monitorNote.operationContent = string.Format("保存期限皮重");
+            monitorNote.operationTime = TareactualFirst.createTime.Value.ToString("yyyy-MM-dd HH:mm:ss");
+            monitorNote.carNo = TareactualFirst.carNo;
+            monitorNote.meterNoteSource = "0";
+
+            //期限皮重数据保存
+            MeterWorkCarActualService actualService = new MeterWorkCarActualService();
+            RESTfulResult<string> rmI = actualService.doAddDoubleMuchNet(actualFirsts, TareactualFirst, monitorNote);
+
+            if (rmI.Succeed)
+            {
+                rt.result = true;
+                rt.resultInfo = "计量完成";
+                PbCache.actualFirstNo = rmI.Data;
+                PbCache.strQRCode = rmI.Message;
+                PbCache.isTareWeight = true;//皮重
+            }
+            else
+            {
+                rt.result = false;
+                rt.isError = true;
+                rt.resultInfo = "称重数据保存失败";
+            }
+            return rt;
+        }
+
+        /// <summary>
+        /// 存期限皮多毛一皮
+        /// </summary>
+        /// <param name="scale"></param>
+        /// <param name="actualFirst"></param>
+        /// <param name="actualFirst1"></param>
+        /// <returns></returns>
+        public rtInfo doAddDoubleMuchNetRetain(List<MeterWorkCarActualFirst> actualFirsts, MeterWorkCarActualFirst TareactualFirst)
+        {
+            //操作日志
+            MeterMonitorNote monitorNote = new MeterMonitorNote();
+            monitorNote.baseSpotNo = TareactualFirst.baseSpotNo;
+            monitorNote.baseSpotName = TareactualFirst.baseSpotName;
+            monitorNote.operationContent = string.Format("保存期限皮重");
+            monitorNote.operationTime = TareactualFirst.createTime.Value.ToString("yyyy-MM-dd HH:mm:ss");
+            monitorNote.carNo = TareactualFirst.carNo;
+            monitorNote.meterNoteSource = "0";
+
+            //期限皮重数据保存
+            MeterWorkCarActualService actualService = new MeterWorkCarActualService();
+            RESTfulResult<string> rmI = actualService.doAddDoubleMuchNetRetain(actualFirsts, TareactualFirst, monitorNote);
+
+            if (rmI.Succeed)
+            {
+                rt.result = true;
+                rt.resultInfo = "计量完成";
+                PbCache.actualFirstNo = rmI.Data;
+                PbCache.strQRCode = rmI.Message;
+                PbCache.isTareWeight = true;//皮重
+            }
+            else
+            {
+                rt.result = false;
+                rt.isError = true;
+                rt.resultInfo = "称重数据保存失败";
+            }
+            return rt;
+        }
+
+        public rtInfo doTermTareNetDoubleRetain(PreTrackScale scale, PreTrackScale scale1, MeterWorkCarActualFirst TareactualFirst, MeterWorkCarActualFirst GrossactualFirst,string flag)
+        {
+            //期限皮重数据保存
+            MeterWorkCarActualService actualService = new MeterWorkCarActualService();
+            RESTfulResult<string> rmI = actualService.doTermTareNetDoubleRetain(scale, scale1, TareactualFirst, GrossactualFirst);
+
+            if (rmI.Succeed)
+            {
+                rt.result = true;
+                rt.resultInfo = "计量完成";
+                PbCache.actualFirstNo = rmI.Data;
+                PbCache.strQRCode = rmI.Message;
+                if (flag == "1")
+                {
+                    PbCache.isTareWeight = true;//皮重
+                }
+                else
+                {
+                    PbCache.isTareWeight = false;//毛重
+                }
+            }
+            else
+            {
+                rt.result = false;
+                rt.isError = true;
+                rt.resultInfo = "称重数据保存失败";
+            }
+            return rt;
+        }
         #endregion
     }
 }

MeterSceneLibrary/MeterSceneLibrary.csproj

@@ -69,6 +69,7 @@
     <Compile Include="JISCO\InnerCarJISCO.cs" />
     <Compile Include="InnerMeter.cs" />
     <Compile Include="InnerRemoteMeter.cs" />
+    <Compile Include="JISCO\InnerDoubleJISCO.cs" />
     <Compile Include="JISCO\NormalCar.cs" />
     <Compile Include="JISCO\private\SaveMethod.cs" />
     <Compile Include="LianDaMeter.cs" />