permissionmanager.cs

破解的飞信源代码

namespace Imps.Client.Core
{
    using Imps.Base.Sipc;
    using Imps.Client.Base;
    using Imps.Client.Core.Login;
    using Imps.Client.Resource;
    using Imps.Client.Utils;
    using Imps.Common;
    using Imps.Common.Permission;
    using Imps.Utils;
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Xml;

    public class PermissionManager : ICommittable
    {
        private PermissionDict _globalPermission;
        private bool _hasGotPermission;
        private Imps.Client.Core.User _owner;
        private string _permissionVersion;

        public PermissionManager(Imps.Client.Core.User owner)
        {
            this._owner = owner;
            this._owner.SipNotifyReceived += new EventHandler<SipRequestReceivedEventArgs>(this, (IntPtr) this._owner_SipNotifyReceived);
        }

        private void _owner_SipNotifyReceived(object sender, SipRequestReceivedEventArgs e)
        {
            string text;
            SipRequest req = e.Request;
            if (((text = req.Message.Event.Value) != null) && (text == "permission"))
            {
                this.Notify_Permission(req);
            }
        }

        public bool AsyncGetAllContactPermission(string obj, AsyncBizOperation op)
        {
            if (obj.Length == 0)
            {
                LogHelper.LogFatalError("AsyncGetContactPermission,obj为空");
                return false;
            }
            SipRequest req = this._owner.CreateSipRequest("S");
            req.Message.AddHeader(new SipcEventHeader("GetContactPermission"));
            req.Context = op;
            StringWriter tw = new StringWriter();
            XmlHelper.CreateXmlWriterForSipRequest(tw, null, delegate (XmlWriter writer, object context) {
                writer.WriteStartElement("permissions");
                writer.WriteAttributeString("all", "1");
                writer.WriteAttributeString("objects", obj);
                writer.WriteEndElement();
            });
            req.Message.Body = tw.ToString();
            tw.Dispose();
            ErrorHelper.HandleSendRequestErrorAndTimeout(req);
            req.FinalResponseReceived += new EventHandler<SipResponseReceivedEventArgs>(this, (IntPtr) this.getAllContactsPermission_FinalResponseReceived);
            this._owner.SendSipMessage(req);
            return true;
        }

        public bool AsyncGetContactPermission(Imps.Client.Core.Contact contact, AsyncBizOperation op)
        {
            if (contact == null)
            {
                return false;
            }
            return this.AsyncGetContactsPermission(new string[] { contact.Uri.Raw }, "all", op);
        }

        public bool AsyncGetContactsPermission(string[] uriArray, string obj, AsyncBizOperation op)
        {
            if (uriArray.Length == 0)
            {
                LogHelper.LogFatalError("AsyncGetContactPermission,uriArray为空");
                return false;
            }
            if (obj.Length == 0)
            {
                LogHelper.LogFatalError("AsyncGetContactPermission,obj为空");
                return false;
            }
            SipRequest req = this._owner.CreateSipRequest("S");
            req.Message.AddHeader(new SipcEventHeader("GetContactPermission"));
            req.Context = op;
            StringWriter tw = new StringWriter();
            XmlHelper.CreateXmlWriterForSipRequest(tw, null, delegate (XmlWriter writer, object context) {
                writer.WriteStartElement("permissions");
                writer.WriteAttributeString("all", "0");
                writer.WriteAttributeString("objects", obj);
                for (int j = 0; i < uriArray.Length; i++)
                {
                    string uriString = uriArray[i];
                    IicUri uri = new IicUri(uriString);
                    if (uri.IsValid && (this._owner.ContactList.Contacts[uriString] != null))
                    {
                        writer.WriteStartElement("permission");
                        writer.WriteAttributeString("uri", uriString);
                        writer.WriteEndElement();
                    }
                }
                writer.WriteEndElement();
            });
            req.Message.Body = tw.ToString();
            tw.Dispose();
            ErrorHelper.HandleSendRequestErrorAndTimeout(req);
            req.FinalResponseReceived += new EventHandler<SipResponseReceivedEventArgs>(this, (IntPtr) this.getContactsPermission_FinalResponseReceived);
            this._owner.SendSipMessage(req);
            return true;
        }

        private void AsyncGetGlobalAndContactPermissions(AsyncBizOperation op)
        {
            AsyncBizOperation operation = new AsyncBizOperation();
            operation.Successed += delegate (object sender, EventArgs e) {
                EventHandler handler = null;
                try
                {
                    AsyncBizOperation operation1 = new AsyncBizOperation();
                    if (handler == null)
                    {
                        handler = delegate {
                            try
                            {
                                this._hasGotPermission = true;
                                if (op != null)
                                {
                                    op.FireSuccessedInUiThread(EventArgs.Empty);
                                }
                            }
                            catch
                            {
                            }
                        };
                    }
                    operation1.Successed += handler;
                    this.AsyncGetAllContactPermission("all", operation1);
                }
                catch (Exception exception)
                {
                    ClientLogger.WriteException(exception);
                }
            };
            this.AsyncGetUserGlobalPermission("all", operation);
        }

