void AccountGroupsMembershipsManage_Show(object sender, EventArgs e)
        {
            SetTemplate("account_group_membership");

            long groupTypeId = ItemKey.GetTypeId(core, typeof(UserGroup));

            SelectQuery query = GroupMember.GetSelectQueryStub(core, UserLoadOptions.Common);
            query.AddCondition("user_keys.user_id", LoggedInMember.Id);

            DataTable membershipGroupsTable = db.Query(query);

            List<long> groupIds = new List<long>();
            for (int i = 0; i < membershipGroupsTable.Rows.Count; i++)
            {
                long groupId = (long)membershipGroupsTable.Rows[i]["group_id"];
                core.PrimitiveCache.LoadPrimitiveProfile(groupId, groupTypeId);
                groupIds.Add(groupId);
            }

            int pending = 0;
            int approved = 0;
            for (int i = 0; i < membershipGroupsTable.Rows.Count; i++)
            {
                VariableCollection groupVariableCollection = null;
                UserGroup thisGroup = null;

                try
                {
                    thisGroup = (UserGroup)core.PrimitiveCache[(long)membershipGroupsTable.Rows[i]["group_id"], groupTypeId];
                }
                catch
                {
                    continue;
                }

                if ((byte)membershipGroupsTable.Rows[i]["group_member_approved"] == 0)
                {
                    groupVariableCollection = template.CreateChild("pending_list");
                    pending++;

                    groupVariableCollection.Parse("U_LEAVE", thisGroup.LeaveUri);
                }
                else if ((byte)membershipGroupsTable.Rows[i]["group_member_approved"] == 1)
                {
                    groupVariableCollection = template.CreateChild("group_list");
                    approved++;

                    GroupMember gm = new GroupMember(core, membershipGroupsTable.Rows[i], UserLoadOptions.Common);

                    if (!gm.IsOperator)
                    {
                        groupVariableCollection.Parse("U_LEAVE", thisGroup.LeaveUri);
                    }

                    groupVariableCollection.Parse("U_INVITE", thisGroup.InviteUri);
                }

                groupVariableCollection.Parse("GROUP_DISPLAY_NAME", thisGroup.DisplayName);
                groupVariableCollection.Parse("MEMBERS", thisGroup.Members.ToString());

                groupVariableCollection.Parse("U_VIEW", thisGroup.Uri);
                groupVariableCollection.Parse("U_MEMBERLIST", thisGroup.MemberlistUri);

                switch (thisGroup.GroupType)
                {
                    case "OPEN":
                        groupVariableCollection.Parse("GROUP_TYPE", "Open");
                        break;
                    case "REQUEST":
                        groupVariableCollection.Parse("GROUP_TYPE", "Request");
                        break;
                    case "CLOSED":
                        groupVariableCollection.Parse("GROUP_TYPE", "Closed");
                        break;
                    case "PRIVATE":
                        groupVariableCollection.Parse("GROUP_TYPE", "Private");
                        break;
                }
            }

            if (pending > 0)
            {
                template.Parse("PENDING_MEMBERSHIPS", "TRUE");
            }

            if (approved > 0)
            {
                template.Parse("GROUP_MEMBERSHIPS", "TRUE");
            }
        }
