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

namespace MeterConditionLibrary
{
    /// <summary>
    /// 验证是否可留期限皮重
    /// </summary>
    public class validTermTareCar
    {
        Log lg = Log.GetInstance();

        public bool ValidMethod(string carNo)
        {
            //是否在黑名单内
            MeterBaseCarBlacelistService bService = new MeterBaseCarBlacelistService();
            RESTfulResult<List<MeterBaseCarBlacelist>> rmB = bService.doQueryWf(new MeterBaseCarBlacelist { carNo = carNo, valueFlag = "0" });
            if (rmB.Succeed)
            {
                if (rmB.Data != null && rmB.Data.Count > 0)
                {
                    PbCache.ResultMessage = string.Format("车辆[{0}]在黑名单内，不能留皮", carNo);
                    lg.WriteLog(3, string.Format("车辆[{0}]在黑名单内，不能留皮", carNo));
                    return false;
                }
                else
                {
                    //是否可留期限皮
                    MeterBaseTermTareCarService service = new MeterBaseTermTareCarService();
                    RESTfulResult<List<MeterBaseTermTareCar>> rm = service.doQueryWf(new MeterBaseTermTareCar { carNo = carNo, valueFlag = "0" });
                    if (rm.Succeed)
                    {
                        if (rm.Data != null && rm.Data.Count == 1)
                        {
                            //如果可以留期限皮重，则判断车辆历史皮重，若当前皮重在 历史皮重最大最小偏差范围内，则认为当前确实是皮重允许留皮
                            MeterBaseHisTareDataService mbhds = new MeterBaseHisTareDataService();
                            RESTfulResult<List<MeterBaseHisTareData>> rtHisTare = mbhds.doQueryWf(new MeterBaseHisTareData { carNo = carNo, valueFlag = "0" });
                            if (!rtHisTare.Succeed)
                            {
                                PbCache.ResultMessage = string.Format("车辆[{0}]获取历史皮重维护数据失败，请语音求助", carNo);
                                lg.WriteLog(3, string.Format("车辆[{0}]获取历史皮重维护数据失败，请语音求助", carNo));
                                return false;
                            }
                            else
                            {
                                if (rtHisTare.Data == null || rtHisTare.Data.Count == 0)
                                {
                                    PbCache.ResultMessage = string.Format("车辆[{0}]首次进行计量业务时，无法留期限皮", carNo);
                                    lg.WriteLog(3, string.Format("车辆[{0}]首次进行计量业务时，无法留期限皮", carNo));
                                    return false;
                                }
                                else
                                {
                                    //查下是否有有效的期限皮重信息
                                    MeterBaseTermTareDataService termTareDataService = new MeterBaseTermTareDataService();
                                    RESTfulResult<List<MeterBaseTermTareData>> resTermData = termTareDataService.doQueryWf(new MeterBaseTermTareData { carNo = carNo, valueFlag = "0" });
                                    //2021年12月23日 杨秀东添加，九钢的特殊处理，全部的皮重校验，都走历史皮重；
                                    if (resTermData.Succeed && resTermData.Data.Count > 0 && false)
                                    {
                                        MeterBaseTermTareCount mbhtc = PbCache.termTareCount;
                                        double maxWgt = 0, minWgt = 0;
                                        if (mbhtc.countTypeNo == "001011001") //固重 当前重量>=历史皮重-固重   当前重量<=历史皮重+固重
                                        {
                                            double meterWeight = (PbCache.termTareCount.contrastTypeNo == "001012001" ? resTermData.Data[0].upWeight.Value : resTermData.Data[0].meterWeight.Value);
                                            maxWgt = meterWeight + mbhtc.fixedWeightValue.Value;
                                            minWgt = meterWeight - mbhtc.fixedWeightValue.Value;

                                            // 杨秀东 2021年3月15日 新增逻辑，若不验证车号则可以强制进行期限皮重保存；
                                            if ((PbCache.lockWgt >= minWgt && PbCache.lockWgt <= maxWgt) || PbCache.monitor.validWgt.Equals("0"))
                                            {
                                                return true;
                                            }
                                            else
                                            {
                                                PbCache.ResultMessage = string.Format("车辆[{0}]当前重量【" + PbCache.lockWgt / 1000 + " T】不在期限皮重【" + Convert.ToDouble(meterWeight) / 1000 + "T】允许的范围【" + mbhtc.fixedWeightValue + "kg】内，无法留期限皮，请点击语音求助", carNo);
                                                lg.WriteLog(3, string.Format("车辆[{0}]当前重量【" + PbCache.lockWgt / 1000 + " T】不在期限皮重【" + Convert.ToDouble(meterWeight) / 1000 + "T】允许的范围内【" + mbhtc.fixedWeightValue + "kg】，无法留期限皮，请点击语音求助", carNo));
                                                //不在范围内，无法留期限皮
                                                return false;
                                            }
                                        }
                                        else if (mbhtc.countTypeNo == "001011002") //比例 当前重量>=历史皮重-历史皮重*比例   当前重量<=历史皮重+历史皮重*比例
                                        {
                                            double meterWeight = (PbCache.termTareCount.contrastTypeNo == "001012001" ? resTermData.Data[0].upWeight.Value : resTermData.Data[0].meterWeight.Value);

                                            maxWgt = meterWeight + meterWeight * (mbhtc.rateValue.Value / 100);
                                            minWgt = meterWeight - meterWeight * (mbhtc.rateValue.Value / 100);

                                            //杨秀东 2021年3月15日 新增逻辑，若不验证车号则可以强制进行期限皮重保存；
                                            if ((PbCache.lockWgt >= minWgt && PbCache.lockWgt <= maxWgt) || PbCache.monitor.validWgt.Equals("0"))
                                            {
                                                return true;
                                            }
                                            else
                                            {
                                                PbCache.ResultMessage = string.Format("车辆[{0}]当前重【" + PbCache.lockWgt / 1000 + " T】不在期限皮重【" + Convert.ToDouble(meterWeight) / 1000 + "T】允许的范围【" + mbhtc.fixedWeightValue + "%】内，无法留期限皮，请点击语音求助", carNo);
                                                lg.WriteLog(3, string.Format("车辆[{0}]当前重量【" + PbCache.lockWgt / 1000 + " T】不在期限皮重【" + Convert.ToDouble(meterWeight) / 1000 + "T】允许的范围内【" + mbhtc.fixedWeightValue + "%】，无法留期限皮，请点击语音求助", carNo));
                                                //不在范围内，无法留期限皮
                                                return false;
                                            }
                                        }
                                        else
                                        {
                                            PbCache.ResultMessage = string.Format("车辆[{0}]期限皮重计算配置表中配置的计算方式[{1}]无对应逻辑", carNo, mbhtc.countTypeName);
                                            //没有配置比例，也没配置固重，这个需要增加逻辑代码
                                            lg.WriteLog(3, string.Format("车辆[{0}]期限皮重计算配置表中配置的计算方式[{1}]无对应逻辑", carNo, mbhtc.countTypeName));
                                            return false;
                                        }
                                    }
                                    else
                                    {
                                        //lg.WriteLog(3, string.Format("6车辆[{0}进入留皮判断", carNo));
                                        #region 外面的那一层是新加的代码，这个里面的是原有的判断
                                        //历史皮重计算方式
                                        MeterBaseHisTareCount mbhtc = PbCache.tareCount;
                                        double maxWgt = 0, minWgt = 0;
                                        if (mbhtc.countTypeNo == "001011001") //固重 当前重量>=历史皮重-固重   当前重量<=历史皮重+固重
                                        {
                                            long meterWeight = (PbCache.tareCount.contrastTypeNo == "001012001" ? rtHisTare.Data[0].upWeight.Value : rtHisTare.Data[0].meterWeight.Value);
                                            maxWgt = meterWeight + mbhtc.fixedWeightValue.Value;
                                            minWgt = meterWeight - mbhtc.fixedWeightValue.Value;

                                            if (PbCache.lockWgt >= minWgt && PbCache.lockWgt <= maxWgt || PbCache.monitor.validWgt.Equals("0"))
                                            {
                                                return true;
                                            }
                                            else
                                            {
                                                PbCache.ResultMessage = string.Format("车辆[{0}]当前重量【" + PbCache.lockWgt / 1000 + " T】不在历史皮重【" + Convert.ToDouble(meterWeight) / 1000 + "T】允许的范围【" + mbhtc.fixedWeightValue + "kg】内，无法留皮重，请点击语音求助", carNo);
                                                lg.WriteLog(3, string.Format("车辆[{0}]当前重量【" + PbCache.lockWgt / 1000 + " T】不在历史皮重【" + Convert.ToDouble(meterWeight) / 1000 + "T】允许的范围内【" + mbhtc.fixedWeightValue + "kg】，无法留皮重，请点击语音求助", carNo));
                                                //不在范围内，无法留期限皮
                                                return false;
                                            }
                                        }
                                        else if (mbhtc.countTypeNo == "001011002") //比例 当前重量>=历史皮重-历史皮重*比例   当前重量<=历史皮重+历史皮重*比例
                                        {
                                            long meterWeight = (PbCache.tareCount.contrastTypeNo == "001012001" ? rtHisTare.Data[0].upWeight.Value : rtHisTare.Data[0].meterWeight.Value);

                                            maxWgt = meterWeight + meterWeight * (mbhtc.rateValue.Value / 100);
                                            minWgt = meterWeight - meterWeight * (mbhtc.rateValue.Value / 100);

                                            if (PbCache.lockWgt >= minWgt && PbCache.lockWgt <= maxWgt || PbCache.monitor.validWgt.Equals("0"))
                                            {
                                                return true;
                                            }
                                            else
                                            {
                                                lg.WriteLog(3, string.Format("8车辆[{0}进入留皮判断min:{1}，max:{2}，当前{3}", carNo, minWgt, maxWgt, PbCache.lockWgt));
                                                PbCache.ResultMessage = string.Format("车辆[{0}]当前重量【" + PbCache.lockWgt / 1000 + " T】不在期限皮重【" + Convert.ToDouble(meterWeight) / 1000 + "T】允许的范围【" + mbhtc.rateValue + "%】内，无法留期限皮，请点击语音求助", carNo);
                                                lg.WriteLog(3, string.Format("车辆[{0}]当前重量【" + PbCache.lockWgt / 1000 + " T】不在期限皮重【" + Convert.ToDouble(meterWeight) / 1000 + "T】允许的范围内【" + mbhtc.rateValue + "%】，无法留期限皮，请点击语音求助", carNo));
                                                //不在范围内，无法留期限皮
                                                return false;
                                            }
                                        }
                                        else
                                        {
                                            PbCache.ResultMessage = string.Format("车辆[{0}]历史皮重计算配置表中配置的计算方式[{1}]无对应逻辑", carNo, mbhtc.countTypeName);
                                            //没有配置比例，也没配置固重，这个需要增加逻辑代码
                                            lg.WriteLog(3, string.Format("车辆[{0}]历史皮重计算配置表中配置的计算方式[{1}]无对应逻辑", carNo, mbhtc.countTypeName));
                                            return false;
                                        }
                                        #endregion
                                    }
                                }
                            }
                        }
                        else
                        {

                            PbCache.ResultMessage = string.Format("车辆[{0}]未给留期限皮权限，不允许留期限皮", carNo);
                            if (rm.Data == null)
                            {
                                lg.WriteLog(3, string.Format("车辆[{0}]未给留期限皮权限，不允许留期限皮！！车号[{0}]，状态[0]，数据条数为0", carNo));
                            }
                            else
                            {
                                lg.WriteLog(3, string.Format("车辆[{0}]未给留期限皮权限，不允许留期限皮！！车号[{0}]，状态[0]，数据条数大于1，为[{1}]", carNo, rm.Data.Count));
                            }
                            return false;
                        }
                    }
                    else
                    {
                        PbCache.ResultMessage = string.Format("车辆[{0}]获取是否可留期限皮时异常，请语音求助", carNo);
                        lg.WriteLog(3, string.Format("车辆[{0}]获取是否可留期限皮时，服务端查询失败", carNo));
                        return false;
                    }
                }
            }
            else
            {
                PbCache.ResultMessage = string.Format("车辆[{0}]获取黑名单数据时，请语音求助", carNo);
                lg.WriteLog(3, string.Format("车辆[{0}]获取黑名单数据时，服务端查询失败", carNo));
                return false;
            }
        }


