persistentmanager.cs

破解的飞信源代码

namespace Imps.Client.Pc
{
    using Imps.Client;
    using Imps.Client.Core;
    using Imps.Client.Resource;
    using Imps.Client.Utils;
    using Imps.Common;
    using Imps.Utils;
    using System;
    using System.Drawing;
    using System.Drawing.Imaging;
    using System.IO;
    using System.Runtime.InteropServices;
    using System.Text;
    using System.Xml;

    public class PersistentManager : IPersistentManager
    {
        private string _dirHistory;
        private string _dirImps;
        private string _dirMyContactPortrait;
        private string _dirMyUsedGroupPortrait;
        private string _dirMyUsedPortrait;
        private string _dirWin;
        private IFrameworkWindow _host;
        private string _pathCfgImps;
        private string _pathCfgWnd;
        private string _pathContacts;
        private string _pathPermissions;
        private string _pathPersonalGroups;
        private string _pathPGroupCategorys;
        private string _pathPlugins;
        private string _pathRecentBuddies;
        private string _pathScheduleSms;
        private string _pathUserInfo;
        private object _syncObjCfgImps = new object();
        private object _syncObjCfgWnd = new object();
        private object _syncObjContacts = new object();
        private object _syncObjPermissions = new object();
        private object _syncObjPlugins = new object();
        private object _syncObjPortraits = new object();
        private object _syncObjRecentBuddies = new object();
        private object _syncObjUserInfo = new object();
        private object _syncPgroups = new object();
        private object _syncScheduleSms = new object();
        private long _userId;
        private const string XA_StoreMode = "StoreMode";
        private const string XN_RootConfig = "ImpsConfiguration";
        private const string XN_SystemConfig = "SystemConfiguration";
        private const string XN_UserConfig = "UserConfiguration";

