dbhistorymanager.cs

破解的飞信源代码

namespace Imps.Client.Core.History
{
    using Imps.Client.Core;
    using Imps.Client.Data;
    using Imps.Utils.TagParser;
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Runtime.InteropServices;
    using System.Text;
    using System.Threading;
    using System.Xml;

    public class DbHistoryManager : IHistoryManager, IDisposable
    {
        private Player _currentPlayer;
        private User _currentUser;
        private const int MESSAGE_PER_PAGE = 30;

        internal DbHistoryManager(User currentUser)
        {
            this._currentUser = currentUser;
            this._currentPlayer = new Player(currentUser.Uri.Raw, currentUser.Nickname, PlayerType.User);
            this.InitializeDatabase();
            this.CurrentUser.ContactList.ContactTypeChanged += new EventHandler<ContactTypeChangedEventArgs>(this, (IntPtr) this.ContactList_ContactTypeChanged);
        }

        public bool ClearMessage(MessageType type)
        {
            try
            {
                this._dbHelper.JoinTransaction();
                this._dbHelper.ExecuteNonQuery("DELETE FROM [Message] WHERE [MessageID] IN (SELECT [ID] FROM [MessageBody] WHERE [MessageType] = [MessageType] & @Type)", new object[] { (int) type });
                this._dbHelper.ExecuteNonQuery("DELETE FROM [MessageBody] WHERE [MessageType] = [MessageType] & @Type", new object[] { (int) type });
                this._dbHelper.CommitTransaction();
                return true;
            }
            catch
            {
                this._dbHelper.RollbackTransaction();
                return false;
            }
        }

        protected void ClearPlayer()
        {
            List<string> list = new List<string>();
            using (SQLiteDataReader reader = this._dbHelper.ExecuteReader("SELECT DISTINCT [Uri] FROM [vPlayerRef] WHERE [RefCount] = 0", null))
            {
                while (reader.Read())
                {
                    list.Add(reader["Uri"].ToString());
                }
                reader.Close();
            }
            List<string>.Enumerator enumerator = list.GetEnumerator();
            try
            {
                while (enumerator.MoveNext())
                {
                    string text = enumerator.get_Current();
                    this._dbHelper.ExecuteNonQuery("DELETE FROM [Player] WHERE [Uri] = @Uri", new object[] { text });
                }
            }
            finally
            {
                enumerator.Dispose();
            }
        }

        private void ContactList_ContactTypeChanged(object sender, ContactTypeChangedEventArgs e)
        {
            try
            {
                if (e.NewContactInstance.Uri.Raw != e.OldContactInstance.Uri.Raw)
                {
                    Player newPlayer = new Player(e.NewContactInstance.Uri.Raw, e.NewContactInstance.DisplayName, PlayerType.Contact);
                    Player oldPlayer = new Player(e.OldContactInstance.Uri.Raw, e.OldContactInstance.DisplayName, PlayerType.Contact);
                    this.UpdatePlayer(oldPlayer, newPlayer);
                }
            }
            catch
            {
            }
        }

        public bool DeleteMessage(string messageID)
        {
            try
            {
                this._dbHelper.JoinTransaction();
                this._dbHelper.ExecuteNonQuery("DELETE FROM [Message] WHERE [MessageID] = @ID", new object[] { messageID });
                this._dbHelper.ExecuteNonQuery("DELETE FROM [MessageBody] WHERE [ID] = @ID", new object[] { messageID });
                this._dbHelper.CommitTransaction();
            }
            catch
            {
                this._dbHelper.RollbackTransaction();
                return false;
            }
            return true;
        }

        public bool DeleteMessage(MessageType type, params string[] players)
        {
            try
            {
                this._dbHelper.JoinTransaction();
                foreach (string text in players)
                {
                    if (text != this._currentPlayer.Uri)
                    {
                        this._dbHelper.ExecuteNonQuery("DELETE FROM [Message] WHERE [MessageID] IN (SELECT [ID] FROM [vMessage] WHERE [MessageType] = [MessageType] & @Type AND ([SenderUri] = @Uri OR [ReceiverUri] = @Uri))", new object[] { (int) type, text });
                    }
                    else
                    {
                        this._dbHelper.ExecuteNonQuery("DELETE FROM [Message] WHERE [MessageID] IN (SELECT [ID] FROM [vMessage] WHERE [MessageType] = [MessageType] & @Type AND ([SenderUri] = @Uri AND [ReceiverUri] = @Uri))", new object[] { (int) type, text });
                    }
                }
                this._dbHelper.ExecuteNonQuery("DELETE FROM [MessageBody] WHERE [ID] NOT IN (SELECT [MessageID] FROM [Message])", null);
                this._dbHelper.CommitTransaction();
            }
            catch
            {
                this._dbHelper.RollbackTransaction();
                return false;
            }
            return true;
        }

