using System;
using System.Collections.Generic;
using System.Data;
using System.Globalization;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Windows.Threading;


namespace ConnectPoint
{
    /// <summary>
    /// MainWindow.xaml 的交互逻辑
    /// </summary>
    public partial class MainWindow : Window
    {
        #region 属性
        /// <summary>
        /// 状态反馈主定时器
        /// </summary>
        private readonly DispatcherTimer WorkerTimer;
        /// <summary>
        /// 平台稽核结果校验线程定时器
        /// </summary>
        private readonly DispatcherTimer CheckAuditTimer;
        /// <summary>
        /// 数据传输接口地址
        /// </summary>
        private string WebServiceUrl { get; set; }
        /// <summary>
        /// 主支付通道接口地址
        /// </summary>
        private string PayServiceUrl { get; set; }
        /// <summary>
        /// 数据传输线程类
        /// </summary>
        GetHttpData.SDK.ThreadPool.ClientThread DataClientThread { get; set; }
        #endregion

        public MainWindow()
        {
            InitializeComponent();

            #region 状态反馈主定时器，每分钟执行一次
            WorkerTimer = new DispatcherTimer
            {
                Interval = TimeSpan.FromSeconds(60)
            };
            WorkerTimer.Tick += WorkerTimer_Tick;
            WorkerTimer.Start();
            #endregion

            #region 检测并获取长款智能稽核记录的后台补录流水记录，10分钟执行一次
            CheckAuditTimer = new DispatcherTimer
            {
                Interval = TimeSpan.FromMinutes(10)
            };
            CheckAuditTimer.Tick += CheckAuditTimer_Tick;
            CheckAuditTimer.Start();
            #endregion
        }