        public bool AsyncGetUserGlobalPermission(string strObject, AsyncBizOperation op)
        {
            if ((strObject == null) || (strObject.Length == 0))
            {
                throw new ArgumentException("strObject 参数为空");
            }
            SipRequest req = this._owner.CreateSipRequest("S");
            req.Message.AddHeader(new SipcEventHeader("GetGlobalPermission"));
            StringWriter tw = new StringWriter();
            XmlHelper.CreateXmlWriterForSipRequest(tw, null, delegate (XmlWriter writer, object context) {
                writer.WriteStartElement("permissions");
                writer.WriteAttributeString("objects", strObject);
                writer.WriteEndElement();
            });
            req.Message.Body = tw.ToString();
            tw.Dispose();
            ErrorHelper.HandleSendRequestErrorAndTimeout(req);
            req.Context = op;
            req.FinalResponseReceived += new EventHandler<SipResponseReceivedEventArgs>(this, (IntPtr) this.getUserGlobalPermission_FinalResponseReceived);
            this._owner.SendSipMessage(req);
            return true;
        }

        internal void AsyncInitialize(AsyncBizOperation op)
        {
            this.AsyncInitialize(op, true);
        }

        internal void AsyncInitialize(AsyncBizOperation op, bool loadLocalStorage)
        {
            this._hasGotPermission = false;
            if (loadLocalStorage)
            {
                this.LoadLocalStorage();
            }
            this.AsyncGetGlobalAndContactPermissions(op);
        }

        internal void AsyncRetry(RetryResult result)
        {
            result.IsCompleted = this._hasGotPermission;
            if (!this._hasGotPermission)
            {
                this.AsyncGetGlobalAndContactPermissions(new AsyncBizOperation());
            }
        }

        public bool AsyncSetAllContactsPermission(AsyncBizOperation op)
        {
            return this.AsyncSetContactsPermission(this._owner.ContactList.Contacts, op);
        }

        public bool AsyncSetContactPermission(Imps.Client.Core.Contact contact, AsyncBizOperation op)
        {
            if (contact == null)
            {
                throw new ArgumentNullException("contact");
            }
            List<Imps.Client.Core.Contact> contacts = new List<Imps.Client.Core.Contact>(1);
            contacts.Add(contact);
            return this.AsyncSetContactsPermission(contacts, op);
        }

        private bool AsyncSetContactsPermission(ICollection<Imps.Client.Core.Contact> contacts, AsyncBizOperation op)
        {
            if ((contacts != null) && (contacts.get_Count() != 0))
            {
                bool flag = true;
                StringWriter w = new StringWriter();
                XmlTextWriter writer2 = new XmlTextWriter(w);
                writer2.Formatting = Formatting.Indented;
                writer2.WriteStartElement("args");
                writer2.WriteStartElement("permissions");
                using (IEnumerator<Imps.Client.Core.Contact> enumerator = contacts.GetEnumerator())
                {
                    while (enumerator.MoveNext())
                    {
                        Imps.Client.Core.Contact contact = enumerator.get_Current();
                        if (contact.HasCustimizedPermissions)
                        {
                            string proposedValues = contact.Permissions.GetProposedValues();
                            if (!string.IsNullOrEmpty(proposedValues))
                            {
                                flag = false;
                                writer2.WriteStartElement("permission");
                                writer2.WriteAttributeString("uri", contact.Uri.Raw);
                                writer2.WriteAttributeString("values", proposedValues);
                                writer2.WriteEndElement();
                            }
                        }
                    }
                }
                writer2.WriteEndElement();
                writer2.WriteEndElement();
                writer2.Flush();
                writer2.Close();
                if (!flag)
                {
                    SipRequest req = this._owner.CreateSipRequest("S");
                    req.Message.AddHeader(new SipcEventHeader("SetContactPermission"));
                    req.Context = op;
                    req.Message.Body = w.ToString();
                    ErrorHelper.HandleSendRequestErrorAndTimeout(req);
                    req.FinalResponseReceived += new EventHandler<SipResponseReceivedEventArgs>(this, (IntPtr) this.SetContactOrContactsPermission_FinalResponseReceived);
                    this._owner.SendSipMessage(req);
                }
            }
            return true;
        }

        internal bool AsyncSetUserGlobalPermission(AsyncBizOperation op)
        {
            string newValues = this.UserGlobalPermission.GetProposedValues();
            if (!string.IsNullOrEmpty(newValues))
            {
                SipRequest req = this._owner.CreateSipRequest("S");
                req.Message.AddHeader(new SipcEventHeader("SetGlobalPermission"));
                req.Context = op;
                StringWriter tw = new StringWriter();
                XmlHelper.CreateXmlWriterForSipRequest(tw, null, delegate (XmlWriter writer, object context) {
                    writer.WriteStartElement("permissions");
                    writer.WriteAttributeString("values", newValues);