        /// <summary>
        /// 是否显示期限皮重按钮
        /// </summary>
        /// <param name="carNo"></param>
        /// <returns></returns>
        public bool isShowBtnTare(string carNo)
        {
            Log lg = Log.GetInstance();
            //是否可留期限皮
            MeterBaseTermTareCarService service = new MeterBaseTermTareCarService();
            RESTfulResult<List<MeterBaseTermTareCar>> rm = service.doQueryWf(new MeterBaseTermTareCar { carNo = carNo, valueFlag = "0" });
            if (rm.Succeed && rm.Data != null && rm.Data.Count == 1)
            {
                return true;
            }
            return false;
        }


        #region
        /// <summary>
        /// 我们在这个对象中存储
        /// </summary>
        /// <param name="tareCarInfo"></param>
        /// <returns></returns>
        public bool ValidMethod(PreTrackScale pre)
        {
            string carNo = pre.carNo;
            //是否可留期限皮
            MeterBaseTermTareCarService service = new MeterBaseTermTareCarService();
            RESTfulResult<List<MeterBaseTermTareCar>> rm = service.doValidTareWf(pre); //业务类型、物资、车辆均配置能够使用期限皮重
            if (rm.Succeed)
            {
                if (rm.Data != null && rm.Data.Count == 1)
                {
                    //如果可以留期限皮重，则判断车辆历史皮重，若当前皮重在 历史皮重最大最小偏差范围内，则认为当前确实是皮重允许留皮
                    MeterBaseHisTareDataService mbhds = new MeterBaseHisTareDataService();
                    RESTfulResult<List<MeterBaseHisTareData>> rtHisTare = mbhds.doQueryWf(new MeterBaseHisTareData { carNo = carNo, valueFlag = "0" });
                    if (!rtHisTare.Succeed)
                    {
                        PbCache.ResultMessage = string.Format("车辆[{0}]获取历史皮重维护数据失败，请语音求助", carNo);
                        lg.WriteLog(3, string.Format("车辆[{0}]获取历史皮重维护数据失败，请语音求助", carNo));
                        return false;
                    }
                    else
                    {
                        if (rtHisTare.Data == null || rtHisTare.Data.Count == 0)
                        {
                            PbCache.ResultMessage = string.Format("车辆[{0}]首次进行计量业务时，无法留期限皮", carNo);
                            lg.WriteLog(3, string.Format("车辆[{0}]首次进行计量业务时，无法留期限皮", carNo));
                            return false;
                        }
                        else
                        {
                            //查下是否有有效的期限皮重信息
                            MeterBaseTermTareDataService termTareDataService = new MeterBaseTermTareDataService();
                            RESTfulResult<List<MeterBaseTermTareData>> resTermData = termTareDataService.doQueryWf(new MeterBaseTermTareData { carNo = carNo, valueFlag = "0" });
                            if (resTermData.Succeed && resTermData.Data.Count > 0)
                            {
                                MeterBaseTermTareCount mbhtc = PbCache.termTareCount;
                                double maxWgt = 0, minWgt = 0;
                                if (mbhtc.countTypeNo == "001011001") //固重 当前重量>=历史皮重-固重   当前重量<=历史皮重+固重
                                {
                                    double meterWeight = (PbCache.termTareCount.contrastTypeNo == "001012001" ? resTermData.Data[0].upWeight.Value : resTermData.Data[0].meterWeight.Value);
                                    maxWgt = meterWeight + mbhtc.fixedWeightValue.Value;
                                    minWgt = meterWeight - mbhtc.fixedWeightValue.Value;

                                    // 杨秀东 2021年3月15日 新增逻辑，若不验证车号则可以强制进行期限皮重保存；
                                    if ((PbCache.lockWgt >= minWgt && PbCache.lockWgt <= maxWgt) || PbCache.monitor.validWgt.Equals("0"))
                                    {
                                        return true;
                                    }
                                    else
                                    {
                                        PbCache.ResultMessage = string.Format("车辆[{0}]当前重量【" + PbCache.lockWgt / 1000 + " T】不在期限皮重允许的范围【" + meterWeight + "kg】内，无法留期限皮，请点击语音求助", carNo);
                                        lg.WriteLog(3, string.Format("车辆[{0}]当前重量【" + PbCache.lockWgt / 1000 + " T】不在期限皮重允许的范围内，无法留期限皮，请点击语音求助", carNo));
                                        //不在范围内，无法留期限皮
                                        return false;
                                    }
                                }
                                else if (mbhtc.countTypeNo == "001011002") //比例 当前重量>=历史皮重-历史皮重*比例   当前重量<=历史皮重+历史皮重*比例
                                {
                                    double meterWeight = (PbCache.termTareCount.contrastTypeNo == "001012001" ? resTermData.Data[0].upWeight.Value : resTermData.Data[0].meterWeight.Value);

                                    maxWgt = meterWeight + meterWeight * (mbhtc.rateValue.Value / 100);
                                    minWgt = meterWeight - meterWeight * (mbhtc.rateValue.Value / 100);

                                    //杨秀东 2021年3月15日 新增逻辑，若不验证车号则可以强制进行期限皮重保存；
                                    if ((PbCache.lockWgt >= minWgt && PbCache.lockWgt <= maxWgt) || PbCache.monitor.validWgt.Equals("0"))
                                    {
                                        return true;
                                    }
                                    else
                                    {
                                        PbCache.ResultMessage = string.Format("车辆[{0}]当前重量【" + PbCache.lockWgt / 1000 + " T】不在期限皮重【" + Convert.ToDouble(meterWeight) / 1000 + "T】允许的范围【" + mbhtc.rateValue + "%】内，无法留期限皮，请点击语音求助", carNo);
                                        lg.WriteLog(3, string.Format("车辆[{0}]当前重量【" + PbCache.lockWgt / 1000 + " T】不在期限皮重【" + Convert.ToDouble(meterWeight) / 1000 + "T】允许的范围内【" + mbhtc.rateValue + "%】，无法留期限皮，请点击语音求助", carNo));
                                        //不在范围内，无法留期限皮
                                        return false;
                                    }
                                }
                                else
                                {
                                    PbCache.ResultMessage = string.Format("车辆[{0}]期限皮重计算配置表中配置的计算方式[{1}]无对应逻辑", carNo, mbhtc.countTypeName);
                                    //没有配置比例，也没配置固重，这个需要增加逻辑代码
                                    lg.WriteLog(3, string.Format("车辆[{0}]期限皮重计算配置表中配置的计算方式[{1}]无对应逻辑", carNo, mbhtc.countTypeName));
                                    return false;
                                }
                            }
                            else
                            {
                                //lg.WriteLog(3, string.Format("6车辆[{0}进入留皮判断", carNo));
                                #region 外面的那一层是新加的代码，这个里面的是原有的判断
                                //历史皮重计算方式
                                MeterBaseHisTareCount mbhtc = PbCache.tareCount;
                                double maxWgt = 0, minWgt = 0;
                                if (mbhtc.countTypeNo == "001011001") //固重 当前重量>=历史皮重-固重   当前重量<=历史皮重+固重
                                {
                                    long meterWeight = (PbCache.tareCount.contrastTypeNo == "001012001" ? rtHisTare.Data[0].upWeight.Value : rtHisTare.Data[0].meterWeight.Value);
                                    maxWgt = meterWeight + mbhtc.fixedWeightValue.Value;
                                    minWgt = meterWeight - mbhtc.fixedWeightValue.Value;

                                    if (PbCache.lockWgt >= minWgt && PbCache.lockWgt <= maxWgt || PbCache.monitor.validWgt.Equals("0"))
                                    {
                                        return true;
                                    }
                                    else
                                    {
                                        PbCache.ResultMessage = string.Format("车辆[{0}]当前重量【" + PbCache.lockWgt / 1000 + " T】不在历史皮重【" + Convert.ToDouble(meterWeight) / 1000 + "T】允许的范围【" + mbhtc.fixedWeightValue + "kg】内，无法留皮重，请点击语音求助", carNo);
                                        lg.WriteLog(3, string.Format("7车辆[{0}进入留皮判断;车辆[{0}]当前重量【" + PbCache.lockWgt / 1000 + " T】不在历史皮重【" + Convert.ToDouble(meterWeight) / 1000 + "T】允许的范围内【" + mbhtc.fixedWeightValue + "kg】，无法留皮重，请点击语音求助", carNo));
                                        //不在范围内，无法留期限皮
                                        return false;
                                    }
                                }
                                else if (mbhtc.countTypeNo == "001011002") //比例 当前重量>=历史皮重-历史皮重*比例   当前重量<=历史皮重+历史皮重*比例
                                {
                                    long meterWeight = (PbCache.tareCount.contrastTypeNo == "001012001" ? rtHisTare.Data[0].upWeight.Value : rtHisTare.Data[0].meterWeight.Value);

                                    maxWgt = meterWeight + meterWeight * (mbhtc.rateValue.Value / 100);
                                    minWgt = meterWeight - meterWeight * (mbhtc.rateValue.Value / 100);

                                    if (PbCache.lockWgt >= minWgt && PbCache.lockWgt <= maxWgt || PbCache.monitor.validWgt.Equals("0"))
                                    {
                                        return true;
                                    }
                                    else
                                    {
                                        PbCache.ResultMessage = string.Format("车辆[{0}]当前重量【" + PbCache.lockWgt / 1000 + " T】不在历史皮重【" + Convert.ToDouble(meterWeight) / 1000 + "T】允许的范围【" + mbhtc.rateValue + "%】内，无法留皮重，请点击语音求助", carNo);
                                        lg.WriteLog(3, string.Format("车辆[{0}]当前重量【" + PbCache.lockWgt / 1000 + " T】不在历史皮重【" + Convert.ToDouble(meterWeight) / 1000 + "T】允许的范围内【" + mbhtc.rateValue + "%】，无法留皮重，请点击语音求助", carNo));
                                        //不在范围内，无法留期限皮
                                        return false;
                                    }
                                }
                                else
                                {
                                    PbCache.ResultMessage = string.Format("车辆[{0}]历史皮重计算配置表中配置的计算方式[{1}]无对应逻辑", carNo, mbhtc.countTypeName);
                                    //没有配置比例，也没配置固重，这个需要增加逻辑代码
                                    lg.WriteLog(3, string.Format("车辆[{0}]历史皮重计算配置表中配置的计算方式[{1}]无对应逻辑", carNo, mbhtc.countTypeName));
                                    return false;
                                }
                                #endregion
                            }
                        }
                    }
                }
                else
                {

                    PbCache.ResultMessage = string.Format("车辆[{0}]未给留期限皮权限，不允许留期限皮", carNo);
                    if (rm.Data == null)
                    {
                        lg.WriteLog(3, string.Format("车辆[{0}]未给留期限皮权限，不允许留期限皮！！车号[{0}]，状态[0]，数据条数为0", carNo));
                    }
                    else
                    {
                        lg.WriteLog(3, string.Format("车辆[{0}]未给留期限皮权限，不允许留期限皮！！车号[{0}]，状态[0]，数据条数大于1，为[{1}]", carNo, rm.Data.Count));
                    }
                    return false;
                }
            }
            else
            {
                PbCache.ResultMessage = string.Format("车辆[{0}]获取是否可留期限皮时异常，请语音求助", carNo);
                lg.WriteLog(3, string.Format("车辆[{0}]获取是否可留期限皮时，服务端查询失败", carNo));
                return false;
            }

        }