        #region 事件 -> 主程序启动加载事件
        /// <summary>
        /// 主程序启动加载事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            #region 程序启动时，进行过期日志、备份文件清理操作并升级本地表结构
            new Thread(() =>
            {
                int _FileCount = 0;
                //清理程序根目录下过期日志文件
                try { ESSupport.Lib.FileHelper.DeleteFiles(AppDomain.CurrentDomain.BaseDirectory, new string[] { ".log" }, false, false, 10, ref _FileCount); } catch { }
                //清理错误日志文件夹中过期日志文件
                try { ESSupport.Lib.FileHelper.DeleteFiles(AppDomain.CurrentDomain.BaseDirectory + "\\log", new string[] { ".log" }, false, false, 10, ref _FileCount); } catch { }
                //清理流水日志文件
                try { ESSupport.Lib.FileHelper.DeleteFiles(AppDomain.CurrentDomain.BaseDirectory + "\\selldata", new string[] { ".log" }, false, false, 60, ref _FileCount); } catch { }
                //升级本地数据库表结构
                try { ESSupport.Lib.DataBaseUpdate.PosDataBaseUpdate(); } catch { }
                //清理采集的过期客群图像文件
                try { ESSupport.Lib.DataBaseUpdate.ClearCustomerInfo(AppDomain.CurrentDomain.BaseDirectory + "\\CustomerInfo", 7); } catch { }
                try
                {
                    #region 清理本地数据库历史数据，默认清理60天以前的数据
                    //获取服务区编码
                    string _ServerPartCode = ESSupport.Pos.PosConfigInit.ConfigurationValues("serverpartcode", string.Empty);
                    //获取门店编码
                    string _ShopCode = ESSupport.Pos.PosConfigInit.ConfigurationValues("shopcode", string.Empty);
                    //获取数据保留时长
                    int _EffectiveDay = int.Parse(ESSupport.Pos.PosConfigInit.ConfigurationValues("effective_day", "60"));
                    //获取门店ID
                    string _ServerPartShopID = ESSupport.Lib.SyBaseHelper.QueryOdbc(
                        $@"SELECT SERVERPARTSHOP_ID FROM T_SHOPMESSAGE 
                        WHERE SERVERPARTCODE = '{_ServerPartCode}' AND 
                            SHOPCODE = '{_ShopCode}'").Tables[0].Rows[0]["SERVERPARTSHOP_ID"].ToString();
                    //清理历史过期数据
                    //读取上次启动同步的时间
                    string _strLocalDate = ESSupport.Pos.PosConfigInit.ConfigurationValues("syncdtime", "2021/01/01 00:00:00");
                    if (DateTime.TryParse(_strLocalDate, out DateTime _LocalDate))
                    {
                        //本地时间与上次同步时间误差在3天内时，启动数据库过期数据清理
                        if (DateTime.Now.Subtract(_LocalDate).TotalDays < 3 && DateTime.Now.Subtract(_LocalDate).TotalDays >= 0)
                        {
                            ESSupport.Lib.DataBaseUpdate.ClearData(_ServerPartCode, _ShopCode, _ServerPartShopID, _EffectiveDay);
                        }
                    }
                    #endregion
                }
                catch { }
                //清理过期备份数据文件
                try
                {
                    #region 清理过期的历史交易文本备份文件
                    //读取上次启动同步的时间
                    string _strLocalDate = ESSupport.Pos.PosConfigInit.ConfigurationValues("syncdtime", "2021/01/01 00:00:00");
                    if (DateTime.TryParse(_strLocalDate, out DateTime _LocalDate))
                    {
                        //本地时间同步失败超过3天或本地时间小于上次同步时间，不执行超时备份文件直接清理
                        if (DateTime.Now.Subtract(_LocalDate).TotalDays > 3 || DateTime.Now.Subtract(_LocalDate).TotalDays < 0)
                        {
                            ESSupport.Lib.DataBaseUpdate.ClearDataBackup(AppDomain.CurrentDomain.BaseDirectory + "\\DataBackup", 60, false);
                        }
                        else
                        {
                            ESSupport.Lib.DataBaseUpdate.ClearDataBackup(AppDomain.CurrentDomain.BaseDirectory + "\\DataBackup", 60, true);
                        }
                    }
                    #endregion
                }
                catch { }
            })
            { IsBackground = true }.Start();
            #endregion

            this.Hide();

            #region 程序启动时立即上报一次心跳数据，解决PB版本收银系统结账后立即关机导致版本信息未回传至服务器的问题
            //程序启动时立即上报一次心跳数据，解决PB版本收银系统结账后立即关机导致版本信息未回传至服务器的问题
            try
            {
                if (ESSupport.Common.PosControl.StateFeedbackThread == null ||
                    !ESSupport.Common.PosControl.StateFeedbackThread.IsAlive)
                {
                    ESSupport.Common.PosControl.StateFeedbackThread = new Thread(() =>
                    {
                        ESSupport.Pos.ThreadHelper.StateFeedbackUpload($"http://{ESSupport.Pos.PosConfigInit.ConfigurationValues("server_ip", string.Empty)}:" +
                            $"{ESSupport.Pos.PosConfigInit.ConfigurationValues("DataServicePort", "7080")}/DataServices/Service.asmx");
                    })
                    {
                        IsBackground = true
                    };
                    ESSupport.Common.PosControl.StateFeedbackThread.Start();
                }
            }
            catch { }
            #endregion

            #region 旧模式数据传输控制，仅用于PB版本系统
            try
            {
                if (ESSupport.Pos.PosConfigInit.ConfigurationValues("NewSystem", "1") == "0")
                {
                    //获取服务区编码
                    string _ServerPartCode = ESSupport.Pos.PosConfigInit.ConfigurationValues("serverpartcode", string.Empty);
                    //获取门店编码
                    string _ShopCode = ESSupport.Pos.PosConfigInit.ConfigurationValues("shopcode", string.Empty);
                    //h获取收银机号
                    string _MachineCode = ESSupport.Pos.PosConfigInit.ConfigurationValues("machinecode", string.Empty);
                    if (!string.IsNullOrWhiteSpace(_ServerPartCode) && !string.IsNullOrWhiteSpace(_ShopCode) && !string.IsNullOrWhiteSpace(_MachineCode))
                    {
                        if (DataClientThread == null)
                        {
                            DataClientThread = new GetHttpData.SDK.ThreadPool.ClientThread();
                        }
                        Common.ConfigThread _ConfigThread = new Common.ConfigThread(_ServerPartCode);
                        DataClientThread.setConfiguration($"http://{ESSupport.Pos.PosConfigInit.ConfigurationValues("server_ip", string.Empty)}:" +
                            $"{ESSupport.Pos.PosConfigInit.ConfigurationValues("DataServicePort", "7080")}/DataServices/Service.asmx",
                            ESSupport.Pos.PosConfigInit.ConfigurationValues("authorization", string.Empty), _ServerPartCode, "",
                            _ShopCode, ESSupport.Lib.PCHelper.GetMacAddressByNetworkInformation(), _MachineCode, 400, 15, 20);

                        switch (ESSupport.Pos.PosConfigInit.ConfigurationValues("ProvinceCode", "330000"))
                        {
                            //使用旧数据源下发数据的业主单位
                            case "140000":
                            case "330200":
                            case "330300":
                            case "450000":
                            case "500000":
                                DataClientThread.IsDownload(true, new List<string>()
                            {
                                "T_SELLWORKER", "T_SHOPMESSAGE", "T_CONFIGURATION"
                            });
                                break;
                            //使用新数据源下发数据的业主单位
                            case "330000":
                            case "451200":
                            case "510000":
                            case "520000":
                            case "620000":
                            case "650000":
                            default:
                                DataClientThread.IsDownload(true, new List<string>()
                            {
                                "T_SELLWORKER_UNIT", "T_SELLWORKER_CLOUD",
                                "T_SHOPMESSAGE_EX", "T_CONFIGURATION"
                            });
                                break;
                        }
                        //PB系统数据传输
                        DataClientThread.IsUpload(true, new List<string>
                        {
                            "T_ENDACCOUNT",
                            "T_PERSONSELL",
                            "T_COMMODITYSALE",
                            "T_MOBILE_PAY",
                            "T_EXCEPTION",
                            "T_SELLDATA",
                        });
                        DataClientThread.setConfigThread(_ConfigThread);
                        DataClientThread.DownloadStringEvent += new GetHttpData.SDK.ThreadPool.ClientThread.OutputResultsDownArg(DownStringEvent);//监听下载事件
                        DataClientThread.UploadStringEvent += new GetHttpData.SDK.ThreadPool.ClientThread.OutputResultsUploadArg(UploadStringEvent);
                        DataClientThread.onState();
                    }
                }
            }
            catch { }
            #endregion

        }
        #endregion

