using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Linq;
using System.ServiceProcess;
using System.Windows.Forms;
using DataTransmission.Method.BLL;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json;
using EShang.Common.Model;
using HZQR.Common;

namespace DataTransmission
{
    public partial class DataTransmission : Form
    {
        #region 方法 -> 定义全局变量
        /// <summary>
        /// 需要重启的服务名称
        /// </summary>
        protected static string ServiceName = ConfigurationManager.AppSettings["ServiceName"].ToString();
        /// <summary>
        /// 微信推送APIUrl
        /// </summary>
        protected static string WebAPIUrl = ConfigurationManager.AppSettings["WebAPIUrl"].ToString();
        /// <summary>
        /// webapi主项目接口地址
        /// </summary>
        protected static string EShangApiMain = ConfigurationManager.AppSettings["EShangApiMain"].ToString();
        /// <summary>
        /// 数据传输日志数据库链接：172,orcl数据库
        /// </summary>
        protected static string OracleConnStrEx = ConfigurationManager.AppSettings["OracleConnStrEx"].ToString();
        /// <summary>
        /// 业务日志数据库链接：175,orcl数据库
        /// </summary>
        protected static string OracleConnStr = ConfigurationManager.AppSettings["OracleConnStr"].ToString();
        /// <summary>
        /// 四川进销存数据库链接：175,orcl_sc数据库
        /// </summary>
        protected static string OracleConnStr_SC = ConfigurationManager.AppSettings["OracleConnStr_SC"].ToString();
        /// <summary>
        /// 合作商户进销存数据库链接：175,orcl_cm数据库
        /// </summary>
        protected static string OracleConnStr_Coop = ConfigurationManager.AppSettings["OracleConnStr_Coop"].ToString();
        /// <summary>
        /// 移动业务数据库链接：175,orcl_msp数据库
        /// </summary>
        protected static string OracleConnStr_Msp = ConfigurationManager.AppSettings["OracleConnStr_Msp"].ToString();
        /// <summary>
        /// 对比数据的月份，如果今天是下半月，那就是本月；否则，取上个月
        /// </summary>
        protected static string compareMonth = DateTime.Now.Day > 15 ? DateTime.Now.ToString("yyyyMM") :
            DateTime.Now.AddMonths(-1).ToString("yyyyMM");
        /// <summary>
        /// 微信推送的消息内容
        /// </summary>
        protected static string PushContent = "";
        /// <summary>
        /// Windows服务
        /// </summary>
        ServiceController service = new ServiceController(ServiceName);
        #endregion

        public DataTransmission()
        {
            InitializeComponent();
        }

        #region 方法 -> 初始加载事件
        /// <summary>
        /// 重启服务
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void DataTransmission_Load(object sender, EventArgs e)
        {
            //创建业务日志数据库链接
            Method.OracleHelper _OracleHelper = new Method.OracleHelper(OracleConnStr.Split(',')[0],
                OracleConnStr.Split(',')[1], OracleConnStr.Split(',')[2], OracleConnStr.Split(',')[3]);
            //创建合作商户数据库链接
            Method.OracleHelper _OracleHelper_Coop = new Method.OracleHelper(OracleConnStr_Coop.Split(',')[0],
                OracleConnStr_Coop.Split(',')[1], OracleConnStr_Coop.Split(',')[2], OracleConnStr_Coop.Split(',')[3]);
            //创建建行、工行对账数据库链接
            Method.OracleHelper _OracleHelperEx = new Method.OracleHelper(OracleConnStrEx.Split(',')[0],
                OracleConnStrEx.Split(',')[1], OracleConnStrEx.Split(',')[2], OracleConnStrEx.Split(',')[3]);
            ////创建移动支付业务数据库链接
            //Method.OracleHelper _OracleHelper_Msp = new Method.OracleHelper(OracleConnStr_Msp.Split(',')[0],
            //    OracleConnStr_Msp.Split(',')[1], OracleConnStr_Msp.Split(',')[2], OracleConnStr_Msp.Split(',')[3]);
            ////创建四川进销存数据库链接
            //Method.OracleHelper _OracleHelper_SC = new Method.OracleHelper(OracleConnStr_SC.Split(',')[0],
            //    OracleConnStr_SC.Split(',')[1], OracleConnStr_SC.Split(',')[2], OracleConnStr_SC.Split(',')[3]);

            PushBillLading(_OracleHelper);

            //DateTime curDateTime = DateTime.Now;
            ////MobilePayHelper.GetRefundMobilePay(_OracleHelper, _OracleHelper_Coop, curDateTime.AddDays(-1), "511300");
            ////CuringDataHelper.CorrectShopCigarette(_OracleHelper, curDateTime.AddDays(-1), "511300");
            //CuringDataHelper.BuildRefundSplit(_OracleHelper, _OracleHelper_Coop, _OracleHelperEx,
            //    curDateTime.AddDays(-1).ToString("yyyyMMdd"), "511300", "", true);
            //CuringDataHelper.ValidateRefundSplitRevenue(_OracleHelper, _OracleHelper_Coop, _OracleHelperEx,
            //    curDateTime.AddDays(-1).ToShortDateString(), "511300");
            ////获取移动支付分账数据
            //MobilePayHelper.GetKwyMobileShare(_OracleHelper, _OracleHelper_Coop, curDateTime.AddDays(num));
            ////存储营收分账数据
            //CuringDataHelper.BuildDailyRevenueSplit(_OracleHelper, _OracleHelper_Coop,
            //    _OracleHelperEx, curDateTime.AddDays(-1).ToString("yyyyMMdd"));
            ////生成昨日应收拆分数据
            //BusinessProjectHelper.RebuildSplitData(_OracleHelper);
            //验证移动支付分账数据的一致性
            //MobilePayHelper.ValidateRoyaltyMobilePay(_OracleHelper, _OracleHelper_Coop,
            //    _OracleHelperEx, curDateTime.AddDays(num).ToString("yyyyMMdd"));
            //CuringDataHelper.ValidateSplitRevenue(_OracleHelper, _OracleHelper_Coop,
            //    _OracleHelperEx, curDateTime.AddDays(num).ToString("yyyy-MM-dd"));

            //try
            //{
            //    //数据处理
            //    ExcuteDealData();
            //}
            //catch (Exception ex)
            //{
            //    LogUtil.WriteLog(null, "【" + curDateTime.ToShortTimeString() + "】任务执行异常，失败原因：【" + ex.Message + "】",
            //        curDateTime.ToString("yyyyMMdd") + "_DataTransmission_Error");
            //}
            //重启服务
            //RestartService();

            //关闭窗口
            this.Close();
        }
        #endregion

        #region 方法 -> 执行“重启服务”操作
        /// <summary>
        /// 重启服务
        /// </summary>
        public void RestartService()
        {
            try
            {
                LogUtil.WriteLog(null, string.Format("重启服务开始，服务名：【" + ServiceName + "】"),
                    DateTime.Now.ToString("yyyyMMdd") + "_DataTransmission");
                //判断服务状态，正在运行则停止服务，然后开启服务
                if (service.Status == ServiceControllerStatus.Running)
                {
                    service.Stop();
                    service.WaitForStatus(ServiceControllerStatus.Stopped);
                }
                service.Start();
                service.WaitForStatus(ServiceControllerStatus.Running);

                PushContent = "socket通讯出现异常，服务已重启";
                string url = WebAPIUrl + "WeChat/RunningBulletinPush";//消息推送接口
                //调用消息推送接口
                EShang.Common.HttpUtil.HttpUrlPost("SecondContent=" + PushContent, url);

                LogUtil.WriteLog(null, "重启服务结束，服务名：【" + ServiceName + "】",
                    DateTime.Now.ToString("yyyyMMdd") + "_DataTransmission");
            }
            catch (Exception ex)
            {
                LogUtil.WriteLog(null, "重启服务失败，服务名：【" + ServiceName + "】, 失败原因：【" +
                    ex.Message + "】", DateTime.Now.ToString("yyyyMMdd") + "_DataTransmission_Error");
            }
        }
        #endregion

