personalgroupmanager.cs

破解的飞信源代码

            req.FinalResponseReceived += new EventHandler<SipResponseReceivedEventArgs>(this, (IntPtr) this.finalResponseReceived_AsyncUndoApply);
            ErrorHelper.HandleSendRequestErrorAndTimeout(req);
            base.Owner.SendSipMessage(req);
            return true;
        }

        public void AsyncUnsubscribeAllGroup()
        {
            this.AsyncUnsubscribeGroup(null, new AsyncBizOperation());
        }

        public void AsyncUnsubscribeGroup(PersonalGroup group, AsyncBizOperation op)
        {
            SipRequest req = base.Owner.CreateSipRequest("SUB", this._subscribeCallId, this._subscribeCesq++);
            req.Message.AddHeader(new SipcEventHeader("PGPresence"));
            req.Message.AddHeader(new SipcExpiresHeader(0));
            op.ContextForBiz = group;
            req.Context = op;
            StringWriter tw = new StringWriter();
            XmlHelper.CreateXmlWriterForSipRequest(tw, group, delegate (XmlWriter writer, object context) {
                writer.WriteStartElement("subscription");
                writer.WriteStartElement("groups");
                if (context != null)
                {
                    writer.WriteStartElement("group");
                    writer.WriteAttributeString("uri", (context as PersonalGroup).Uri.Raw);
                    writer.WriteEndElement();
                }
                else
                {
                    lock (base.Owner.PersonalGroups.SyncRoot)
                    {
                        using (IEnumerator<PersonalGroup> enumerator = base.Owner.PersonalGroups.GetEnumerator())
                        {
                            while (enumerator.MoveNext())
                            {
                                PersonalGroup group = enumerator.get_Current();
                                writer.WriteStartElement("group");
                                writer.WriteAttributeString("uri", group.Uri.Raw);
                                writer.WriteEndElement();
                            }
                        }
                    }
                }
                writer.WriteEndElement();
                writer.WriteEndElement();
            });
            req.Message.Body = tw.ToString();
            tw.Dispose();
            req.FinalResponseReceived += new EventHandler<SipResponseReceivedEventArgs>(this, (IntPtr) this.finalResponseReceived_AsyncUnsubscribeGroup);
            ErrorHelper.HandleSendRequestErrorAndTimeout(req);
            base.Owner.SendSipMessage(req);
        }

        public void AsyncUpdateGroupInfo(PersonalGroup group, AsyncBizOperation op)
        {
            SipRequest req = base.Owner.CreateSipRequest("S");
            req.Message.AddHeader(new SipcEventHeader("PGUpdateGroupInfo"));
            op.ContextForBiz = group;
            req.Context = op;
            StringWriter tw = new StringWriter();
            XmlHelper.CreateXmlWriterForSipRequest(tw, group, delegate (XmlWriter writer, object context) {
                PersonalGroup group = context as PersonalGroup;
                writer.WriteStartElement("group");
                writer.WriteAttributeString("uri", group.Uri.Raw);
                if (group.GroupInfo.Name.ProposedValue != null)
                {
                    writer.WriteAttributeString("name", group.GroupInfo.Name.ToString());
                }
                if (!string.IsNullOrEmpty(group.GroupInfo.Category.ProposedValue))
                {
                    writer.WriteAttributeString("category", group.GroupInfo.Category.ToString());
                }
                if (group.GroupInfo.Introduce.ProposedValue != null)
                {
                    writer.WriteAttributeString("introduce", group.GroupInfo.Introduce.ToString());
                }
                if (group.GroupInfo.Bulletin.ProposedValue != null)
                {
                    writer.WriteAttributeString("bulletin", group.GroupInfo.Bulletin.ToString());
                }
                bool proposedValue = group.GroupInfo.EnableSearched.ProposedValue;
                writer.WriteAttributeString("enable-searched", (group.GroupInfo.EnableSearched != null) ? "1" : "2");
                PersonalGroupValidateType local2 = group.GroupInfo.ValidateType.ProposedValue;
                writer.WriteAttributeString("valid-type", ((int) group.GroupInfo.ValidateType.Value).ToString());
                writer.WriteEndElement();
            });
            req.Message.Body = tw.ToString();
            tw.Dispose();
            req.FinalResponseReceived += new EventHandler<SipResponseReceivedEventArgs>(this, (IntPtr) this.finalResponseReceived_AsyncUpdateGroupInfo);
            ErrorHelper.HandleSendRequestErrorAndTimeout(req);
            base.Owner.SendSipMessage(req);
            group.GroupInfo.InnerResetProposedProperties();
        }

        public void AsyncUpdatePersonalInfo(PersonalGroup group, AsyncBizOperation op)
        {
            SipRequest req = base.Owner.CreateSipRequest("S");
            req.Message.AddHeader(new SipcEventHeader("PGUpdatePersonalInfo"));
            op.ContextForBiz = group;
            req.Context = op;
            StringWriter tw = new StringWriter();
            XmlHelper.CreateXmlWriterForSipRequest(tw, group, delegate (XmlWriter writer, object context) {
                PersonalGroup group = context as PersonalGroup;
                writer.WriteStartElement("personal-properties");
                writer.WriteStartElement("personal-property");
                writer.WriteAttributeString("group-uri", group.Uri.Raw);
                if (group.UserInfo.GroupNickName.ProposedValue != null)
                {
                    writer.WriteAttributeString("group-nickname", group.UserInfo.GroupNickName.Value);
                }
                bool proposedValue = group.UserInfo.GroupReceiveSMSPolicy.ProposedValue;
                writer.WriteAttributeString("sms-recv-policy", group.UserInfo.GroupReceiveSMSPolicy.Value ? "1" : "2");
                PersonalGroupReceiveMessagePolicy local2 = group.UserInfo.GroupReceiveMessagePolicy.ProposedValue;
                writer.WriteAttributeString("msg-recv-policy", ((int) group.UserInfo.GroupReceiveMessagePolicy.Value).ToString());
                writer.WriteEndElement();
                writer.WriteEndElement();
            });
            req.Message.Body = tw.ToString();
            tw.Dispose();
            req.FinalResponseReceived += new EventHandler<SipResponseReceivedEventArgs>(this, (IntPtr) this.finalResponseReceived_AsyncUpdatePersonalInfo);
            ErrorHelper.HandleSendRequestErrorAndTimeout(req);
            base.Owner.SendSipMessage(req);
            group.UserInfo.InnerResetProposedProperties();
        }

        public void AsyncUploadGroupPortrait(PersonalGroup group, AsyncBizOperation op)
        {
            op.ContextForBiz = group;
            ThreadPool.QueueUserWorkItem(new WaitCallback(this.UploadPortraitInThread), op);
        }

        internal void Clear()
        {
            try
            {
                if (base.Owner.PersonalGroups != null)
                {
                    base.Owner.PersonalGroups.GroupLoadStatus = PersonalGroupLoadStatus.None;
                    base.Owner.PersonalGroups.Version = string.Empty;
                    this._groupMembersNode = null;
                    lock (base.Owner.PersonalGroups.SyncRoot)
                    {
                        using (IEnumerator<PersonalGroup> enumerator = base.Owner.PersonalGroups.GetEnumerator())
                        {
                            while (enumerator.MoveNext())
                            {
                                enumerator.get_Current().Dispose();
                            }
                        }
                    }
                    base.Owner.PersonalGroups.Clear();
                }
            }
            catch (Exception exception)
            {
                ClientLogger.WriteException(exception);
            }
        }

        internal void CloseGroupConversation(PersonalGroup group)
        {
            if (group.GroupConversation != null)
            {
                group.GroupConversation.Close();
            }
            group.GroupConversation = null;
        }

        private void DoAfterDeleteGroup(PersonalGroup group)
        {
            this.AsyncUnsubscribeGroup(group, new AsyncBizOperation());
            this.CloseGroupConversation(group);
            this.SavePersonalGroupsToLocal();
        }

        private void DoAfterGetGroupList()
        {
            if (base.Owner.PersonalGroups.Count != 0)
            {
                this.LoadGroupsPortraitFromLocal();
                this.AsyncStartAllGroupConversation();
                this.AsyncGetAllGroupInfo(new AsyncBizOperation());
                this.AsyncGetAllPersonalInfo();
                this.AsyncSubscribeAllGroup(new AsyncBizOperation(), false);
                this.RegisterKeepAlive();
                Thread.Sleep(0xea60);
                this.AsyncSetPresence(null, new AsyncBizOperation());
            }
        }

        private void DoAfterGetGroupMemberList(PersonalGroup group)
        {
            this.AsyncSubscribeGroup(group, new AsyncBizOperation(), true);
            ClientLogger.WriteGeneral("获得成员列表后,订阅群" + group.Uri.Sid);
        }

        private void DoReceiveApplyJoinGroupNotify(XmlNode node)
        {
            XmlNode node2 = node.SelectSingleNode("//group");
            string text = node2.Attributes["uri"].Value;
            node2 = node2.SelectSingleNode("user");
            string uri = node2.Attributes["uri"].Value;
            string name = node2.Attributes["nickname"].Value;
            string description = "";
            if (node2.Attributes["note"] != null)
            {
                description = node2.Attributes["note"].Value;
            }
            PersonalGroup group = base.Owner.PersonalGroups[text];
            if (group != null)
            {
                this.OnApplyJoinGroup(new ApplyJoinGroupEventArgs(uri, name, description, group));
            }
        }

        private void DoReceiveApproveResultNotify(XmlNode node)
        {
            XmlNode node2 = node.SelectSingleNode("//authorize");
            string text = node2.Attributes["group-uri"].Value;
            int num = int.Parse(node2.Attributes["approve-result"].Value);
            string text1 = node2.Attributes["approver-uri"].Value;
            string approverNickname = node2.Attributes["approver-nickname"].Value;
            string text4 = node2.Attributes["applicant-uri"].Value;
            string text5 = node2.Attributes["applicant-nickname"].Value;
            string note = "";
            if (node2.Attributes["approve-note"] != null)
            {
                note = node2.Attributes["approve-note"].Value;
            }
            PersonalGroup group = base.Owner.PersonalGroups[text];
            if (group != null)
            {
                if (num == 1)
                {
                    group.UserInfo.GroupUserIdentity = new ProposedData<UserIdentity>(UserIdentity.Member);
                    this.AsyncGetGroupInfo(group, new AsyncBizOperation());
                    this.AsyncSetAllGroupPresence(new AsyncBizOperation());
                    this.AsyncStartGroupConversation(group);
                }
                else
                {
                    group.UserInfo.GroupUserIdentity = new ProposedData<UserIdentity>(UserIdentity.Rejct);
                }
                this.OnReplyResult(new PersonalGroupReplyResultEventArgs(group, note, approverNickname));
            }
        }

        private void DoReceiveGroupDeletedNotify(XmlNode node)
        {
            XmlNode node2 = node.SelectSingleNode("//group");
            string uri = node2.Attributes["uri"].Value;
            if ((this._deletedGroups == null) || !this._deletedGroups.Contains(uri))
            {
                PersonalGroup item = base.Owner.PersonalGroups[uri];
                if (item == null)
                {
                    item = new PersonalGroup(base.Owner, uri);
                    if (node2.Attributes["name"] != null)
                    {
                        item.GroupInfo.Name = new ProposedData<string>(node2.Attributes["name"].Value);
                    }
                }
                else
                {
                    base.Owner.PersonalGroups.Remove(item);
                    this.DoAfterDeleteGroup(item);
                }
                this.OnGroupDeleted(new PersonalGroupEventArgs(item));
            }
        }