        #region 方法 -> 旧模式数据传输监听
        /// <summary>
        /// 数据下载监听事件
        /// </summary>
        /// <param name="downResultInfo"></param>
        /// <param name="resultString"></param>
        private void DownStringEvent(GetHttpData.SDK.ThreadPool.DownResultInfo downResultInfo, string resultString)
        {

        }

        /// <summary>
        /// 数据上传监听事件
        /// </summary>
        /// <param name="uploadResultInfo"></param>
        /// <param name="resultString"></param>
        private void UploadStringEvent(GetHttpData.SDK.ThreadPool.UploadResultInfo uploadResultInfo, string resultString)
        {
            //if (!uploadResultInfo.StartToEnd)
            //{
            //    //获取服务区编码
            //    string _ServerPartCode = ESSupport.Pos.PosConfigInit.ConfigurationValues("serverpartcode", string.Empty);
            //    //获取门店编码
            //    string _ShopCode = ESSupport.Pos.PosConfigInit.ConfigurationValues("shopcode", string.Empty);
            //    //h获取收银机号
            //    string _MachineCode = ESSupport.Pos.PosConfigInit.ConfigurationValues("machinecode", string.Empty);
            //    ESSupport.Lib.LogHelper.WriteServiceLog("状态反馈工具：原DataServices接口上传数据：" + uploadResultInfo.TableDesc);
            //    try
            //    {
            //        #region 调用云端【/WebSocket/RecordLogToOracle】接口上报Socket消息通知执行结果到云端
            //        //文件上传耗时记录
            //        string str_HttpURL = $"http://{ESSupport.Pos.PosConfigInit.ConfigurationValues("server_ip", string.Empty)}:7198/webApi_publish/WebSocket/RecordLogToOracle";
            //        string str_PostData = $"ServerpartCode={_ServerPartCode}&ShopCode={_ShopCode}&" +
            //        $"MachineCode={_MachineCode}&LogCentent={"状态反馈工具：原DataServices接口上传数据：" + uploadResultInfo.TableDesc}";
            //        ESSupport.Lib.HttpHelper.HttpPost(str_PostData, $"{str_HttpURL}?{str_PostData}");
            //        #endregion
            //    }
            //    catch (Exception ex)
            //    {
            //        ESSupport.Lib.LogHelper.WriteServiceLog("状态反馈工具：原DataServices接口上传数据失败。原因：" + ex.Message);
            //    }
            //}
        }
        #endregion