        public PersistentManager(IFrameworkWindow host)
        {
            this._host = host;
            this._dirWin = FilePathHelper.GetPathWithEnvVar(@"%AppData%\" + AppDictionary.ShortEnglishName + @"\");
            this._pathCfgWnd = this._dirWin + "configuration.dat";
            this._pathPGroupCategorys = this._dirWin + "PGCategorys.dat";
        }

        private static string DecodeMode1(string text)
        {
            string text2 = string.Empty;
            try
            {
                text2 = GZipHelper.DecompressString(text);
            }
            catch
            {
                text2 = string.Empty;
            }
            if (!string.IsNullOrEmpty(text2))
            {
                return text2;
            }
            return text;
        }

        public void DelById(string userId)
        {
            this.InnerDelSingleDir(Path.Combine(this._dirWin, userId));
        }

        public void DelChatHistoryById(string userId)
        {
            this.InnerDelSingleFileById(userId, "history.dat");
        }

        public void DelContactsInfoById(string userId)
        {
            this.InnerDelSingleFileById(userId, "contacts.dat");
        }

        public void DelPermissionById(string userId)
        {
            this.InnerDelSingleFileById(userId, "permissions.dat");
        }

        public void DelPluginsCfgById(string userId)
        {
            this.InnerDelSingleDir(this._dirWin + userId + @"\Plugins");
        }

        public void DelPortraitsById(string userId)
        {
            this.InnerDelSingleDir(this._dirWin + userId + @"\Portraits");
        }

        public void DelUserCfgById(string userId)
        {
            this.InnerDelSingleFileById(userId, "configuration.dat");
        }

        public void DelUserInfoById(string userId)
        {
            this.InnerDelSingleFileById(userId, "userinfo.dat");
        }

        private void DoLoadData(PersistentDelegate load, string filename, string xpath, object syncObj)
        {
            this.DoLoadData(load, filename, xpath, syncObj, true);
        }

        private void DoLoadData(PersistentDelegate load, string filename, string xpath, object syncObj, bool verify)
        {
            try
            {
                if (!string.IsNullOrEmpty(filename))
                {
                    XmlNode section = this.GetXmlNodeFromFile(filename, xpath, syncObj);
                    if (verify)
                    {
                        XmlNode node = section.SelectSingleNode("verify/info");
                        if ((node == null) || (XmlHelper.ReadXmlAttributeDateTime(node, "datetime", DateTime.MinValue).AddDays(30).CompareTo(Imps.Client.Core.User.ServerTime) < 0))
                        {
                            return;
                        }
                    }
                    load(section);
                }
            }
            catch (Exception exception)
            {
                ClientLogger.WriteGeneral("加载本地缓存失败", string.Format("{0}\r\n{1}", filename, exception.Message), 10);
            }
        }

        private void DoSaveData(PersistentDelegate save, string filename, string xpath, object syncObj)
        {
            try
            {
                if (!string.IsNullOrEmpty(filename))
                {
                    XmlNode section = this.GetXmlNodeFromFile(filename, xpath, syncObj);
                    save(section);
                    XmlNode newChild = section.SelectSingleNode("verify/info");
                    if (newChild != null)
                    {
                        newChild.Attributes["datetime"].Value = Imps.Client.Core.User.ServerTime.ToString("yyyy-MM-dd");
                    }
                    else
                    {
                        newChild = section.OwnerDocument.CreateNode(XmlNodeType.Element, "verify", null);
                        newChild.InnerXml = "<info datetime='" + Imps.Client.Core.User.ServerTime.ToString("yyyy-MM-dd") + "' />";
                        section.AppendChild(newChild);
                    }
                    XmlWriterSettings settings = new XmlWriterSettings();
                    settings.set_Encoding(Encoding.UTF8);
                    settings.set_CloseOutput(true);
                    settings.set_Indent(true);
                    settings.set_OmitXmlDeclaration(false);
                    XmlNode node = section.OwnerDocument.DocumentElement;
                    string innerXml = node.InnerXml;
                    node.InnerXml = EncodeMode1(innerXml);
                    XmlHelper.SetNodeAttributeInt32(node, "StoreMode", 1);
                    if (!File.Exists(filename))
                    {
                        FilePathHelper.MakeSureFilePathExists(filename);
                    }
                    lock (syncObj)
                    {
                        using (XmlWriter w = XmlWriter.Create(filename, settings))
                        {
                            section.OwnerDocument.Save(w);
                            w.Flush();
                            w.Close();
                        }
                    }
                }
            }
            catch (Exception exception)
            {
                ClientLogger.WriteGeneral("保存本地缓存失败", string.Format("{0}\r\n{1}", filename, exception.Message), 10);
            }
        }

        private static string EncodeMode1(string text)
        {
            try
            {
                return GZipHelper.CompressString(text);
            }
            catch
            {
            }
            return string.Empty;
        }

        private XmlNode GetXmlNodeFromFile(string filename, string xpath, object syncObj)
        {
            XmlDocument document = new XmlDocument();
            XmlNode node = null;
            try
            {
                if (!File.Exists(filename))
                {
                    return node;
                }
                lock (syncObj)
                {
                    document.Load(filename);
                }
                XmlNode documentElement = document.DocumentElement;
                if (documentElement == null)
                {
                    return node;
                }
                XmlAttribute attribute = documentElement.Attributes["StoreMode"];
                if (attribute == null)
                {
                    return node;
                }
                if (attribute.Value == "1")
                {
                    string innerXml = documentElement.InnerXml;
                    documentElement.InnerXml = DecodeMode1(innerXml);
                    if (documentElement.FirstChild is XmlText)
                    {
                        documentElement.RemoveChild(documentElement.FirstChild);
                    }
                    return node;
                }
                documentElement.InnerXml = string.Empty;
            }
            catch
            {
            }
            finally
            {
                if (string.IsNullOrEmpty(xpath))
                {
                    node = document;
                }
                else
                {
                    node = XmlHelper.MakeSureChildPathExists(document, xpath);
                }
            }
            return node;
        }

        private void InnerDelSingleDir(string dir)
        {
            if (Directory.Exists(dir))
            {
                try
                {
                    Directory.Delete(dir, true);
                }
                catch
                {
                }
            }
        }

        private void InnerDelSingleFileById(string userId, string filename)
        {
            string path = this._dirWin + userId + @"\" + filename;
            if (File.Exists(path))
            {
                try
                {
                    File.Delete(path);
                }
                catch
                {
                }
            }
        }

        public void LoadAccountsData(PersistentDelegate load)
        {
            this.DoLoadData(load, this._pathCfgWnd, "ImpsConfiguration/AccountsData", this._syncObjCfgWnd, false);
        }

        public void LoadById(long userId)
        {
            this._userId = userId;
            this._dirImps = this._dirWin + userId.ToString() + @"\";
            this._dirHistory = this._dirImps + @"History\";
            this._dirMyContactPortrait = this._dirImps + @"Portraits\";
            this._dirMyUsedPortrait = this._dirImps + @"MyPortraits\";
            this._pathPlugins = this._dirImps + @"Plugins\";
            this._dirMyUsedGroupPortrait = this._dirImps + @"GroupPortraits\";
            this._pathCfgImps = this._dirImps + "configuration.dat";
            this._pathUserInfo = this._dirImps + "userinfo.dat";
            this._pathContacts = this._dirImps + "contacts.dat";
            this._pathPermissions = this._dirImps + "permissions.dat";
            this._pathPersonalGroups = this._dirImps + "PersonalGroups.dat";
            this._pathScheduleSms = this._dirImps + "scheduleSms.dat";
            this._pathRecentBuddies = this._dirImps + "recentBuddies.dat";
        }

        public void LoadContacts(PersistentDelegate load)
        {
            this.DoLoadData(load, this._pathContacts, "ContactList", this._syncObjContacts);
        }

        public void LoadImpsUserConfig(PersistentDelegate load)
        {