personalgroupmanager.cs

破解的飞信源代码

        private void DoReceiveGroupMemberDeletedNotify(XmlNode node)
        {
            XmlNode node2 = node.SelectSingleNode("//member");
            string uri = node2.Attributes["group-uri"].Value;
            string text2 = node2.Attributes["uri"].Value;
            string text1 = node2.Attributes["admin-uri"].Value;
            string adminName = node2.Attributes["admin-name"].Value;
            string text4 = node2.Attributes["member-list-major-version"].Value;
            PersonalGroup personalGroup = base.Owner.PersonalGroups[uri];
            if (personalGroup == null)
            {
                if (text2 == base.Owner.Uri.Raw)
                {
                    personalGroup = new PersonalGroup(base.Owner, uri);
                    if (node2.Attributes["group-name"] != null)
                    {
                        personalGroup.GroupInfo.Name = new ProposedData<string>(node2.Attributes["group-name"].Value);
                    }
                    this.OnMeBeDeleted(new PersonalGroupEventArgs(personalGroup));
                }
            }
            else
            {
                personalGroup.Members.MainVersion = text4;
                if (text2 == base.Owner.Uri.Raw)
                {
                    base.Owner.PersonalGroups.Remove(personalGroup);
                    this.OnMeBeDeleted(new PersonalGroupEventArgs(personalGroup));
                    this.DoAfterDeleteGroup(personalGroup);
                }
                else
                {
                    PersonalGroupMember item = personalGroup.Members[text2];
                    if (item != null)
                    {
                        personalGroup.Members.Remove(item);
                        this.OnMemberDeleted(new GroupMemberDeletedEventArgs(adminName, item));
                        this.SavePersonalGroupsToLocal();
                    }
                }
            }
        }

        private void DoReceiveInviteJoinGroup(XmlNode node)
        {
            if (node != null)
            {
                string uri = node.FirstChild.Attributes["inviter-uri"].Value;
                string friendlyName = node.FirstChild.Attributes["inviter-nickname"].Value;
                Imps.Client.Core.Contact contact = base.Owner.ContactList.FindOrCreateContact(uri, null);
                if (!contact.IsBlocked)
                {
                    if (contact.Type == ContactType.Stranger)
                    {
                        contact.DisplayName = friendlyName;
                    }
                    string text3 = node.FirstChild.Attributes["group-uri"].Value;
                    if (!string.IsNullOrEmpty(text3))
                    {
                        PersonalGroup group = base.Owner.PersonalGroups[text3];
                        if (group == null)
                        {
                            group = new PersonalGroup(base.Owner, text3);
                            this.LoadInviteGroupInfoFromXmlNode(group, node.FirstChild, false);
                        }
                        this.OnInviteJoinGroup(new InviteJoinGroupEventArgs(contact, group));
                        IMessage msg = new InstantMessage();
                        msg.ID = Guid.NewGuid().ToString();
                        msg.Sender = new Player(uri, friendlyName, PlayerType.Contact);
                        msg.Receivers.Add(new Player(base.Owner.Uri.Raw, base.Owner.Nickname, PlayerType.User));
                        msg.Time = Imps.Client.Core.User.ServerTime;
                        msg.Type = Imps.Client.Core.MessageType.InviteJoinGroup;
                        msg.Body = "邀请加入群！";
                        msg.Extend = group.Uri.Id;
                        if (base.Owner.HistoryManager != null)
                        {
                            base.Owner.HistoryManager.SaveMessage(msg);
                        }
                    }
                }
            }
        }

        private void DoReceiveMeJoinedNotify(string groupUri, string groupName, UserIdentity indentity)
        {
            PersonalGroup group = base.Owner.PersonalGroups[groupUri];
            AsyncBizOperation op = new AsyncBizOperation();
            bool flag = true;
            if (group == null)
            {
                group = new PersonalGroup(base.Owner, groupUri);
                group.GroupInfo.Name = new ProposedData<string>(groupName);
                this.AsyncGetPersonalInfo(group, op);
                group.AttributeVersion = string.Empty;
                group.GroupInfo.PortraitCrc = string.Empty;
                base.Owner.PersonalGroups.Add(group);
                this.OnGroupAdded(new PersonalGroupEventArgs(group));
            }
            else
            {
                flag = false;
            }
            group.UserInfo.GroupUserIdentity = new ProposedData<UserIdentity>(indentity);
            this.AsyncGetGroupInfo(group, op);
            if (((indentity == UserIdentity.Member) || (indentity == UserIdentity.SuperManager)) || (indentity == UserIdentity.Manager))
            {
                this.AsyncStartGroupConversation(group);
                this.AsyncSetPresence(group, new AsyncBizOperation());
                this.OnReplyResult(new PersonalGroupReplyResultEventArgs(group, "", "System", false));
            }
            else if (indentity == UserIdentity.WaitingApprove)
            {
                this.OnWebJoinGroup(new PersonalGroupEventArgs(group));
            }
            this.SavePersonalGroupsToLocal();
            Thread.Sleep(0x3e8);
            if (flag)
            {
                this.AsyncSubscribeGroup(group, op, false);
            }
        }

        private void DoReceiveMemberDestroyedNotify(XmlNode node)
        {
            XmlNode node2 = node.SelectSingleNode("//group");
            string groupUri = XmlHelper.ReadXmlAttributeString(node2, "uri");
            string uri = XmlHelper.ReadXmlAttributeString(node2, "member-uri");
            string reason = XmlHelper.ReadXmlAttributeString(node2, "reason");
            string memberNickname = XmlHelper.ReadXmlAttributeString(node2, "nickname");
            DateTime beginDate = DateTime.Now;
            DateTime endDate = DateTime.Now;
            try
            {
                DateTime.TryParse(node2.Attributes["begin-time"].Value, ref beginDate);
                DateTime.TryParse(node2.Attributes["destroy-time"].Value, ref endDate);
            }
            catch
            {
            }
            PersonalGroup ownerGroup = base.Owner.PersonalGroups[groupUri];
            if (ownerGroup != null)
            {
                PersonalGroupMember item = ownerGroup.Members[uri];
                if (item == null)
                {
                    item = new PersonalGroupMember(base.Owner, uri, ownerGroup);
                    if (node2.Attributes["nickname"] != null)
                    {
                        item.DisplayName = node2.Attributes["nickname"].Value;
                    }
                    if (node2.Attributes["identity"] != null)
                    {
                        item.GroupMemeberInfo.GroupUserIdentity = new ProposedData<UserIdentity>((UserIdentity) Convert.ToInt32(node2.Attributes["identity"].Value));
                    }
                }
                if (item.GroupMemeberInfo.GroupUserIdentity == 1)
                {
                    ownerGroup.Members.Remove(item);
                }
                ownerGroup.GroupInfo.DestroyTime = new DateTime?(endDate);
                this.OnMemberDestroyed(new MemberDestroyedEventArgs(item, groupUri, uri, beginDate, endDate, reason, memberNickname));
                this.SavePersonalGroupsToLocal();
            }
        }

        private void DoReceiveMemberExitedNotify(XmlNode node)
        {
            string text = node.FirstChild.Attributes["uri"].Value;
            string text2 = node.FirstChild.Attributes["exit-member-uri"].Value;
            string text3 = node.FirstChild.Attributes["member-list-major-version"].Value;
            PersonalGroup group = base.Owner.PersonalGroups[text];
            if (group != null)
            {
                PersonalGroupMember item = group.Members[text2];
                if (item != null)
                {
                    group.Members.Remove(item);
                    this.OnMemberExited(new PersonalGroupMemberEventArgs(item));
                    group.Members.MainVersion = text3;
                    this.SavePersonalGroupsToLocal();
                }
            }
        }

        private void DoReceiveMemberIdentifyChanged(XmlNode node)
        {
            if (node != null)
            {
                this.LoadMemberIdentifyChangedXmlNode(node);
            }
            this.SavePersonalGroupsToLocal();
        }

        private void DoReceiveMemberJoinedNotify(XmlNode node)
        {
            XmlNode node2 = node.SelectSingleNode("//group");
            string groupUri = node2.Attributes["uri"].Value;
            string uri = node2.Attributes["member-uri"].Value;
            string text3 = node2.Attributes["member-nickname"].Value;
            string text4 = node2.Attributes["member-list-major-version"].Value;
            string groupName = "";
            if (node2.Attributes["name"] != null)
            {
                groupName = node2.Attributes["name"].Value;
            }
            UserIdentity indentity = UserIdentity.Member;
            if (node2.Attributes["identity"] != null)
            {
                indentity = (UserIdentity) Convert.ToInt32(node2.Attributes["identity"].Value);
            }
            if (base.Owner.Uri.Raw == uri)
            {
                this.DoReceiveMeJoinedNotify(groupUri, groupName, indentity);
            }
            else if ((indentity != UserIdentity.WaitingApprove) && (indentity != UserIdentity.Rejct))
            {
                PersonalGroup ownerGroup = base.Owner.PersonalGroups[groupUri];
                if ((ownerGroup != null) && (ownerGroup.Members[uri] == null))
                {
                    PersonalGroupMember item = new PersonalGroupMember(base.Owner, uri, ownerGroup);
                    item.GroupMemeberInfo.IicNickName = text3;
                    item.GroupMemeberInfo.GroupInnerNickName = (string) new ProposedData<string>(string.Empty);
                    item.GroupMemeberInfo.GroupUserIdentity = new ProposedData<UserIdentity>(indentity);
                    item.GroupMemeberInfo.ComputeGroupNickName();
                    ownerGroup.Members.MainVersion = text4;
                    ownerGroup.Members.Add(item);
                    this.OnMemberJoined(new PersonalGroupMemberEventArgs(item));
                    this.SavePersonalGroupsToLocal();
                }
            }
        }

        private void DoReceivePGGetGroupInfoNotify(XmlNode node)
        {
            XmlNode groupsNode = node.SelectSingleNode("//groups");
            if (groupsNode != null)
            {
                this.LoadGroupsInfoFromXmlNode(groupsNode);
            }
        }

        private void DoReceivePGSubscriptionNotify(XmlNode node)
        {
            XmlNode groupsNode = node.SelectSingleNode("//groups");
            if (groupsNode != null)
            {
                this.LoadSubscribeFromXmlNode(groupsNode);
            }
            this.SavePersonalGroupsToLocal();
        }

        private void DoReceivePresenceChanged(XmlNode node)
        {
            if (node != null)
            {
                this.LoadGroupsPresenceChangedXmlNode(node);
            }
            this.SavePersonalGroupsToLocal();
        }

        private void DownLoadGroupPortraitInThread(object context)
        {
            try
            {
                PersonalGroup group = context as PersonalGroup;
                if (!string.IsNullOrEmpty((string) group.GroupInfo.GetGroupPortraitHds))
                {
                    HttpWebRequest request = ConnectionFactory.CreateHttpWebRequest(((string) group.GroupInfo.GetGroupPortraitHds) + ("?uri=" + group.Uri.Raw) + "&size=96", group, false, true);
                    request.Accept = "image/pjpeg