        #region 计时器方法 -> 主定时器运行事件
        /// <summary>
        /// 主定时器运行事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void WorkerTimer_Tick(object sender, EventArgs e)
        {
            #region 初始化数据传输接口地址，每隔10分钟重新设置检查一次，避免接口连接失败导致心跳无法上报
            //初始化数据传输接口地址，每隔10分钟重新设置检查一次，避免接口连接失败导致心跳无法上报
            if (string.IsNullOrWhiteSpace(WebServiceUrl) ||
                (DateTime.Now - ESSupport.Common.PosControl.DataCollectionTime).Minutes % 10 == 0)
            {
                //心跳数据上报主接口地址，此地址正常访问时，心跳通过这个地址上报
                string _ServiceUrl = $"http://{ESSupport.Pos.PosConfigInit.ConfigurationValues("server_ip", string.Empty)}:" +
                    $"{ESSupport.Pos.PosConfigInit.ConfigurationValues("DataServicePort", "7080")}/DataServices/Service.asmx";

                //检查主数据传输接口是否可以正常访问，不能正常访问的话，使用备用接口
                if (ESSupport.Lib.HttpHelper.UrlIsExist(_ServiceUrl))
                {
                    WebServiceUrl = _ServiceUrl;
                }
                else
                {
                    //心跳数据上报备用接口地址，当主接口地址无法访问时，心跳通过这个地址上报
                    WebServiceUrl = $"http://{ESSupport.Pos.PosConfigInit.ConfigurationValues("server_ip", string.Empty)}:" +
                        $"{ESSupport.Pos.PosConfigInit.ConfigurationValues("service_port", "7080")}/Service.asmx";
                }
            }
            #endregion

            #region 初始化移动支付交易检测接口地址
            //初始化移动支付交易检测接口地址
            if (string.IsNullOrWhiteSpace(PayServiceUrl))
            {
                PayServiceUrl = $"http://{ESSupport.Pos.PosConfigInit.ConfigurationValues("server_ip", string.Empty)}:" +
                    $"{ESSupport.Pos.PosConfigInit.ConfigurationValues("service_port", "7080")}/Service.asmx";
            }
            #endregion

            #region 记录十分钟营收统计首次启动时间，后续每隔10分钟统计一次交易数据并上传到后台
            //记录十分钟营收统计首次启动时间，后续每隔10分钟统计一次交易数据并上传到后台
            if (ESSupport.Common.PosControl.DataCollectionTime == DateTime.MinValue)
            {
                ESSupport.Common.PosControl.DataCollectionTime = DateTime.Now.AddMilliseconds(-Environment.TickCount);
            }
            #endregion

            #region 收银机指令执行线程，执行后台下发的收银机命令
            //收银机指令执行线程
            if (ESSupport.Common.PosControl.CommodityMachineThread == null ||
                !ESSupport.Common.PosControl.CommodityMachineThread.IsAlive)
            {
                ESSupport.Common.PosControl.CommodityMachineThread = new Thread(() =>
                {
                    //ESSupport.Pos.ThreadHelper.CommodityMachine(WebServiceUrl);
                    ESSupport.Pos.ThreadHelper.InstructionExecute(WebServiceUrl);
                    ESSupport.Pos.ThreadHelper.License();
                })
                {
                    IsBackground = true
                };
                ESSupport.Common.PosControl.CommodityMachineThread.Start();
            }
            #endregion

            #region 系统运行日志记录线程，每隔5分钟保存一条运行记录到本地数据库
            //启动运行日志记录线程
            if (ESSupport.Common.PosControl.RuningLogThread == null ||
                !ESSupport.Common.PosControl.RuningLogThread.IsAlive)
            {
                ESSupport.Common.PosControl.RuningLogThread = new Thread(() =>
                {
                    if (ESSupport.Pos.ThreadHelper.RuningLog(ESSupport.Common.PosControl.RuningTime))
                    {
                        ESSupport.Common.PosControl.RuningTime = DateTime.Now;
                    }
                })
                {
                    IsBackground = true
                };
                ESSupport.Common.PosControl.RuningLogThread.Start();
            }
            #endregion

            #region 定时启动实时交易统计线程
            //定时启动实时交易统计线程
            if (!ESSupport.Common.PosControl.DataCollectionRun &&
                (DateTime.Now - ESSupport.Common.PosControl.DataCollectionTime).Minutes % 10 == 0)
            {
                if (ESSupport.Common.PosControl.DataCollectionThread == null ||
                    !ESSupport.Common.PosControl.DataCollectionThread.IsAlive)
                {
                    ESSupport.Common.PosControl.DataCollectionThread = new Thread(() =>
                    {
                        ESSupport.Common.PosControl.DataCollectionRun = true;
                        ESSupport.Pos.ThreadHelper.DataCollectionUpload(WebServiceUrl);
                        ESSupport.Pos.ThreadHelper.NewSystemConfig();
                    })
                    {
                        IsBackground = true
                    };
                    ESSupport.Common.PosControl.DataCollectionThread.Start();
                    //Common.PosControl.DataCollectionTime = DateTime.Now.AddMinutes(10);
                }
            }
            #endregion

            #region 控制实时交易统计线程是否需要启动（每隔10分钟启动一次）
            if (ESSupport.Common.PosControl.DataCollectionRun &&
                (DateTime.Now - ESSupport.Common.PosControl.DataCollectionTime).Minutes % 10 != 0)
            {
                ESSupport.Common.PosControl.DataCollectionRun = false;
            }
            #endregion

            #region 每隔10分钟启动一次移动支付交易验证、通道配置获取线程
            //定时启动移动支付交易校验、配置下发线程
            if (DateTime.Now > ESSupport.Common.PosControl.MobilePayCheckTime)
            {
                if (ESSupport.Common.PosControl.MobilePayCheckThread == null ||
                    !ESSupport.Common.PosControl.MobilePayCheckThread.IsAlive)
                {
                    ESSupport.Common.PosControl.MobilePayCheckThread = new Thread(() =>
                    {
                        //获取后台移动支付通道配置信息
                        //ESSupport.Pos.ThreadHelper.MobilePayConfigUpdate(ESSupport.Pos.PosConfigInit.ConfigurationValues("server_ip", string.Empty));
                        //对待确认的移动支付交易进行交易结果查询
                        ESSupport.Pos.ThreadHelper.MobilePayQueryCheck(PayServiceUrl, DateTime.Today.AddMinutes(-10));
                    })
                    {
                        IsBackground = true
                    };
                    ESSupport.Common.PosControl.MobilePayCheckThread.Start();
                    //每隔10分钟执行一次移动支付交易验证
                    ESSupport.Common.PosControl.MobilePayCheckTime = DateTime.Now.AddMinutes(10);
                }
            }
            #endregion

            #region 每分钟启动一次状态反馈（心跳）上报线程
            //定时启动状态反馈线程
            if (DateTime.Now > ESSupport.Common.PosControl.StateFeedBackTime)
            {
                if (ESSupport.Common.PosControl.StateFeedbackThread == null ||
                    !ESSupport.Common.PosControl.StateFeedbackThread.IsAlive)
                {
                    ESSupport.Common.PosControl.StateFeedbackThread = new Thread(() =>
                    {
                        //获取服务区编码
                        string _ServerPartCode = ESSupport.Pos.PosConfigInit.ConfigurationValues("serverpartcode", string.Empty);
                        //获取门店编码
                        string _ShopCode = ESSupport.Pos.PosConfigInit.ConfigurationValues("shopcode", string.Empty);
                        //获取收银机号
                        string _MachineCode = ESSupport.Pos.PosConfigInit.ConfigurationValues("machinecode", string.Empty);
                        //获取新系统标识
                        bool _NewSystem = ESSupport.Pos.PosConfigInit.ConfigurationValues("NewSystem", "0") == "1";
                        //初始化交易信息获取类（用于读取统一的实时交易数据）
                        ESSupport.Pos.DataStatistics _DataStatistics = new ESSupport.Pos.DataStatistics
                        {
                            ServerPartCode = _ServerPartCode,
                            ShopCode = _ShopCode,
                            MachineCode = _MachineCode
                        };

                        //心跳数据上传至区服接口
                        ESSupport.Pos.ThreadHelper.StateFeedbackUpload(WebServiceUrl, _DataStatistics);

                        ////心跳数据上传至云端接口
                        //ESSupport.Pos.ThreadHelper.StateFeedbackUploadByCloud(PayServiceUrl, "http://user.eshangtech.com:7089/Service.asmx", _DataStatistics);
                        ////日结数据上传至云端接口
                        //ESSupport.Pos.ThreadHelper.EndAccountUploadByCloud(PayServiceUrl, "http://user.eshangtech.com:7089/Service.asmx", _DataStatistics);
                    })
                    {
                        IsBackground = true
                    };
                    ESSupport.Common.PosControl.StateFeedbackThread.Start();
                    ESSupport.Common.PosControl.StateFeedBackTime = DateTime.Now.AddMinutes(1);
                }
            }
            #endregion

            #region 每隔30分钟运行一次收银机基础信息更新检测线程
            //每隔30分钟运行一次收银机基础信息更新检测线程
            if (DateTime.Now > ESSupport.Common.PosControl.BaseInfoFeedbackTime)
            {
                if (ESSupport.Common.PosControl.BaseInfoFeedbackThread == null ||
                    !ESSupport.Common.PosControl.BaseInfoFeedbackThread.IsAlive)
                {
                    ESSupport.Common.PosControl.BaseInfoFeedbackThread = new Thread(() =>
                    {
                        ////基础数据版本接口上报
                        //ESSupport.Pos.ThreadHelper.BaseInfoFeedbackUpload(WebServiceUrl);
                        ////收银机器信息接口上报
                        //ESSupport.Pos.ThreadHelper.MachineInfoFeedbackUpload(WebServiceUrl);
                        try
                        {
                            //读取后台配置的更新服务地址
                            string _UpdateIP = ESSupport.Pos.PosConfigInit.ConfigurationValues("UpdateIP", string.Empty);
                            if (string.IsNullOrWhiteSpace(_UpdateIP))
                            {
                                //更新服务地址未配置时，默认同收银服务器地址
                                _UpdateIP = ESSupport.Pos.PosConfigInit.ConfigurationValues("server_ip", string.Empty);
                            }
                            //读取后台配置的更新服务端口，默认：11000
                            string _UpdatePort = ESSupport.Pos.PosConfigInit.ConfigurationValues("UpdatePort", "11000");
                            if (!string.IsNullOrWhiteSpace(_UpdateIP) && !string.IsNullOrWhiteSpace(_UpdatePort))
                            {
                                //检测更新站点是否存在，存在则更新配置文件
                                if (ESSupport.Lib.HttpHelper.UrlIsExist($"http://{_UpdateIP}:{_UpdatePort}/Update.asmx"))
                                {
                                    //修改更新服务IP地址
                                    if (ESSupport.Lib.ConfigHelper.GetAppConfig(AppDomain.CurrentDomain.BaseDirectory + "\\update.xml", "IP") != _UpdateIP)
                                    {
                                        ESSupport.Lib.ConfigHelper.UpdateAppConfig(AppDomain.CurrentDomain.BaseDirectory + "\\update.xml", "IP", _UpdateIP);
                                    }
                                    //修改更新服务端口
                                    if (ESSupport.Lib.ConfigHelper.GetAppConfig(AppDomain.CurrentDomain.BaseDirectory + "\\update.xml", "Port") != _UpdatePort)
                                    {
                                        ESSupport.Lib.ConfigHelper.UpdateAppConfig(AppDomain.CurrentDomain.BaseDirectory + "\\update.xml", "Port", _UpdatePort);
                                    }
                                }
                            }
                            //更新配置文件不存在端口号配置项时，写入默认端口
                            if (string.IsNullOrWhiteSpace(ESSupport.Lib.ConfigHelper.GetAppConfig(AppDomain.CurrentDomain.BaseDirectory + "\\update.xml", "Port")))
                            {
                                ESSupport.Lib.ConfigHelper.UpdateAppConfig(AppDomain.CurrentDomain.BaseDirectory + "\\update.xml", "Port", "11000");
                            }
                        }
                        catch { }
                        #region 待生效商品检查（先注释掉，需要使用时打开）
                        //try
                        //{
                        //    //删除待生效商品表中已生效的商品数据
                        //    ESSupport.Lib.SyBaseHelper.ExecuteSqlTran(
                        //        @"DELETE FROM T_COMMODITYEX_INEFFECTIVE A 
                        //            WHERE EXISTS(SELECT 1 FROM T_COMMODITYEX B 
                        //                WHERE A.SERVERPARTCODE = B.SERVERPARTCODE AND 
                        //                    A.COMMODITY_BARCODE = B.COMMODITY_BARCODE AND 
                        //                    A.COMMODITY_CODE = B.COMMODITY_CODE AND 
                        //                    A.SERVERPARTSHOP_ID = B.SERVERPARTSHOP_ID AND 
                        //                    A.DOWNLOADDATE <= B.DOWNLOADDATE)");
                        //    //将待生效商品表中已生效商品更新至正式商品表中
                        //    ESSupport.Lib.SyBaseHelper.ExecuteSqlTran(
                        //        @"UPDATE T_COMMODITYEX A 
                        //            SET A.COMMODITY_TYPE = B.COMMODITY_TYPE,
                        //                A.COMMODITY_NAME = B.COMMODITY_NAME,
                        //                A.COMMODITY_RULE = B.COMMODITY_RULE,
                        //                A.COMMODITY_UNIT = B.COMMODITY_UNIT,
                        //                A.COMMODITY_RETAILPRICE = B.COMMODITY_RETAILPRICE,
                        //                A.COMMODITY_MEMBERPRICE = B.COMMODITY_MEMBERPRICE,
                        //                A.CANCHANGEPRICE = B.CANCHANGEPRICE,A.ISVALID = B.ISVALID,
                        //                A.COMMODITY_EN = B.COMMODITY_EN,A.ISBULK = B.ISBULK,
                        //                A.METERINGMETHOD = B.METERINGMETHOD,
                        //                A.DOWNLOADDATE = B.DOWNLOADDATE,A.FLAG = B.FLAG,
                        //                A.COMMODITY_SYMBOL = B.COMMODITY_SYMBOL,
                        //                A.COMMODITY_HOTKEY = B.COMMODITY_HOTKEY,
                        //                A.USERDEFINEDTYPE_ID = B.USERDEFINEDTYPE_ID,
                        //                A.REMINDER_DAY = B.REMINDER_DAY,
                        //                A.GUARANTEE_DAY = B.GUARANTEE_DAY,
                        //                A.COMMODITY_TYPECODE = B.COMMODITY_TYPECODE
                        //            FROM T_COMMODITYEX_INEFFECTIVE B 
                        //            WHERE A.SERVERPARTCODE = B.SERVERPARTCODE AND 
                        //                A.COMMODITY_CODE = B.COMMODITY_CODE AND 
                        //                A.COMMODITY_BARCODE = B.COMMODITY_BARCODE AND 
                        //                A.SERVERPARTSHOP_ID = B.SERVERPARTSHOP_ID AND 
                        //                A.DOWNLOADDATE < B.DOWNLOADDATE AND B.DOWNLOADDATE < TODAY() + 1");
                        //    //将待生效商品表中已生效的商品插入正式商品表
                        //    ESSupport.Lib.SyBaseHelper.ExecuteSqlTran(
                        //        @"INSERT INTO T_COMMODITYEX (COMMODITYEX_ID,
                        //                SERVERPARTCODE,COMMODITY_TYPE,COMMODITY_CODE,
                        //                COMMODITY_BARCODE,COMMODITY_NAME,COMMODITY_RULE,
                        //                COMMODITY_UNIT,COMMODITY_RETAILPRICE,
                        //                COMMODITY_MEMBERPRICE,CANCHANGEPRICE,
                        //                ISVALID,COMMODITY_EN,ISBULK,METERINGMETHOD,
                        //                DOWNLOADDATE,FLAG,BUSINESSTYPE,SERVERPARTSHOP_ID,
                        //                PRINT_DATE,CONTAINER_CODE,COMMODITY_SYMBOL,
                        //                COMMODITY_HOTKEY,USERDEFINEDTYPE_ID,
                        //                TRANSFER_STATE,REMINDER_DAY,GUARANTEE_DAY,
                        //                COMMODITY_TYPECODE) 
                        //            SELECT A.COMMODITYEX_ID,A.SERVERPARTCODE,
                        //                A.COMMODITY_TYPE,A.COMMODITY_CODE,
                        //                A.COMMODITY_BARCODE,A.COMMODITY_NAME,
                        //                A.COMMODITY_RULE,A.COMMODITY_UNIT,
                        //                A.COMMODITY_RETAILPRICE,A.COMMODITY_MEMBERPRICE,
                        //                A.CANCHANGEPRICE,A.ISVALID,A.COMMODITY_EN,
                        //                A.ISBULK,A.METERINGMETHOD,A.DOWNLOADDATE,
                        //                A.FLAG,A.BUSINESSTYPE,A.SERVERPARTSHOP_ID,
                        //                A.PRINT_DATE,A.CONTAINER_CODE,A.COMMODITY_SYMBOL,
                        //                A.COMMODITY_HOTKEY,A.USERDEFINEDTYPE_ID,
                        //                A.TRANSFER_STATE,A.REMINDER_DAY,
                        //                A.GUARANTEE_DAY,A.COMMODITY_TYPECODE 
                        //            FROM T_COMMODITYEX_INEFFECTIVE A 
                        //            WHERE A.DOWNLOADDATE < TODAY() + 1 AND 
                        //                NOT EXISTS  (SELECT 1 FROM T_COMMODITYEX B 
                        //                WHERE A.SERVERPARTCODE = B.SERVERPARTCODE AND 
                        //                    A.COMMODITY_BARCODE = B.COMMODITY_BARCODE AND 
                        //                    A.COMMODITY_CODE = B.COMMODITY_CODE AND 
                        //                    A.SERVERPARTSHOP_ID = B.SERVERPARTSHOP_ID )");
                        //}
                        //catch { }
                        #endregion
                    })
                    {
                        IsBackground = true
                    };
                    ESSupport.Common.PosControl.BaseInfoFeedbackThread.Start();
                    ESSupport.Common.PosControl.BaseInfoFeedbackTime = DateTime.Now.AddMinutes(30);
                }
            }
            #endregion

            #region PB区服传输指令通知检测程序启动
            try
            {
                //检查是否存在未处理的PB传输指令
                if (ESSupport.Lib.SyBaseHelper.QueryOdbc(
                    @"SELECT 1 FROM T_TRANSDATALOG 
                    WHERE ISNULL(TRANSDATALOG_STATE,0) <> 1").Tables[0].Rows.Count > 0)
                {
                    System.Diagnostics.Process process = new System.Diagnostics.Process();
                    //隐藏窗口
                    process.StartInfo.UseShellExecute = true;
                    //隐藏窗口
                    process.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
                    //设置启动目录
                    process.StartInfo.WorkingDirectory = AppDomain.CurrentDomain.BaseDirectory;
                    //设置启动程序
                    process.StartInfo.FileName = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "TransDataByPB.exe");
                    //运行收银端PB数据指令检测和通知程序
                    process.Start();
                }
            }
            catch (Exception ex)
            {
                ESSupport.Lib.LogHelper.WriteServiceLog($"PB区服传输指令通知检测程序启动失败。原因：{ex.Message}");
            }
            #endregion
        }
        #endregion

        #region 计时器方法 ->  PB系统智能稽核平台校验记录获取线程定时器运行事件
        /// <summary>
        /// 平台稽核记录校验记录获取线程定时器运行事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void CheckAuditTimer_Tick(object sender, EventArgs e)
        {
            //初始化移动支付交易检测接口地址
            if (string.IsNullOrWhiteSpace(PayServiceUrl))
            {
                PayServiceUrl = $"http://{ESSupport.Pos.PosConfigInit.ConfigurationValues("server_ip", string.Empty)}:" +
                    $"{ESSupport.Pos.PosConfigInit.ConfigurationValues("service_port", "7080")}/Service.asmx";
            }
            //启动平台稽核反馈结果获取线程
            if (ESSupport.Common.PosControl.CheckAuditToPowerBuilderThread == null ||
                !ESSupport.Common.PosControl.CheckAuditToPowerBuilderThread.IsAlive)
            {
                ESSupport.Common.PosControl.CheckAuditToPowerBuilderThread = new Thread(() =>
                {
                    ESSupport.Pos.ThreadHelper.CheckAuditToPowerBuilder(PayServiceUrl);
                })
                {
                    IsBackground = true
                };
                ESSupport.Common.PosControl.CheckAuditToPowerBuilderThread.Start();
            }
        }
        #endregion
    }
}