        #endregion

        /// <summary>
        /// 按业务类型，物资编码、车辆、业务类型
        /// </summary>
        /// <param name="pre"></param>
        /// <returns></returns>
        public bool ValidMethodThree(PreTrackScale pre)
        {
            if (pre == null || string.IsNullOrEmpty(pre.matterNo) || string.IsNullOrEmpty(pre.meterTypeNo) || string.IsNullOrEmpty(pre.carNo))
            {
                PbCache.ResultMessage = string.Format("车辆[{0}]预报中的物资名称、业务类型、车号，均不允许为空！请重新扫描二维码！", pre.carNo);
                lg.WriteLog(3, string.Format("车辆[{0}]预报中的物资名称、业务类型、车号，均不允许为空！请重新扫描二维码！", pre.carNo));
                return false;
            }
            //查下当前拖的物料是否可用期限皮;验证业务类型是否允许使用期限皮重
            string sqls = @"select t.matter_no id, t.matter_name text
                                              from meter_base_matter_info t,meter_base_metertype_conf t2
                                             where t.allowed_tare_weight = '1'
                                               and t.valid_flag = '1'
                                               and t.matter_no='" + pre.matterNo + @"'
                                               and t2.is_allow_term_tare = '1' and  t2.meter_type_no = '" + pre.meterTypeNo + @"'";

            PbModelDbService<List<PbModelDb>> pbp = new PbModelDbService<List<PbModelDb>>();
            RESTfulResult<List<PbModelDb>> rmT = pbp.executeSqlDataWf(sqls);
            if (rmT.Succeed)
            {
                if (rmT.Data != null && rmT.Data.Count > 0)
                {
                    PbCache.ResultMessage = string.Format("物资【{0}】在使用【{1}】业务类型计量时，不能使用一次皮重计量，" +
                       "请点击【期限皮重】留期限皮重，然后计量重车！", pre.matterName, pre.meterTypeName);
                    return true;
                }
                else
                {
                    PbCache.ResultMessage = string.Format("物资【{0}】在使用【{1}】业务类型计量时，不允许留期限皮重，" +
                        "请点击【保存】普通皮重，然后计量重车！", pre.matterName, pre.meterTypeName);
                    return false;
                }
            }
            else
            {
                PbCache.ResultMessage = "计量失败，获取期限皮可用物料异常：" + rmT.ResultMessage;
                return false;
            }
        }