        #region 方法 -> 执行“数据处理”操作
        private void ExcuteDealData()
        {
            DateTime curDateTime = DateTime.Now;

            if (curDateTime.Hour == 1 && curDateTime.Minute == 30)
            {
                #region 时段数据统计
                try
                {
                    LogUtil.WriteLog(null, "///------------【时段数据统计】开始执行------------///",
                        curDateTime.ToString("yyyyMMdd") + "_DataTransmission");
                    //创建车流数据库链接
                    Method.OracleHelper _OracleHelper = new Method.OracleHelper(OracleConnStr.Split(',')[0],
                        OracleConnStr.Split(',')[1], OracleConnStr.Split(',')[2], OracleConnStr.Split(',')[3]);
                    BayonetHelper.GetHourInOut(_OracleHelper);
                    //创建销售流水数据库链接
                    Method.OracleHelper _OracleHelperEx = new Method.OracleHelper(OracleConnStrEx.Split(',')[0],
                        OracleConnStrEx.Split(',')[1], OracleConnStrEx.Split(',')[2], OracleConnStrEx.Split(',')[3]);
                    //统计月度门店消费水平
                    CuringDataHelper.GetShopConsumptionLevel(_OracleHelper, _OracleHelperEx, -1);
                    //统计月度时段销售流水
                    CuringDataHelper.GetHourSellMaster(_OracleHelper, _OracleHelperEx, -1);
                }
                catch (Exception ex)
                {
                    LogUtil.WriteLog(null, "【时段数据统计】执行失败，失败原因：【" + ex.Message + "】",
                        curDateTime.ToString("yyyyMMdd") + "_DataTransmission_Error");
                }
                finally
                {
                    LogUtil.WriteLog(null, "///------------【时段数据统计】执行结束------------///",
                        curDateTime.ToString("yyyyMMdd") + "_DataTransmission");
                }
                #endregion
            }
            else
            {
                if (curDateTime.Hour >= 6 && curDateTime.Hour < 9)
                {
                    #region 每日6点至9点之间，每隔半小时从客无忧获取移动支付分账数据
                    //创建卡口流水数据库链接
                    Method.OracleHelper _OracleHelper = new Method.OracleHelper(OracleConnStr.Split(',')[0],
                        OracleConnStr.Split(',')[1], OracleConnStr.Split(',')[2], OracleConnStr.Split(',')[3]);
                    if (curDateTime.Hour == 8 && curDateTime.Minute >= 30)
                    {
                        //生成服务区营收固化数据
                        CuringDataHelper.CalculateRevenue(_OracleHelper);
                        //生成昨日应收拆分数据
                        //BusinessProjectHelper.RebuildSplitData(_OracleHelper);
                    }
                    else
                    {
                        //创建合作商户数据库链接
                        Method.OracleHelper _OracleHelper_Coop = new Method.OracleHelper(OracleConnStr_Coop.Split(',')[0],
                            OracleConnStr_Coop.Split(',')[1], OracleConnStr_Coop.Split(',')[2], OracleConnStr_Coop.Split(',')[3]);

                        //生成车流量预警数据
                        BayonetHelper.RecordWarningData(_OracleHelper, compareMonth, curDateTime.AddHours(-1).Hour);
                        if (curDateTime.Hour == 7)
                        {
                            //更新断面流量服务区标识
                            BayonetHelper.UpdateSectionFlow(_OracleHelper);
                            //模拟车流量数值
                            //BayonetHelper.AnalogBayonet(_OracleHelper, DateTime.Now.AddDays(-1));
                        }
                        else if (curDateTime.Hour == 8)
                        {
                            PushFixedRent(_OracleHelper);
                        }
                        //生成服务区营收固化数据
                        CuringDataHelper.CalculateRevenue(_OracleHelper);
                        //执行万佳商品调价审批预生效
                        BusinessLogHelper.PutInStorageGoods(_OracleHelper);

                        if (curDateTime.Hour == 8)
                        {
                            //创建建行、工行对账数据库链接
                            //Method.OracleHelper _OracleConnStrEx = new Method.OracleHelper(OracleConnStrEx.Split(',')[0],
                            //    OracleConnStrEx.Split(',')[1], OracleConnStrEx.Split(',')[2], OracleConnStrEx.Split(',')[3]);
                            ////验证移动支付分账数据的一致性
                            //MobilePayHelper.ValidateRoyaltyMobilePay(_OracleHelper, _OracleHelper_Coop,
                            //    _OracleConnStrEx, curDateTime.AddDays(-1).ToString("yyyyMMdd"));
                            ////存储营收分账数据
                            //CuringDataHelper.BuildDailyRevenueSplit(_OracleHelper, _OracleHelper_Coop,
                            //    _OracleConnStrEx, curDateTime.AddDays(-1).ToString("yyyyMMdd"));
                            //CuringDataHelper.ValidateSplitRevenue(_OracleHelper, _OracleHelper_Coop,
                            //    _OracleConnStrEx, curDateTime.AddDays(-1).ToString("yyyy-MM-dd"));
                            //生成昨日应收拆分数据
                            //BusinessProjectHelper.RebuildSplitData(_OracleHelper);
                            CuringDataHelper.CorrectShopCigarette(_OracleHelper, curDateTime.AddDays(-1), "511300");
                        }
                        else
                        {
                            //获取移动支付分账数据
                            MobilePayHelper.GetKwyMobileShare(_OracleHelper, _OracleHelper_Coop, curDateTime.AddDays(-1));
                            //获取资金返款分账数据
                            MobilePayHelper.GetRefundMobilePay(_OracleHelper, _OracleHelper_Coop, curDateTime.AddDays(-1), "511300");
                        }

                        if (curDateTime.Hour == 6)
                        {
                            CuringDataHelper.SolidServerpartWeather(_OracleHelper);
                        }
                    }
                    #endregion
                }
                else if (curDateTime.Hour >= 9 && curDateTime.Hour <= 23)
                {
                    if (curDateTime.Hour == 9 && curDateTime.Minute >= 30)
                    {
                        //创建营收固化数据库链接
                        Method.OracleHelper _OracleHelper = new Method.OracleHelper(OracleConnStr.Split(',')[0],
                            OracleConnStr.Split(',')[1], OracleConnStr.Split(',')[2], OracleConnStr.Split(',')[3]);
                        //生成服务区营收固化数据
                        CuringDataHelper.CalculateRevenue(_OracleHelper);

                        if (curDateTime.Minute >= 45)
                        {
                            //生成卡口流水月度汇总数据
                            BayonetHelper.CalculateBayonet(curDateTime.AddDays(-1).ToString("yyyyMM"));
                        }
                        else if (curDateTime.Minute >= 30)
                        {
                            //创建建行、工行对账数据库链接
                            Method.OracleHelper _OracleConnStrEx = new Method.OracleHelper(OracleConnStrEx.Split(',')[0],
                                OracleConnStrEx.Split(',')[1], OracleConnStrEx.Split(',')[2], OracleConnStrEx.Split(',')[3]);
                            //创建合作商户数据库链接
                            Method.OracleHelper _OracleHelper_Coop = new Method.OracleHelper(OracleConnStr_Coop.Split(',')[0],
                                OracleConnStr_Coop.Split(',')[1], OracleConnStr_Coop.Split(',')[2], OracleConnStr_Coop.Split(',')[3]);

                            //存储营收分账数据
                            CuringDataHelper.BuildDailyRevenueSplit(_OracleHelper, _OracleHelper_Coop,
                                _OracleConnStrEx, curDateTime.AddDays(-1).ToString("yyyyMMdd"), "", true);
                            CuringDataHelper.BuildRefundSplit(_OracleHelper, _OracleHelper_Coop, _OracleConnStrEx,
                                curDateTime.AddDays(-1).ToString("yyyyMMdd"), "511300", "", true);
                            //生成昨日应收拆分数据
                            BusinessProjectHelper.RebuildSplitData(_OracleHelper);
                            //存储昨日移动支付银行到账数据
                            MobilePayHelper.SolidBankAccount(_OracleHelper_Coop, curDateTime.AddDays(-1).ToShortDateString(),
                                curDateTime.AddDays(-1).ToShortDateString());

                            //验证营收分账数据的一致性
                            CuringDataHelper.ValidateSplitRevenue(_OracleHelper, _OracleHelper_Coop,
                                _OracleConnStrEx, curDateTime.AddDays(-1).ToString("yyyy-MM-dd"));
                            CuringDataHelper.ValidateRefundSplitRevenue(_OracleHelper, _OracleHelper_Coop, _OracleConnStrEx,
                                curDateTime.AddDays(-1).ToShortDateString(), "511300");
                        }
                    }
                    else if (curDateTime.Hour == 10 && curDateTime.Minute >= 30)
                    {
                        //创建业务日志数据库链接
                        Method.OracleHelper _OracleHelper = new Method.OracleHelper(OracleConnStr.Split(',')[0],
                            OracleConnStr.Split(',')[1], OracleConnStr.Split(',')[2], OracleConnStr.Split(',')[3]);

                        #region 推送即将到期商品
                        string SQLString = string.Format(@"SELECT COUNT(1) AS TOTALCOUNT,SERVERPART_ID,SERVERPART_NAME 
                            FROM HIGHWAY_STORAGE.T_COMMODITY_TEMP 
                            WHERE STATISTICS_DATE = {0} AND COMMODITY_TEMP_STATE = 1 
                            GROUP BY SERVERPART_ID,SERVERPART_NAME", curDateTime.ToString("yyyyMMdd"));
                        DataTable dtQualification = _OracleHelper.ExcuteSqlGetDataSet(SQLString).Tables[0];
                        if (dtQualification.Rows.Count > 0)
                        {
                            string url = EShangApiMain + "WeChat/WeChatPushMessage";

                            foreach (DataRow drQualification in dtQualification.Rows)
                            {
                                WeChatPushModel weChatPushModel = new WeChatPushModel();

                                weChatPushModel.PushModule = "WarningAttention";
                                weChatPushModel.JumpUrl = "pages/commodity_temp/index?serverpartid=" +
                                    drQualification["SERVERPART_ID"] + "&statisticsdate=" + curDateTime.ToShortDateString();

                                weChatPushModel.PushParameterObject = new PushParameter();
                                weChatPushModel.PushParameterObject.ServerpartIds = drQualification["SERVERPART_ID"].ToString();

                                weChatPushModel.PushContentObject = new PushContent();
                                weChatPushModel.PushContentObject.TitleContent = "商品资质到期预警通知";
                                weChatPushModel.PushContentObject.FisrtContent = "您的" + drQualification["SERVERPART_NAME"] +
                                    "有" + drQualification[0] + "件商品资质证书即将过期";
                                weChatPushModel.PushContentObject.SecondContent = curDateTime.ToString();
                                weChatPushModel.PushContentObject.LastContent = "注：过期商品将无法售卖！小程序只支持连续3次的3天临时延期设置";

                                string Result = EShang.Common.HttpUtil.HttpUrlPost(JsonConvert.SerializeObject(weChatPushModel), url, "application/json");

                                LogUtil.WriteLog(null, "推送【资质到期提醒日志】返回结果：" + Result, curDateTime.ToString("yyyyMMdd") + "_WeChatPush");
                            }
                        }
                        #endregion

                        //推送驿达万佳供应商检测报告预警
                        CuringDataHelper.PushCheckReport(_OracleHelper);
                    }
                    else
                    {
                        //每日9点开始每隔1小时进行异常数据检测
                        GetEndaccountException();
                    }
                }
                else if (curDateTime.Hour == 1)
                {
                    #region 卡口日汇总统计
                    try
                    {
                        LogUtil.WriteLog(null, "///------------【卡口日汇总统计】开始执行------------///",
                            curDateTime.ToString("yyyyMMdd") + "_DataTransmission");
                        //创建卡口流水数据库链接
                        Method.OracleHelper _OracleHelper = new Method.OracleHelper(OracleConnStr.Split(',')[0],
                            OracleConnStr.Split(',')[1], OracleConnStr.Split(',')[2], OracleConnStr.Split(',')[3]);
                        //记录车流预警数据
                        BayonetHelper.RecordWarningData(_OracleHelper, compareMonth, curDateTime.AddHours(-1).Hour);
                        //生成卡口流水固化表数据
                        BayonetHelper.GetDailyInOut(_OracleHelper);
                        BayonetHelper.GetDailyVehicleOwner(_OracleHelper);
                        BayonetHelper.GetMonthlyVehicleOwner(_OracleHelper);
                        BayonetHelper.GetAllMonthlyVehicleOwner(_OracleHelper, curDateTime.ToString("yyyyMM"));
                        //删除历史卡口流水数据
                        BayonetHelper.DeleteBayonet(_OracleHelper);
                    }
                    catch (Exception ex)
                    {
                        LogUtil.WriteLog(null, "【卡口日汇总统计】执行失败，失败原因：【" + ex.Message + "】",
                            curDateTime.ToString("yyyyMMdd") + "_DataTransmission_Error");
                    }
                    finally
                    {
                        LogUtil.WriteLog(null, "///------------【卡口日汇总统计】执行结束------------///",
                            curDateTime.ToString("yyyyMMdd") + "_DataTransmission");
                    }
                    #endregion
                }
                else if (curDateTime.Hour == 2 && curDateTime.Minute == 0)
                {
                    #region 应收账款数据处理
                    try
                    {
                        LogUtil.WriteLog(null, "///------------【应收账款数据处理】开始执行------------///",
                            curDateTime.ToString("yyyyMMdd") + "_DataTransmission");
                        //创建应收账款数据库链接
                        Method.OracleHelper _OracleHelper = new Method.OracleHelper(OracleConnStr.Split(',')[0],
                            OracleConnStr.Split(',')[1], OracleConnStr.Split(',')[2], OracleConnStr.Split(',')[3]);
                        //记录车流预警数据
                        BayonetHelper.RecordWarningData(_OracleHelper, compareMonth, curDateTime.AddHours(-1).Hour);
                        //如果是本月1号，则生成上个月的门店费用记录
                        if (curDateTime.Day == 1)
                        {
                            BusinessProjectHelper.CreateShopExpenses(_OracleHelper, curDateTime.AddDays(-1).ToString("yyyyMM"));
                        }
                        //应收账款数据处理
                        //BusinessProjectHelper.BuildProjectData(_OracleHelper);
                    }
                    catch (Exception ex)
                    {
                        LogUtil.WriteLog(null, "【应收账款数据处理】执行失败，失败原因：【" + ex.Message + "】",
                            curDateTime.ToString("yyyyMMdd") + "_DataTransmission_Error");
                    }
                    finally
                    {
                        LogUtil.WriteLog(null, "///------------【应收账款数据处理】执行结束------------///",
                            curDateTime.ToString("yyyyMMdd") + "_DataTransmission");
                    }
                    #endregion
                }
                else if (curDateTime.Hour == 2 && curDateTime.Minute == 30)
                {
                    #region 拉取驿达考核、巡检数据
                    try
                    {
                        LogUtil.WriteLog(null, "///------------【拉取驿达考核、巡检数据】开始执行------------///",
                            curDateTime.ToString("yyyyMMdd") + "_DataTransmission");
                        //创建业务日志数据库链接
                        Method.OracleHelper _OracleHelper = new Method.OracleHelper(OracleConnStr.Split(',')[0],
                            OracleConnStr.Split(',')[1], OracleConnStr.Split(',')[2], OracleConnStr.Split(',')[3]);
                        ////创建四川进销存数据库链接
                        //Method.OracleHelper _OracleHelper_SC = new Method.OracleHelper(OracleConnStr_SC.Split(',')[0],
                        //    OracleConnStr_SC.Split(',')[1], OracleConnStr_SC.Split(',')[2], OracleConnStr_SC.Split(',')[3]);
                        ////生成供应商门店库存数据
                        //CuringDataHelper.GetSupplierShopStock(_OracleHelper, _OracleHelper_SC);
                        ExamineHelper.GetExamineData(_OracleHelper, curDateTime.AddDays(-1).ToShortDateString(),
                            curDateTime.AddDays(-1).ToShortDateString());
                    }
                    catch (Exception ex)
                    {
                        LogUtil.WriteLog(null, "【拉取驿达考核、巡检数据】执行失败，失败原因：【" + ex.Message + "】",
                            curDateTime.ToString("yyyyMMdd") + "_DataTransmission_Error");
                    }
                    finally
                    {
                        LogUtil.WriteLog(null, "///------------【拉取驿达考核、巡检数据】执行结束------------///",
                            curDateTime.ToString("yyyyMMdd") + "_DataTransmission");
                    }
                    #endregion
                }
                else if (curDateTime.Hour == 3 && curDateTime.Minute == 0)
                {
                    #region 固化数据【客群分析、单品报表】
                    try
                    {
                        //创建固化单品报表数据库链接
                        Method.OracleHelper _OracleHelper = new Method.OracleHelper(OracleConnStr.Split(',')[0],
                            OracleConnStr.Split(',')[1], OracleConnStr.Split(',')[2], OracleConnStr.Split(',')[3]);
                        //记录车流预警数据
                        BayonetHelper.RecordWarningData(_OracleHelper, compareMonth, curDateTime.AddHours(-1).Hour);

                        int IntervalMonth = ConfigurationManager.AppSettings["Interval"].TryParseToInt();
                        if (curDateTime.Day == 1)
                        {
                            LogUtil.WriteLog(null, "///------------固化数据【客群分析】开始执行------------///",
                                curDateTime.ToString("yyyyMMdd") + "_DataTransmission");

                            //创建客群分析数据库链接
                            Method.OracleHelper _OracleHelperEx = new Method.OracleHelper(OracleConnStrEx.Split(',')[0],
                                OracleConnStrEx.Split(',')[1], OracleConnStrEx.Split(',')[2], OracleConnStrEx.Split(',')[3]);
                            CustomerHelper.CustomerDataCuring(_OracleHelperEx,
                                curDateTime.AddMonths(IntervalMonth).ToString("yyyyMM01000000"),
                                curDateTime.AddMonths(IntervalMonth + 1).ToString("yyyyMM01000000"));
                        }
                        else if (curDateTime.Day == 2)
                        {
                            LogUtil.WriteLog(null, "///------------固化数据【单品报表】开始执行------------///",
                                curDateTime.ToString("yyyyMMdd") + "_DataTransmission");
                            //生成固化单品报表数据
                            CuringDataHelper.CommoditySaleCuring(_OracleHelper,
                                curDateTime.AddMonths(IntervalMonth).ToString("yyyy-MM-01"),
                                curDateTime.AddMonths(IntervalMonth + 1).ToString("yyyy-MM-01"));
                        }
                    }
                    catch (Exception ex)
                    {
                        LogUtil.WriteLog(null, "固化数据【客群分析、单品报表】执行失败，失败原因：【" + ex.Message + "】",
                            curDateTime.ToString("yyyyMMdd") + "_DataTransmission_Error");
                    }
                    finally
                    {
                        LogUtil.WriteLog(null, "///------------固化数据【客群分析、单品报表】执行结束------------///",
                            curDateTime.ToString("yyyyMMdd") + "_DataTransmission");
                    }
                    #endregion
                }
                else if (curDateTime.Hour == 4)
                {
                    #region 固化数据【商品表临期数据、更新各业主有效门店数量、生成供应商原材料价格浮动表、生成实时库存信息】
                    try
                    {
                        int TimeLimit = ConfigurationManager.AppSettings["TimeLimit"].TryParseToInt(7);
                        LogUtil.WriteLog(null, "///------------固化数据开始执行------------///",
                            curDateTime.ToString("yyyyMMdd") + "_DataTransmission");
                        //创建资质证书表数据库链接
                        Method.OracleHelper _OracleHelperCM = new Method.OracleHelper(OracleConnStr_Coop.Split(',')[0],
                            OracleConnStr_Coop.Split(',')[1], OracleConnStr_Coop.Split(',')[2], OracleConnStr_Coop.Split(',')[3]);
                        //创建商品表数据库链接
                        Method.OracleHelper _OracleHelper = new Method.OracleHelper(OracleConnStr.Split(',')[0],
                            OracleConnStr.Split(',')[1], OracleConnStr.Split(',')[2], OracleConnStr.Split(',')[3]);
                        //记录车流预警数据
                        BayonetHelper.RecordWarningData(_OracleHelper, compareMonth, curDateTime.AddHours(-1).Hour);

                        //生成资质即将到期的商品数据
                        CuringDataHelper.CreateCommodityTempData(_OracleHelper, _OracleHelperCM, TimeLimit);
                        //更新各业主有效门店数量
                        CuringDataHelper.ModifyShopCount();

                        //延迟1s执行
                        System.Threading.Thread.Sleep(1000);

                        //生成供应商原材料价格浮动表
                        CuringDataHelper.CalculateDeviate();
                        ////生成实时库存信息
                        //CuringDataHelper.CalculateCurStock(_OracleHelper);

                        //创建客群分析表数据库链接
                        Method.OracleHelper _OracleHelperEx = new Method.OracleHelper(OracleConnStrEx.Split(',')[0],
                            OracleConnStrEx.Split(',')[1], OracleConnStrEx.Split(',')[2], OracleConnStrEx.Split(',')[3]);
                        //生成客群偏好统计表数据
                        CustomerHelper.CalculateCustomerShop(_OracleHelper, _OracleHelperEx, curDateTime.AddDays(-1).ToString("yyyyMM"));
                        //CustomerHelper.CalculateCustomerSale(_OracleHelper, _OracleHelperEx, curDateTime.AddDays(-1).ToString("yyyyMM"));
                    }
                    catch (Exception ex)
                    {
                        LogUtil.WriteLog(null, "固化数据执行失败，失败原因：【" + ex.Message + "】",
                            curDateTime.ToString("yyyyMMdd") + "_DataTransmission_Error");
                    }
                    finally
                    {
                        LogUtil.WriteLog(null, "///------------固化数据执行结束------------///",
                            curDateTime.ToString("yyyyMMdd") + "_DataTransmission");
                    }
                    #endregion
                }
                else if (curDateTime.Hour == 0)
                {
                    //创建卡口流水数据库链接
                    Method.OracleHelper _OracleHelper = new Method.OracleHelper(OracleConnStr.Split(',')[0],
                        OracleConnStr.Split(',')[1], OracleConnStr.Split(',')[2], OracleConnStr.Split(',')[3]);
                    //创建合作商户数据库链接
                    Method.OracleHelper _OracleHelper_Coop = new Method.OracleHelper(OracleConnStr_Coop.Split(',')[0],
                        OracleConnStr_Coop.Split(',')[1], OracleConnStr_Coop.Split(',')[2], OracleConnStr_Coop.Split(',')[3]);

                    //判断是否有经营项目到了新周期的第一天，要重新下发分账比例
                    MobilePayHelper.NewPeriodIssueCommand(_OracleHelper, _OracleHelper_Coop, curDateTime.ToString("yyyyMMdd"));
                    //下发移动支付切换指令
                    MobilePayHelper.IssueCommand(_OracleHelper, _OracleHelper_Coop, curDateTime.ToString("yyyyMMdd"));
                    //生成车流量预警数据
                    BayonetHelper.RecordWarningData(_OracleHelper, compareMonth, curDateTime.AddHours(-1).Hour);
                    //更新门店经营状态
                    //BaseInfoHelper.ModifyShopState(_OracleHelper);
                    //执行万佳商品调价审批预生效
                    BusinessLogHelper.PutInStorageGoods(_OracleHelper);
                }
                else if (curDateTime.Hour == 5)
                {
                    //创建卡口流水数据库链接
                    Method.OracleHelper _OracleHelper = new Method.OracleHelper(OracleConnStr.Split(',')[0],
                        OracleConnStr.Split(',')[1], OracleConnStr.Split(',')[2], OracleConnStr.Split(',')[3]);

                    //生成车流量预警数据
                    BayonetHelper.RecordWarningData(_OracleHelper, compareMonth, curDateTime.AddHours(-1).Hour);
                }
            }
        }
        #endregion

        #region 方法 -> 查询异常日志，并进行微信推送
        /// <summary>
        /// 获取账期异常单品情况（销售单品和实收金额不一致）
        /// 获取CHECK_STATE=0的日志记录，并查询对应的单品数据是否与实收金额一致
        /// 若一致，则重新生成库存单品销售日志（记录文本日志）
        /// 若不一致，则在消息推送中标注说明（记录文本日志）
        /// </summary>
        private void GetEndaccountException()
        {
            DateTime curDateTime = DateTime.Now;

            try
            {
                string SQLString;
                //定义变量：已处理的记录条数，仍存在异常的记录条数
                int DealCount = 0, ExceptionCount = 0;

                //创建业务日志数据库链接
                Method.OracleHelper _OracleHelper = new Method.OracleHelper(OracleConnStr.Split(',')[0],
                    OracleConnStr.Split(',')[1], OracleConnStr.Split(',')[2], OracleConnStr.Split(',')[3]);
                //创建四川进销存数据库链接
                Method.OracleHelper _OracleHelper_SC = new Method.OracleHelper(OracleConnStr_SC.Split(',')[0],
                    OracleConnStr_SC.Split(',')[1], OracleConnStr_SC.Split(',')[2], OracleConnStr_SC.Split(',')[3]);
                //创建合作商户数据库链接
                Method.OracleHelper _OracleHelper_Coop = new Method.OracleHelper(OracleConnStr_Coop.Split(',')[0],
                    OracleConnStr_Coop.Split(',')[1], OracleConnStr_Coop.Split(',')[2], OracleConnStr_Coop.Split(',')[3]);
                //创建建行、工行对账数据库链接
                Method.OracleHelper _OracleConnStrEx = new Method.OracleHelper(OracleConnStrEx.Split(',')[0],
                    OracleConnStrEx.Split(',')[1], OracleConnStrEx.Split(',')[2], OracleConnStrEx.Split(',')[3]);
                //创建移动支付业务数据库链接
                Method.OracleHelper _OracleHelper_Msp = new Method.OracleHelper(OracleConnStr_Msp.Split(',')[0],
                    OracleConnStr_Msp.Split(',')[1], OracleConnStr_Msp.Split(',')[2], OracleConnStr_Msp.Split(',')[3]);

                //万佳配送：超时订单催单提醒
                BayonetHelper.RecordWarningData(_OracleHelper, compareMonth, curDateTime.AddHours(-1).Hour);
                //执行万佳商品调价审批预生效
                BusinessLogHelper.PutInStorageGoods(_OracleHelper);

                #region 查询单品不一致的账期数据，并进行单品数据重新验证【统计数量去除陶山服务区北区浙鑫小吃】
                //查询当天有单品不一致的异常数据，CHECK_STATE=0
                //陶山服务区北区浙鑫小吃：SERVERPARTCODE【330342】，SHOPCODE【143004】
                DataTable _DataTable = BusinessLogHelper.GetSaleData(_OracleHelper, "100000");

                if (_DataTable.Rows.Count > 0)
                {
                    //有差异数据进行推送消息
                    foreach (DataRow dataRow in _DataTable.Rows)
                    {
                        string LogCentent = "开始对账期【唯一标识：" + dataRow[1] + "，内码：" + dataRow[0] + "】进行单品验证操作";
                        LogUtil.WriteLog(null, LogCentent, curDateTime.ToString("yyyyMMdd") + "_DataTransmission");
                        //获取业务内码
                        int BusinessId = dataRow[0].TryParseToInt();
                        //获取商品业态
                        string BusinessType = dataRow["BUSINESSTYPE"].ToString();
                        //获取日志中的账期唯一标识，格式：服务区编码|门店编码|日结时间|机器编码|实收金额
                        string UniqueCode = dataRow[1].ToString();
                        if (!string.IsNullOrWhiteSpace(UniqueCode))
                        {
                            string ServerpartCode = UniqueCode.Split('|')[0];   //服务区编码
                            string ShopCode = UniqueCode.Split('|')[1];         //门店编码
                            string EndaccountDate = UniqueCode.Split('|')[2];   //日结时间
                            string MachineCode = UniqueCode.Split('|')[3];      //机器编码

                            //获取账期单品金额，判断是否和实收金额一致
                            DataTable dtSaleTotalData = BusinessLogHelper.GetSaleTotalData(_OracleHelper,
                                ServerpartCode, ShopCode, EndaccountDate, MachineCode);

                            if (dtSaleTotalData.Rows.Count > 0)
                            {
                                //获取账期实收金额
                                decimal CashPay = UniqueCode.Split('|')[4].TryParseToDecimal();
                                //获取单品销售金额
                                decimal TotalSaleAmount = dtSaleTotalData.Rows[0][1].TryParseToDecimal();
                                if (CashPay == TotalSaleAmount)
                                {
                                    //定义校验后的日志内容
                                    string BusinessLogContent = dataRow[3].ToString().Split("单品销售金额：")[0] +
                                        "单品销售金额：" + TotalSaleAmount + "，实收金额：" + CashPay;

                                    DataTable dtShopInfo = BusinessLogHelper.GetInSaleShop(_OracleHelper, ServerpartCode, ShopCode);
                                    if (dtShopInfo.Rows.Count == 0)
                                    {
                                        LogCentent = "单品验证成功";

                                        //更新日志反查标识为1
                                        BusinessLogHelper.UpdateBusinessLogCheckState(_OracleHelper, 100000,
                                            BusinessId, "T_ENDACCOUNT", "HIGHWAY_SELLDATA", 1, BusinessLogContent);

                                        if (ServerpartCode != "330342" && ShopCode != "143004")
                                        {
                                            DealCount++;
                                        }
                                    }
                                    else
                                    {
                                        string ServerpartShopID = dtShopInfo.Rows[0][0].ToString();
                                        //获取日结单品异常数据
                                        DataTable dtSales = StockLogHelper.GetSaleData(_OracleHelper, ServerpartCode,
                                            ShopCode, EndaccountDate, MachineCode, dtShopInfo.Rows[0][0].ToString());
                                        if (BusinessType.StartsWith("3"))
                                        {
                                            if (StockLogHelper.AddRestaurantStockLog(_OracleHelper, 5000, BusinessId,
                                                dtSales, EndaccountDate, ServerpartShopID, BusinessLogContent))
                                            {
                                                LogCentent = "餐饮进销存单品数据记录与数据库一致，单品验证成功";

                                                if (ServerpartCode != "330342" && ShopCode != "143004")
                                                {
                                                    DealCount++;
                                                }
                                            }
                                            else
                                            {
                                                LogCentent = "餐饮进销存单品数据记录与数据库不一致，单品验证失败";

                                                if (ServerpartCode != "330342" && ShopCode != "143004")
                                                {
                                                    ExceptionCount++;
                                                }
                                            }
                                        }
                                        else
                                        {
                                            bool DealFlag = false;
                                            if (ServerpartCode.StartsWith("51"))
                                            {
                                                //如果服务区编码是51开头，标识是四川的服务区，进销存数据库调取_OracleHelper_SC；
                                                DealFlag = StockLogHelper.AddStockLog(_OracleHelper, _OracleHelper_SC, 5000,
                                                    BusinessId, dtSales, EndaccountDate, ServerpartShopID, BusinessLogContent);
                                            }
                                            else
                                            {
                                                //其他服务区的进销存数据为_OracleHelper
                                                DealFlag = StockLogHelper.AddStockLog(_OracleHelper, _OracleHelper, 5000,
                                                    BusinessId, dtSales, EndaccountDate, ServerpartShopID, BusinessLogContent);
                                            }
                                            if (DealFlag)
                                            {
                                                LogCentent = "进销存单品数据记录与数据库一致，单品验证成功";

                                                if (ServerpartCode != "330342" && ShopCode != "143004")
                                                {
                                                    DealCount++;
                                                }
                                            }
                                            else
                                            {
                                                LogCentent = "进销存单品数据记录与数据库不一致，单品验证失败";

                                                if (ServerpartCode != "330342" && ShopCode != "143004")
                                                {
                                                    ExceptionCount++;
                                                }
                                            }
                                        }
                                    }
                                }
                                else
                                {
                                    LogCentent = "单品金额与实收金额不一致，单品验证失败";

                                    if (ServerpartCode != "330342" && ShopCode != "143004")
                                    {
                                        ExceptionCount++;
                                    }
                                }
                            }
                            else
                            {
                                LogCentent = "单品数据未上传，单品验证失败";

                                if (ServerpartCode != "330342" && ShopCode != "143004")
                                {
                                    ExceptionCount++;
                                }
                            }
                        }
                        else
                        {
                            LogCentent = "账期唯一标识不存在，单品验证失败";

                            if (dataRow["SERVERPARTCODE"].ToString() != "330342" && dataRow["SHOPCODE"].ToString() != "143004")
                            {
                                ExceptionCount++;
                            }
                        }

                        LogUtil.WriteLog(null, LogCentent, curDateTime.ToString("yyyyMMdd") + "_DataTransmission");
                    }

                    PushContent = string.Format("处理{0}条单品数据，{1}条单品不一致；", DealCount, ExceptionCount);
                }
                else
                {
                    PushContent = "单品数据无异常；";
                }
                #endregion

                #region 推送异常日志消息提醒
                switch (curDateTime.Hour)
                {
                    case 13:
                    case 18:
                    case 23:
                        DataTable dtMaterialData = BusinessLogHelper.GetBusinessLogErrorData(_OracleHelper, "701000,702000,703000,704000,705000");
                        PushContent += "餐饮成本管控异常日志" + dtMaterialData.Rows.Count + "条；";

                        DataTable dtInSaleData = BusinessLogHelper.GetBusinessLogErrorData(_OracleHelper, "201000,202000,203000,204000");
                        PushContent += "进销存异常日志" + dtInSaleData.Rows.Count + "条；";

                        //23点是最后一次推送，将统计总仓实时库存表与业务记录是否一致
                        if (curDateTime.Hour == 23)
                        {
                            //迁移前天的正常日志记录
                            BusinessLogHelper.RemoveBuisnessLog(_OracleHelper, _OracleConnStrEx);

                            //记录进销存重复入库记录
                            int RepeatCount = StockLogHelper.GetRepeatStorageBill(_OracleHelper, _OracleHelper_SC);
                            PushContent += "进销存重复入库" + RepeatCount + "条；";

                            //查询总仓异常库存记录
                            //CompareWareHouseStock(_OracleHelper, ref PushContent);

                            //查询移动支付到账差异数据
                            DataTable dtBankAccountLogData = BusinessLogHelper.GetBusinessLogErrorData(_OracleHelper, "1");
                            PushContent += "移动支付到账差异" + dtBankAccountLogData.Select("CHANNEL_AMOUNT <> 0").Length + "条；";
                        }
                        //查询解压缩异常数据
                        DataTable dtErrorLogData = BusinessLogHelper.GetBusinessLogErrorData(_OracleHelper, "0");
                        if (dtErrorLogData.Select("TABLE_NAME like '%_ReEndAccount.zip'").Length > 0)
                        {
                            DataTable dtReEndAccount = dtErrorLogData.Select("TABLE_NAME like '%_ReEndAccount.zip'").CopyToDataTable();
                            SQLString = "UPDATE PLATFORM_FRAMEWORK.T_BUSINESSLOG SET CHECK_STATE = 1 WHERE BUSINESSLOG_ID IN (" +
                                EShang.Common.CommonHelper.JoinStrFromDataTable(dtReEndAccount, "BUSINESSLOG_ID") + ") AND CHECK_STATE = 0";
                        }
                        PushContent += "解压缩异常" + dtErrorLogData.Select("TABLE_NAME not like '%_ReEndAccount.zip'").Length + "条；";

                        //查询日结账期异常数据
                        DataTable dtEndaccountErrorData = BusinessLogHelper.GetEndaccountErrorData(_OracleConnStrEx);
                        PushContent += "日结账期异常" + dtEndaccountErrorData.Select("CHECK_STATE is null").Length + "条；";

                        //查询移动支付分账异常数据
                        DataTable dtRoyaltyErrorData = BusinessLogHelper.GetBusinessLogErrorData(_OracleHelper, "9");
                        PushContent += "移动支付分账差异" + dtRoyaltyErrorData.Select("SERVERPARTCODE <> '348888'").Length + "条；";

                        //查询未传输的移动支付门店数据
                        DataTable dtMobilePayErrorData = BusinessLogHelper.GetBusinessLogErrorData(_OracleHelper, "12");
                        PushContent += "移动支付未传输门店" + dtMobilePayErrorData.Select("SERVERPARTCODE <> '348888'").Length + "条";

                        //获取消息推送接口地址
                        string url = EShangApiMain + "WeChat/RunningBulletinPush";
                        //调用消息推送接口
                        string Result = EShang.Common.HttpUtil.HttpUrlPost("SecondContent=" + PushContent, url);

                        LogUtil.WriteLog(null, "推送【异常日志】返回结果：" + Result, curDateTime.ToString("yyyyMMdd") + "_WeChatPush");
                        break;
                }
                #endregion

                //生成服务区营收固化数据
                CuringDataHelper.CalculateRevenue(_OracleHelper);
                //更新门店经营状态
                //BaseInfoHelper.ModifyShopState(_OracleHelper);

                if (curDateTime.Hour == 10 || curDateTime.Hour == 18)
                {
                    //BusinessProjectHelper.SendSMSMessage(_OracleHelper);
                }
                else if (curDateTime.Hour == 12)
                {
                    #region 12点执行进程：固化营收数据；生成项目预警并推送；生成所有项目应收拆分；
                    //生成服务区业态营收汇总数据，验证日期从上月1号至昨日的日度数据，上月和本月的月度数据，并记录异常数据
                    VerifyRevenueData(_OracleHelper);
                    //检测客无忧没传数据的门店
                    string[] provinceCodeList = { "330200", "330300", "340000", "500000", "520000", "630000" };
                    foreach (string province_code in provinceCodeList)
                    {
                        string trade_date = curDateTime.AddDays(-1).ToString("yyyy-MM-dd");
                        List<Model.AccountModel> AccountList = AccountHelper.GetAccountList(
                            _OracleHelper, _OracleHelper_Coop, province_code, "1005", trade_date);
                    }

                    //生成经营项目预警数据，并进行推送
                    BusinessProjectHelper.ProjectWarning(_OracleHelper, curDateTime.AddDays(-1).ToString("yyyyMMdd"));
                    //推送分账比例切换审批
                    PushProjectWarning(_OracleHelper);
                    //推送年度结算提单提醒
                    PushBillLading(_OracleHelper);
                    ////拉取驿达考核、巡检数据
                    //ExamineHelper.GetExamineData(_OracleHelper, curDateTime.ToShortDateString(), curDateTime.ToShortDateString());
                    ////重新校验移动支付到账差异数据
                    //MobilePayHelper.RecheckMobileShare(_OracleHelper, _OracleHelper_Coop, _OracleConnStrEx);
                    ////推送营收拆分差异数据
                    //PushRevenueWarning(_OracleHelper, DateTime.Now.AddDays(-1));
                    //生成昨日应收拆分数据
                    BusinessProjectHelper.RebuildSplitData(_OracleHelper);
                    //生成本月营收分润的项目财务报表数据
                    //BusinessProjectHelper.SolidMonthProjectSplit(_OracleHelper, curDateTime.AddDays(-1).ToString("yyyyMMdd"));
                    #endregion

                    //推送项目到期提醒
                    BusinessProjectHelper.ProjectDueWarning(_OracleHelper);
                    //验证卡口流水差异数据
                    BayonetHelper.CompareVehicleCount(_OracleHelper);
                    //记录服务区天气情况
                    CuringDataHelper.SolidServerpartWeather(_OracleHelper);
                    //推送财务共享数据变更未传输数据
                    CuringDataHelper.PushFinanceRevenueError(_OracleHelper, DateTime.Now.AddDays(-1).ToString("yyyyMM"));
                }
                else if (curDateTime.Hour == 23)
                {
                    //ExamineHelper.GetExamineData(_OracleHelper, curDateTime.ToShortDateString(), curDateTime.ToShortDateString());
                    ////重新校验移动支付分账差异数据
                    //MobilePayHelper.RecheckMobileShare(_OracleHelper, _OracleHelper_Coop, _OracleConnStrEx);
                    ////推送营收拆分差异数据
                    //PushRevenueWarning(_OracleHelper, DateTime.Now.AddDays(-1));    

                    //重新验证移动支付到账差异
                    ValidateBankAccount(_OracleHelper, _OracleHelper_Coop, _OracleHelper, _OracleConnStrEx);
                }
                else
                {
                    if (curDateTime.Hour == 19)
                    {
                        //重新校验移动支付分账差异数据
                        MobilePayHelper.RecheckMobileShare(_OracleHelper, _OracleHelper_Coop, _OracleConnStrEx);
                    }
                    else if (curDateTime.Hour == 21)
                    {
                        //存储经营异常预警月度固化数据
                        if (curDateTime.Day < 5 && curDateTime.Day > 1)
                        {
                            //如果是月初，上个月的数据也同步更新一次
                            CuringDataHelper.SolidMonthINCAnalysis(_OracleHelper, curDateTime.AddMonths(-1).ToString("yyyyMM"));
                        }
                        CuringDataHelper.SolidMonthINCAnalysis(_OracleHelper, curDateTime.AddDays(-1).ToString("yyyyMM"));
                        //重新计算经营项目周期预计数据
                        BusinessProjectHelper.ModifyPeriodWarning(_OracleHelper, _OracleHelper_Coop);
                        BusinessProjectHelper.RecordCACOST(_OracleHelper);
                    }
                    else if (curDateTime.Hour == 22)
                    {
                        //查询卡口流水误差率
                        double ErrorRate = BayonetHelper.GetErrorRate(_OracleHelper);
                        if (Math.Abs(ErrorRate) > 2)
                        {
                            PushContent += "卡口流水误差率：" + ErrorRate + "%";
                        }
                        //获取消息推送接口地址
                        string url = EShangApiMain + "WeChat/RunningBulletinPush";
                        //调用消息推送接口
                        string Result = EShang.Common.HttpUtil.HttpUrlPost("SecondContent=" + PushContent, url);

                        LogUtil.WriteLog(null, "推送【异常日志】返回结果：" + Result, curDateTime.ToString("yyyyMMdd") + "_WeChatPush");

                        //推送营收拆分差异数据
                        PushRevenueWarning(_OracleHelper, DateTime.Now.AddDays(-1));
                        //生成经营项目预警数据，并进行推送
                        BusinessProjectHelper.WarningProject(_OracleHelper);
                        PushSplitWarning(_OracleHelper);
                        //处理日结异常数据
                        BusinessLogHelper.CorrectErrorAccount(_OracleHelper);

                        //删除前天的测试数据
                        SQLString = "DELETE FROM PLATFORM_FRAMEWORK.T_BUSINESSLOG WHERE SUBSTR(STATISTICS_DATE,1,8) <= '" +
                            curDateTime.AddDays(-2).ToString("yyyyMMdd") + "' AND SERVERPARTCODE = '348888'";
                        int DeleteCount = _OracleHelper.ExcuteSql(SQLString);
                        LogUtil.WriteLog(null, "删除测试数据日志共" + DeleteCount + "条",
                            curDateTime.ToString("yyyyMMdd") + "_DataTransmission");
                    }
                }

                //授权用户微信推送权限
                BusinessLogHelper.AuthorPush(_OracleHelper, _OracleHelper_Msp);
                //处理万佳配送业务异常日期
                BusinessLogHelper.DealWJProinst(_OracleHelper);

                //重新验证移动支付到账差异
                //ValidateBankAccount(_OracleHelper, _OracleHelper_Coop, _OracleHelper, _OracleConnStrEx);
            }
            catch (Exception ex)
            {
                LogUtil.WriteLog(null, "获取异常日志数据失败，失败原因：【" + ex.Message + "】",
                    curDateTime.ToString("yyyyMMdd") + "_DataTransmission_Error");
            }
            finally
            {
                LogUtil.WriteLog(null, "///------------【异常日志】执行结束------------///",
                    curDateTime.ToString("yyyyMMdd") + "_DataTransmission");
            }
        }
        #endregion

        #region 方法 -> 统计总仓实时库存数据，与业务记录进行比对
        protected void CompareWareHouseStock(Method.OracleHelper _OracleHelper, ref string PushContent)
        {
            List<string> SQLStringList = new List<string>();
            string _WAREHOUSE_ID = "3", _CHECKCOMMODITY_ID = "0", _CHECKDATE = "";
            //查询上次盘点数据
            string SQLString = @"SELECT CHECKCOMMODITY_ID,CHECKDATE 
                FROM SELLER_STORAGE.T_CHECKCOMMODITY 
                WHERE CHECK_STATE = 1 AND WAREHOUSE_ID = " + _WAREHOUSE_ID;
            DataTable dtCheckInfo = _OracleHelper.ExcuteSqlGetDataSet(SQLString).Tables[0];
            if (dtCheckInfo.Rows.Count > 0)
            {
                //获取上次盘点单内码、盘点时间
                DataRow drCheckInfo = dtCheckInfo.Select("", "CHECKDATE desc")[0];
                _CHECKCOMMODITY_ID = drCheckInfo["CHECKCOMMODITY_ID"].ToString();
                _CHECKDATE = drCheckInfo["CHECKDATE"].ToString();
            }
            //统计实时库存表与本期业务数据【入库、配送、退货、损溢、调拨】和上期结存的差异 
            SQLString = string.Format(@"SELECT 
	                A.SELLERCOMMODITY_ID,A.COMMODITY_CODE,
                    A.COMMODITY_NAME,A.COMMODITY_BARCODE,
	                NVL(A.SURPLUS_STOCK,0) AS SURPLUS_STOCK,
                    NVL(B.TOTAL_COUNT,0) AS TOTAL_COUNT,
                    NVL(D.OVERPLUSCOUNT,0) AS OVERPLUSCOUNT 
                FROM 
	                SELLER_STORAGE.V_TOTALSTOCK A 
                LEFT JOIN 
	                (
	                SELECT 
		                B.SELLERCOMMODITY_ID,B.WAREHOUSE_ID,
		                SUM(TOTAL_COUNT) AS TOTAL_COUNT 
	                FROM 
		                SELLER_STORAGE.V_COSTINFOFORSTOCK B 
	                WHERE 
		                B.RECEIVE_DATE > TO_DATE('{0}','YYYY/MM/DD HH24:MI:SS') AND 
                        B.WAREHOUSE_ID = {2} 
	                GROUP BY 
		                B.SELLERCOMMODITY_ID,B.WAREHOUSE_ID 
	                ) B 
                ON 
	                A.SELLERCOMMODITY_ID = B.SELLERCOMMODITY_ID AND 
	                A.WAREHOUSE_ID = B.WAREHOUSE_ID 
                LEFT JOIN 
	                SELLER_STORAGE.T_INSALES_STATISTIC D 
                ON 
	                A.WAREHOUSE_ID = D.WAREHOUSE_ID AND 
	                D.CHECKCOMMODITY_ID = {1} AND 
	                A.SELLERCOMMODITY_ID = D.SELLERCOMMODITY_ID 
                WHERE 
	                A.WAREHOUSE_ID = {2}", _CHECKDATE, _CHECKCOMMODITY_ID, _WAREHOUSE_ID);
            DataTable dtStockDifference = _OracleHelper.ExcuteSqlGetDataSet(SQLString).Tables[0];
            //计算有差异的条数=实时库存-业务发生数量-上期结存数量
            foreach (DataRow dataRow in dtStockDifference.Select("SURPLUS_STOCK - TOTAL_COUNT - OVERPLUSCOUNT <> 0"))
            {
                SQLString = string.Format(@"INSERT INTO PLATFORM_FRAMEWORK.T_BUSINESSLOG (
                        BUSINESSLOG_ID,BUSINESSLOG_TYPE,BUSINESS_ID,TABLE_NAME,OWNER_NAME,
                        BUSINESSLOG_CONTENT,OPERATE_DATE,DATA_CONSISTENCY,CHECK_STATE) 
                    VALUES (
                        PLATFORM_FRAMEWORK.SEQ_BUSINESSLOG.NEXTVAL,
                        507000,{0},'T_GOODSSTOCK','SELLER_STORAGE','{1}',{2},0,0)",
                    dataRow[0], dataRow[2] + "【" + dataRow[3] + "】" + "实时库存：" + dataRow[4] +
                    "，业务发生数量：" + dataRow[5] + "，上期结存数量：" + dataRow[6],
                    DateTime.Now.ToString("yyyyMMddHHmmss").TryParseToDecimal());
                SQLStringList.Add(SQLString);
            }

            //因为现在生成的数据是最新的，要把历史差异更新为已处理
            SQLString = @"UPDATE PLATFORM_FRAMEWORK.T_BUSINESSLOG SET CHECK_STATE = 1 
                WHERE CHECK_STATE = 0 AND BUSINESSLOG_TYPE = 507000 AND OPERATE_DATE < " +
                    DateTime.Now.ToString("yyyyMMdd000000");
            SQLStringList.Add(SQLString);

            if (SQLStringList.Count > 0)
            {
                _OracleHelper.ExecuteSqlTran(SQLStringList);
            }

            PushContent += "总仓实时库存异常" + SQLStringList.Count + "条；";
        }
        #endregion

        #region 方法 -> 重新验证移动支付到账差异
        /// <summary>
        /// 重新验证移动支付到账差异
        /// </summary>
        /// <param name="OracleHelperLog">业务日志数据库链接</param>
        /// <param name="OracleHelperCM">合作商户平台数据库链接</param>
        /// <param name="OracleHelperED">自然日报表数据库链接</param>
        /// <param name="OracleHelperEx">建行、工行对账数据库链接</param>
        public static void ValidateBankAccount(Method.OracleHelper OracleHelperLog, Method.OracleHelper OracleHelperCM,
            Method.OracleHelper OracleHelperED, Method.OracleHelper OracleHelperEx)
        {
            string SQLString = @"DELETE FROM PLATFORM_FRAMEWORK.T_BUSINESSLOG 
                WHERE BUSINESSLOG_TYPE = 1 AND SERVERPARTCODE IN ('340403','340409','341003','330340')";
            OracleHelperLog.ExcuteSql(SQLString);

            DataTable dtBankAccountLogData = BusinessLogHelper.GetBankAccountLogData(OracleHelperLog);
            if (DateTime.Now.TimeOfDay.TotalHours > 10)
            {
                //每天10点以后（不含10点）查询通道返回金额返回为0的数据
                foreach (DataRow drBankAccountLogData in dtBankAccountLogData.Select(
                    "SERVERPARTCODE not like '51%' and CHANNEL_AMOUNT = 0"))
                {
                    //获取门店移动支付商户编号信息
                    DataTable dtBusinessShopCode = MobilePayHelper.GetBusinessShopCodeList(OracleHelperCM,
                        drBankAccountLogData["SERVERPARTCODE"].ToString(), drBankAccountLogData["SHOPCODE"].ToString());
                    //重新校验通道返回金额为0的异常数据
                    string AccountDate = drBankAccountLogData["STATISTICS_DATE"].ToString();
                    AccountDate = AccountDate.Substring(0, 4) + "-" + AccountDate.Substring(4, 2) + "-" + AccountDate.Substring(6, 2);
                    MobilePayHelper.BankAccountCompare(OracleHelperLog, OracleHelperED, OracleHelperEx,
                        dtBankAccountLogData, dtBusinessShopCode, AccountDate, drBankAccountLogData["SERVERPARTCODE"].ToString(),
                        drBankAccountLogData["SHOPCODE"].ToString(), drBankAccountLogData["MACHINECODE"].ToString());
                }
            }

            //验证3天内的移动支付差异数据
            decimal FormatDate = DateTime.Now.Date.AddDays(-3).ToString("yyyyMMdd").TryParseToDecimal();
            var ServerpartCodeList = from t in dtBankAccountLogData.AsEnumerable()
                                     where !t.Field<string>("SERVERPARTCODE").StartsWith("51") &&
                                            t["STATISTICS_DATE"].TryParseToDecimal() >= FormatDate &&
                                            t["CHANNEL_AMOUNT"].TryParseToDecimal() != 0
                                     group t by new
                                     {
                                         t0 = t.Field<string>("SERVERPARTCODE"),
                                         t1 = t["STATISTICS_DATE"].TryParseToDecimal(),
                                         t2 = t.Field<decimal?>("CHANNEL_AMOUNT")
                                     } into m
                                     select new
                                     {
                                         ServerpartCode = m.Key.t0,
                                         AccountDate = m.Key.t1,
                                         BankAccountAmount = m.Key.t2,
                                         CashPay = m.Sum(o => o.Field<decimal?>("DAILY_AMOUNT"))
                                     };
            foreach (var ServerpartCode in ServerpartCodeList)
            {
                string SelectSQL = "CHECK_STATE = 0 and SERVERPARTCODE = '" + ServerpartCode.ServerpartCode + "' and STATISTICS_DATE = " +
                    ServerpartCode.AccountDate + " and CHANNEL_AMOUNT = " + ServerpartCode.BankAccountAmount;
                foreach (DataRow drBankAccountLogData in dtBankAccountLogData.Select(SelectSQL))
                {
                    if (ServerpartCode.CashPay != ServerpartCode.BankAccountAmount)
                    {
                        SQLString = "UPDATE PLATFORM_FRAMEWORK.T_BUSINESSLOG SET CHECK_COUNT = CHECK_COUNT + 1 " +
                            "WHERE BUSINESSLOG_ID = " + drBankAccountLogData["BUSINESSLOG_ID"];
                    }
                    else
                    {
                        drBankAccountLogData["DATA_CONSISTENCY"] = 1;
                        drBankAccountLogData["CHECK_STATE"] = 1;
                        SQLString = @"UPDATE PLATFORM_FRAMEWORK.T_BUSINESSLOG 
                            SET CHECK_COUNT = CHECK_COUNT + 1,DATA_CONSISTENCY = 1,CHECK_STATE = 1 
                            WHERE BUSINESSLOG_ID = " + drBankAccountLogData["BUSINESSLOG_ID"];
                    }
                    OracleHelperLog.ExcuteSql(SQLString);
                }
            }
        }
        #endregion

        #region 方法 -> 验证日结营收固化表的数据一致性
        /// <summary>
        /// 验证日结营收固化表的数据一致性
        /// </summary>
        /// <param name="oracleHelper">营收数据表所在数据库链接</param>
        public static void VerifyRevenueData(Method.OracleHelper oracleHelper)
        {
            List<Model.EndaccountModel> EndaccountList = new List<Model.EndaccountModel>();
            //更新历史未处理的日度差异日志数据，重新生成差异日志
            string SQLString = @"UPDATE PLATFORM_FRAMEWORK.T_BUSINESSLOG SET CHECK_STATE = 1 
                WHERE CHECK_STATE = 0 AND BUSINESSLOG_TYPE = 7 AND STATISTICS_DATE >= " +
                    DateTime.Now.AddMonths(-1).ToString("yyyyMM01") +
                    " AND STATISTICS_DATE <= " + DateTime.Now.Date.ToString("yyyyMMdd");
            oracleHelper.ExcuteSql(SQLString);
            //验证服务区日度营收固化数据的一致性，验证日期从上月1号至昨日，并记录异常数据
            for (DateTime StartDate = DateTime.Parse(DateTime.Now.AddMonths(-1).ToString("yyyy-MM-01"));
                StartDate <= DateTime.Now.Date; StartDate = StartDate.AddDays(1))
            {
                CuringDataHelper.VerifyDailyRevenueData(oracleHelper,
                    StartDate.ToString("yyyy-MM-dd"), EndaccountList);
            }
            //设置微信推送的内容
            PushContent = "本次验证【" + DateTime.Now.AddMonths(-1).ToString("yyyy-MM-01") + "至" +
                DateTime.Now.ToString("yyyy-MM-dd") + "】日度营收数据";
            if (EndaccountList.Count == 0)
            {
                PushContent += "，数据一致没有异常；";
            }
            else
            {
                PushContent += "，";
            }
            //获取当前存在异常账期的数量
            int CurCount = EndaccountList.Count;

            //更新历史未处理的月度差异日志数据，重新生成差异日志
            SQLString = @"UPDATE PLATFORM_FRAMEWORK.T_BUSINESSLOG SET CHECK_STATE = 1 
                WHERE CHECK_STATE = 0 AND BUSINESSLOG_TYPE = 8 AND STATISTICS_DATE >= " +
                    DateTime.Now.AddMonths(-1).ToString("yyyyMM") +
                    " AND STATISTICS_DATE <= " + DateTime.Now.Date.ToString("yyyyMM");
            oracleHelper.ExcuteSql(SQLString);
            //验证服务区月度营收固化数据的一致性，验证上月和本月的数据
            for (DateTime LastMonth = DateTime.Now.AddMonths(-1);
                LastMonth <= DateTime.Now.AddMonths(1);
                LastMonth = LastMonth.AddMonths(1))
            {
                CuringDataHelper.VerifyMonthlyRevenueData(
                    oracleHelper, LastMonth.ToString("yyyyMM"), EndaccountList);
            }
            //设置微信推送的内容
            if (DateTime.Now.AddMonths(-1).Month == DateTime.Now.AddDays(-1).Month)
            {
                PushContent += "【" + DateTime.Now.AddMonths(-1).ToString("yyyy-MM") + "】月度营收数据";
            }
            else
            {
                PushContent += "【" + DateTime.Now.AddMonths(-1).ToString("yyyy-MM") + "和" +
                    DateTime.Now.AddDays(-1).ToString("yyyy-MM") + "】月度营收数据";
            }
            //获取新增的账期
            int AddCount = EndaccountList.FindAll(o => o.ErrorType == 1).Count;
            //获取调整的账期
            int ModifyCount = EndaccountList.FindAll(o => o.ErrorType == 2).Count;
            //获取异常时间的账期
            int ErrorCount = EndaccountList.FindAll(o => o.ErrorType == 9).Count;

            if (EndaccountList.Count == 0)
            {
                PushContent += "，数据一致没有异常；";
            }
            else
            {
                PushContent += "，";
            }
            if (EndaccountList.Count > 0)
            {
                if (EndaccountList.Count > 3)
                {
                    PushContent += "其中" + (AddCount > 0 ? "新增" + AddCount + "笔账期，" : "") +
                        (ModifyCount > 0 ? "调整" + ModifyCount + "笔账期，" : "") +
                        (ErrorCount > 0 ? "有" + ErrorCount + "笔账期被无效" : "");
                }
                else
                {
                    string EndaccountStr = "其中";
                    if (AddCount > 0)
                    {
                        EndaccountStr = "新增的账期:";
                        string curEndaccountStr = "";
                        foreach (Model.EndaccountModel endaccountModel in EndaccountList.FindAll(o => o.ErrorType == 1))
                        {
                            curEndaccountStr += (curEndaccountStr == "" ? "" : "、") + endaccountModel.ServerpartName +
                                endaccountModel.ShopName + "【" + endaccountModel.EndaccountDate + "】";
                        }
                        EndaccountStr += curEndaccountStr;
                    }
                    if (ModifyCount > 0)
                    {
                        EndaccountStr = (EndaccountStr == "" ? "" : "，") + "有调整的账期:";
                        string curEndaccountStr = "";
                        foreach (Model.EndaccountModel endaccountModel in EndaccountList.FindAll(o => o.ErrorType == 2))
                        {
                            curEndaccountStr += (curEndaccountStr == "" ? "" : "、") + endaccountModel.ServerpartName +
                                endaccountModel.ShopName + "【" + endaccountModel.EndaccountDate + "】";
                        }
                        EndaccountStr += curEndaccountStr;
                    }
                    if (ErrorCount > 0)
                    {
                        EndaccountStr += (EndaccountStr == "" ? "" : "，") + "被无效的账期:";
                        string curEndaccountStr = "";
                        foreach (Model.EndaccountModel endaccountModel in EndaccountList.FindAll(o => o.ErrorType == 9))
                        {
                            curEndaccountStr += (curEndaccountStr == "" ? "" : "、") + endaccountModel.ServerpartName +
                                endaccountModel.ShopName + "【" + endaccountModel.EndaccountDate + "】";
                        }
                        EndaccountStr += curEndaccountStr;
                    }
                    PushContent += EndaccountStr;
                }
            }
            //获取消息推送接口地址
            string url = EShangApiMain + "WeChat/RunningBulletinPush";
            //调用消息推送接口
            string Result = EShang.Common.HttpUtil.HttpUrlPost("SecondContent=" + PushContent, url);

            LogUtil.WriteLog(null, "推送【异常日志】返回结果：" + Result, DateTime.Now.ToString("yyyyMMdd") + "_WeChatPush");
        }
        #endregion

        #region 方法 -> 推送营收拆分预警信息
        public static void PushRevenueWarning(Method.OracleHelper oracleHelper, DateTime cudDate)
        {
            //设置微信推送的内容
            string PushContent = "本次验证【" + cudDate.ToString("yyyy-MM-dd") + "】营收拆分数据";
            string SQLString = "SELECT 1 FROM PLATFORM_FRAMEWORK.T_BUSINESSLOG WHERE BUSINESSLOG_TYPE = 11 AND CHECK_STATE = 0";
            DataTable dtErrorLog = oracleHelper.ExcuteSqlGetDataSet(SQLString).Tables[0];
            if (dtErrorLog.Rows.Count == 0)
            {
                PushContent += "，数据一致没有异常";
                //每天的第一次推送，才显示无差异的情况
                if (cudDate.Hour > 9)
                {
                    return;
                }
            }
            else
            {
                PushContent += "，产生" + dtErrorLog.Rows.Count + "条异常数据，详细请登录综管平台查看";
            }
            //获取消息推送接口地址
            string url = EShangApiMain + "WeChat/WarningPush";
            //定义推送跳转链接
            string jumpUrl = "https://eshangtech.com/Public/Bulletin/warningPage.html?BUSINESSLOG_TYPE=11".ToEncrypt();
            //定义推送入参
            string pushContent = "PushModule=PushWarning&FirstContent=营收拆分预警&SecondContent=" + PushContent + "&PushUrl=" + jumpUrl;

            //调用消息推送接口
            string Result = EShang.Common.HttpUtil.HttpUrlPost(pushContent, url + "?" + pushContent);

            LogUtil.WriteLog(null, "推送【异常日志】返回结果：" + Result, DateTime.Now.ToString("yyyyMMdd") + "_WeChatPush");
        }
        #endregion

        #region 方法 -> 推送分润比例切换审批提醒
        public static void PushProjectWarning(Method.OracleHelper oracleHelper)
        {
            string SQLString = "SELECT * FROM CONTRACT_STORAGE.T_PROJECTWARNING WHERE PROJECTWARNING_STATE in (1000,2000)";
            DataTable dtWarning = oracleHelper.ExcuteSqlGetDataSet(SQLString).Tables[0];

            //从配置文件获取预警天数
            string WarningDays = ConfigurationManager.AppSettings["WarningDays"];
            //定义微信推送的接口地址
            string url = EShangApiMain + "WeChat/WeChatPushMessageByPhone"; //WeChatPushMessage

            foreach (DataRow drWarning in dtWarning.Select("", "PROJECTWARNING_STATE,EXPIREDAYS"))
            {
                if (drWarning["PROJECTWARNING_STATE"].ToString() == "1000" &&
                    drWarning["EXPIREDAYS"].TryParseToInt() > WarningDays.TryParseToInt())
                {
                    continue;
                }

                WeChatPushModel weChatPushModel = new WeChatPushModel();

                weChatPushModel.PushModule = "WarningAttention";
                weChatPushModel.PushPhoneNum = drWarning["PROJECTWARNING_STATE"].ToString() == "2000" ?
                    ConfigurationManager.AppSettings["ApprovePhone"] : ConfigurationManager.AppSettings["SwitchPhone"];
                weChatPushModel.JumpUrl = "pages/projectWarning/detail?id=" + drWarning["PROJECTWARNING_ID"];
                //weChatPushModel.AppletAppId = "wxa99ef047735c031e";//推送驿行畅旅小程序

                weChatPushModel.PushParameterObject = new PushParameter();
                weChatPushModel.PushParameterObject.ProvinceCode = 340000;
                weChatPushModel.PushParameterObject.ServerpartIds = drWarning["SERVERPART_ID"].ToString();

                weChatPushModel.PushContentObject = new PushContent();
                if (drWarning["EXPIREDAYS"].TryParseToInt() == 0)
                {
                    weChatPushModel.PushContentObject.FisrtContent = "【" + drWarning["SERVERPART_NAME"] +
                        drWarning["SERVERPARTSHOP_NAME"] + "】分润比例切换审批申请";
                }
                else
                {
                    weChatPushModel.PushContentObject.FisrtContent = "【" + drWarning["SERVERPART_NAME"] +
                        drWarning["SERVERPARTSHOP_NAME"] + "】分润比例切换审批申请";
                }
                weChatPushModel.PushContentObject.SecondContent = DateTime.Now.ToString();

                string Result = EShang.Common.HttpUtil.HttpUrlPost(JsonConvert.SerializeObject(weChatPushModel), url, "application/json");

                LogUtil.WriteLog(null, "推送【分润比例切换" + (drWarning["PROJECTWARNING_STATE"].ToString() == "2000" ?
                    "审核" : "提醒") + "日志】返回结果：" + Result, DateTime.Now.ToString("yyyyMMdd") + "_WeChatPush");
            }
        }
        #endregion

        #region 方法 -> 推送年度结算审批提单
        public static void PushBillLading(Method.OracleHelper oracleHelper)
        {
            string SQLString = @"SELECT A.*,B.BUSINESSPROJECT_NAME 
                FROM PLATFORM_FRAMEWORK.T_BUSINESSAPPROVAL A,CONTRACT_STORAGE.T_BUSINESSPROJECT B 
                WHERE A.BUSINESSPROCESS_ID = B.BUSINESSPROJECT_ID AND A.OPERATION_TYPE = 11 AND 
                    A.BUSINESSAPPROVAL_STATE = 9000 AND NVL(A.BILL_STATE,0) = 0";
            DataTable dtBill = oracleHelper.ExcuteSqlGetDataSet(SQLString).Tables[0];

            //定义微信推送的接口地址
            string url = EShangApiMain + "WeChat/WeChatPushMessageByPhone"; //WeChatPushMessage

            foreach (DataRow drBill in dtBill.Select("", "BUSINESS_ENDDATE"))
            {
                WeChatPushModel weChatPushModel = new WeChatPushModel
                {
                    PushModule = "WarningAttention",
                    PushPhoneNum = ConfigurationManager.AppSettings["BillLadingPhone"],
                    JumpUrl = "pages/billOfLading/detail?id=" + drBill["BUSINESSAPPROVAL_ID"] + "&ispush=true",
                    //weChatPushModel.AppletAppId = "wxa99ef047735c031e";//推送驿行畅旅小程序

                    PushParameterObject = new PushParameter
                    {
                        ProvinceCode = 340000,
                        ServerpartIds = drBill["SERVERPART_ID"].ToString()
                    },

                    PushContentObject = new PushContent
                    {
                        FisrtContent = "【" + drBill["BUSINESSPROJECT_NAME"] + "】年度结算审批提单",
                        SecondContent = DateTime.Now.ToString()
                    }
                };

                string Result = EShang.Common.HttpUtil.HttpUrlPost(JsonConvert.SerializeObject(weChatPushModel), url, "application/json");

                LogUtil.WriteLog(null, "推送【年度结算审批提单日志】返回结果：" + Result, DateTime.Now.ToString("yyyyMMdd") + "_WeChatPush");
            }
        }
        #endregion

        #region 方法 -> 推送固定租金项目预警信息
        public static void PushFixedRent(Method.OracleHelper oracleHelper)
        {
            string SQLString = string.Format(@"SELECT * FROM CONTRACT_STORAGE.T_PROJECTWARNING 
                WHERE PROJECTWARNING_STATE = 9000 AND SWITCH_DATE IS NULL AND 
                    BUSINESS_TYPE = 2000 AND WARNING_DATE >= {0} AND WARNING_DATE <= {1}",
                DateTime.Now.ToString("yyyyMM01"), DateTime.Now.ToString("yyyyMM31"));
            DataTable dtWarning = oracleHelper.ExcuteSqlGetDataSet(SQLString).Tables[0];
            foreach (DataRow drWarning in dtWarning.Rows)
            {
                PushContent = "固定租金【" + drWarning["BUSINESSPROJECT_NAME"] + "】已达保底，请及时联系客无忧进行切换通道！";
                //获取消息推送接口地址
                string url = EShangApiMain + "WeChat/RunningBulletinPush";
                //调用消息推送接口
                string Result = EShang.Common.HttpUtil.HttpUrlPost("SecondContent=" + PushContent, url);

                LogUtil.WriteLog(null, "推送【固定租金项目预警信息】返回结果：" + Result,
                    DateTime.Now.ToString("yyyyMMdd") + "_WeChatPush");
            }
        }
        #endregion

        #region 方法 -> 推送应收拆分预警信息
        /// <summary>
        /// 推送应收拆分预警信息
        /// </summary>
        /// <param name="oracleHelper"></param>
        public static void PushSplitWarning(Method.OracleHelper oracleHelper)
        {
            string SQLString = "SELECT 1,BUSINESSLOG_TYPE FROM PLATFORM_FRAMEWORK.T_BUSINESSLOG WHERE BUSINESSLOG_TYPE IN (17,18)";
            DataTable dtWarning = oracleHelper.ExcuteSqlGetDataSet(SQLString).Tables[0];
            //推送【应收拆分预警信息】
            if (dtWarning.Select("BUSINESSLOG_TYPE = 17").Length > 0)
            {
                PushContent = "应收拆分预警" + dtWarning.Select("BUSINESSLOG_TYPE = 17").Length + "条，请点击详情查看具体内容！";
                //获取消息推送接口地址
                string url = EShangApiMain + "WeChat/WarningPush";
                //定义推送跳转链接
                string jumpUrl = "https://eshangtech.com/Public/Bulletin/warningPage.html?BUSINESSLOG_TYPE=17".ToEncrypt();
                //定义推送入参
                string pushContent = "PushModule=PushWarning&FirstContent=应收拆分预警&SecondContent=" + PushContent + "&PushUrl=" + jumpUrl;

                //调用消息推送接口
                string Result = EShang.Common.HttpUtil.HttpUrlPost(pushContent, url + "?" + pushContent);

                LogUtil.WriteLog(null, "推送【应收拆分预警信息】返回结果：" + Result,
                    DateTime.Now.ToString("yyyyMMdd") + "_WeChatPush");
            }
            //推送【附件上传预警信息】
            if (dtWarning.Select("BUSINESSLOG_TYPE = 18").Length > 0)
            {
                PushContent = "合同附件未上传" + dtWarning.Select("BUSINESSLOG_TYPE = 18").Length + "条，请点击详情查看具体内容！";
                //获取消息推送接口地址
                string url = EShangApiMain + "WeChat/WarningPush";
                //定义推送跳转链接
                string jumpUrl = "https://eshangtech.com/Public/Bulletin/warningPage.html?BUSINESSLOG_TYPE=18".ToEncrypt();
                //定义推送入参
                string pushContent = "PushModule=PushWarning&FirstContent=附件上传预警&SecondContent=" + PushContent + "&PushUrl=" + jumpUrl;

                //调用消息推送接口
                string Result = EShang.Common.HttpUtil.HttpUrlPost(pushContent, url + "?" + pushContent);

                LogUtil.WriteLog(null, "推送【附件上传预警信息】返回结果：" + Result,
                    DateTime.Now.ToString("yyyyMMdd") + "_WeChatPush");
            }
        }
        #endregion

        #region 方法 -> 迁移历史数据
        public static void RemoveHisData(Method.OracleHelper _OracleHelper, Method.OracleHelper _OracleHelperEx)
        {
            int ExcuteCount;
            //查询有盘点数据的门店
            string SQLString, selectedSQL;
            //SQLString = "SELECT * FROM SALESTORE_STORAGE.T_CHECKCOMMODITY WHERE CHECK_STATE > 0";
            //DataTable dtCheckInfo = _OracleHelperEx.ExcuteSqlGetDataSet(SQLString).Tables[0];
            for (DateTime curDate = DateTime.Parse("2023/12/1"); curDate > DateTime.Parse("2020/1/1"); curDate = curDate.AddMonths(-1))
            {
                //SQLString = string.Format(@"INSERT INTO SALESTORE_STORAGE.T_INSALES_STATISTIC_HIS 
                //    SELECT * FROM SALESTORE_STORAGE.T_INSALES_STATISTIC A 
                //    WHERE CHECKDATE >= TO_DATE('{0}','YYYY/MM/DD HH24:MI:SS') AND 
                //        CHECKDATE < TO_DATE('{1}','YYYY/MM/DD HH24:MI:SS')", curDate.AddMonths(-1), curDate);
                //ExcuteCount = _OracleHelper.ExcuteSql(SQLString);
                //LogUtil.WriteLog(null, "迁移" + curDate.AddMonths(-1) + "进销存报表数据" +
                //    ExcuteCount + "条记录到历史库", DateTime.Now.ToString("yyyyMMdd") + "_InSales");
                //if (ExcuteCount > 0)
                //{
                //    SQLString = string.Format(@"DELETE FROM SALESTORE_STORAGE.T_INSALES_STATISTIC A 
                //        WHERE CHECKDATE >= TO_DATE('{0}','YYYY/MM/DD HH24:MI:SS') AND 
                //            CHECKDATE < TO_DATE('{1}','YYYY/MM/DD HH24:MI:SS')", curDate.AddMonths(-1), curDate);
                //    ExcuteCount = _OracleHelper.ExcuteSql(SQLString);
                //    LogUtil.WriteLog(null, "删除" + curDate.AddMonths(-1) + "进销存报表数据" +
                //        ExcuteCount + "条记录", DateTime.Now.ToString("yyyyMMdd") + "_InSales");
                //}

                SQLString = string.Format(@"INSERT INTO SALESTORE_STORAGE.T_INSALES_STATISTIC_HIS (
                        INSALES_STATISTIC_ID,SERVERPART_ID,SERVERPART_CODE,SERVERPART_NAME,
	                    PROVINCE_CODE,SERVERPARTSHOP_ID,SHOPCODE,SHOPNAME,COMMODITY_ID,COMMODITY_TYPE,
	                    COMMODITYTYPE_NAME,BUSINESSTYPE,COMMODITY_CODE,COMMODITY_NAME,COMMODITY_BARCODE,
	                    COMMODITY_UNIT,COMMODITY_RULE,COMMODITY_RETAILPRICE,COMMODITY_PURCHASEPRICE,
	                    PURCHASE_COUNT,PURCHASE_TAXPRICE,PURCHASE_TOTALTAXPRICE,PURCHASE_PRICE,
	                    PURCHASE_TOTALPRICE,SELL_COUNT,SELL_UNITTAXPRICE,SELL_TOTALTAXPRICE,
	                    SELL_UNITPRICE,SELL_TOTALPRICE,SELL_COST,SELL_COSTPRICE,TRANSFER_COUNT,
	                    TRANSFER_AMOUNT,TRANSFER_PRICE,RECEIVE_COUNT,RECEIVE_AMOUNT,RECEIVE_PRICE,
	                    BACK_COUNT,BACK_AMOUNT,BACK_PRICE,LAST_OVERPLUSCOUNT,LAST_OVERPLUSAMOUNT,
	                    LAST_OVERPLUSPRICE,OVERPLUSCOUNT,OVERPLUS_AMOUNT,OVERPLUS_PRICE,LOSSPROFIT_COUNT,
	                    LOSSPROFIT_AMOUNT,LOSSPROFIT_PRICE,GROSS_PROFIT,GROSS_PROFITPRICE,TOTAL_PROFIT,
	                    TOTAL_PROFITPRICE,GROUPPURCHASE_AMOUNT,GROUPPURCHASE_COST,GROUPPURCHASE_COUNT,
	                    LOSSPROFIT_CHECKAMOUNT,LOSSPROFIT_CHECKCOUNT,PROCESSORDER_AMOUNT,PROCESSORDER_COUNT,
	                    LOSSPROFIT_CHECKPRICE,GROUPPURCHASE_PRICE,GROUPPURCHASE_COSTPRICE,
	                    PROCESSORDER_PRICE,CHECKDATE,INSALES_STATISTIC_DESC)
                    SELECT 
                        INSALES_STATISTIC_ID,SERVERPART_ID,SERVERPART_CODE,SERVERPART_NAME,
	                    PROVINCE_CODE,SERVERPARTSHOP_ID,SHOPCODE,SHOPNAME,COMMODITY_ID,COMMODITY_TYPE,
	                    COMMODITYTYPE_NAME,BUSINESSTYPE,COMMODITY_CODE,COMMODITY_NAME,COMMODITY_BARCODE,
	                    COMMODITY_UNIT,COMMODITY_RULE,COMMODITY_RETAILPRICE,COMMODITY_PURCHASEPRICE,
	                    PURCHASE_COUNT,PURCHASE_TAXPRICE,PURCHASE_TOTALTAXPRICE,PURCHASE_PRICE,
	                    PURCHASE_TOTALPRICE,SELL_COUNT,SELL_UNITTAXPRICE,SELL_TOTALTAXPRICE,
	                    SELL_UNITPRICE,SELL_TOTALPRICE,SELL_COST,SELL_COSTPRICE,TRANSFER_COUNT,
	                    TRANSFER_AMOUNT,TRANSFER_PRICE,RECEIVE_COUNT,RECEIVE_AMOUNT,RECEIVE_PRICE,
	                    BACK_COUNT,BACK_AMOUNT,BACK_PRICE,LAST_OVERPLUSCOUNT,LAST_OVERPLUSAMOUNT,
	                    LAST_OVERPLUSPRICE,OVERPLUSCOUNT,OVERPLUS_AMOUNT,OVERPLUS_PRICE,LOSSPROFIT_COUNT,
	                    LOSSPROFIT_AMOUNT,LOSSPROFIT_PRICE,GROSS_PROFIT,GROSS_PROFITPRICE,TOTAL_PROFIT,
	                    TOTAL_PROFITPRICE,GROUPPURCHASE_AMOUNT,GROUPPURCHASE_COST,GROUPPURCHASE_COUNT,
	                    LOSSPROFIT_CHECKAMOUNT,LOSSPROFIT_CHECKCOUNT,PROCESSORDER_AMOUNT,PROCESSORDER_COUNT,
	                    LOSSPROFIT_CHECKPRICE,GROUPPURCHASE_PRICE,GROUPPURCHASE_COSTPRICE,
	                    PROCESSORDER_PRICE,CHECKDATE,INSALES_STATISTIC_DESC 
                    FROM SALESTORE_STORAGE.T_INSALES_STATISTIC A 
                    WHERE CHECKDATE >= TO_DATE('{0}','YYYY/MM/DD HH24:MI:SS') AND 
                        CHECKDATE < TO_DATE('{1}','YYYY/MM/DD HH24:MI:SS')", curDate.AddMonths(-1), curDate);
                ExcuteCount = _OracleHelperEx.ExcuteSql(SQLString);
                LogUtil.WriteLog(null, "迁移" + curDate.AddMonths(-1) + "四川进销存报表数据" +
                    ExcuteCount + "条记录到历史库", DateTime.Now.ToString("yyyyMMdd") + "_InSales");
                if (ExcuteCount > 0)
                {
                    SQLString = string.Format(@"DELETE FROM SALESTORE_STORAGE.T_INSALES_STATISTIC A 
                        WHERE CHECKDATE >= TO_DATE('{0}','YYYY/MM/DD HH24:MI:SS') AND 
                            CHECKDATE < TO_DATE('{1}','YYYY/MM/DD HH24:MI:SS')", curDate.AddMonths(-1), curDate);
                    ExcuteCount = _OracleHelperEx.ExcuteSql(SQLString);
                    LogUtil.WriteLog(null, "删除" + curDate.AddMonths(-1) + "四川进销存报表数据" +
                        ExcuteCount + "条记录", DateTime.Now.ToString("yyyyMMdd") + "_InSales");
                }
            }
            //foreach (DataRow drShop in dtCheckInfo.DefaultView.ToTable(true, "SERVERPARTSHOP_ID").Rows)
            //{
            //    selectedSQL = "SERVERPARTSHOP_ID = " + drShop[0];
            //    DataRow[] CheckInfoList = dtCheckInfo.Select(selectedSQL, "CHECKDATE desc");
            //    string shopName = CheckInfoList[0]["SERVERPART_NAME"] + "" + CheckInfoList[0]["SHOPNAME"];

            //    for (int curNum = 1; curNum < CheckInfoList.Length; curNum++)
            //    {
            //        if (curNum == CheckInfoList.Length - 1)
            //        {
            //            SQLString = string.Format(@"INSERT INTO SALESTORE_STORAGE.T_STOCKLOG_HIS 
            //                SELECT * FROM SALESTORE_STORAGE.T_STOCKLOG A 
            //                WHERE {0} AND OPERATE_DATE <= TO_DATE('{1}','YYYY/MM/DD HH24:MI:SS')",
            //                selectedSQL, CheckInfoList[curNum]["CHECKDATE"]);
            //            ExcuteCount = _OracleHelperEx.ExcuteSql(SQLString);
            //            LogUtil.WriteLog(null, "迁移" + shopName + "【" + CheckInfoList[curNum]["CHECKDATE"] + "】进销存日志" +
            //                ExcuteCount + "条记录到历史库", DateTime.Now.ToString("yyyyMMdd") + "_StockLog");
            //            if (ExcuteCount > 0)
            //            {
            //                SQLString = string.Format(@"DELETE FROM SALESTORE_STORAGE.T_STOCKLOG A 
            //                    WHERE {0} AND OPERATE_DATE <= TO_DATE('{1}','YYYY/MM/DD HH24:MI:SS')",
            //                    selectedSQL, CheckInfoList[curNum]["CHECKDATE"]);
            //                ExcuteCount = _OracleHelperEx.ExcuteSql(SQLString);
            //                LogUtil.WriteLog(null, "删除" + shopName + "【" + CheckInfoList[curNum]["CHECKDATE"] + "】进销存日志" +
            //                    ExcuteCount + "条记录", DateTime.Now.ToString("yyyyMMdd") + "_StockLog");
            //            }
            //        }
            //        else
            //        {
            //            SQLString = string.Format(@"INSERT INTO SALESTORE_STORAGE.T_STOCKLOG_HIS 
            //                SELECT * FROM SALESTORE_STORAGE.T_STOCKLOG A 
            //                WHERE {0} AND OPERATE_DATE <= TO_DATE('{1}','YYYY/MM/DD HH24:MI:SS') AND 
            //                    OPERATE_DATE > TO_DATE('{2}','YYYY/MM/DD HH24:MI:SS')",
            //                selectedSQL, CheckInfoList[curNum]["CHECKDATE"], CheckInfoList[curNum + 1]["CHECKDATE"]);
            //            ExcuteCount = _OracleHelperEx.ExcuteSql(SQLString);
            //            LogUtil.WriteLog(null, "迁移" + shopName + "【" + CheckInfoList[curNum]["CHECKDATE"] + "】进销存日志" +
            //                ExcuteCount + "条记录到历史库", DateTime.Now.ToString("yyyyMMdd") + "_StockLog");
            //            if (ExcuteCount > 0)
            //            {
            //                SQLString = string.Format(@"DELETE FROM SALESTORE_STORAGE.T_STOCKLOG A 
            //                    WHERE {0} AND OPERATE_DATE <= TO_DATE('{1}','YYYY/MM/DD HH24:MI:SS') AND 
            //                        OPERATE_DATE > TO_DATE('{2}','YYYY/MM/DD HH24:MI:SS')",
            //                    selectedSQL, CheckInfoList[curNum]["CHECKDATE"], CheckInfoList[curNum + 1]["CHECKDATE"]);
            //                ExcuteCount = _OracleHelperEx.ExcuteSql(SQLString);
            //                LogUtil.WriteLog(null, "删除" + shopName + "【" + CheckInfoList[curNum]["CHECKDATE"] + "】进销存日志" +
            //                    ExcuteCount + "条记录", DateTime.Now.ToString("yyyyMMdd") + "_StockLog");
            //            }
            //        }
            //    }
            //}
            //SQLString = "SELECT * FROM HIGHWAY_STORAGE.T_SERVERPART WHERE PROVINCE_CODE IN (3544,4962) AND STATISTICS_TYPE = 1000";
            //DataTable dtServerpart = _OracleHelper.ExcuteSqlGetDataSet(SQLString).Tables[0];
            //foreach (DataRow drServerpart in dtServerpart.Rows)
            //{
            //    string ExtraCode = "";
            //    switch (drServerpart["PROVINCE_CODE"].ToString())
            //    {
            //        case "3544":
            //            ExtraCode = "_340000";
            //            break;
            //        case "4962":
            //            ExtraCode = "_330300";
            //            break;
            //    }

            //    SQLString = "DELETE FROM HIGHWAY_EXCHANGE.T_COMMODITYSALE" + ExtraCode +
            //        " WHERE SERVERPARTCODE = '" + drServerpart["SERVERPART_CODE"] + "'";
            //    ExcuteCount = _OracleHelperEx.ExcuteSql(SQLString);
            //    LogUtil.WriteLog(null, "删除" + drServerpart["SERVERPART_NAME"] + "单品数据" +
            //        ExcuteCount + "条记录", DateTime.Now.ToString("yyyyMMdd") + "_CommoditySale");

            //    SQLString = string.Format(@"INSERT INTO HIGHWAY_EXCHANGE.T_COMMODITYSALE{0}@NEWEX 
            //        SELECT * FROM HIGHWAY_EXCHANGE.T_COMMODITYSALE 
            //        WHERE SERVERPARTCODE = '{1}'", ExtraCode, drServerpart["SERVERPART_CODE"]);
            //    ExcuteCount = _OracleHelper.ExcuteSql(SQLString);
            //    LogUtil.WriteLog(null, "复制" + drServerpart["SERVERPART_NAME"] + "单品数据" +
            //        ExcuteCount + "条记录", DateTime.Now.ToString("yyyyMMdd") + "_CommoditySale");
            //}

            //for (int decade = 0; decade < 7; decade++)
            //{
            //    string month = DateTime.Now.AddMonths(num).ToString("yyyyMM"),
            //        startTime = DateTime.Now.AddMonths(num).ToString("yyyyMM") + (decade * 5).ToString("00") + "000000",
            //        endTime = DateTime.Now.AddMonths(num).ToString("yyyyMM") + ((decade + 1) * 5).ToString("00") + "000000";

            //    SQLString = string.Format(@"INSERT INTO HIGHWAY_HISTORY.T_YSSELLMASTER_{2} 
            //        SELECT * FROM HIGHWAY_SELLDATA.T_YSSELLMASTER A 
            //        WHERE SELLMASTER_DATE BETWEEN {0} AND {1}", startTime, endTime, month);
            //    int ExcuteCount = _OracleHelperEx.ExcuteSql(SQLString);
            //    LogUtil.WriteLog(null, "迁移【" + startTime + "至" + endTime + "】销售流水" + ExcuteCount +
            //        "条记录到历史库", DateTime.Now.ToString("yyyyMMdd") + "_SellMaster");
            //    if (ExcuteCount > 0)
            //    {
            //        SQLString = string.Format(@"DELETE FROM HIGHWAY_SELLDATA.T_YSSELLMASTER A 
            //            WHERE SELLMASTER_DATE BETWEEN {0} AND {1}", startTime, endTime);
            //        ExcuteCount = _OracleHelperEx.ExcuteSql(SQLString);
            //        LogUtil.WriteLog(null, "删除【" + startTime + "至" + endTime + "】销售流水" + ExcuteCount +
            //            "条记录", DateTime.Now.ToString("yyyyMMdd") + "_SellMaster");
            //    }
            //    SQLString = string.Format(@"INSERT INTO HIGHWAY_HISTORY.T_YSSELLDETAILS_{2} 
            //        SELECT * FROM HIGHWAY_SELLDATA.T_YSSELLDETAILS A 
            //        WHERE CREATE_DATE BETWEEN {0} AND {1}", startTime, endTime, month);
            //    ExcuteCount = _OracleHelperEx.ExcuteSql(SQLString);
            //    LogUtil.WriteLog(null, "迁移【" + startTime + "至" + endTime + "】销售流水明细" + ExcuteCount +
            //        "条记录到历史库", DateTime.Now.ToString("yyyyMMdd") + "_SellMaster");
            //    if (ExcuteCount > 0)
            //    {
            //        SQLString = string.Format(@"DELETE FROM HIGHWAY_SELLDATA.T_YSSELLDETAILS A 
            //            WHERE CREATE_DATE BETWEEN {0} AND {1}", startTime, endTime);
            //        ExcuteCount = _OracleHelperEx.ExcuteSql(SQLString);
            //        LogUtil.WriteLog(null, "删除【" + startTime + "至" + endTime + "】销售流水明细" + ExcuteCount +
            //            "条记录", DateTime.Now.ToString("yyyyMMdd") + "_SellMaster");
            //    }
            //}

            //SQLString = string.Format(@"INSERT INTO HIGHWAY_EXCHANGE.T_YSABNORMALITY_HIS 
            //    SELECT * FROM HIGHWAY_EXCHANGE.T_YSABNORMALITY A 
            //    WHERE ABNORMALITY_TIME BETWEEN {0}01000000 AND {0}32000000",
            //    DateTime.Now.AddMonths(num).ToString("yyyyMM"));
            //int ExcuteCount = _OracleHelperEx.ExcuteSql(SQLString);
            //LogUtil.WriteLog(null, "迁移【" + DateTime.Now.AddMonths(num).ToString("yyyy/MM") +
            //    "】异常稽核" + ExcuteCount + "条记录到历史库", DateTime.Now.ToString("yyyyMMdd") + "_Abnormal");
            //if (ExcuteCount > 0)
            //{
            //    SQLString = string.Format(@"DELETE FROM HIGHWAY_EXCHANGE.T_YSABNORMALITY A 
            //    WHERE ABNORMALITY_TIME BETWEEN {0}01000000 AND {0}32000000",
            //        DateTime.Now.AddMonths(num).ToString("yyyyMM"));
            //    ExcuteCount = _OracleHelperEx.ExcuteSql(SQLString);
            //    LogUtil.WriteLog(null, "删除【" + DateTime.Now.AddMonths(num).ToString("yyyy/MM") +
            //        "】异常稽核" + ExcuteCount + "条记录", DateTime.Now.ToString("yyyyMMdd") + "_Abnormal");
            //}
            //SQLString = string.Format(@"INSERT INTO HIGHWAY_EXCHANGE.T_YSABNORMALITYDETAIL_HIS 
            //    SELECT * FROM HIGHWAY_EXCHANGE.T_YSABNORMALITYDETAIL A 
            //    WHERE OPERATEDATE BETWEEN {0}01000000 AND {0}32000000",
            //    DateTime.Now.AddMonths(num).ToString("yyyyMM"));
            //ExcuteCount = _OracleHelperEx.ExcuteSql(SQLString);
            //LogUtil.WriteLog(null, "迁移【" + DateTime.Now.AddMonths(num).ToString("yyyy/MM") +
            //    "】异常稽核明细" + ExcuteCount + "条记录到历史库", DateTime.Now.ToString("yyyyMMdd") + "_Abnormal");
            //if (ExcuteCount > 0)
            //{
            //    SQLString = string.Format(@"DELETE FROM HIGHWAY_EXCHANGE.T_YSABNORMALITYDETAIL A 
            //    WHERE OPERATEDATE BETWEEN {0}01000000 AND {0}32000000",
            //        DateTime.Now.AddMonths(num).ToString("yyyyMM"));
            //    ExcuteCount = _OracleHelperEx.ExcuteSql(SQLString);
            //    LogUtil.WriteLog(null, "删除【" + DateTime.Now.AddMonths(num).ToString("yyyy/MM") +
            //        "】异常稽核明细" + ExcuteCount + "条记录", DateTime.Now.ToString("yyyyMMdd") + "_Abnormal");
            //}
        }
        #endregion

        #region 方法 -> 删除历史数据
        public static void DeleteData(Method.OracleHelper oracleHelper, Method.OracleHelper oracleHelperEx)
        {
            int ExcuteCount;
            string SQLString = "SELECT * FROM HIGHWAY_STORAGE.T_SERVERPART WHERE PROVINCE_CODE = 8832";
            DataTable dtServerpart = oracleHelper.ExcuteSqlGetDataTable(SQLString);
            foreach (DataRow drSP in dtServerpart.Rows)
            {
                LogUtil.WriteLog("开始删除【" + drSP["SERVERPART_NAME"] + "】营收趋势数据表");

                SQLString = @"DELETE FROM HIGHWAY_EXCHANGE.T_REVENUETREND WHERE SERVERPARTCODE = '" + drSP["SERVERPART_CODE"] + "'";
                ExcuteCount = oracleHelperEx.ExcuteSql(SQLString);

                LogUtil.WriteLog("删除营收趋势数据表" + ExcuteCount + "条记录");
            }

            //for (DateTime curDate = StartDate; curDate < EndDate; curDate = curDate.AddDays(1))
            //{
            //    LogUtil.WriteLog("开始删除【" + curDate.ToShortDateString() + "】销售流水数据");

            //    SQLString = "DELETE FROM HIGHWAY_SELLDATA.T_YSSELLMASTER WHERE SELLMASTER_DATE BETWEEN " +
            //        curDate.ToString("yyyyMMdd") + "000000 AND " + curDate.AddDays(1).ToString("yyyyMMdd") + "000000";
            //    ExcuteCount = oracleHelper.ExcuteSql(SQLString);

            //    LogUtil.WriteLog("删除【" + curDate.ToShortDateString() + "】销售流水数据" + ExcuteCount + "条记录");
            //}
        }
        #endregion
    }
}