Esempio n. 2
0
        public static void ShowMemberlist(Core core, GPage page)
        {
            core.Template.SetTemplate("Groups", "viewgroupmemberlist");

            core.Template.Parse("PAGE_TITLE", "Member list for " + page.Group.DisplayName);
            core.Template.Parse("MEMBERS_TITLE", "Member list for " + page.Group.DisplayName);
            core.Template.Parse("MEMBERS", ((ulong)page.Group.Members).ToString());

            core.Template.Parse("U_FILTER_ALL", page.Group.MemberlistUri);
            core.Template.Parse("U_FILTER_BEGINS_A", page.Group.GetMemberlistUri("a"));
            core.Template.Parse("U_FILTER_BEGINS_B", page.Group.GetMemberlistUri("b"));
            core.Template.Parse("U_FILTER_BEGINS_C", page.Group.GetMemberlistUri("c"));
            core.Template.Parse("U_FILTER_BEGINS_D", page.Group.GetMemberlistUri("d"));
            core.Template.Parse("U_FILTER_BEGINS_E", page.Group.GetMemberlistUri("e"));
            core.Template.Parse("U_FILTER_BEGINS_F", page.Group.GetMemberlistUri("f"));
            core.Template.Parse("U_FILTER_BEGINS_G", page.Group.GetMemberlistUri("g"));
            core.Template.Parse("U_FILTER_BEGINS_H", page.Group.GetMemberlistUri("h"));
            core.Template.Parse("U_FILTER_BEGINS_I", page.Group.GetMemberlistUri("i"));
            core.Template.Parse("U_FILTER_BEGINS_J", page.Group.GetMemberlistUri("j"));
            core.Template.Parse("U_FILTER_BEGINS_K", page.Group.GetMemberlistUri("k"));
            core.Template.Parse("U_FILTER_BEGINS_L", page.Group.GetMemberlistUri("l"));
            core.Template.Parse("U_FILTER_BEGINS_M", page.Group.GetMemberlistUri("m"));
            core.Template.Parse("U_FILTER_BEGINS_N", page.Group.GetMemberlistUri("n"));
            core.Template.Parse("U_FILTER_BEGINS_O", page.Group.GetMemberlistUri("o"));
            core.Template.Parse("U_FILTER_BEGINS_P", page.Group.GetMemberlistUri("p"));
            core.Template.Parse("U_FILTER_BEGINS_Q", page.Group.GetMemberlistUri("q"));
            core.Template.Parse("U_FILTER_BEGINS_R", page.Group.GetMemberlistUri("r"));
            core.Template.Parse("U_FILTER_BEGINS_S", page.Group.GetMemberlistUri("s"));
            core.Template.Parse("U_FILTER_BEGINS_T", page.Group.GetMemberlistUri("t"));
            core.Template.Parse("U_FILTER_BEGINS_U", page.Group.GetMemberlistUri("u"));
            core.Template.Parse("U_FILTER_BEGINS_V", page.Group.GetMemberlistUri("v"));
            core.Template.Parse("U_FILTER_BEGINS_W", page.Group.GetMemberlistUri("w"));
            core.Template.Parse("U_FILTER_BEGINS_X", page.Group.GetMemberlistUri("x"));
            core.Template.Parse("U_FILTER_BEGINS_Y", page.Group.GetMemberlistUri("y"));
            core.Template.Parse("U_FILTER_BEGINS_Z", page.Group.GetMemberlistUri("z"));

            if (page.Group.IsGroupOperator(core.LoggedInMemberItemKey))
            {
                core.Template.Parse("GROUP_OPERATOR", "TRUE");

                SelectQuery query = GroupMember.GetSelectQueryStub(core, UserLoadOptions.All);
                query.AddCondition("group_members.group_id", page.Group.Id);
                query.AddCondition("group_member_approved", false);
                query.AddSort(SortOrder.Ascending, "group_member_date_ut");

                System.Data.Common.DbDataReader approvalReader = core.Db.ReaderQuery(query);

                if (approvalReader.HasRows)
                {
                    core.Template.Parse("IS_WAITING_APPROVAL", "TRUE");
                }

                while(approvalReader.Read())
                {
                    GroupMember approvalMember = new GroupMember(core, approvalReader, UserLoadOptions.Profile);

                    VariableCollection approvalVariableCollection = core.Template.CreateChild("approval_list");

                    approvalVariableCollection.Parse("USER_DISPLAY_NAME", approvalMember.DisplayName);
                    approvalVariableCollection.Parse("U_PROFILE", approvalMember.Uri);
                    approvalVariableCollection.Parse("U_APPROVE", approvalMember.ApproveMemberUri);
                }

                approvalReader.Close();
                approvalReader.Dispose();

            }

            List<GroupMember> members = page.Group.GetMembers(page.TopLevelPageNumber, 18, core.Functions.GetFilter());
            foreach (GroupMember member in members)
            {
                VariableCollection memberVariableCollection = core.Template.CreateChild("member_list");

                memberVariableCollection.Parse("USER_DISPLAY_NAME", member.DisplayName);
                memberVariableCollection.Parse("JOIN_DATE", page.tz.DateTimeToString(member.GetGroupMemberJoinDate(page.tz)));
                memberVariableCollection.Parse("USER_AGE", member.Profile.AgeString);
                memberVariableCollection.Parse("USER_COUNTRY", member.Profile.Country);
                memberVariableCollection.Parse("USER_CAPTION", string.Empty);

                memberVariableCollection.Parse("U_PROFILE", member.Uri);
                if (core.LoggedInMemberId > 0)
                {
                    if (page.Group.IsGroupOperator(core.LoggedInMemberItemKey))
                    {
                        if (!member.IsOperator)
                        {
                            // let's say you can't ban an operator, show ban link if not an operator
                            memberVariableCollection.Parse("U_BAN", member.BanUri);
                            memberVariableCollection.Parse("U_MAKE_OPERATOR", member.MakeOperatorUri);
                        }

                        memberVariableCollection.Parse("U_MAKE_OFFICER", member.MakeOfficerUri);
                    }
                }
                memberVariableCollection.Parse("ICON", member.Icon);
                memberVariableCollection.Parse("TILE", member.Tile);
                memberVariableCollection.Parse("MOBILE_COVER", member.MobileCoverPhoto);

                memberVariableCollection.Parse("ID", member.Id);
                memberVariableCollection.Parse("TYPE", member.TypeId);
                memberVariableCollection.Parse("LOCATION", member.Profile.Country);
                memberVariableCollection.Parse("ABSTRACT", page.Core.Bbcode.Parse(member.Profile.Autobiography));
                memberVariableCollection.Parse("SUBSCRIBERS", member.Info.Subscribers);

                if (Subscription.IsSubscribed(page.Core, member.ItemKey))
                {
                    memberVariableCollection.Parse("SUBSCRIBERD", "TRUE");
                    memberVariableCollection.Parse("U_SUBSCRIBE", page.Core.Hyperlink.BuildUnsubscribeUri(member.ItemKey));
                }
                else
                {
                    memberVariableCollection.Parse("U_SUBSCRIBE", page.Core.Hyperlink.BuildSubscribeUri(member.ItemKey));
                }

                if (page.Core.Session.SignedIn && member.Id == page.Core.LoggedInMemberId)
                {
                    memberVariableCollection.Parse("ME", "TRUE");
                }
            }

            string pageUri = page.Group.MemberlistUri;
            core.Display.ParsePagination(pageUri, 18, page.Group.Members);

            List<string[]> breadCrumbParts = new List<string[]>();

            breadCrumbParts.Add(new string[] { "members", core.Prose.GetString("MEMBERS") });

            page.Group.ParseBreadCrumbs(breadCrumbParts);
        }
        void AccountGroupsMembershipsManage_BanMember_Save(object sender, EventArgs e)
        {
            AuthoriseRequestSid();

            long groupId;
            long userId;

            try
            {
                string[] idString = core.Http.Form["id"].Split(new char[] { ',' });
                groupId = long.Parse(idString[0]);
                userId = long.Parse(idString[1]);
            }
            catch
            {
                core.Functions.ThrowError();
                return;
            }

            if (core.Display.GetConfirmBoxResult() == ConfirmBoxResult.Yes)
            {
                try
                {
                    UserGroup group = new UserGroup(core, groupId);

                    if (group.IsGroupOperator(LoggedInMember.ItemKey))
                    {
                        try
                        {
                            GroupMember member = new GroupMember(core, group, userId);

                            member.Ban();

                            core.Display.ShowMessage("Member Banned", "The member has been banned from the group.");
                            return;
                        }
                        catch (InvalidUserException)
                        {
                            DisplayGenericError();
                            return;
                        }
                    }
                    else
                    {
                        core.Display.ShowMessage("Cannot ban member", "Only group operators can ban members from groups.");
                        return;
                    }
                }
                catch (InvalidGroupException)
                {
                    DisplayGenericError();
                    return;
                }
            }
            else
            {
                core.Display.ShowMessage("Cancelled", "You cancelled the banning of this member.");
                return;
            }
        }