机器人,插入辅助器

 

using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Data.OleDb;
using System.Xml;
using System.Text.RegularExpressions;
using System.Net;
using System.Threading;
using System.IO;

namespace AutoGetCore
{
    public delegate void InsertCompletedHandler(bool HasError, string ErrorDescription);
    public delegate void ProgressLogHandler(string Description);
    public delegate void InsertingHandler(out bool Cancel);
    public delegate void HtmlDownloadedHandler(string Html);

    /// <summary>
    /// 单页捕捉器
    /// </summary>
    public class InsertHelper : IDisposable
    {
        protected Thread MainThread;
        public event InsertCompletedHandler InsertCompleted;
        public event ProgressLogHandler ProgressLoging;
        public event HtmlDownloadedHandler HtmlDownloaded;
        public event InsertingHandler Inserting;
        protected XmlDocument _XmlDoc;
        protected OleDbConnection Conn;
        protected List<SettingCache> Caches;
        protected string Html;
        protected bool _Completed;
        public string LogFilePath;
        public string LogText;
        protected string _MyUri;
        protected int _ProgressValue;
        protected GettingTask _GettingTask;
        protected bool _InsertDB;
        protected CookieContainer _LoginedCookieContainer;

        public bool Completed
        {
            get
            {
                return _Completed;
            }
        }

        public InsertHelper(CookieContainer LoginedCookieContainer, string XmlFilePath, OleDbConnection Conn, GettingTask gettingTask, bool InsertDB)
        {
            _InsertDB = InsertDB;
            _GettingTask = gettingTask;
            _LoginedCookieContainer = LoginedCookieContainer;
            Init(XmlFilePath, Conn);
        }

        protected void Init(string XmlFilePath, OleDbConnection Conn)
        {
            _Completed = false;
            Caches = new List<SettingCache>();
            _XmlDoc = new XmlDocument();
            _XmlDoc.Load(XmlFilePath);
            this.Conn = Conn;
            MainThread = new Thread(new ThreadStart(Run));
            MainThread.IsBackground = true;
            if (Conn != null)
                if (Conn.State == ConnectionState.Closed) Conn.Open();
        }

        /// <summary>
        /// 开始插入数据
        /// </summary>
        /// <param name="Uri">网页链接地址</param>
        public void StartInsert(DownloadUri downloadUri)
        {
            _MyUri = downloadUri.Uri;
            
            WebClient wc = new WebClient();
            
            string Html = "";
            
            // 单页插入数据时，直接使用 WebClient 对象。
            //Html = ContentDownloader.Download(new DownloadUri(Uri.OriginalString, true), ref _LoginedCookieContainer);
            Html = ContentDownloader.Download(downloadUri, ref _LoginedCookieContainer);

            RaiseLog(downloadUri.Uri + "页面下载完成。");
            
            try
            {
                HtmlDownloaded(Html);
            }
            catch { }
            
            StartInsert(Html);
        }

        /// <summary>
        /// 开始插入数据
        /// </summary>
        /// <param name="Html">HTML代码</param>
        public void StartInsert(string Html)
        {
            this.Html = Html;
            Run();
            //MainThread.Start();
        }