        /// <summary>
        /// 若存在有效的一次计量数据，则不允许进行期限皮重保存
        /// </summary>
        /// <param name="pre"></param>
        /// <returns></returns>
        public bool ValidActualFirst(PreTrackScale pre)
        {
            if (pre == null || string.IsNullOrEmpty(pre.matterNo) || string.IsNullOrEmpty(pre.meterTypeNo) || string.IsNullOrEmpty(pre.carNo))
            {
                PbCache.ResultMessage = string.Format("车辆[{0}]预报中的物资名称、业务类型、车号，均不允许为空！请重新扫描二维码！", pre.carNo);
                lg.WriteLog(3, string.Format("车辆[{0}]预报中的物资名称、业务类型、车号，均不允许为空！请重新扫描二维码！", pre.carNo));
                return false;
            }
            MeterWorkCarActualFirstService mwcfs = new MeterWorkCarActualFirstService();
            //VALUE_FLAG 状态（0=作废，1=有效，2=结净）
            RESTfulResult<List<MeterWorkCarActualFirst>> rmX = mwcfs.doQueryOrderByTime(new MeterWorkCarActualFirst { valueFlag="1", carNo = pre.carNo });
            if (rmX.Succeed)
            {
                if (rmX.Data != null && rmX.Data.Count > 0)
                {
                    PbCache.ResultMessage = string.Format("车辆【{0}】存在一条计量时间为【" + rmX.Data[0].createTime?.ToString("yyyy-MM-dd HH:mm:ss") + "】，" +
                        "重量为【" + rmX.Data[0].meterWeight / 1000 + "T】的一次计量数据，不允许留期限皮重，" +
                           "请完成上一次计量流程,或点击【语音求助】联系司秤工处理！", pre.carNo, pre.meterTypeName);
                    return false;
                } 
            }       
            else
            {
                PbCache.ResultMessage = "计量失败，一次计量数据异常：" + rmX.ResultMessage;
                return false;
            }
            return true;
        }
    }
}