personalgroupmanager.cs

破解的飞信源代码

namespace Imps.Client.Core
{
    using Imps.Base.Sipc;
    using Imps.Client;
    using Imps.Client.Base;
    using Imps.Client.Resource;
    using Imps.Client.Utils;
    using Imps.Common;
    using Imps.Utils;
    using System;
    using System.Collections.Generic;
    using System.Drawing;
    using System.IO;
    using System.Net;
    using System.Runtime.CompilerServices;
    using System.Text;
    using System.Threading;
    using System.Windows.Forms;
    using System.Xml;

    public class PersonalGroupManager : UserItemBase
    {
        private List<string> _deletedGroups;
        private PersonalGroupCategory _groupCategory;
        private XmlNode _groupMembersNode;
        private PersonalGroup _loadGroup;
        private long _subscribeCallId;
        private int _subscribeCesq;

        public event EventHandler<ApplyJoinGroupEventArgs> ApplyJoinGroup;

        public event EventHandler<PersonalGroupEventArgs> GroupAdded;

        public event EventHandler<PersonalGroupEventArgs> GroupDeleted;

        public event EventHandler<PersonalGroupEventArgs> GroupInfoChanged;

        public event EventHandler<PersonalGroupEventArgs> GroupRemoved;

        public event EventHandler<InviteJoinGroupEventArgs> InviteJoinGroup;

        public event EventHandler<PersonalGroupEventArgs> MeBeDeleted;

        public event EventHandler<GroupMemberIdentifyEventArgs> MeIdentityChanged;

        public event EventHandler<GroupMemberDeletedEventArgs> MemberDeleted;

        public event EventHandler<MemberDestroyedEventArgs> MemberDestroyed;

        public event EventHandler<PersonalGroupMemberEventArgs> MemberExited;

        public event EventHandler<PersonalGroupMemberEventArgs> MemberJoined;

        public event EventHandler<GroupMembersInfoChangedEventArgs> MembersInfoChanged;

        public event EventHandler<PersonalGroupReplyResultEventArgs> ReplyResult;

        public event EventHandler<PersonalGroupEventArgs> WebJoinGroup;

        public PersonalGroupManager(Imps.Client.Core.User owner) : base(owner)
        {
            this._subscribeCesq = 1;
            this._deletedGroups = new List<string>();
            owner.SipNotifyReceived += new EventHandler<SipRequestReceivedEventArgs>(this, (IntPtr) this.owner_SipNotifyReceived);
            owner.StatusChanged += new EventHandler<UserSatusChangedEventArgs>(this, (IntPtr) this.owner_StatusChanged);
            owner.Presence.PropertiesChanged += new EventHandler<PropertiesChangedEventArgs>(this, (IntPtr) this.Presence_PropertiesChanged);
        }

        public bool AsyncApplyJoinGroup(PersonalGroup group, string description, string nickname, AsyncBizOperation op)
        {
            SipRequest req = base.Owner.CreateSipRequest("S");
            req.Message.AddHeader(new SipcEventHeader("PGApplyGroup"));
            string groupUri = group.Uri.Raw;
            op.ContextForBiz = group;
            req.Context = op;
            StringWriter tw = new StringWriter();
            XmlHelper.CreateXmlWriterForSipRequest(tw, groupUri, delegate (XmlWriter writer, object context) {
                writer.WriteStartElement("group");
                writer.WriteAttributeString("uri", groupUri);
                writer.WriteAttributeString("nickname", nickname);
                writer.WriteAttributeString("desc", description);
                writer.WriteEndElement();
            });
            req.Message.Body = tw.ToString();
            tw.Dispose();
            req.FinalResponseReceived += new EventHandler<SipResponseReceivedEventArgs>(this, (IntPtr) this.finalResponseReceived_AsyncApplyJoinGroup);
            ErrorHelper.HandleSendRequestErrorAndTimeout(req);
            base.Owner.SendSipMessage(req);
            return true;
        }