        private void Run()
        {
            Dictionary<string, string> ChildContentsXML = new Dictionary<string, string>();  // 临时存放的内容
            OleDbCommand cmd;
            
            string Sql = "";
            bool HasError = false;
            string ErrDesc = "";
            //int tmpIndex = 0;

            string GroupSplit = _XmlDoc.LastChild.Attributes["Split"].Value;
            string[] GroupSplited;

            Caches.Clear();
            GroupSplited = Html.Split(new string[] { GroupSplit }, StringSplitOptions.RemoveEmptyEntries);

            int ParamCount2 = 0;
            int ChkExistParamCount = 0;
            foreach (XmlNode xn in _XmlDoc.LastChild.SelectNodes("Setting"))
            {
                if (!(xn.Attributes["NoInsert"] != null && xn.Attributes["NoInsert"].Value.ToLower() == "true"))
                    ParamCount2++;

                if (xn.Attributes["CheckExist"] != null && xn.Attributes["CheckExist"].Value.ToLower() == "true")
                    ChkExistParamCount++;
            }

            for (int k = 0; k < GroupSplited.Length; k++)
            {
                bool HasCheckExist = false; // 需要检验是否存在。

                cmd = new OleDbCommand();
                cmd.Connection = Conn;
                OleDbParameter[] Parameters = new OleDbParameter[ParamCount2];
                OleDbParameter[] CheckParameters = new OleDbParameter[ChkExistParamCount];

                int ParamCount = 0;
                int ChkExistParamIndex = 0;
                string Tablename = _XmlDoc.LastChild.Attributes["TableName"].Value;
                
                string TimeColName = null;
                if (_XmlDoc.LastChild.Attributes["TimeColName"] != null)
                    TimeColName = _XmlDoc.LastChild.Attributes["TimeColName"].Value;

                ChildContentsXML.Clear();

                //string[] ContentsXML = new string[_XmlDoc.LastChild.SelectNodes("Setting").Count];  //　包含HTML的内容

                Sql = "INSERT INTO " + Tablename + "(";

                if (k == GroupSplited.Length - 1 && GroupSplit != "")
                {
                    break;// 如果属于拆分行时，最后一截丢弃
                }

                //tmpIndex = 0;
                foreach (XmlNode xn in _XmlDoc.LastChild.SelectNodes("Setting"))
                {
                    string FieldName = xn.Attributes["FieldName"].Value;
                    string Before = xn.SelectSingleNode("Before").InnerText;
                    string End = xn.SelectSingleNode("End").InnerText;
                    bool IsSplitGroup = !Convert.ToBoolean(xn.Attributes["NoGroup"].Value);
                    bool UseBefore = xn.SelectSingleNode("UseBeforeAll") != null;  // 使用依赖
                    bool NotInsertToDb = xn.Attributes["NoInsert"] != null && 
                        xn.Attributes["NoInsert"].Value.ToLower() == "true";
                    bool CheckExist = xn.Attributes["CheckExist"] != null &&
                        xn.Attributes["CheckExist"].Value.ToLower() == "true";

                    if (UseBefore)
                    {
                        // 当使用依赖时
                        foreach (XmlNode xnBefores in xn.SelectSingleNode("UseBeforeAll").ChildNodes)
                        {
                            Before += ChildContentsXML[xnBefores.InnerText];
                        }
                    }

                    //try
                    //{
                    string FieldValue = string.Empty;
                    if (Before == "random")
                    {
                        FieldValue = DateTime.Now.ToFileTime().ToString();
                    }
                    else if (Before == "custom")
                    {
                        FieldValue = End;
                    }
                    else if (Before == "now")
                    {
                        FieldValue = DateTime.Now.ToString();
                    }
                    else
                    {
                        if (IsSplitGroup)
                        {
                            FieldValue = GetContents(Before, End, GroupSplited[k], 0);  // 属拆分组
                        }
                        else
                        {
                            // 非拆分组则有缓存机制
                            foreach (SettingCache cache in Caches)
                            {
                                if (cache.FieldName == FieldName)
                                {
                                    FieldValue = cache.CacheValue;
                                }
                            }

                            if (FieldValue == string.Empty)
                            {
                                FieldValue = GetContents(Before, End, Html, 0); // 非拆分组
                                Caches.Add(new SettingCache(FieldName, FieldValue));   // 加入缓存
                            }
                        }
                        ChildContentsXML.Add(FieldName, Before + FieldValue + End); // 存入所有内容
                    }

                    if (CheckExist == true)
                    {
                        HasCheckExist = true;

                        // 需要检验数据库是否重复！
                        CheckParameters[ChkExistParamIndex] = new OleDbParameter(FieldName, FieldValue);
                        ChkExistParamIndex++;
                    }

                    if (!NotInsertToDb) // 当需要插入DB时
                        Parameters[ParamCount] = new OleDbParameter(FieldName, FieldValue);

                    RaiseLog("成功获取'" + xn.Attributes["Name"].Value + "',内容:\n" + FieldValue);
                    //}
                    //catch (Exception ex)
                    //{
                    //    ErrDesc += ex.Message + "\n";
                    //    RaiseLog("获取内容" + xn.Attributes["Name"].Value + "失败，可能原因配置错误。\n" + ex.Message);
                    //    break;
                    //}
                    //tmpIndex++;
                    if (!NotInsertToDb)
                        ParamCount++;   // 当需要插入DB时
                }

                ////////////////////////////////////////////////////
                // 开始插入数据
                ////////////////////////////////////////////////////

                //bool Cancel = false;
                //try
                //{
                //    Inserting(out Cancel);  //获取外部取消命令
                //}
                //catch { }

                if (_InsertDB)
                {

                    if (HasCheckExist == true)
                    {
                        if (CheckExist(Tablename, CheckParameters))
                        {
                            UpdateExistTime(Tablename, TimeColName, CheckParameters);
                            continue;   // 跳过循环 不执行数据添加
                        }
                    }

                    for (int i = 0; i < Parameters.Length; i++)
                    {
                        Sql += "[" + Parameters[i].ParameterName + "]";

                        if (i < Parameters.Length - 1)
                            Sql += ",";
                    }

                    Sql += ") VALUES(";

                    for (int i = 0; i < Parameters.Length; i++)
                    {
                        Sql += "@" + Parameters[i].ParameterName;
                        if (i < Parameters.Length - 1)
                            Sql += ",";
                    }

                    Sql += ")";

                    cmd.Parameters.Clear();
                    foreach (OleDbParameter param in Parameters)
                    {
                        cmd.Parameters.Add(param);
                    }
                    cmd.CommandText = Sql;
                    //try
                    //{
                        //lock (Conn)
                        //{
                    //try
                    //{
                        cmd.ExecuteNonQuery();
                    //}
                    //catch(Exception ex) {
                    //    RaiseLog("插入数据出现异常：\r\n" + ex.Message + "\r\n" + ex.StackTrace);
                    //}

                    cmd.Dispose();
                            //Thread.Sleep(1500);
                            
                        //}
                    //}
                    //catch (Exception ex)
                    //{
                    //    RaiseLog("■发生错误：" + ex.Message);
                    //}
                    RaiseLog("数据库内容添加完成。");
                }

                try
                {
                    InsertCompleted(HasError, ErrDesc);
                }
                catch { }

                Thread.Sleep(GettingTask.WATING_TIME);// 延迟一下,减低系统负担。
            }

            _GettingTask.ProgressValue++;
            //GettingTask.ProgressValue++;    //任务完成，加进度。
            SaveLogFile();
            _Completed = true;
        }