        protected void DeletePlayer(Player player)
        {
            this._dbHelper.ExecuteNonQuery("DELETE FROM [Player] WHERE [Uri] = @Uri", new object[] { player.Uri });
        }

        public void Dispose()
        {
            this.Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected void Dispose(bool disposed)
        {
            try
            {
                if (disposed)
                {
                    this.CurrentUser.ContactList.ContactTypeChanged -= new EventHandler<ContactTypeChangedEventArgs>(this, (IntPtr) this.ContactList_ContactTypeChanged);
                }
            }
            catch
            {
            }
        }

        public bool ExistMessage(IMessage msg)
        {
            return (this._dbHelper.ExecuteScalar("SELECT COUNT(*) FROM [MessageBody] WHERE [ID] = @ID", new object[] { msg.ID }) > 0);
        }

        public bool ExistPlayer(Player player)
        {
            return (this._dbHelper.ExecuteScalar("SELECT COUNT(*) FROM [Player] WHERE Uri = @Uri", new object[] { player.Uri }) > 0);
        }

        ~DbHistoryManager()
        {
            this.Dispose(false);
        }

        private int GetCurrentPage(int page, int msgCount)
        {
            if ((page * this.MessagesPerPage) > msgCount)
            {
                page = (((msgCount - 1) > 0) ? (msgCount - 1) : 0) / this.MessagesPerPage;
            }
            if (page < 0)
            {
                page = 0;
            }
            return page;
        }

        private SystemMessage GetMessage(XmlNode node)
        {
            string id = node.Attributes["ID"].Value;
            string exprieTime = node.Attributes["Expired"].Value;
            string link = node.Attributes["Link"].Value;
            string content = node.InnerText;
            SystemMessage message = new SystemMessage(id, content, link, exprieTime);
            message.CurrentUser = this._currentUser;
            return message;
        }

        private InstantMessage GetMessage(XmlNode node, Player player)
        {
            DateTime minValue;
            if (node.Attributes["FromUri"] == null)
            {
                return null;
            }
            string uri = node.Attributes["FromUri"].Value;
            string id = node.Attributes["MessageID"].Value;
            string friendlyName = node.Attributes["From"].Value;
            string text4 = node.Attributes["Date"].Value;
            string text5 = node.Attributes["Time"].Value;
            string body = Imps.Utils.TagParser.TagParser.Create(node.SelectSingleNode("Text").InnerText, false).Text;
            Player sender = null;
            if (uri == this.CurrentPlayer.Uri)
            {
                sender = this.CurrentPlayer;
            }
            else
            {
                sender = new Player(uri, friendlyName, PlayerType.Contact);
            }
            InstantMessage message = new InstantMessage(id, sender, body, MessageType.IM);
            if (uri != this.CurrentPlayer.Uri)
            {
                message.Receivers.Add(this.CurrentPlayer);
            }
            if (uri != player.Uri)
            {
                message.Receivers.Add(player);
            }
            if (message.Receivers.get_Count() == 0)
            {
                message.Receivers.Add(this.CurrentPlayer);
            }
            try
            {
                DateTime.TryParse(text4 + " " + text5, ref minValue);
            }
            catch
            {
                minValue = DateTime.MinValue;
            }
            message.Time = minValue;
            return message;
        }

        private void InitializeDatabase()
        {
            List<string> objects = this._dbHelper.Objects;
            StringBuilder builder = null;
            if (!objects.Contains("Player"))
            {
                builder = new StringBuilder();
                builder.AppendLine("CREATE TABLE Player(");
                builder.AppendLine("Uri VARCHAR(256) PRIMARY KEY,");
                builder.AppendLine("Name VARCHAR(256),");
                builder.AppendLine("Type INTEGER)");
                builder.AppendLine("");
                this._dbHelper.ExecuteNonQuery(builder.ToString(), null);
            }
            if (!objects.Contains("MessageBody"))
            {
                builder = new StringBuilder();
                builder.AppendLine("CREATE TABLE MessageBody(");
                builder.AppendLine("ID VARCHAR(64) PRIMARY KEY,");
                builder.AppendLine("SenderUri VARCHAR(256),");
                builder.AppendLine("SenderName VARCHAR(256),");
                builder.AppendLine("Body VARCHAR(1000),");
                builder.AppendLine("Extend VARCHAR(1000),");
                builder.AppendLine("MessageType INTEGER,");