        public void AsyncBlockMember(PersonalGroupMember member)
        {
            member.GroupMemeberInfo.IsBlocked = new ProposedData<bool>(!member.GroupMemeberInfo.IsBlocked.Value);
            this.SavePersonalGroupsToLocal();
            List<PersonalGroupMember> members = new List<PersonalGroupMember>();
            members.Add(member);
            this.OnMembersInfoChanged(new GroupMembersInfoChangedEventArgs(members));
        }

        private void AsyncCreateGroup_After_GroupInfo_PropertiesChanged(object sender, PropertiesChangedEventArgs e)
        {
            if (e.ContainsProperty("SetGroupPortraitHds"))
            {
                PersonalGroup owner = (sender as PersonalGroupInfo).Owner;
                this.AsyncUploadGroupPortrait(owner, new AsyncBizOperation());
                owner.GroupInfo.PropertiesChanged -= new EventHandler<PropertiesChangedEventArgs>(this, (IntPtr) this.AsyncCreateGroup_After_GroupInfo_PropertiesChanged);
            }
        }

        public bool AsyncCreatePersonalGroup(AsyncBizOperation op, PersonalGroupInfo info)
        {
            SipRequest req = base.Owner.CreateSipRequest("S");
            req.Message.AddHeader(new SipcEventHeader("PGCreateGroup"));
            op.ContextForBiz = info;
            req.Context = op;
            StringWriter tw = new StringWriter();
            XmlHelper.CreateXmlWriterForSipRequest(tw, info, delegate (XmlWriter writer, object context) {
                PersonalGroupInfo info = context as PersonalGroupInfo;
                writer.WriteStartElement("group");
                writer.WriteAttributeString("name", (string) info.Name);
                writer.WriteAttributeString("category", (string) info.Category);
                writer.WriteAttributeString("tags", (string) info.Tags);
                writer.WriteAttributeString("introduce", (string) info.Introduce);
                writer.WriteAttributeString("bulletin ", (string) info.Bulletin);
                writer.WriteAttributeString("join-approved-type", ((int) info.ValidateType.Value).ToString());
                writer.WriteAttributeString("enable-searched ", (info.EnableSearched != null) ? "1" : "2");
                writer.WriteEndElement();
            });
            req.Message.Body = tw.ToString();
            tw.Dispose();
            req.WaitResponseTimeout += new EventHandler(this.req_WaitResponseTimeout);
            req.FinalResponseReceived += new EventHandler<SipResponseReceivedEventArgs>(this, (IntPtr) this.finalResponseReceived_AsyncCreatePersonalGroup);
            ErrorHelper.HandleSendRequestErrorAndTimeout(req);
            base.Owner.SendSipMessage(req);
            return true;
        }

        public void AsyncDeleteGroupMember(PersonalGroupMember member, AsyncBizOperation op)
        {
            SipRequest req = base.Owner.CreateSipRequest("S");
            req.Message.AddHeader(new SipcEventHeader("PGDeleteGroupMember"));
            op.ContextForBiz = member;
            req.Context = op;
            StringWriter tw = new StringWriter();
            XmlHelper.CreateXmlWriterForSipRequest(tw, member, delegate (XmlWriter writer, object context) {
                PersonalGroupMember member = context as PersonalGroupMember;
                writer.WriteStartElement("group");
                writer.WriteAttributeString("uri", member.OwnerGroup.Uri.Raw);
                writer.WriteStartElement("member");
                writer.WriteAttributeString("uri", member.Uri.Raw);
                writer.WriteEndElement();
                writer.WriteEndElement();
            });
            req.Message.Body = tw.ToString();
            tw.Dispose();
            req.FinalResponseReceived += new EventHandler<SipResponseReceivedEventArgs>(this, (IntPtr) this.finalResponseReceived_AsyncDeleteGroupMember);
            ErrorHelper.HandleSendRequestErrorAndTimeout(req);
            base.Owner.SendSipMessage(req);
        }