        /// <summary>
        /// 更新已存在的日期字段
        /// </summary>
        /// <param name="Tablename"></param>
        /// <param name="TimeColName"></param>
        /// <param name="Params"></param>
        private void UpdateExistTime(string Tablename,string TimeColName, OleDbParameter[] Params)
        {
            if (TimeColName == null) return;

            OleDbCommand cmd = new OleDbCommand();
            cmd.Connection = Conn;
            cmd.Parameters.Clear();
            foreach (OleDbParameter param in Params)
            {
                cmd.Parameters.Add(param);
            }

            string Sql = "UPDATE " + Tablename + " SET " + TimeColName + "='" + DateTime.Now +"' WHERE ";
            for (int i = 0; i < Params.Length; i++)
            {
                Sql += Params[i].ParameterName + "=@" + Params[i].ParameterName;
                if (i < Params.Length - 1)
                    Sql += " AND ";
            }

            cmd.CommandText = Sql;
            cmd.ExecuteNonQuery();
            cmd.Dispose();
        }

        private bool CheckExist(string Tablename,OleDbParameter[] Params)
        {
            bool Result = false;
            OleDbCommand cmd = new OleDbCommand();
            cmd.Connection = Conn;
            cmd.Parameters.Clear();
            foreach (OleDbParameter param in Params)
            {
                cmd.Parameters.Add(param);
            }

            string Sql = "SELECT * FROM " + Tablename + " WHERE ";
            for (int i = 0; i < Params.Length; i++)
            {
                Sql += Params[i].ParameterName + "=@" + Params[i].ParameterName;
                if (i < Params.Length - 1)
                    Sql += " AND ";
            }

            cmd.CommandText = Sql;
            OleDbDataReader dr = cmd.ExecuteReader();
            Result = dr.HasRows;
            dr.Close();
            cmd.Dispose();
            return Result;
        }

        private void SaveLogFile()
        {
            try
            {
                File.AppendAllText(LogFilePath, LogText);
            }
            catch { }
        }

        private void RaiseLog(string Log)
        {
            try
            {
                if (LogFilePath != string.Empty)
                    LogText += Log + "\r\n";
                //ProgressLoging(Log + "\r\n");
            }
            catch { }
        }

        /// <summary>
        /// 根据头尾标注获得内容
        /// </summary>
        /// <param name="BeforeText">头</param>
        /// <param name="EndText">尾</param>
        /// <param name="AllContents">全部内容</param>
        /// <param name="StartIn">从什么地方开始 字符索引</param>
        /// <returns></returns>
        public static string GetContents(string BeforeText,string EndText,
            string AllContents,int StartIn)
        {
            string Result = "";
            int StartIndex = AllContents.IndexOf(BeforeText, StartIn) + BeforeText.Length;
            int EndIndex = AllContents.IndexOf(EndText, StartIndex);
            if (StartIndex != BeforeText.Length - 1)
            {
                // 当找到数据时。
                Result = AllContents.Substring(StartIndex, EndIndex - StartIndex)
                    .Replace("\t", "").Replace("\n", "").Trim();
            }
            else
            {
                Result = "";
            }
            return Result;
        }

        public class SettingCache
        {
            public string FieldName;
            public string CacheValue;
            public SettingCache(string FieldName,string CacheValue)
            {
                this.FieldName = FieldName;
                this.CacheValue = CacheValue;
            }
        }

        #region IDisposable 成员

        public void Dispose()
        {
            MainThread.Abort();
        }

        #endregion
    }
}