using System;
using System.Collections;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Web.Services;
using HighWay = DataTransferService.Model.HighWay;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json;
using OperatingData.SDK;
using HZQR.Common;

namespace DataTransferService
{
    /// <summary>
    /// Service 的摘要说明
    /// </summary>
    [WebService(Namespace = "http://tempuri.org/")]
    [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
    [System.ComponentModel.ToolboxItem(false)]
    // 若要允许使用 ASP.NET AJAX 从脚本中调用此 Web 服务，请取消注释以下行。 
    // [System.Web.Script.Services.ScriptService]
    public class Service : System.Web.Services.WebService
    {
        protected static string _OracleConnStr = ConfigurationManager.AppSettings["OracleConnStr"];
        protected static string _OracleConnStrEx = ConfigurationManager.AppSettings["OracleConnStrEx"];

        /// <summary>
        /// 本地连接
        /// </summary>
        OracleHelper LocalOracle { get; set; }

        #region 方法 -> 数据上传
        /// <summary>
        /// 数据上传
        /// </summary>
        /// <param name="code">机器授权码</param>
        /// <param name="tableName">上传数据表名</param>
        /// <param name="jsonString">传输数据内容，json字符串格式</param>
        /// <param name="orderString">json字符串，存储服务区编码、门店编码、门店内码、收银机号、MAC地址、收银机上传时间（预留字段，暂不使用）</param>
        /// <param name="UniqueCode">redis数据库判断数据表的唯一标识</param>
        /// <param name="redisInsert">是否只进行缓存数据更新，默认为false，进行正常的数据传输</param>
        /// <returns>error：-1【代码执行异常】，1【代码执行正常】，2【redis数据库存储异常】</returns>
        /// tableName：HIGHWAY_EXCHANGE.T_ENDACCOUNT_NEW 日结报表
        ///             HIGHWAY_EXCHANGE.T_PERSONSELL_NEW 收银交班表
        [WebMethod]
        public string UploadTableData(string code, string tableName, string jsonString,
            string orderString, string UniqueCode, string redisInsert = "false")
        {
            //获取本地收银数据库连接
            if (LocalOracle == null)
            {
                LocalOracle = new OracleHelper(_OracleConnStr.Split(',')[0], _OracleConnStr.Split(',')[1],
                    _OracleConnStr.Split(',')[2], _OracleConnStr.Split(',')[3]);
            }

            if (!string.IsNullOrWhiteSpace(orderString))
            {
                //设置文本日志记录的地址：log/日期
                string LogPath = "Log\\" + DateTime.Now.ToString("yyyyMMdd");
                try
                {
                    #region 判断orderString中必填项参数传入的值是否正常，并将对应的值赋予codes数组中
                    JObject _OrderString = JObject.Parse(orderString);
                    //判断orderString中是否缺失必填项【服务区编码、门店编码、收银机号】
                    if (_OrderString.Property("SERVERPARTCODE") == null || _OrderString.Property("SHOPCODE") == null ||
                        _OrderString.Property("MACHINECODE") == null)
                    {
                        return "{\"error\": -1 ,\"msg\": \"获取数据上传失败：JSON参数解析异常！\",\"rows\":[]}";
                    }
                    //服务区编码
                    string _SERVERPARTCODE = _OrderString.Property("SERVERPARTCODE").Value.ToString();
                    //门店编码
                    string _SHOPCODE = _OrderString.Property("SHOPCODE").Value.ToString();
                    //门店ID
                    string _SERVERPARTSHOP_ID = _OrderString.Property("SERVERPARTSHOP_ID") == null ? "" :
                        _OrderString.Property("SERVERPARTSHOP_ID").Value.ToString();
                    //收银机编码
                    string _MACHINECODE = _OrderString.Property("MACHINECODE").Value.ToString();
                    //Mac地址
                    string _MACADDRESS = _OrderString.Property("MACADDRESS") == null ? "" :
                        _OrderString.Property("MACADDRESS").Value.ToString();
                    //收银机上传时间，预留字段，暂不使用
                    string _ENDDATE = _OrderString.Property("ENDDATE") == null ? "" :
                        _OrderString.Property("ENDDATE").Value.ToString();

                    //必填项“服务区编码、门店内码、门店编码”不可为空
                    if (string.IsNullOrWhiteSpace(_SERVERPARTCODE) || string.IsNullOrWhiteSpace(_SHOPCODE) ||
                        string.IsNullOrWhiteSpace(_MACHINECODE))
                    {
                        return "{\"error\": -1 ,\"msg\": \"获取数据上传失败：JSON缺少必要参数：" +
                                "SERVERPARTCODE、SHOPCODE、MACHINECODE \",\"rows\":[]}";
                    }

                    string[] codes = new string[6];
                    codes[0] = _SERVERPARTCODE;     //服务区编码
                    codes[1] = _SHOPCODE;           //门店编码
                    codes[2] = _SERVERPARTSHOP_ID;  //门店内码
                    codes[3] = _MACHINECODE;        //机器编码
                    codes[4] = _ENDDATE;            //收银机上传时间，预留字段，暂不使用
                    codes[5] = _MACADDRESS;         //MAC地址
                    #endregion

                    //记录数据到本地数据库，返回数据上传结果
                    string Result = Method.UploadMethod.DataUploading(LocalOracle, tableName, jsonString, codes, UniqueCode, redisInsert);

                    //匹配需要异步上传数据的服务区
                    if (!string.IsNullOrWhiteSpace(ConfigurationManager.AppSettings[_SERVERPARTCODE]))
                    {
                        Task task = Task.Factory.StartNew(() =>
                        {
                            //根据服务区编码获取数据转发地址
                            string TransmitUrl = ConfigurationManager.AppSettings[_SERVERPARTCODE];

                            try
                            {
                                //将传输报文转换成has格式
                                Hashtable hashtable = new Hashtable();
                                hashtable["code"] = code;
                                hashtable["tableName"] = tableName;
                                hashtable["jsonString"] = jsonString;
                                hashtable["orderString"] = orderString;
                                hashtable["UniqueCode"] = UniqueCode;
                                hashtable["redisInsert"] = redisInsert;

                                WebService.SDK.LogHelper.WriteLog("数据转发地址：" + TransmitUrl +
                                    "；发送报文：" + JsonConvert.SerializeObject(hashtable), LogPath);
                                //传输结果
                                string transmitRes = WebService.SDK.SoapWSHelper.QuerySoapWebServiceString(
                                    TransmitUrl, "UploadTableData", hashtable);
                                WebService.SDK.LogHelper.WriteLog("数据转发结果：" + transmitRes, LogPath);
                            }
                            catch (Exception ex)
                            {
                                WebService.SDK.LogHelper.WriteLog(ex.Message, LogPath);
                            }
                        });
                    }

                    return Result;
                }
                catch (Exception ex)
                {
                    WebService.SDK.LogHelper.WriteLog(ex.Message, LogPath);
                }
            }
            else
            {
                return "{\"error\": -1 ,\"msg\": \"获取数据上传失败：JSON参数解析异常！\",\"rows\":[]}";
            }

            return "{\"error\": -1 ,\"msg\": \"获取数据上传失败：发生异常！\",\"rows\":[]}";
        }
        #endregion

        #region 营收数据传输相关接口

        #region 方法 -> 商品信息
        /// <summary>
        /// 商品信息
        /// </summary>
        /// <param name="jsonString"></param>
        /// <returns></returns>
        [WebMethod]
        public string AddGoodsInfo(string code, string jsonString)
        {
            OracleHelper _OracleExHelper = new OracleHelper(
                    _OracleConnStrEx.Split(',')[0], _OracleConnStrEx.Split(',')[1],
                    _OracleConnStrEx.Split(',')[2], _OracleConnStrEx.Split(',')[3]);

            OracleHelper _OracleHelper = new OracleHelper(
                    _OracleConnStr.Split(',')[0], _OracleConnStr.Split(',')[1],
                    _OracleConnStr.Split(',')[2], _OracleConnStr.Split(',')[3]);

            string[] codes = OperationDataHelper<string>.IsCorrectCode(_OracleExHelper, code);
            if (codes == null)
            {
                WebService.SDK.LogHelper.WriteSendLog(code);
                return "{\"ResultCode\": 201 ,\"ResultDesc\": \"授权码不正确\",\"ResultData\":[]}";
            }

            try
            {
                //先检查传入的参数是否为空数据包
                if (string.IsNullOrWhiteSpace(jsonString))
                {
                    return "{\"ResultCode\": 200 ,\"ResultDesc\": \"报文参数不正确\",\"ResultData\":[]}";
                }
                #region 定义必填参数
                //必填项
                string[] str_RequiredDatas = new string[]
                {
                    "Commodity_Name","Commodity_BarCode",
                    "Commodity_Unit","Commodity_Rule",
                    "Commodity_RetailPrice","Commodity_State"
                };
                #endregion

                #region 解析并检查传入的数据集合
                //解析传入的数据集合
                List<HighWay.CommodityInfo> list_CommodityInfo =
                    Newtonsoft.Json.JsonConvert.DeserializeObject<List<HighWay.CommodityInfo>>(jsonString);
                if (list_CommodityInfo == null || list_CommodityInfo.Count == 0)
                {
                    return "{\"ResultCode\": 200 ,\"ResultDesc\": \"报文参数不正确\",\"ResultData\":[]}";
                }
                for (int i = 0; i < list_CommodityInfo.Count; i++)
                {
                    foreach (var str_ColumnName in str_RequiredDatas)
                    {
                        //检查必填参数是否未传入
                        if (list_CommodityInfo[i][str_ColumnName] == null ||
                            string.IsNullOrWhiteSpace(list_CommodityInfo[i][str_ColumnName].ToString()))
                        {
                            return "{\"ResultCode\": 200 ,\"ResultDesc\": \"第" + (i + 1) +
                                "组数据，缺少必要参数：" + str_ColumnName + "\",\"ResultData\":[]}";
                        }
                    }
                    list_CommodityInfo[i].Serverpart_Code = codes[0];
                    list_CommodityInfo[i].ShopCode = codes[1];
                }
                #endregion

                //定义需要更新的数据集
                List<HighWay.CommodityInfo> CommodityInfoUpdateList = new List<HighWay.CommodityInfo>();

                //逐条插入数据到数据库
                for (int i = 0; i < list_CommodityInfo.Count; i++)
                {
                    //判断商品数据是否存在，若存在则加入到更新列表中
                    //判断条件：服务区编码+门店编码+商品条码
                    if (_OracleHelper.ExcuteSqlGetDataSet("SELECT 1 FROM HIGHWAY_STORAGE.T_COMMODITYINFO WHERE SERVERPART_CODE = '" +
                        list_CommodityInfo[i].Serverpart_Code + "' AND SHOPCODE = '" + list_CommodityInfo[i].ShopCode +
                        "' AND COMMODITY_BARCODE = '" + list_CommodityInfo[i].Commodity_Barcode + "'").Tables[0].Rows.Count > 0)
                    {
                        CommodityInfoUpdateList.Add(list_CommodityInfo[i]);
                    }
                    else
                    {
                        OperationDataHelper<HighWay.CommodityInfo>.InsertTableData(
                            _OracleHelper, list_CommodityInfo[i], "HIGHWAY_STORAGE.T_COMMODITYINFO",
                            "COMMODITYINFO_ID", "HIGHWAY_STORAGE.SEQ_COMMODITYINFO.NEXTVAL");
                    }
                }
                //执行商品信息更新操作
                if (CommodityInfoUpdateList.Count > 0)
                {
                    string[] WhereName = { "SERVERPART_CODE", "SHOPCODE", "COMMODITY_BARCODE" };
                    OperationDataHelper<HighWay.CommodityInfo>.UpdateTableData(
                        _OracleHelper, CommodityInfoUpdateList, "HIGHWAY_STORAGE.T_COMMODITYINFO", WhereName);
                }

                //返回保存结果
                return "{\"ResultCode\": 100 ,\"ResultDesc\": \"添加成功！\",\"ResultData\":[]}";
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"商品数据接收保存失败。原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"系统异常。\",\"ResultData\":[]}";
            }
        }
        #endregion

        #region 方法 -> 结账报表
        /// <summary>
        /// 结账报表
        /// </summary>
        /// <param name="jsonString"></param>
        /// <returns></returns>
        [WebMethod]
        public string AddEndaccountData(string code, string jsonString)
        {
            OracleHelper _OracleExHelper = new OracleHelper(
                    _OracleConnStrEx.Split(',')[0], _OracleConnStrEx.Split(',')[1],
                    _OracleConnStrEx.Split(',')[2], _OracleConnStrEx.Split(',')[3]);

            OracleHelper _OracleHelper = new OracleHelper(
                    _OracleConnStr.Split(',')[0], _OracleConnStr.Split(',')[1],
                    _OracleConnStr.Split(',')[2], _OracleConnStr.Split(',')[3]);

            string[] codes = OperationDataHelper<string>.IsCorrectCode(_OracleExHelper, code);
            if (codes == null)
            {
                WebService.SDK.LogHelper.WriteSendLog(code);
                return "{\"ResultCode\": 201 ,\"ResultDesc\": \"授权码不正确\",\"ResultData\":[]}";
            }

            try
            {
                //先检查传入的参数是否为空数据包
                if (string.IsNullOrWhiteSpace(jsonString))
                {
                    return "{\"ResultCode\": 200 ,\"ResultDesc\": \"报文参数不正确\",\"ResultData\":[]}";
                }

                #region 定义必填参数
                //必填项
                string[] str_RequiredDatas = new string[]
                {
                    "Endaccount_StartDate","Endaccount_EndDate",
                    "Endaccount_UniqueCode","Cashier_Name",
                    "TicketCount","TotalCount","TotalSellAmount",
                    "TotalOffAmount","CashPay","CreditcardPay",
                    "WechatPay","AliPay","VIPCardPay","CostBillPay",
                    "OtherPay","Different_Amount","Endaccount_State"
                };
                #endregion

                #region 解析并检查传入的数据集合
                //解析传入的数据集合
                List<HighWay.EndaccountData> list_EndaccountData =
                    Newtonsoft.Json.JsonConvert.DeserializeObject<List<HighWay.EndaccountData>>(jsonString);
                if (list_EndaccountData == null || list_EndaccountData.Count == 0)
                {
                    return "{\"ResultCode\": 200 ,\"ResultDesc\": \"报文参数不正确\",\"ResultData\":[]}";
                }
                for (int i = 0; i < list_EndaccountData.Count; i++)
                {
                    foreach (var str_ColumnName in str_RequiredDatas)
                    {
                        if (list_EndaccountData[i][str_ColumnName] == null || string.IsNullOrWhiteSpace(list_EndaccountData[i][str_ColumnName].ToString()))
                        {
                            //检查必填参数是否未传入
                            return "{\"ResultCode\": 200 ,\"ResultDesc\": \"第" + (i + 1) +
                                "组数据，缺少必要参数：" + str_ColumnName + "\",\"ResultData\":[]}";
                        }
                    }
                    list_EndaccountData[i].Serverpart_Code = codes[0];
                    list_EndaccountData[i].ShopCode = codes[1];
                }
                #endregion

                //定义需要更新的数据集
                List<HighWay.EndaccountData> EndaccountDataUpdateList = new List<HighWay.EndaccountData>();

                //逐条插入数据到数据库
                for (int i = 0; i < list_EndaccountData.Count; i++)
                {
                    //判断商品数据是否存在，若存在则加入到更新列表中
                    //判断条件：服务区编码+门店编码+账期唯一标识
                    if (_OracleHelper.ExcuteSqlGetDataSet("SELECT 1 FROM HIGHWAY_SELLDATA.T_ENDACCOUNTDATA WHERE SERVERPART_CODE = '" +
                        list_EndaccountData[i].Serverpart_Code + "' AND SHOPCODE = '" + list_EndaccountData[i].ShopCode +
                        "' AND ENDACCOUNT_UNIQUECODE = '" + list_EndaccountData[i].Endaccount_UniqueCode + "'").Tables[0].Rows.Count > 0)
                    {
                        EndaccountDataUpdateList.Add(list_EndaccountData[i]);
                    }
                    else
                    {
                        OperationDataHelper<HighWay.EndaccountData>.InsertTableData(
                            _OracleHelper, list_EndaccountData[i], "HIGHWAY_SELLDATA.T_ENDACCOUNTDATA",
                            "ENDACCOUNTDATA_ID", "HIGHWAY_SELLDATA.SEQ_ENDACCOUNTDATA.NEXTVAL");
                    }
                }
                //执行日结账单更新操作
                if (EndaccountDataUpdateList.Count > 0)
                {
                    string[] WhereName = { "SERVERPART_CODE", "SHOPCODE", "ENDACCOUNT_UNIQUECODE" };
                    OperationDataHelper<HighWay.EndaccountData>.UpdateTableData(
                        _OracleHelper, EndaccountDataUpdateList, "HIGHWAY_SELLDATA.T_ENDACCOUNTDATA", WhereName);
                }

                return "{\"ResultCode\": 100 ,\"ResultDesc\": \"添加成功！\",\"ResultData\":[]}";
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"日结数据接收保存失败。原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"系统异常。\",\"ResultData\":[]}";
            }
        }
        #endregion

        #region 方法 -> 收银报表
        /// <summary>
        /// 收银报表
        /// </summary>
        /// <param name="jsonString"></param>
        /// <returns></returns>
        [WebMethod]
        public string AddPersonsellData(string code, string jsonString)
        {
            OracleHelper _OracleExHelper = new OracleHelper(
                    _OracleConnStrEx.Split(',')[0], _OracleConnStrEx.Split(',')[1],
                    _OracleConnStrEx.Split(',')[2], _OracleConnStrEx.Split(',')[3]);

            OracleHelper _OracleHelper = new OracleHelper(
                    _OracleConnStr.Split(',')[0], _OracleConnStr.Split(',')[1],
                    _OracleConnStr.Split(',')[2], _OracleConnStr.Split(',')[3]);

            string[] codes = OperationDataHelper<string>.IsCorrectCode(_OracleExHelper, code);
            if (codes == null)
            {
                WebService.SDK.LogHelper.WriteSendLog(code);
                return "{\"ResultCode\": 201 ,\"ResultDesc\": \"授权码不正确\",\"ResultData\":[]}";
            }

            try
            {
                if (string.IsNullOrWhiteSpace(jsonString))
                {
                    return "{\"ResultCode\": 200 ,\"ResultDesc\": \"报文参数不正确\",\"ResultData\":[]}";
                }

                #region 定义必填参数
                //必填项
                string[] str_RequiredDatas = new string[]
                {
                    "Personsell_StartDate","Personsell_EndDate",
                    "Endaccount_UniqueCode","Cashier_Name",
                    "TicketCount","TotalCount","TotalSellAmount",
                    "TotalOffAmount","CashPay","CreditcardPay",
                    "WeChatPay","AliPay","VIPCardPay","CostBillPay",
                    "OtherPay","Personsell_State"
                };
                #endregion

                #region 解析并检查传入的数据集合
                List<HighWay.PersonsellData> list_PersonsellData =
                    Newtonsoft.Json.JsonConvert.DeserializeObject<List<HighWay.PersonsellData>>(jsonString);
                if (list_PersonsellData == null || list_PersonsellData.Count == 0)
                {
                    return "{\"ResultCode\": 200 ,\"ResultDesc\": \"报文参数不正确\",\"ResultData\":[]}";
                }
                for (int i = 0; i < list_PersonsellData.Count; i++)
                {
                    foreach (var str_ColumnName in str_RequiredDatas)
                    {
                        if (list_PersonsellData[i][str_ColumnName] == null || string.IsNullOrWhiteSpace(list_PersonsellData[i][str_ColumnName].ToString()))
                        {
                            //检查必填参数是否未传入
                            return "{\"ResultCode\": 200 ,\"ResultDesc\": \"第" + (i + 1) +
                                "组数据，缺少必要参数：" + str_ColumnName + "\",\"ResultData\":[]}";
                        }
                    }
                    list_PersonsellData[i].Serverpart_Code = codes[0];
                    list_PersonsellData[i].ShopCode = codes[1];
                }
                #endregion

                //逐条插入数据到数据库
                for (int i = 0; i < list_PersonsellData.Count; i++)
                {
                    OperationDataHelper<HighWay.PersonsellData>.InsertTableData(
                        _OracleHelper, list_PersonsellData[i], "HIGHWAY_SELLDATA.T_PERSONSELLDATA",
                        "PERSONSELLDATA_ID", "HIGHWAY_SELLDATA.SEQ_PERSONSELLDATA.NEXTVAL");

                }
                return "{\"ResultCode\": 100 ,\"ResultDesc\": \"添加成功！\",\"ResultData\":[]}";
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"交班数据接收保存失败。原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"系统异常。\",\"ResultData\":[]}";
            }
        }
        #endregion

        #region 方法 -> 单品报表
        /// <summary>
        /// 单品报表
        /// </summary>
        /// <param name="jsonString"></param>
        /// <returns></returns>
        [WebMethod]
        public string AddCommoditySaleData(string code, string jsonString)
        {
            OracleHelper _OracleExHelper = new OracleHelper(
                    _OracleConnStrEx.Split(',')[0], _OracleConnStrEx.Split(',')[1],
                    _OracleConnStrEx.Split(',')[2], _OracleConnStrEx.Split(',')[3]);

            OracleHelper _OracleHelper = new OracleHelper(
                    _OracleConnStr.Split(',')[0], _OracleConnStr.Split(',')[1],
                    _OracleConnStr.Split(',')[2], _OracleConnStr.Split(',')[3]);

            string[] codes = OperationDataHelper<string>.IsCorrectCode(_OracleExHelper, code);
            if (codes == null)
            {
                WebService.SDK.LogHelper.WriteSendLog(code);
                return "{\"ResultCode\": 201 ,\"ResultDesc\": \"授权码不正确\",\"ResultData\":[]}";
            }

            try
            {
                if (string.IsNullOrWhiteSpace(jsonString))
                {
                    return "{\"ResultCode\": 200 ,\"ResultDesc\": \"报文参数不正确\",\"ResultData\":[]}";
                }

                #region 定义必填参数
                //必填项
                string[] str_RequiredDatas = new string[]
                {
                    "StartDate","EndDate","Endaccount_UniqueCode",
                    "Commodity_Code","Commodity_Name",
                    "TotalCount","TotalSellAmount","TotalOffAmount",
                    "CommoditySale_State"
                };
                #endregion

                #region 解析并检查传入的数据集合
                List<HighWay.CommoditySaleData> list_CommoditySaleData =
                    Newtonsoft.Json.JsonConvert.DeserializeObject<List<HighWay.CommoditySaleData>>(jsonString);
                if (list_CommoditySaleData == null || list_CommoditySaleData.Count == 0)
                {
                    return "{\"ResultCode\": 200 ,\"ResultDesc\": \"报文参数不正确\",\"ResultData\":[]}";
                }
                for (int i = 0; i < list_CommoditySaleData.Count; i++)
                {
                    foreach (var str_ColumnName in str_RequiredDatas)
                    {
                        if (list_CommoditySaleData[i][str_ColumnName] == null || string.IsNullOrWhiteSpace(list_CommoditySaleData[i][str_ColumnName].ToString()))
                        {
                            //检查必填参数是否未传入
                            return "{\"ResultCode\": 200 ,\"ResultDesc\": \"第" + (i + 1) +
                                "组数据，缺少必要参数：" + str_ColumnName + "\",\"ResultData\":[]}";
                        }
                    }
                    list_CommoditySaleData[i].Serverpart_Code = codes[0];
                    list_CommoditySaleData[i].ShopCode = codes[1];
                }
                #endregion

                //逐条插入数据到数据库
                for (int i = 0; i < list_CommoditySaleData.Count; i++)
                {
                    OperationDataHelper<HighWay.CommoditySaleData>.InsertTableData(
                        _OracleHelper, list_CommoditySaleData[i], "HIGHWAY_SELLDATA.T_COMMODITYSALEDATA",
                        "COMMODITYSALEDATA_ID", "HIGHWAY_SELLDATA.SEQ_COMMODITYSALEDATA.NEXTVAL");
                }
                return "{\"ResultCode\": 100 ,\"ResultDesc\": \"添加成功！\",\"ResultData\":[]}";
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"单品数据接收保存失败。原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"系统异常。\",\"ResultData\":[]}";
            }
        }
        #endregion

        #region 方法 -> 销售流水
        /// <summary>
        /// 销售流水
        /// </summary>
        /// <param name="jsonString"></param>
        /// <returns></returns>
        [WebMethod]
        public string AddSaleData(string code, string jsonString)
        {
            OracleHelper _OracleExHelper = new OracleHelper(
                    _OracleConnStrEx.Split(',')[0], _OracleConnStrEx.Split(',')[1],
                    _OracleConnStrEx.Split(',')[2], _OracleConnStrEx.Split(',')[3]);

            OracleHelper _OracleHelper = new OracleHelper(
                    _OracleConnStr.Split(',')[0], _OracleConnStr.Split(',')[1],
                    _OracleConnStr.Split(',')[2], _OracleConnStr.Split(',')[3]);

            string[] codes = OperationDataHelper<string>.IsCorrectCode(_OracleExHelper, code);
            if (codes == null)
            {
                WebService.SDK.LogHelper.WriteSendLog(code);
                return "{\"ResultCode\": 201 ,\"ResultDesc\": \"授权码不正确\",\"ResultData\":[]}";
            }

            try
            {
                if (string.IsNullOrWhiteSpace(jsonString))
                {
                    return "{\"ResultCode\": 200 ,\"ResultDesc\": \"报文参数不正确\",\"ResultData\":[]}";
                }

                #region 定义必填参数
                //必填项
                string[] str_RequiredDatas = new string[]
                {
                    "SaleData_Date","MachineCode","TicketCode",
                    "CashierName","SellCount","SellAmount",
                    "SellOffAmount","SellDetail","SellData_State"
                };
                #endregion

                #region 解析并检查传入的数据集合
                List<HighWay.SaleData> list_SaleData =
                    Newtonsoft.Json.JsonConvert.DeserializeObject<List<HighWay.SaleData>>(jsonString);
                if (list_SaleData == null || list_SaleData.Count == 0)
                {
                    return "{\"ResultCode\": 200 ,\"ResultDesc\": \"报文参数不正确\",\"ResultData\":[]}";
                }
                for (int i = 0; i < list_SaleData.Count; i++)
                {
                    foreach (var str_ColumnName in str_RequiredDatas)
                    {
                        if (list_SaleData[i][str_ColumnName] == null || string.IsNullOrWhiteSpace(list_SaleData[i][str_ColumnName].ToString()))
                        {
                            //检查必填参数是否未传入
                            return "{\"ResultCode\": 200 ,\"ResultDesc\": \"第" + (i + 1) +
                                "组数据，缺少必要参数：" + str_ColumnName + "\",\"ResultData\":[]}";
                        }
                    }
                    list_SaleData[i].Serverpart_Code = codes[0];
                    list_SaleData[i].ShopCode = codes[1];
                }
                #endregion

                //逐条插入数据到数据库
                for (int i = 0; i < list_SaleData.Count; i++)
                {
                    OperationDataHelper<HighWay.SaleData>.InsertTableData(
                        _OracleHelper, list_SaleData[i], "HIGHWAY_SELLDATA.T_SALEDATA",
                        "SALEDATA_ID", "HIGHWAY_SELLDATA.SEQ_SALEDATA.NEXTVAL");
                }
                return "{\"ResultCode\": 100 ,\"ResultDesc\": \"添加成功！\",\"ResultData\":[]}";
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"流水数据接收保存失败。原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"系统异常。\",\"ResultData\":[]}";
            }
        }
        #endregion

        #region 方法 -> 查询数据
        /// <summary>
        /// 查询数据
        /// </summary>
        /// <param name="code">授权码</param>
        /// <param name="DataType">要查询的数据类型</param>
        /// <param name="MachineCode">收银机号</param>
        /// <param name="CommodityBarcode">商品条码</param>
        /// <param name="StartDate">开始时间</param>
        /// <param name="EndDate">结束时间</param>
        /// <returns></returns>
        [WebMethod]
        public string SearchData(string code, string DataType, string MachineCode, string CommodityBarcode, string StartDate, string EndDate)
        {
            OracleHelper _OracleExHelper = new OracleHelper(
                    _OracleConnStrEx.Split(',')[0], _OracleConnStrEx.Split(',')[1],
                    _OracleConnStrEx.Split(',')[2], _OracleConnStrEx.Split(',')[3]);

            OracleHelper _OracleHelper = new OracleHelper(
                    _OracleConnStr.Split(',')[0], _OracleConnStr.Split(',')[1],
                    _OracleConnStr.Split(',')[2], _OracleConnStr.Split(',')[3]);

            string[] codes = OperationDataHelper<string>.IsCorrectCode(_OracleExHelper, code);

            string SqlString = "";
            if (codes == null)
            {
                return "{\"ResultCode\": 201,\"ResultDesc\": \"授权码不正确\",\"ResultData\":[]}";
            }
            try
            {
                //必填项
                if (string.IsNullOrWhiteSpace(DataType))
                {
                    return "{\"ResultCode\": 200 ,\"ResultDesc\": \"报文参数不正确\",\"ResultData\":[]}";
                }
                DataTable _DataTable = new DataTable();
                switch (DataType)
                {
                    case "Endaccount":
                        #region 结账报表
                        if (!string.IsNullOrWhiteSpace(StartDate))
                        {
                            SqlString += " AND ENDACCOUNT_ENDDATE >= TO_DATE('" + StartDate + "','YYYY/MM/DD')";
                        }
                        if (!string.IsNullOrWhiteSpace(EndDate))
                        {
                            SqlString += " AND ENDACCOUNT_ENDDATE < TO_DATE('" + EndDate + "','YYYY/MM/DD') + 1";
                        }
                        _DataTable = _OracleHelper.ExcuteSqlGetDataSet(
                            $@"SELECT SERVERPART_CODE,SHOPCODE,ENDACCOUNT_STARTDATE,
                                ENDACCOUNT_ENDDATE,ENDACCOUNT_UNIQUECODE,CASHIER_NAME,
                                TICKETCOUNT,TOTALCOUNT,TOTALSELLAMOUNT,TOTALOFFAMOUNT,
                                CASHPAY,CREDITCARDPAY,WECHATPAY,ALIPAY,VIPCARDPAY,COSTBILLPAY,
                                OTHERPAY,DIFFERENT_AMOUNT,ROUND(ENDACCOUNT_STATE,0) AS ENDACCOUNT_STATE 
                            FROM HIGHWAY_SELLDATA.T_ENDACCOUNTDATA 
                            WHERE SERVERPART_CODE = '{codes[0]}' AND SHOPCODE = '{codes[1]}' {SqlString} 
                            ORDER BY ENDACCOUNT_ENDDATE,SERVERPART_CODE,SHOPCODE").Tables[0];
                        if (_DataTable.Rows.Count > 0)
                        {
                            return "{\"ResultCode\": 100 ,\"ResultDesc\": \"查询成功！\",\"ResultData\":" +
                               Newtonsoft.Json.JsonConvert.SerializeObject(
                                   Newtonsoft.Json.JsonConvert.DeserializeObject<List<HighWay.EndaccountData>>(
                                   Newtonsoft.Json.JsonConvert.SerializeObject(_DataTable))) + "}";
                        }
                        else
                        {
                            return "{\"ResultCode\": 100 ,\"ResultDesc\": \"查询成功！\",\"ResultData\":[]}";
                        }
                    #endregion
                    case "Personsell":
                        #region 收银员报表
                        if (!string.IsNullOrWhiteSpace(StartDate))
                        {
                            SqlString += " AND PERSONSELL_ENDDATE >= TO_DATE('" + StartDate + "','YYYY/MM/DD')";
                        }
                        if (!string.IsNullOrWhiteSpace(EndDate))
                        {
                            SqlString += " AND PERSONSELL_ENDDATE < TO_DATE('" + EndDate + "','YYYY/MM/DD') + 1";
                        }
                        _DataTable = _OracleHelper.ExcuteSqlGetDataSet(
                            $@"SELECT SERVERPART_CODE,SHOPCODE,PERSONSELL_STARTDATE,
                                PERSONSELL_ENDDATE,ENDACCOUNT_UNIQUECODE,CASHIER_NAME,
                                TICKETCOUNT,TOTALCOUNT,TOTALSELLAMOUNT,TOTALOFFAMOUNT,
                                CASHPAY,CREDITCARDPAY,WECHATPAY,ALIPAY,VIPCARDPAY,COSTBILLPAY,
                                OTHERPAY,ROUND(PERSONSELL_STATE,0) AS PERSONSELL_STATE 
                            FROM HIGHWAY_SELLDATA.T_PERSONSELLDATA 
                            WHERE SERVERPART_CODE = '{codes[0]}' AND SHOPCODE = '{codes[1]}' {SqlString} 
                            ORDER BY PERSONSELL_ENDDATE,SERVERPART_CODE,SHOPCODE").Tables[0];
                        if (_DataTable.Rows.Count > 0)
                        {
                            return "{\"ResultCode\": 100 ,\"ResultDesc\": \"查询成功！\",\"ResultData\":" +
                                 Newtonsoft.Json.JsonConvert.SerializeObject(
                                   Newtonsoft.Json.JsonConvert.DeserializeObject<List<HighWay.PersonsellData>>(
                                       Newtonsoft.Json.JsonConvert.SerializeObject(_DataTable))) + "}";
                        }
                        else
                        {
                            return "{\"ResultCode\": 100 ,\"ResultDesc\": \"查询成功！\",\"ResultData\":[]}";
                        }
                    #endregion
                    case "CommoditySale":
                        #region 单品报表
                        if (!string.IsNullOrWhiteSpace(StartDate))
                        {
                            SqlString += " AND ENDDATE >= TO_DATE('" + StartDate + "','YYYY/MM/DD')";
                        }
                        if (!string.IsNullOrWhiteSpace(EndDate))
                        {
                            SqlString += " AND ENDDATE < TO_DATE('" + EndDate + "','YYYY/MM/DD') + 1";
                        }
                        _DataTable = _OracleHelper.ExcuteSqlGetDataSet(
                            $@"SELECT SERVERPART_CODE,SHOPCODE,STARTDATE,ENDDATE,
                                ENDACCOUNT_UNIQUECODE,COMMODITY_TYPE,COMMODITY_CODE,
                                COMMODITY_NAME,TOTALCOUNT,TOTALSELLAMOUNT,TOTALOFFAMOUNT,
                                ROUND(COMMODITYSALE_STATE,0) AS COMMODITYSALE_STATE 
                            FROM HIGHWAY_SELLDATA.T_COMMODITYSALEDATA 
                            WHERE SERVERPART_CODE = '{codes[0]}' AND SHOPCODE = '{codes[1]}'{SqlString} 
                            ORDER BY SERVERPART_CODE,SHOPCODE,ENDDATE").Tables[0];
                        if (_DataTable.Rows.Count > 0)
                        {
                            return "{\"ResultCode\": 100 ,\"ResultDesc\": \"查询成功！\",\"ResultData\":" +
                                 Newtonsoft.Json.JsonConvert.SerializeObject(
                                   Newtonsoft.Json.JsonConvert.DeserializeObject<List<HighWay.CommoditySaleData>>(
                                       Newtonsoft.Json.JsonConvert.SerializeObject(_DataTable))) + "}";
                        }
                        else
                        {
                            return "{\"ResultCode\": 100 ,\"ResultDesc\": \"查询成功！\",\"ResultData\":[]}";
                        }
                    #endregion
                    case "SaleData":
                        #region 销售流水
                        if (!string.IsNullOrWhiteSpace(MachineCode))
                        {
                            SqlString += " AND MACHINECODE = '" + MachineCode + "'";
                        }
                        if (!string.IsNullOrWhiteSpace(StartDate))
                        {
                            SqlString += " AND SALEDATA_DATE >= TO_DATE('" + StartDate + "','YYYY/MM/DD')";
                        }
                        if (!string.IsNullOrWhiteSpace(EndDate))
                        {
                            SqlString += " AND SALEDATA_DATE < TO_DATE('" + EndDate + "','YYYY/MM/DD') + 1";
                        }
                        _DataTable = _OracleHelper.ExcuteSqlGetDataSet(
                            $@"SELECT SERVERPART_CODE,SHOPCODE,SALEDATA_DATE,
                                MACHINECODE,TICKETCODE,CASHIERNAME,SELLCOUNT,
                                SELLAMOUNT,SELLOFFAMOUNT,SELLDETAIL,
                                ROUND(SELLDATA_STATE,0) AS SELLDATA_STATE
                            FROM HIGHWAY_SELLDATA.T_SALEDATA 
                            WHERE SERVERPART_CODE = '{codes[0]}' AND SHOPCODE = '{codes[1]}'{SqlString} 
                            ORDER BY SERVERPART_CODE,SHOPCODE,MACHINECODE,SALEDATA_DATE").Tables[0];
                        if (_DataTable.Rows.Count > 0)
                        {
                            return "{\"ResultCode\": 100 ,\"ResultDesc\": \"查询成功！\",\"ResultData\":" +
                                 Newtonsoft.Json.JsonConvert.SerializeObject(
                                   Newtonsoft.Json.JsonConvert.DeserializeObject<List<HighWay.SaleData>>(
                                       Newtonsoft.Json.JsonConvert.SerializeObject(_DataTable))) + "}";
                        }
                        else
                        {
                            return "{\"ResultCode\": 100 ,\"ResultDesc\": \"查询成功！\",\"ResultData\":[]}";
                        }
                    #endregion
                    case "CommodityInfo":
                        #region 商品信息
                        if (!string.IsNullOrWhiteSpace(CommodityBarcode))
                        {
                            SqlString += " AND COMMODITY_BARCODE = '" + CommodityBarcode + "' ";
                        }
                        _DataTable = _OracleHelper.ExcuteSqlGetDataSet(
                            $@"SELECT COMMODITYINFO_ID,SERVERPART_CODE,SHOPCODE,
                                COMMODITY_TYPE,COMMODITY_NAME,COMMODITY_BARCODE,
                                COMMODITY_UNIT,COMMODITY_RULE,COMMODITY_RETAILPRICE,
                                ROUND(COMMODITY_STATE,0) AS COMMODITY_STATE 
                            FROM HIGHWAY_STORAGE.T_COMMODITYINFO
                            WHERE SERVERPART_CODE = '{codes[0]}' AND 
                                SHOPCODE = '{codes[1]}' {SqlString} ").Tables[0];
                        if (_DataTable.Rows.Count > 0)
                        {
                            return "{\"ResultCode\": 100 ,\"ResultDesc\": \"查询成功！\",\"ResultData\":" +
                                 Newtonsoft.Json.JsonConvert.SerializeObject(
                                   Newtonsoft.Json.JsonConvert.DeserializeObject<List<HighWay.CommodityInfo>>(
                                       Newtonsoft.Json.JsonConvert.SerializeObject(_DataTable))) + "}";
                        }
                        else
                        {
                            return "{\"ResultCode\": 100 ,\"ResultDesc\": \"查询成功！\",\"ResultData\":[]}";
                        }
                    #endregion
                    default:
                        return "{\"ResultCode\": 200 ,\"ResultDesc\": \"报文参数不正确！\",\"ResultData\":[]}";
                }
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"【{DataType}】数据查询失败。原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"系统异常。\",\"ResultData\":[]}";
            }
        }
        #endregion

        #endregion

        #region 卡口数据传输相关接口

        #region 方法 -> 上传实时卡口数据
        /// <summary>
        /// 上传实时卡口数据
        /// </summary>
        /// <param name="code">授权码</param>
        /// <param name="jsonString">传输字符串</param>
        /// <returns></returns>
        [WebMethod]
        public string AddBayonet(string code, string jsonString)
        {
            //授权码数据库链接
            OracleHelper _OracleExHelper = new OracleHelper(_OracleConnStrEx.Split(',')[0],
                _OracleConnStrEx.Split(',')[1], _OracleConnStrEx.Split(',')[2], _OracleConnStrEx.Split(',')[3]);
            //卡口数据存储数据库链接
            OracleHelper _OracleHelper = new OracleHelper(_OracleConnStr.Split(',')[0],
                _OracleConnStr.Split(',')[1], _OracleConnStr.Split(',')[2], _OracleConnStr.Split(',')[3]);

            string[] codes = OperationDataHelper<string>.IsCorrectCode(_OracleExHelper, code);
            if (codes == null)
            {
                WebService.SDK.LogHelper.WriteSendLog(code);
                return "{\"ResultCode\": 201 ,\"ResultDesc\": \"授权码不正确\",\"ResultData\":[]}";
            }

            try
            {
                //先检查传入的参数是否为空数据包
                if (string.IsNullOrWhiteSpace(jsonString))
                {
                    return "{\"ResultCode\": 200 ,\"ResultDesc\": \"报文参数不正确\",\"ResultData\":[]}";
                }

                #region 定义必填参数
                //必填项
                string[] str_RequiredDatas = new string[]
                {
                    "Serverpart_Name","Serverpart_Region",
                    "InOut_Type","InOut_Time","Vehicle_Type",
                    "License_Plate","Vehicle_Speed",
                    "Stay_Times","Statistics_Date"
                };
                #endregion

                #region 解析并检查传入的数据集合
                //解析传入的数据集合
                List<HighWay.BayonetModel> BayonetList = JsonConvert.DeserializeObject<List<HighWay.BayonetModel>>(jsonString);
                if (BayonetList == null || BayonetList.Count == 0)
                {
                    return "{\"ResultCode\": 200 ,\"ResultDesc\": \"报文参数不正确\",\"ResultData\":[]}";
                }
                for (int i = 0; i < BayonetList.Count; i++)
                {
                    foreach (var str_ColumnName in str_RequiredDatas)
                    {
                        //检查必填参数是否未传入
                        if (BayonetList[i][str_ColumnName] == null ||
                            string.IsNullOrWhiteSpace(BayonetList[i][str_ColumnName].ToString()))
                        {
                            return "{\"ResultCode\": 200 ,\"ResultDesc\": \"第" + (i + 1) +
                                "组数据，缺少必要参数：" + str_ColumnName + "\",\"ResultData\":[]}";
                        }
                    }
                    //设置数据上传时间
                    BayonetList[i].Operate_Date = long.Parse(DateTime.Now.ToString("yyyyMMddHHmmss"));
                    //默认数据状态为有效
                    if (BayonetList[i].Bayonet_Status == null)
                    {
                        BayonetList[i].Bayonet_Status = 1;
                    }
                }
                #endregion

                //批量插入数据到数据库
                OperationDataHelper<HighWay.BayonetModel>.InsertTableData(
                    _OracleHelper, BayonetList, "HIGHWAY_SELLDATA.T_BAYONET", true,
                    "BAYONET_ID", "HIGHWAY_SELLDATA.SEQ_BAYONET.NEXTVAL");

                //返回保存结果
                return "{\"ResultCode\": 100 ,\"ResultDesc\": \"添加成功！\",\"ResultData\":[]}";
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"实时卡口数据接收保存失败。原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"系统异常。\",\"ResultData\":[]}";
            }
        }
        #endregion

        #region 方法 -> 添加断面流量数据
        /// <summary>
        /// 添加断面流量数据
        /// </summary>
        /// <param name="code">授权码</param>
        /// <param name="jsonString">传输字符串</param>
        /// <returns></returns>
        [WebMethod]
        public string AddSectionFlow(string code, string jsonString)
        {
            //授权码数据库链接
            OracleHelper _OracleExHelper = new OracleHelper(_OracleConnStrEx.Split(',')[0],
                _OracleConnStrEx.Split(',')[1], _OracleConnStrEx.Split(',')[2], _OracleConnStrEx.Split(',')[3]);
            //卡口数据存储数据库链接
            OracleHelper _OracleHelper = new OracleHelper(_OracleConnStr.Split(',')[0],
                _OracleConnStr.Split(',')[1], _OracleConnStr.Split(',')[2], _OracleConnStr.Split(',')[3]);

            string[] codes = OperationDataHelper<string>.IsCorrectCode(_OracleExHelper, code);
            if (codes == null)
            {
                WebService.SDK.LogHelper.WriteSendLog(code);
                return "{\"ResultCode\": 201 ,\"ResultDesc\": \"授权码不正确\",\"ResultData\":[]}";
            }

            try
            {
                //先检查传入的参数是否为空数据包
                if (string.IsNullOrWhiteSpace(jsonString))
                {
                    return "{\"ResultCode\": 200 ,\"ResultDesc\": \"报文参数不正确\",\"ResultData\":[]}";
                }

                #region 定义必填参数
                //必填项
                string[] str_RequiredDatas = new string[]
                {
                    "Serverpart_Name","Serverpart_Region",
                    "SectionFlow_Num","Serverpart_Flow","Statistics_Date"
                };
                #endregion

                #region 解析并检查传入的数据集合
                //解析传入的数据集合
                List<HighWay.SectionFlowModel> SectionFlowList = JsonConvert.DeserializeObject<List<HighWay.SectionFlowModel>>(jsonString);
                if (SectionFlowList == null || SectionFlowList.Count == 0)
                {
                    return "{\"ResultCode\": 200 ,\"ResultDesc\": \"报文参数不正确\",\"ResultData\":[]}";
                }
                for (int i = 0; i < SectionFlowList.Count; i++)
                {
                    foreach (var str_ColumnName in str_RequiredDatas)
                    {
                        if (SectionFlowList[i][str_ColumnName] == null || string.IsNullOrWhiteSpace(SectionFlowList[i][str_ColumnName].ToString()))
                        {
                            //检查必填参数是否未传入
                            return "{\"ResultCode\": 200 ,\"ResultDesc\": \"第" + (i + 1) +
                                "组数据，缺少必要参数：" + str_ColumnName + "\",\"ResultData\":[]}";
                        }
                    }
                    //设置数据上传时间
                    SectionFlowList[i].Operate_Date = long.Parse(DateTime.Now.ToString("yyyyMMddHHmmss"));
                    //默认数据状态为有效
                    if (SectionFlowList[i].SectionFlow_Status == null)
                    {
                        SectionFlowList[i].SectionFlow_Status = 1;
                    }
                }
                #endregion

                //批量插入数据到数据库
                OperationDataHelper<HighWay.SectionFlowModel>.InsertTableData(
                    _OracleHelper, SectionFlowList, "HIGHWAY_SELLDATA.T_SECTIONFLOW", true,
                    "SECTIONFLOW_ID", "HIGHWAY_SELLDATA.SEQ_SECTIONFLOW.NEXTVAL");

                return "{\"ResultCode\": 100 ,\"ResultDesc\": \"添加成功！\",\"ResultData\":[]}";
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"日结数据接收保存失败。原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"系统异常。\",\"ResultData\":[]}";
            }
        }
        #endregion

        #endregion

        #region 方法 -> PB系统营收数据压缩文件生成上传
        /// <summary>
        /// PB系统营收数据压缩文件生成上传
        /// </summary>
        /// <param name="serverpartCode">服务区编码</param>
        /// <param name="shopCode">门店编码</param>
        /// <param name="machineCode">收银机号</param>
        /// <param name="startDate">
        /// 起始时间
        /// <para>格式：yyyyMMddHHmmss</para>
        /// </param>
        /// <param name="endDate">
        /// 结束时间
        /// <para>格式：yyyyMMddHHmmss</para>
        /// </param>
        /// <returns></returns>
        [WebMethod]
        public string PBDataZipUpload(string serverpartCode, string shopCode, string machineCode, string startDate, string endDate)
        {
            //启动本地数据库
            try
            {
                string str_BaseDirectory = AppDomain.CurrentDomain.BaseDirectory;
                System.Diagnostics.Process.Start(
                    System.IO.Path.Combine(str_BaseDirectory, "Bin", "DataConverter.exe"),
                    $"{serverpartCode}|{shopCode}|{machineCode}|{startDate}|{endDate}");

                return "{\"ResultCode\": 100 ,\"ResultDesc\": \"启动成功！\",\"ResultData\":[]}";
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"PB系统数据压缩文件生成上传启动失败。原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"启动失败！\",\"ResultData\":[]}";
            }
        }
        #endregion

        #region 方法 -> 调用第三方移动支付接口
        /// <summary>
        /// 调用第三方移动支付接口
        /// </summary>
        /// <param name="requestURL"></param>
        /// <param name="postData"></param>
        /// <param name="contentType"></param>
        /// <returns></returns>
        [WebMethod]
        public string MobilePayProxy(string requestURL, string postData, string contentType)
        {
            if (string.IsNullOrWhiteSpace(contentType))
            {
                contentType = "application/x-www-form-urlencoded";
            }
            return HttpClientHelp.ESHttpClient.HttpUrlPost(postData, requestURL, contentType);
        }
        #endregion

        #region 安徽驿达相关接口

        #region 方法 -> 合同数据同步接口
        /// <summary>
        /// 合同数据同步接口
        /// </summary>
        /// <param name="code">授权码</param>
        /// <param name="jsonString">传输字符串</param>
        /// <returns></returns>
        [WebMethod]
        public string SynContrcat(string code, string jsonString)
        {
            try
            {
                //16684D3D52B39939 => 340000
                string codeDecrypt = code.ToDecrypt();
                if (!"340000".Equals(codeDecrypt))
                {
                    return "{\"ResultCode\": 201 ,\"ResultDesc\": \"授权码不正确\",\"ResultData\":[]}";
                }
            }
            catch (Exception ex)
            {
                LogUtil.WriteLog($"授权码解码失败。原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"授权码解码异常。\",\"ResultData\":[]}";
            }
            try
            {
                //先检查传入的参数是否为空数据包
                if (string.IsNullOrWhiteSpace(jsonString))
                {
                    return "{\"ResultCode\": 200 ,\"ResultDesc\": \"报文参数不正确\",\"ResultData\":[]}";
                }

                #region 定义必填参数
                //必填项
                string[] str_RequiredDatas = new string[]
                {
                    "Compact_Name",
                    "Firstpart_Name",
                    "Firstpart_Linkman",
                    "Secondpart_Name",
                    "Secondpart_Linkman",
                    "Compact_Startdate",
                    "Compact_Enddate",
                    "Compact_Amount",
                    "Securitydeposit",
                    "Attachment_Url",
                    "Business_Trade",
                    "Business_Brand",
                    "Business_Type",
                    "Operating_Scope",
                    "Rentfree_Startdate",
                    "Rentfree_Enddate",
                    "Decorate_Startdate",
                    "Decorate_Enddate",
                    "Erverpart_Names",
                    "Approve_State",
                    "Compact_State",
                    "Contract_Syn_Id",
                };
                #endregion

                #region 解析并检查传入的数据集合
                //解析传入的数据集合
                List<HighWay.ContractSynModel> list_ContractSyn_All =
                    Newtonsoft.Json.JsonConvert.DeserializeObject<List<HighWay.ContractSynModel>>(jsonString);
                if (list_ContractSyn_All == null || list_ContractSyn_All.Count == 0)
                {
                    return "{\"ResultCode\": 200 ,\"ResultDesc\": \"报文参数不正确\",\"ResultData\":[]}";
                }
                //问题数据列表
                List<HighWay.ContractSynModel> list_ContractSyn_Pro = new List<HighWay.ContractSynModel>();
                //缺少列集合
                List<string> str_Columns = new List<string>();
                for (int i = 0; i < list_ContractSyn_All.Count; i++)
                {
                    List<string> str_Columns_temp = new List<string>();
                    foreach (var str_ColumnName in str_RequiredDatas)
                    {
                        //检查必填参数是否未传入
                        if (list_ContractSyn_All[i][str_ColumnName] == null ||
                            string.IsNullOrWhiteSpace(list_ContractSyn_All[i][str_ColumnName].ToString()))
                        {
                            str_Columns_temp.Add(str_ColumnName);
                        }
                    }
                    if (str_Columns_temp.Count > 0)
                    {
                        list_ContractSyn_Pro.Add(list_ContractSyn_All[i]);
                        str_Columns.AddRange(str_Columns_temp);
                    }
                }
                if (list_ContractSyn_Pro.Count > 0)
                {
                    string strResultData = JsonConvert.SerializeObject(list_ContractSyn_Pro);
                    return "{\"ResultCode\": 200 ,\"ResultDesc\": \"缺少必要参数：" + string.Join(",", str_Columns.Distinct()) + "\",\"ResultData\":" + strResultData + "}";
                }
                #endregion

                string _BaseUrl = ConfigurationManager.AppSettings["ApiUrl"];
                _BaseUrl += "/EShangApiMain/Contract/SynchroContractSyn";
                string format = "application/json;charset=UTF-8";
                string reString = WebService.SDK.CommonHelper.HttpUrlPost(jsonString, _BaseUrl, format, 0);

                JObject _JObject = JObject.Parse(reString);
                switch (_JObject["Result_Code"].ToString())
                {
                    case "100":
                        return "{\"ResultCode\": 100 ,\"ResultDesc\": \"同步数据成功！\",\"ResultData\":[]}";
                    case "200":
                        return "{\"ResultCode\": 200 ,\"ResultDesc\": \"保存数据失败！\",\"ResultData\":[]}";
                    case "999":
                        return "{\"ResultCode\": 999 ,\"ResultDesc\": \"" + _JObject["Result_Desc"] + "\",\"ResultData\":[]}";
                    default:
                        return "{\"ResultCode\": 200 ,\"ResultDesc\": \"未知错误！\",\"ResultData\":[]}";
                }
            }
            catch (Exception ex)
            {
                LogUtil.WriteLog($"合同数据同步失败。原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"系统异常。\",\"ResultData\":[]}";
            }
        }
        #endregion

        #region 方法 -> 回写票据开票结果信息
        /// <summary>
        /// 回写票据开票结果信息
        /// </summary>
        /// <param name="code">授权码</param>
        /// <param name="jsonString">传输字符串</param>
        /// <returns></returns>
        [WebMethod]
        public string WriteBackInvoice(string code, string jsonString)
        {
            JObject resultInfo = new JObject();

            if (code != "340000".ToEncrypt())
            {
                resultInfo["ResultCode"] = 201;
                resultInfo["ResultDesc"] = "授权码不正确";

                return resultInfo.ToString();
            }

            try
            {
                LogUtil.WriteLog($"开票信息回写入参：{ jsonString }");
                //先检查传入的参数是否为空数据包
                if (string.IsNullOrWhiteSpace(jsonString))
                {
                    resultInfo["ResultCode"] = 200;
                    resultInfo["ResultDesc"] = "请传入报文参数";

                    return resultInfo.ToString();
                }

                #region 定义必填参数
                //必填项
                string[] _RequiredDatas = new string[]
                {
                    "BillNo",
                    "SerialNo",
                    "BillAmount",
                    "BillDate",
                    "DownloadUrl",
                };
                #endregion

                #region 解析并检查传入的参数
                string postData = "";
                List<string> str_Columns = new List<string>();
                JObject _Json = JObject.Parse(jsonString);
                foreach (string _RequiredData in _RequiredDatas)
                {
                    if (_Json.Property(_RequiredData) == null ||
                        string.IsNullOrWhiteSpace(_Json.Property(_RequiredData).Value + ""))
                    {
                        str_Columns.Add(_RequiredData);
                    }
                    else
                    {
                        postData += (postData == "" ? "" : "&") + _RequiredData + "=" + _Json[_RequiredData];
                    }
                }
                if (str_Columns.Count > 0)
                {
                    resultInfo["ResultCode"] = 200;
                    resultInfo["ResultDesc"] = "缺少必要参数：" + string.Join(",", str_Columns.Distinct());

                    return resultInfo.ToString();
                }
                #endregion

                string baseUrl = ConfigurationManager.AppSettings["ApiUrl"] + "/EShangApiMain/Invoice/WriteBackInvoice";
                string reString = WebService.SDK.CommonHelper.HttpUrlPost(jsonString, baseUrl, "application/json; charset=utf-8");

                JObject _JObject = JObject.Parse(reString);
                switch (_JObject["Result_Code"].ToString())
                {
                    case "100":
                    case "999":
                        resultInfo["ResultCode"] = _JObject["Result_Code"];
                        resultInfo["ResultDesc"] = _JObject["Result_Desc"];
                        break;
                    default:
                        resultInfo["ResultCode"] = 300;
                        resultInfo["ResultDesc"] = _JObject["Result_Desc"];
                        break;
                }
            }
            catch (Exception ex)
            {
                LogUtil.WriteLog($"开票信息回写失败。原因：{ex.Message}");
                resultInfo["ResultCode"] = 999;
                resultInfo["ResultDesc"] = "回写失败，报文参数格式不正确";
            }

            return resultInfo.ToString();
        }
        #endregion

        #region 方法 -> 获取微信会员信息
        /// <summary>
        /// 获取会员信息
        /// </summary>
        /// <param name="jsonString"></param>
        /// <returns></returns>
        [WebMethod]
        public string GetWeChatMembershipInfo(string code, string jsonString)
        {
            JObject resultInfo = new JObject();

            if (code != "wx4c497eddcec4a0e7".ToEncrypt())
            {
                resultInfo["ResultCode"] = 201;
                resultInfo["ResultDesc"] = "授权码不正确";

                return resultInfo.ToString();
            }

            try
            {
                LogUtil.WriteLog($"获取微信会员信息入参：{ jsonString }");
                //先检查传入的参数是否为空数据包
                if (string.IsNullOrWhiteSpace(jsonString))
                {
                    resultInfo["ResultCode"] = 200;
                    resultInfo["ResultDesc"] = "请传入报文参数";

                    return resultInfo.ToString();
                }

                #region 必填项验证
                string[] _RequiredDatas = { "WeChatPhone", "WeChatUnionID" };

                Dictionary<string, string> _Dictionary = new Dictionary<string, string>();
                if (!string.IsNullOrEmpty(jsonString))
                {
                    int EmptyCount = 0; //非必填项未传参数量
                    JObject _Json = JObject.Parse(jsonString);
                    foreach (string _RequiredData in _RequiredDatas)
                    {
                        if (_Json.Property(_RequiredData) == null)
                        {
                            switch (_RequiredData)
                            {
                                case "WeChatPhone":
                                case "WeChatUnionID":
                                    EmptyCount++;
                                    if (EmptyCount == 2)
                                    {
                                        resultInfo["ResultCode"] = 200;
                                        resultInfo["ResultDesc"] = "查询失败：JSON缺少必要查询参数：WeChatPhone";

                                        return resultInfo.ToString();
                                    }
                                    _Dictionary.Add(_RequiredData, "");
                                    break;
                                default:
                                    resultInfo["ResultCode"] = 200;
                                    resultInfo["ResultDesc"] = "查询失败：JSON缺少必要查询参数：" + _RequiredData;

                                    return resultInfo.ToString();
                            }
                        }
                        else if (_RequiredData.ToLower() != "sign")
                        {
                            _Dictionary.Add(_RequiredData, _Json[_RequiredData].ToString());
                        }
                    }
                }
                else
                {
                    resultInfo["ResultCode"] = 200;
                    resultInfo["ResultDesc"] = "查询失败：JSON参数解析异常";

                    return resultInfo.ToString();
                }
                #endregion

                //查询会员信息
                string _BaseUrl = ConfigurationManager.AppSettings["ApiUrl"];
                _BaseUrl += "/OpenApi/GetMemberInfo";
                StringBuilder sb = new StringBuilder();
                sb.AppendFormat("?Membership_Phone={0}", _Dictionary["WeChatPhone"].ToString());
                sb.AppendFormat("&ownerUnitId={0}", "249");//安徽驿达会员
                string parameters = sb.ToString();
                string RequestUrl = _BaseUrl + parameters;
                string format = "application/json;charset=UTF-8";
                string reString = WebService.SDK.CommonHelper.HttpUrlPost(parameters, RequestUrl, format, 0);

                JObject _JObject = JObject.Parse(reString);
                switch (_JObject["Result_Code"].ToString())
                {
                    case "100":
                        resultInfo["ResultCode"] = 100;
                        resultInfo["ResultDesc"] = "查询成功";
                        resultInfo["ResultData"] = new JObject
                        {
                            ["Membership_Type"] = _JObject["Result_Data"]["Membership_Type"],
                            ["Membership_Level"] = _JObject["Result_Data"]["Membership_Level"],
                            ["Membership_Code"] = _JObject["Result_Data"]["Membership_Card"],
                            ["Membership_Name"] = _JObject["Result_Data"]["Membership_Name"],
                            ["Membership_Sex"] = _JObject["Result_Data"]["Membership_Sex"],
                            ["Membership_Birthday"] = _JObject["Result_Data"]["Membership_Birthday"],
                            ["Membership_MobilePhone"] = _JObject["Result_Data"]["Membership_Mobilephone"],
                            ["Membership_Address"] = _JObject["Result_Data"]["Membership_Address"],
                            ["Membership_Point"] = _JObject["Result_Data"]["Membership_Point"],
                            ["Account_Balance"] = _JObject["Result_Data"]["Account_Balance"],
                        };

                        return resultInfo.ToString();
                    default:
                        resultInfo["ResultCode"] = 101;
                        resultInfo["ResultDesc"] = "查询成功！无会员信息";

                        return resultInfo.ToString();
                }
            }
            catch (Exception ex)
            {
                LogUtil.WriteLog(ex.Message);
                resultInfo["ResultCode"] = 999;
                resultInfo["ResultDesc"] = "查询失败：参数不正确";

                return resultInfo.ToString();
            }
        }
        #endregion

        #region 方法 -> 同步会员
        /// <summary>
        /// 同步会员
        /// </summary>
        /// <param name="jsonString"></param>
        /// <returns></returns>
        [WebMethod]
        public string SysncMember(string code, string jsonString)
        {
            JObject resultInfo = new JObject();

            if (code != "wx4c497eddcec4a0e7".ToEncrypt())
            {
                resultInfo["ResultCode"] = 201;
                resultInfo["ResultDesc"] = "授权码不正确";

                return resultInfo.ToString();
            }

            try
            {
                LogUtil.WriteLog($"获取微信会员信息入参：{ jsonString }");
                //先检查传入的参数是否为空数据包
                if (string.IsNullOrWhiteSpace(jsonString))
                {
                    resultInfo["ResultCode"] = 200;
                    resultInfo["ResultDesc"] = "请传入报文参数";

                    return resultInfo.ToString();
                }

                #region 必填项验证
                string[] _RequiredDatas = { "WeChatPhone", "Membership_Name", "Membership_Sex", "Membership_Point" };

                Dictionary<string, string> _Dictionary = new Dictionary<string, string>();
                if (!string.IsNullOrEmpty(jsonString))
                {
                    JObject _Json = JObject.Parse(jsonString);
                    foreach (string _RequiredData in _RequiredDatas)
                    {
                        if (_Json.Property(_RequiredData) == null)
                        {
                            resultInfo["ResultCode"] = 200;
                            resultInfo["ResultDesc"] = "查询失败：JSON缺少必要参数：" + _RequiredData;

                            return resultInfo.ToString();
                        }
                        else if (_RequiredData.ToLower() != "sign")
                        {
                            _Dictionary.Add(_RequiredData, _Json[_RequiredData].ToString());
                        }
                    }
                }
                else
                {
                    resultInfo["ResultCode"] = 200;
                    resultInfo["ResultDesc"] = "查询失败：JSON参数解析异常";

                    return resultInfo.ToString();
                }
                #endregion

                #region 参数定义
                //业主单位
                int OwnerUnitId = 249;
                try
                {
                    OwnerUnitId = Convert.ToInt32(ConfigurationManager.AppSettings["OwnerUnitId"]);
                }
                catch { }
                #endregion

                #region 同步会员
                //根据授权码获取接口来源
                string staffName = "驿佳小程序";

                string _BaseUrl = ConfigurationManager.AppSettings["ApiUrl"];
                _BaseUrl += "/OpenApi/SysncMember";
                StringBuilder sb = new StringBuilder();
                sb.AppendFormat("?MembershipPhone={0}", _Dictionary["WeChatPhone"]);
                sb.AppendFormat("&MembershipName={0}", _Dictionary["Membership_Name"]);
                sb.AppendFormat("&membershipSex={0}", _Dictionary["Membership_Sex"]);
                sb.AppendFormat("&membershipPoint={0}", _Dictionary["Membership_Point"]);
                sb.AppendFormat("&staffName={0}", staffName);
                sb.AppendFormat("&OwnerUnitId={0}", OwnerUnitId);
                string parameters = sb.ToString();
                string RequestUrl = _BaseUrl + parameters;
                string format = "application/json;charset=UTF-8";
                string reString = WebService.SDK.CommonHelper.HttpUrlPost(parameters, RequestUrl, format, 0);

                JObject _JObject = JObject.Parse(reString);
                switch (_JObject["Result_Code"].ToString())
                {
                    case "100":
                        resultInfo["ResultCode"] = 100;
                        resultInfo["ResultDesc"] = "新增成功";
                        resultInfo["ResultData"] = new JObject
                        {
                            ["Membership_Name"] = _Dictionary["Membership_Name"].ToString(),
                            ["Membership_MobilePhone"] = _Dictionary["WeChatPhone"].ToString(),
                            ["Membership_Point"] = _JObject["Result_Data"]["Membership_Point"],
                            ["Account_Balance"] = _JObject["Result_Data"]["Account_Balance"],
                        };
                        
                        return resultInfo.ToString();
                    default:
                        resultInfo["ResultCode"] = _JObject["Result_Code"];
                        resultInfo["ResultDesc"] = _JObject["Result_Desc"];

                        return resultInfo.ToString();
                }
                #endregion
            }
            catch (Exception ex)
            {
                LogUtil.WriteLog(ex.Message);
                resultInfo["ResultCode"] = 999;
                resultInfo["ResultDesc"] = "新增失败：参数不正确";

                return resultInfo.ToString();
            }
        }
        #endregion

        #region 方法 -> 同步商城精选商品
        /// <summary>
        /// 同步商城精选商品
        /// </summary>
        /// <param name="code">授权码</param>
        /// <param name="jsonString">传输字符串</param>
        /// <returns></returns>
        [WebMethod]
        public string SynchroProduct(string code, string jsonString)
        {
            JObject resultInfo = new JObject();

            if (code != "wx4c497eddcec4a0e7".ToEncrypt())
            {
                resultInfo["ResultCode"] = 201;
                resultInfo["ResultDesc"] = "授权码不正确";

                return resultInfo.ToString();
            }

            try
            {
                LogUtil.WriteLog($"同步商城精选商品入参：{ jsonString }");
                //先检查传入的参数是否为空数据包
                if (string.IsNullOrWhiteSpace(jsonString))
                {
                    resultInfo["ResultCode"] = 200;
                    resultInfo["ResultDesc"] = "请传入报文参数";

                    return resultInfo.ToString();
                }

                #region 定义必填参数
                //必填项
                string[] _RequiredDatas = new string[]
                {
                    "ItemName",
                    "ItemBarCode",
                    "ImageUrl",
                    "ItemIndex",
                    "ProductRetailPrice",
                    "UpperState",
                };
                #endregion

                #region 解析并检查传入的数据集合
                //解析传入的数据集合
                List<Model.SelectedProductModel> list_ProductSyn_All =
                    JsonConvert.DeserializeObject<List<Model.SelectedProductModel>>(jsonString);
                if (list_ProductSyn_All == null || list_ProductSyn_All.Count == 0)
                {
                    resultInfo["ResultCode"] = 200;
                    resultInfo["ResultDesc"] = "报文参数不正确";

                    return resultInfo.ToString();
                }
                //问题数据列表
                List<Model.SelectedProductModel> list_ProductSyn_Pro = new List<Model.SelectedProductModel>();
                //缺少列集合
                List<string> str_Columns = new List<string>();
                for (int i = 0; i < list_ProductSyn_All.Count; i++)
                {
                    List<string> str_Columns_temp = new List<string>();
                    foreach (var str_ColumnName in _RequiredDatas)
                    {
                        //检查必填参数是否未传入
                        if (list_ProductSyn_All[i][str_ColumnName] == null ||
                            string.IsNullOrWhiteSpace(list_ProductSyn_All[i][str_ColumnName].ToString()))
                        {
                            str_Columns_temp.Add(str_ColumnName);
                        }
                    }
                    if (str_Columns_temp.Count > 0)
                    {
                        list_ProductSyn_Pro.Add(list_ProductSyn_All[i]);
                        str_Columns.AddRange(str_Columns_temp);
                    }
                    else
                    {
                        list_ProductSyn_All[i].WechatAppSignAppId = code.ToDecrypt();
                    }
                }
                if (list_ProductSyn_Pro.Count > 0)
                {
                    resultInfo["ResultCode"] = 200;
                    resultInfo["ResultDesc"] = "缺少必要参数：" + string.Join(",", str_Columns.Distinct());
                    resultInfo["ResultData"] = JsonConvert.SerializeObject(list_ProductSyn_Pro);

                    return resultInfo.ToString();
                }
                #endregion

                string baseUrl = ConfigurationManager.AppSettings["ApiUrl"] + "/EShangApiMain/WeChatMall/TransferProduct";
                string reString = WebService.SDK.CommonHelper.HttpUrlPost(JsonConvert.SerializeObject(
                    list_ProductSyn_All), baseUrl, "application/json; charset=utf-8");

                JObject _JObject = JObject.Parse(reString);
                switch (_JObject["Result_Code"].ToString())
                {
                    case "100":
                    case "999":
                        resultInfo["ResultCode"] = _JObject["Result_Code"];
                        resultInfo["ResultDesc"] = _JObject["Result_Desc"];
                        break;
                    default:
                        resultInfo["ResultCode"] = 300;
                        resultInfo["ResultDesc"] = _JObject["Result_Desc"];
                        break;
                }
            }
            catch (Exception ex)
            {
                LogUtil.WriteLog($"同步商城精选商品失败。原因：{ex.Message}");
                resultInfo["ResultCode"] = 999;
                resultInfo["ResultDesc"] = "同步失败，报文参数格式不正确";
            }

            return resultInfo.ToString();
        }
        #endregion

        #region 方法 -> 同步商城订单数据
        /// <summary>
        /// 同步商城订单数据
        /// </summary>
        /// <param name="code">授权码</param>
        /// <param name="jsonString">传输字符串</param>
        /// <returns></returns>
        [WebMethod]
        public string SynchroOrderBill(string code, string jsonString)
        {
            JObject resultInfo = new JObject();

            if (code != "wx4c497eddcec4a0e7".ToEncrypt())
            {
                resultInfo["ResultCode"] = 201;
                resultInfo["ResultDesc"] = "授权码不正确";

                return resultInfo.ToString();
            }

            try
            {
                LogUtil.WriteLog($"同步商城订单数据入参：{ jsonString }");
                //先检查传入的参数是否为空数据包
                if (string.IsNullOrWhiteSpace(jsonString))
                {
                    resultInfo["ResultCode"] = 200;
                    resultInfo["ResultDesc"] = "请传入报文参数";

                    return resultInfo.ToString();
                }

                #region 定义必填参数
                //必填项
                string[] _RequiredDatas = new string[]
                {
                    "OrderCode",
                    "OrderPerson",
                    "PhoneNumber",
                    "OrderDate",
                    "OrderCount",
                    "OrderAmount",
                    "OrderState",
                    "ReceivePerson",
                    "ReceivePersonTel",
                    "ReceiveAddress",
                    "ReceiveDoorPlate",
                    "PayMethod",
                    "PayState",
                    "DetailList",
                };
                #endregion

                #region 解析并检查传入的数据集合
                //解析传入的数据集合
                Model.HighWay.OrderModel orderModel = JsonConvert.DeserializeObject<Model.HighWay.OrderModel>(jsonString);
                if (orderModel == null)
                {
                    resultInfo["ResultCode"] = 200;
                    resultInfo["ResultDesc"] = "报文参数不正确";

                    return resultInfo.ToString();
                }

                //缺少列集合
                List<string> str_Columns = new List<string>();
                foreach (var str_ColumnName in _RequiredDatas)
                {
                    //检查必填参数是否未传入
                    if (str_ColumnName == "DetailList")
                    {
                        if (orderModel[str_ColumnName] == null || orderModel.DetailList.Count == 0)
                        {
                            str_Columns.Add(str_ColumnName);
                        }
                    }
                    else if (orderModel[str_ColumnName] == null ||
                        string.IsNullOrWhiteSpace(orderModel[str_ColumnName].ToString()))
                    {
                        str_Columns.Add(str_ColumnName);
                    }
                }

                orderModel.WechatAppSignAppId = code.ToDecrypt();

                if (str_Columns.Count > 0)
                {
                    resultInfo["ResultCode"] = 200;
                    resultInfo["ResultDesc"] = "缺少必要参数：" + string.Join(",", str_Columns.Distinct());

                    return resultInfo.ToString();
                }
                #endregion

                string baseUrl = ConfigurationManager.AppSettings["ApiUrl"] + "/EShangApiMain/OnlineOrder/SynchroOrderBill";
                string reString = WebService.SDK.CommonHelper.HttpUrlPost(jsonString, baseUrl, "application/json; charset=utf-8");

                JObject _JObject = JObject.Parse(reString);
                switch (_JObject["Result_Code"].ToString())
                {
                    case "100":
                    case "999":
                        resultInfo["ResultCode"] = _JObject["Result_Code"];
                        resultInfo["ResultDesc"] = _JObject["Result_Desc"];
                        break;
                    default:
                        resultInfo["ResultCode"] = 300;
                        resultInfo["ResultDesc"] = _JObject["Result_Desc"];
                        break;
                }
            }
            catch (Exception ex)
            {
                LogUtil.WriteLog($"同步商城订单数据失败。原因：{ex.Message}");
                resultInfo["ResultCode"] = 999;
                resultInfo["ResultDesc"] = "同步失败，报文参数格式不正确";
            }

            return resultInfo.ToString();
        }
        #endregion

        #region 方法 -> 同步会员积分
        /// <summary>
        /// 同步会员积分
        /// </summary>
        /// <param name="jsonString"></param>
        /// <returns></returns>
        [WebMethod]
        public string SysncMemberPoint(string code, string jsonString)
        {
            JObject resultInfo = new JObject();

            if (code != "wx4c497eddcec4a0e7".ToEncrypt())
            {
                resultInfo["ResultCode"] = 201;
                resultInfo["ResultDesc"] = "授权码不正确";

                return resultInfo.ToString();
            }

            try
            {
                LogUtil.WriteLog($"同步会员积分入参：{ jsonString }");
                //先检查传入的参数是否为空数据包
                if (string.IsNullOrWhiteSpace(jsonString))
                {
                    resultInfo["ResultCode"] = 200;
                    resultInfo["ResultDesc"] = "请传入报文参数";

                    return resultInfo.ToString();
                }

                #region 必填项验证
                string[] _RequiredDatas = { "WeChatPhone", "ChangePoint", "ChangePointDesc" };

                Dictionary<string, string> _Dictionary = new Dictionary<string, string>();
                if (!string.IsNullOrEmpty(jsonString))
                {
                    JObject _Json = JObject.Parse(jsonString);
                    foreach (string _RequiredData in _RequiredDatas)
                    {
                        if (_Json.Property(_RequiredData) == null)
                        {
                            resultInfo["ResultCode"] = 200;
                            resultInfo["ResultDesc"] = "查询失败：JSON缺少必要参数：" + _RequiredData;

                            return resultInfo.ToString();
                        }
                        else if (_RequiredData.ToLower() != "sign")
                        {
                            _Dictionary.Add(_RequiredData, _Json[_RequiredData].ToString());
                        }
                    }
                }
                else
                {
                    resultInfo["ResultCode"] = 200;
                    resultInfo["ResultDesc"] = "查询失败：JSON参数解析异常";

                    return resultInfo.ToString();
                }
                #endregion

                #region 参数定义
                //业主单位
                int OwnerUnitId = 249;
                try
                {
                    OwnerUnitId = Convert.ToInt32(ConfigurationManager.AppSettings["OwnerUnitId"]);
                }
                catch { }
                #endregion

                #region 同步会员积分
                string _BaseUrl = ConfigurationManager.AppSettings["ApiUrl"];
                _BaseUrl += "/OpenApi/SysncMemberPoint";
                StringBuilder sb = new StringBuilder();
                sb.AppendFormat("?MembershipPhone={0}", _Dictionary["WeChatPhone"]);
                sb.AppendFormat("&ChangePointType={0}", "7001");//那美营销
                sb.AppendFormat("&ChangePointDesc={0}", _Dictionary["ChangePointDesc"]);//改变积分类型描述
                sb.AppendFormat("&ChangePoint={0}", _Dictionary["ChangePoint"]);
                sb.AppendFormat("&OwnerUnitId={0}", OwnerUnitId);
                string parameters = sb.ToString();
                string RequestUrl = _BaseUrl + parameters;
                string format = "application/json;charset=UTF-8";
                string reString = WebService.SDK.CommonHelper.HttpUrlPost(parameters, RequestUrl, format, 0);
                WebService.SDK.LogHelper.WriteSendLog("SysncMemberPoint" + RequestUrl + "||" + reString);
                JObject _JObject = JObject.Parse(reString);

                switch (_JObject["Result_Code"].ToString())
                {
                    case "100":
                        resultInfo["ResultCode"] = 100;
                        resultInfo["ResultDesc"] = "同步积分成功";
                        //resultInfo["ResultData"] = new JObject
                        //{
                        //    ["Membership_MobilePhone"] = _Dictionary["WeChatPhone"].ToString(),
                        //    ["ChangePoint"] = _Dictionary["ChangePoint"].ToString(),
                        //    ["Membership_Point"] = _JObject["Result_Data"]["Membership_Point"],
                        //};

                        return resultInfo.ToString();
                    default:
                        resultInfo["ResultCode"] = _JObject["Result_Code"];
                        resultInfo["ResultDesc"] = _JObject["Result_Desc"];

                        return resultInfo.ToString();
                }
                #endregion
            }
            catch (Exception ex)
            {
                LogUtil.WriteLog(ex.Message);
                resultInfo["ResultCode"] = 999;
                resultInfo["ResultDesc"] = "新增失败：参数不正确";

                return resultInfo.ToString();
            }
        }
        #endregion

        #region 方法 -> 存储充换电实时状态数据

        #endregion

        #endregion

        #region 四川大数据相关接口

        #region 方法 -> 获取营收同比分析
        /// <summary>
        /// 获取营收同比分析
        /// </summary>
        /// <param name="code">授权码</param>
        /// <param name="jsonString">传输字符串</param>
        /// <returns></returns>
        [WebMethod]
        public string GetYOYCompare(string code, string jsonString)
        {
            string codeDecrypt;
            try
            {
                codeDecrypt = code.ToDecrypt();
                if (codeDecrypt != "3760")
                {
                    return "{\"ResultCode\": 201 ,\"ResultDesc\": \"授权码不正确\",\"ResultData\":[]}";
                }
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"授权码解码失败。原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"授权码解码异常。\",\"ResultData\":[]}";
            }
            try
            {
                //先检查传入的参数是否为空数据包
                //if (string.IsNullOrWhiteSpace(jsonString))
                //{
                //    return "{\"ResultCode\": 200 ,\"ResultDesc\": \"报文参数为空\",\"ResultData\":\"" + jsonString + "\"}";
                //}

                string _BaseUrl = ConfigurationManager.AppSettings["AjaxUrl"];
                string _PostData = "action_type=GetYOYCompare&province_code=" + codeDecrypt +
                    "&statistics_Date=" + DateTime.Now.ToShortDateString();
                string reString = WebService.SDK.CommonHelper.HttpUrlPost(_PostData, _BaseUrl + "?" + _PostData);

                JObject _JObject = JObject.Parse(reString);
                switch (_JObject["ResultCode"].ToString())
                {
                    case "100":
                        return "{\"ResultCode\": 100 ,\"ResultDesc\": \"" + _JObject["ResultDesc"] +
                            "\",\"ResultData\":" + _JObject["ResultData"] + "}";
                    default:
                        return "{\"ResultCode\": " + _JObject["ResultCode"] + " ,\"ResultDesc\": \"" + _JObject["ResultDesc"] +
                            "\",\"ResultData\":[]}";
                }
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"获取营收同比分析失败，原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"系统异常。\",\"ResultData\":[]}";
            }
        }
        #endregion

        #region 方法 -> 获取门店营收排行
        /// <summary>
        /// 获取门店营收排行
        /// </summary>
        /// <param name="code">授权码</param>
        /// <param name="jsonString">传输字符串</param>
        /// <returns></returns>
        [WebMethod]
        public string GetRevenueRank(string code, string jsonString)
        {
            string codeDecrypt;
            try
            {
                codeDecrypt = code.ToDecrypt();
                if (codeDecrypt != "3760")
                {
                    return "{\"ResultCode\": 201 ,\"ResultDesc\": \"授权码不正确\",\"ResultData\":[]}";
                }
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"授权码解码失败。原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"授权码解码异常。\",\"ResultData\":[]}";
            }
            try
            {
                //先检查传入的参数是否为空数据包
                //if (string.IsNullOrWhiteSpace(jsonString))
                //{
                //    return "{\"ResultCode\": 200 ,\"ResultDesc\": \"报文参数为空\",\"ResultData\":\"" + jsonString + "\"}";
                //}

                string _BaseUrl = ConfigurationManager.AppSettings["AjaxUrl"];
                string _PostData = "action_type=getCurShopRevenueRank&ProvinceCode=" + 510000 + "&ReRowCount=" + 9999;
                string reString = WebService.SDK.CommonHelper.HttpUrlPost(_PostData, _BaseUrl + "?" + _PostData);

                JObject _JObject = JObject.Parse(reString);
                switch (_JObject["ResultCode"].ToString())
                {
                    case "100":
                        return "{\"ResultCode\": 100 ,\"ResultDesc\": \"" + _JObject["ResultDesc"] +
                            "\",\"ResultData\":" + _JObject["Data"]["List"] + "}";
                    default:
                        return "{\"ResultCode\": " + _JObject["ResultCode"] + " ,\"ResultDesc\": \"" + _JObject["ResultDesc"] +
                            "\",\"ResultData\":[]}";
                }
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"获取小吃营收排行，原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"系统异常。\",\"ResultData\":[]}";
            }
        }
        #endregion

        #region 方法 -> 获取单品销售排行
        /// <summary>
        /// 获取单品销售排行
        /// </summary>
        /// <param name="code">授权码</param>
        /// <param name="jsonString">传输字符串</param>
        /// <returns></returns>
        [WebMethod]
        public string GetCommoditySaleRank(string code, string jsonString)
        {
            string codeDecrypt;
            try
            {
                codeDecrypt = code.ToDecrypt();
                if (codeDecrypt != "3760")
                {
                    return "{\"ResultCode\": 201 ,\"ResultDesc\": \"授权码不正确\",\"ResultData\":[]}";
                }
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"授权码解码失败。原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"授权码解码异常。\",\"ResultData\":[]}";
            }
            try
            {
                //先检查传入的参数是否为空数据包
                //if (string.IsNullOrWhiteSpace(jsonString))
                //{
                //    return "{\"ResultCode\": 200 ,\"ResultDesc\": \"报文参数为空\",\"ResultData\":\"" + jsonString + "\"}";
                //}

                string _BaseUrl = ConfigurationManager.AppSettings["AjaxUrl"];
                string _PostData = "action_type=getCommoditySaleSort&province_code=" + codeDecrypt +
                    "&statDay=" + DateTime.Now.AddDays(-1).ToShortDateString() + "," + DateTime.Now.ToShortDateString() +
                    "&rowNum=" + 10 + "&hasAsc=false";
                string reString = WebService.SDK.CommonHelper.HttpUrlPost(_PostData, _BaseUrl + "?" + _PostData);

                JObject _JObject = JObject.Parse(reString);
                if (_JObject["COMMODITYSALE_DESC"].TryParseToString() != "")
                {
                    return "{\"ResultCode\": 100 ,\"ResultDesc\": \"" + _JObject["ResultDesc"] +
                        "\",\"ResultData\":" + _JObject["COMMODITYSALE_DESC"] + "}";
                }
                else
                {
                    return "{\"ResultCode\": 101,\"ResultDesc\": \"查询失败，无数据返回\",\"ResultData\":[]}";
                }
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"获取小吃营收排行，原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"系统异常。\",\"ResultData\":[]}";
            }
        }
        #endregion

        #region 方法 -> 获取当日实时营收
        /// <summary>
        /// 获取当日实时营收
        /// </summary>
        /// <param name="code">授权码</param>
        /// <param name="jsonString">传输字符串</param>
        /// <returns></returns>
        [WebMethod]
        public string GetCurRevenue(string code, string jsonString)
        {
            string codeDecrypt;
            try
            {
                codeDecrypt = code.ToDecrypt();
                if (codeDecrypt != "3760")
                {
                    return "{\"ResultCode\": 201 ,\"ResultDesc\": \"授权码不正确\",\"ResultData\":[]}";
                }
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"授权码解码失败。原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"授权码解码异常。\",\"ResultData\":[]}";
            }
            try
            {
                //先检查传入的参数是否为空数据包
                //if (string.IsNullOrWhiteSpace(jsonString))
                //{
                //    return "{\"ResultCode\": 200 ,\"ResultDesc\": \"报文参数为空\",\"ResultData\":\"" + jsonString + "\"}";
                //}

                string _BaseUrl = ConfigurationManager.AppSettings["AjaxUrl"];
                string _PostData = "action_type=getServerConnect&province_code=" + codeDecrypt;
                string reString = WebService.SDK.CommonHelper.HttpUrlPost(_PostData, _BaseUrl + "?" + _PostData);

                JObject _JObject = JObject.Parse(reString);
                if (_JObject["CurrentData"].TryParseToString() != "")
                {
                    return "{\"ResultCode\": 100 ,\"ResultDesc\": \"" + _JObject["ResultDesc"] +
                        "\",\"ResultData\":" + _JObject["CurrentData"] + "}";
                }
                else
                {
                    return "{\"ResultCode\": 101,\"ResultDesc\": \"查询失败，无数据返回\",\"ResultData\":[]}";
                }
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"获取当日实时营收失败，原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"系统异常。\",\"ResultData\":[]}";
            }
        }
        #endregion

        #region 方法 -> 获取业态营收占比
        /// <summary>
        /// 获取业态营收占比
        /// </summary>
        /// <param name="code">授权码</param>
        /// <param name="jsonString">传输字符串</param>
        /// <returns></returns>
        [WebMethod]
        public string GetCurBusinessTradeRatio(string code, string jsonString)
        {
            string codeDecrypt;
            try
            {
                codeDecrypt = code.ToDecrypt();
                if (codeDecrypt != "3760")
                {
                    return "{\"ResultCode\": 201 ,\"ResultDesc\": \"授权码不正确\",\"ResultData\":[]}";
                }
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"授权码解码失败。原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"授权码解码异常。\",\"ResultData\":[]}";
            }
            try
            {
                //先检查传入的参数是否为空数据包
                //if (string.IsNullOrWhiteSpace(jsonString))
                //{
                //    return "{\"ResultCode\": 200 ,\"ResultDesc\": \"报文参数为空\",\"ResultData\":\"" + jsonString + "\"}";
                //}

                string _BaseUrl = ConfigurationManager.AppSettings["AjaxUrl"];
                string _PostData = "action_type=getRevenueRatioByBusinessType&province_code=" + codeDecrypt;
                string reString = WebService.SDK.CommonHelper.HttpUrlPost(_PostData, _BaseUrl + "?" + _PostData);

                JObject _JObject = JObject.Parse(reString);
                if (_JObject["CurrentData"].TryParseToString() != "")
                {
                    return "{\"ResultCode\": 100 ,\"ResultDesc\": \"" + _JObject["ResultDesc"] +
                        "\",\"ResultData\":" + _JObject["CurrentData"] + "}";
                }
                else
                {
                    return "{\"ResultCode\": 101,\"ResultDesc\": \"查询失败，无数据返回\",\"ResultData\":[]}";
                }
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"获取业态营收占比失败，原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"系统异常。\",\"ResultData\":[]}";
            }
        }
        #endregion

        #region 方法 -> 获取区域营收占比
        /// <summary>
        /// 获取区域营收占比
        /// </summary>
        /// <param name="code">授权码</param>
        /// <param name="jsonString">传输字符串</param>
        /// <returns></returns>
        [WebMethod]
        public string GetCurRegionRevenueRatio(string code, string jsonString)
        {
            string codeDecrypt;
            try
            {
                codeDecrypt = code.ToDecrypt();
                if (codeDecrypt != "3760")
                {
                    return "{\"ResultCode\": 201 ,\"ResultDesc\": \"授权码不正确\",\"ResultData\":[]}";
                }
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"授权码解码失败。原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"授权码解码异常。\",\"ResultData\":[]}";
            }
            try
            {
                //先检查传入的参数是否为空数据包
                //if (string.IsNullOrWhiteSpace(jsonString))
                //{
                //    return "{\"ResultCode\": 200 ,\"ResultDesc\": \"报文参数为空\",\"ResultData\":\"" + jsonString + "\"}";
                //}

                string _BaseUrl = ConfigurationManager.AppSettings["AjaxUrl"];
                string _PostData = "action_type=GetCurrentAmountByRegion&province_code=" + codeDecrypt;
                string reString = WebService.SDK.CommonHelper.HttpUrlPost(_PostData, _BaseUrl + "?" + _PostData);

                JObject _JObject = JObject.Parse(reString);
                if (_JObject["CurrentData"].TryParseToString() != "")
                {
                    return "{\"ResultCode\": 100 ,\"ResultDesc\": \"" + _JObject["ResultDesc"] +
                        "\",\"ResultData\":" + _JObject["CurrentData"] + "}";
                }
                else
                {
                    return "{\"ResultCode\": 101,\"ResultDesc\": \"查询失败，无数据返回\",\"ResultData\":[]}";
                }
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"获取区域营收占比失败，原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"系统异常。\",\"ResultData\":[]}";
            }
        }
        #endregion

        #region 方法 -> 获取服务区繁忙排行
        /// <summary>
        /// 获取服务区繁忙排行
        /// </summary>
        /// <param name="code">授权码</param>
        /// <param name="jsonString">传输字符串</param>
        /// <returns></returns>
        [WebMethod]
        public string GetCurBusyRank(string code, string jsonString)
        {
            string codeDecrypt;
            try
            {
                codeDecrypt = code.ToDecrypt();
                if (codeDecrypt != "3760")
                {
                    return "{\"ResultCode\": 201 ,\"ResultDesc\": \"授权码不正确\",\"ResultData\":[]}";
                }
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"授权码解码失败。原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"授权码解码异常。\",\"ResultData\":[]}";
            }
            try
            {
                //先检查传入的参数是否为空数据包
                //if (string.IsNullOrWhiteSpace(jsonString))
                //{
                //    return "{\"ResultCode\": 200 ,\"ResultDesc\": \"报文参数为空\",\"ResultData\":\"" + jsonString + "\"}";
                //}

                string _BaseUrl = ConfigurationManager.AppSettings["AjaxUrl"];
                string _PostData = "action_type=getCurHalfCollect&province_code=" + codeDecrypt;
                string reString = WebService.SDK.CommonHelper.HttpUrlPost(_PostData, _BaseUrl + "?" + _PostData);

                JObject _JObject = JObject.Parse(reString);
                if (_JObject["CollectionObject"].TryParseToString() != "")
                {
                    return "{\"ResultCode\": 100 ,\"ResultDesc\": \"" + _JObject["ResultDesc"] +
                        "\",\"ResultData\":" + _JObject["CollectionObject"] + "}";
                }
                else
                {
                    return "{\"ResultCode\": 101,\"ResultDesc\": \"查询失败，无数据返回\",\"ResultData\":[]}";
                }
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"获取服务区繁忙排行失败，原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"系统异常。\",\"ResultData\":[]}";
            }
        }
        #endregion

        #region 方法 -> 获取服务区交易排行
        /// <summary>
        /// 获取服务区交易排行
        /// </summary>
        /// <param name="code">授权码</param>
        /// <param name="jsonString">传输字符串</param>
        /// <returns></returns>
        [WebMethod]
        public string GetCurRevenueRank(string code, string jsonString)
        {
            string codeDecrypt;
            try
            {
                codeDecrypt = code.ToDecrypt();
                if (codeDecrypt != "3760")
                {
                    return "{\"ResultCode\": 201 ,\"ResultDesc\": \"授权码不正确\",\"ResultData\":[]}";
                }
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"授权码解码失败。原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"授权码解码异常。\",\"ResultData\":[]}";
            }
            try
            {
                //先检查传入的参数是否为空数据包
                //if (string.IsNullOrWhiteSpace(jsonString))
                //{
                //    return "{\"ResultCode\": 200 ,\"ResultDesc\": \"报文参数为空\",\"ResultData\":\"" + jsonString + "\"}";
                //}

                string _BaseUrl = ConfigurationManager.AppSettings["AjaxUrl"];
                string _PostData = "action_type=getCurCollect&province_code=" + codeDecrypt;
                string reString = WebService.SDK.CommonHelper.HttpUrlPost(_PostData, _BaseUrl + "?" + _PostData);

                JObject _JObject = JObject.Parse(reString);
                if (_JObject["CurrentData"].TryParseToString() != "")
                {
                    return "{\"ResultCode\": 100 ,\"ResultDesc\": \"" + _JObject["ResultDesc"] +
                        "\",\"ResultData\":" + _JObject["CurrentData"] + "}";
                }
                else
                {
                    return "{\"ResultCode\": 101,\"ResultDesc\": \"查询失败，无数据返回\",\"ResultData\":[]}";
                }
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"获取服务区交易排行失败，原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"系统异常。\",\"ResultData\":[]}";
            }
        }
        #endregion

        #region 方法 -> 获取近一周营收趋势图
        /// <summary>
        /// 获取近一周营收趋势图
        /// </summary>
        /// <param name="code">授权码</param>
        /// <param name="jsonString">传输字符串</param>
        /// <returns></returns>
        [WebMethod]
        public string GetCurRevenueTrend(string code, string jsonString)
        {
            string codeDecrypt;
            try
            {
                codeDecrypt = code.ToDecrypt();
                if (codeDecrypt != "3760")
                {
                    return "{\"ResultCode\": 201 ,\"ResultDesc\": \"授权码不正确\",\"ResultData\":[]}";
                }
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"授权码解码失败。原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"授权码解码异常。\",\"ResultData\":[]}";
            }
            try
            {
                string StartDate = DateTime.Now.AddDays(-7).ToShortDateString(),
                    EndDate = DateTime.Now.ToShortDateString(),
                    LYStartDate = DateTime.Now.AddYears(-1).AddDays(-7).ToShortDateString(),
                    LYEndDate = DateTime.Now.AddYears(-1).ToShortDateString();
                //先检查传入的参数是否为空数据包
                //if (string.IsNullOrWhiteSpace(jsonString))
                //{
                //    return "{\"ResultCode\": 200 ,\"ResultDesc\": \"报文参数为空\",\"ResultData\":\"" + jsonString + "\"}";
                //}

                string _BaseUrl = ConfigurationManager.AppSettings["AjaxUrl"];
                string _PostData = "action_type=RevenueCompare&province_code=" + codeDecrypt +
                    "&action_data=" + StartDate + "|" + EndDate + "&action_record=" + LYStartDate + "|" + LYEndDate;
                string reString = WebService.SDK.CommonHelper.HttpUrlPost(_PostData, _BaseUrl + "?" + _PostData);

                JObject _JObject = JObject.Parse(reString);
                if (_JObject["RevenueCompareObject"].TryParseToString() != "")
                {
                    return "{\"ResultCode\": 100 ,\"ResultDesc\": \"" + _JObject["ResultDesc"] +
                        "\",\"ResultData\":" + _JObject["RevenueCompareObject"] + "}";
                }
                else
                {
                    return "{\"ResultCode\": 101,\"ResultDesc\": \"查询失败，无数据返回\",\"ResultData\":[]}";
                }
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"获取近一周营收趋势图失败，原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"系统异常。\",\"ResultData\":[]}";
            }
        }
        #endregion

        #region 方法 -> 获取今日走势图
        /// <summary>
        /// 获取今日走势图
        /// </summary>
        /// <param name="code">授权码</param>
        /// <param name="jsonString">传输字符串</param>
        /// <returns></returns>
        [WebMethod]
        public string GetCurTrendChart(string code, string jsonString)
        {
            string codeDecrypt;
            try
            {
                codeDecrypt = code.ToDecrypt();
                if (codeDecrypt != "3760")
                {
                    return "{\"ResultCode\": 201 ,\"ResultDesc\": \"授权码不正确\",\"ResultData\":[]}";
                }
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"授权码解码失败。原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"授权码解码异常。\",\"ResultData\":[]}";
            }
            try
            {
                //先检查传入的参数是否为空数据包
                //if (string.IsNullOrWhiteSpace(jsonString))
                //{
                //    return "{\"ResultCode\": 200 ,\"ResultDesc\": \"报文参数为空\",\"ResultData\":\"" + jsonString + "\"}";
                //}

                string _BaseUrl = ConfigurationManager.AppSettings["AjaxUrl"];
                string _PostData = "action_type=getDataCollect&province_code=" + codeDecrypt;
                string reString = WebService.SDK.CommonHelper.HttpUrlPost(_PostData, _BaseUrl + "?" + _PostData);

                JObject _JObject = JObject.Parse(reString);
                if (_JObject["CollectionObject"].TryParseToString() != "")
                {
                    return "{\"ResultCode\": 100 ,\"ResultDesc\": \"" + _JObject["ResultDesc"] +
                        "\",\"ResultData\":" + _JObject["CollectionObject"] + "}";
                }
                else
                {
                    return "{\"ResultCode\": 101,\"ResultDesc\": \"查询失败，无数据返回\",\"ResultData\":[]}";
                }
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"获取今日走势图失败，原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"系统异常。\",\"ResultData\":[]}";
            }
        }
        #endregion

        #region 方法 -> 获取年度营收趋势图
        /// <summary>
        /// 获取年度营收趋势图
        /// </summary>
        /// <param name="code">授权码</param>
        /// <param name="jsonString">传输字符串</param>
        /// <returns></returns>
        [WebMethod]
        public string GetAnnualRevenueTrend(string code, string jsonString)
        {
            string codeDecrypt;
            try
            {
                codeDecrypt = code.ToDecrypt();
                if (codeDecrypt != "3760")
                {
                    return "{\"ResultCode\": 201 ,\"ResultDesc\": \"授权码不正确\",\"ResultData\":[]}";
                }
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"授权码解码失败。原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"授权码解码异常。\",\"ResultData\":[]}";
            }
            try
            {
                string StartDate = DateTime.Now.Year + "/01/01",
                    EndDate = DateTime.Now.ToShortDateString(),
                    LYStartDate = DateTime.Now.AddYears(-1).Year + "/01/01",
                    LYEndDate = DateTime.Now.AddYears(-1).ToShortDateString();
                //先检查传入的参数是否为空数据包
                //if (string.IsNullOrWhiteSpace(jsonString))
                //{
                //    return "{\"ResultCode\": 200 ,\"ResultDesc\": \"报文参数为空\",\"ResultData\":\"" + jsonString + "\"}";
                //}

                string _BaseUrl = ConfigurationManager.AppSettings["AjaxUrl"];
                string _PostData = "action_type=RevenueCompareYOY&province_code=" + codeDecrypt +
                    "&action_data=" + StartDate + "|" + EndDate + "&action_record=" + LYStartDate + "|" + LYEndDate;
                string reString = WebService.SDK.CommonHelper.HttpUrlPost(_PostData, _BaseUrl + "?" + _PostData);

                JObject _JObject = JObject.Parse(reString);
                if (_JObject["RevenueCompareObject"].TryParseToString() != "")
                {
                    return "{\"ResultCode\": 100 ,\"ResultDesc\": \"" + _JObject["ResultDesc"] +
                        "\",\"ResultData\":" + _JObject["RevenueCompareObject"] + "}";
                }
                else
                {
                    return "{\"ResultCode\": 101,\"ResultDesc\": \"查询失败，无数据返回\",\"ResultData\":[]}";
                }
            }
            catch (Exception ex)
            {
                WebService.SDK.LogHelper.WriteReceiveLog($"获取年度营收趋势图，原因：{ex.Message}");
                return "{\"ResultCode\": 999 ,\"ResultDesc\": \"系统异常。\",\"ResultData\":[]}";
            }
        }
        #endregion

        #endregion
    }
}