        public bool AsyncDeletePersonalGroup(PersonalGroup group, AsyncBizOperation op)
        {
            SipRequest req = base.Owner.CreateSipRequest("S");
            req.Message.AddHeader(new SipcEventHeader("PGDeleteGroup"));
            op.ContextForBiz = group;
            req.Context = op;
            StringWriter tw = new StringWriter();
            XmlHelper.CreateXmlWriterForSipRequest(tw, group, delegate (XmlWriter writer, object context) {
                writer.WriteStartElement("group");
                writer.WriteAttributeString("uri", (context as PersonalGroup).Uri.Raw);
                writer.WriteEndElement();
            });
            req.Message.Body = tw.ToString();
            tw.Dispose();
            req.FinalResponseReceived += new EventHandler<SipResponseReceivedEventArgs>(this, (IntPtr) this.finalResponseReceived_AsyncDeletePersonalGroup);
            ErrorHelper.HandleSendRequestErrorAndTimeout(req);
            base.Owner.SendSipMessage(req);
            return true;
        }

        internal void AsyncDoLogout(AsyncBizOperation op)
        {
            try
            {
                ClientLogger.WriteGeneral("注销,群组进行清理操作...");
                if (base.Owner.PersonalGroups != null)
                {
                    this.UnRegisterKeepAlive();
                    this.AsyncUnsubscribeAllGroup();
                    this.Clear();
                    ClientLogger.WriteGeneral("注销,群组清理操作完成...");
                }
            }
            catch (Exception exception)
            {
                ClientLogger.WriteException("注销时,群清理失败", exception);
            }
            finally
            {
                Thread.Sleep(300);
                Imps.Client.Core.User.TryCallReceiveMessageOnOp(op);
            }
        }

        public void AsyncDownLoadGroupPortrait(PersonalGroup group)
        {
            if (!string.IsNullOrEmpty((string) group.GroupInfo.GetGroupPortraitHds))
            {
                ThreadPool.QueueUserWorkItem(new WaitCallback(this.DownLoadGroupPortraitInThread), group);
            }
        }

        public void AsyncExitGroup(PersonalGroup group, AsyncBizOperation op)
        {
            SipRequest req = base.Owner.CreateSipRequest("S");
            req.Message.AddHeader(new SipcEventHeader("PGQuitGroup"));
            op.ContextForBiz = group;
            req.Context = op;
            StringWriter tw = new StringWriter();
            XmlHelper.CreateXmlWriterForSipRequest(tw, group, delegate (XmlWriter writer, object context) {
                writer.WriteStartElement("group");
                writer.WriteAttributeString("uri", (context as PersonalGroup).Uri.Raw);
                writer.WriteEndElement();
            });
            req.Message.Body = tw.ToString();
            tw.Dispose();
            req.FinalResponseReceived += new EventHandler<SipResponseReceivedEventArgs>(this, (IntPtr) this.finalResponseReceived_AsyncExitGroup);
            ErrorHelper.HandleSendRequestErrorAndTimeout(req);
            base.Owner.SendSipMessage(req);
        }

        public void AsyncGetAllGroupInfo(AsyncBizOperation op)
        {
            this.AsyncGetGroupInfo(null, op);
        }

        private void AsyncGetAllPersonalInfo()
        {
            lock (base.Owner.PersonalGroups.SyncRoot)
            {
                using (IEnumerator<PersonalGroup> enumerator = base.Owner.PersonalGroups.GetEnumerator())
                {
                    while (enumerator.MoveNext())
                    {
                        PersonalGroup group = enumerator.get_Current();
                        this.AsyncGetPersonalInfo(group, new AsyncBizOperation());
                    }
                }
            }
        }

        public void AsyncGetGroupInfo(PersonalGroup group, AsyncBizOperation op)
        {
            SipRequest req = base.Owner.CreateSipRequest("S");
            req.Message.AddHeader(new SipcEventHeader("PGGetGroupInfo"));
            req.Context = op;
            op.ContextForBiz = group;
            StringWriter tw = new StringWriter();
            XmlHelper.CreateXmlWriterForSipRequest(tw, group, delegate (XmlWriter writer, object context) {
                PersonalGroup group = context as PersonalGroup;
                writer.WriteStartElement("groups");
                writer.WriteAttributeString("attributes", "all");
                List<PersonalGroup> list = new List<PersonalGroup>();
                if (group != null)
                {
                    list.Add(group);
                }
                else
                {
                    lock (base.Owner.PersonalGroups.SyncRoot)
                    {