/Aurora/Services/DataService/Connectors/Local/LocalGroupsServiceConnector.cs

/*

 * Copyright (c) Contributors, http://aurora-sim.org/

 * See CONTRIBUTORS.TXT for a full list of copyright holders.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 *     * Redistributions of source code must retain the above copyright

 *       notice, this list of conditions and the following disclaimer.

 *     * Redistributions in binary form must reproduce the above copyright

 *       notice, this list of conditions and the following disclaimer in the

 *       documentation and/or other materials provided with the distribution.

 *     * Neither the name of the Aurora-Sim Project nor the

 *       names of its contributors may be used to endorse or promote products

 *       derived from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

 * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY

 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */



using Aurora.Framework;

using Aurora.Framework.ClientInterfaces;

using Aurora.Framework.ConsoleFramework;

using Aurora.Framework.DatabaseInterfaces;

using Aurora.Framework.Modules;

using Aurora.Framework.PresenceInfo;

using Aurora.Framework.Services;

using Aurora.Framework.Utilities;

using Nini.Config;

using OpenMetaverse;

using System;

using System.Collections.Generic;

using System.Linq;



namespace Aurora.Services.DataService

{

    public class LocalGroupsServiceConnector : ConnectorBase, IGroupsServiceConnector

    {

        #region Declares



        private IGenericData data;

        private List<UUID> agentsCanBypassGroupNoticePermsCheck = new List<UUID>();



        #endregion



        #region IAuroraDataPlugin members



        public void Initialize(IGenericData GenericData, IConfigSource source, IRegistryCore simBase,

                               string defaultConnectionString)

        {

            data = GenericData;



            if (source.Configs[Name] != null)

            {

                defaultConnectionString = source.Configs[Name].GetString("ConnectionString", defaultConnectionString);

            }

            if (source.Configs["Groups"] != null)

            {

                agentsCanBypassGroupNoticePermsCheck =

                    Util.ConvertToList(source.Configs["Groups"].GetString("AgentsCanBypassGroupNoticePermsCheck", ""))

                        .ConvertAll(x => new UUID(x));

            }



            if (data != null)

                data.ConnectToDatabase(defaultConnectionString, "Groups",

                                       source.Configs["AuroraConnectors"].GetBoolean("ValidateTables", true));



            Framework.Utilities.DataManager.RegisterPlugin(Name + "Local", this);



            if (source.Configs["AuroraConnectors"].GetString("GroupsConnector", "LocalConnector") == "LocalConnector")

            {

                Framework.Utilities.DataManager.RegisterPlugin(this);

            }

            Init(simBase, Name);

        }



        public string Name

        {

            get { return "IGroupsServiceConnector"; }

        }



        #endregion



        #region IGroupsServiceConnector Members



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public void CreateGroup(UUID groupID, string name, string charter, bool showInList, UUID insigniaID,

                                int membershipFee, bool openEnrollment, bool allowPublish, bool maturePublish,

                                UUID founderID, UUID OwnerRoleID)

        {

            object remoteValue = DoRemote(groupID, name, charter, showInList, insigniaID, membershipFee, openEnrollment,

                                          allowPublish, maturePublish, founderID, OwnerRoleID);

            if (remoteValue != null || m_doRemoteOnly)

                return;



            // Would this be cleaner as (GroupPowers)ulong.MaxValue;

            ulong OwnerPowers = (ulong) (GroupPowers.Accountable

                                         | GroupPowers.AllowEditLand

                                         | GroupPowers.AllowFly

                                         | GroupPowers.AllowLandmark

                                         | GroupPowers.AllowRez

                                         | GroupPowers.AllowSetHome

                                         | GroupPowers.AllowVoiceChat

                                         | GroupPowers.AssignMember

                                         | GroupPowers.AssignMemberLimited

                                         | GroupPowers.ChangeActions

                                         | GroupPowers.ChangeIdentity

                                         | GroupPowers.ChangeMedia

                                         | GroupPowers.ChangeOptions

                                         | GroupPowers.CreateRole

                                         | GroupPowers.DeedObject

                                         | GroupPowers.DeleteRole

                                         | GroupPowers.Eject

                                         | GroupPowers.FindPlaces

                                         | GroupPowers.Invite

                                         | GroupPowers.JoinChat

                                         | GroupPowers.LandChangeIdentity

                                         | GroupPowers.LandDeed

                                         | GroupPowers.LandDivideJoin

                                         | GroupPowers.LandEdit

                                         | GroupPowers.LandEjectAndFreeze

                                         | GroupPowers.LandGardening

                                         | GroupPowers.LandManageAllowed

                                         | GroupPowers.LandManageBanned

                                         | GroupPowers.LandManagePasses

                                         | GroupPowers.LandOptions

                                         | GroupPowers.LandRelease

                                         | GroupPowers.LandSetSale

                                         | GroupPowers.ModerateChat

                                         | GroupPowers.ObjectManipulate

                                         | GroupPowers.ObjectSetForSale

                                         | GroupPowers.ReceiveNotices

                                         | GroupPowers.RemoveMember

                                         | GroupPowers.ReturnGroupOwned

                                         | GroupPowers.ReturnGroupSet

                                         | GroupPowers.ReturnNonGroup

                                         | GroupPowers.RoleProperties

                                         | GroupPowers.SendNotices

                                         | GroupPowers.SetLandingPoint

                                         | GroupPowers.StartProposal

                                         | GroupPowers.VoteOnProposal);



            ulong EveryonePowers = (ulong) (GroupPowers.AllowSetHome |

                                            GroupPowers.Accountable |

                                            GroupPowers.JoinChat |

                                            GroupPowers.AllowVoiceChat |

                                            GroupPowers.ReceiveNotices |

                                            GroupPowers.StartProposal |

                                            GroupPowers.VoteOnProposal);



            Dictionary<string, object> row = new Dictionary<string, object>(11);

            row["GroupID"] = groupID;

            row["Name"] = name;

            row["Charter"] = charter ?? "";

            row["InsigniaID"] = insigniaID;

            row["FounderID"] = founderID;

            row["MembershipFee"] = membershipFee;

            row["OpenEnrollment"] = openEnrollment ? 1 : 0;

            row["ShowInList"] = showInList ? 1 : 0;

            row["AllowPublish"] = allowPublish ? 1 : 0;

            row["MaturePublish"] = maturePublish ? 1 : 0;

            row["OwnerRoleID"] = OwnerRoleID;



            data.Insert("osgroup", row);



            //Add everyone role to group

            AddRoleToGroup(founderID, groupID, UUID.Zero, "Everyone", "Everyone in the group is in the everyone role.",

                           "Member of " + name, EveryonePowers);



            const ulong groupPowers = 296868139497678;



            UUID officersRole = UUID.Random();

            //Add officers role to group

            AddRoleToGroup(founderID, groupID, officersRole, "Officers",

                           "The officers of the group, with more powers than regular members.", "Officer of " + name,

                           groupPowers);



            //Add owner role to group

            AddRoleToGroup(founderID, groupID, OwnerRoleID, "Owners", "Owners of " + name, "Owner of " + name,

                           OwnerPowers);



            //Add owner to the group as owner

            AddAgentToGroup(founderID, founderID, groupID, OwnerRoleID);

            AddAgentToRole(founderID, founderID, groupID, officersRole);



            SetAgentGroupSelectedRole(founderID, groupID, OwnerRoleID);



            SetAgentActiveGroup(founderID, groupID);

        }



        //[CanBeReflected(ThreatLevel = ThreatLevel.Full)]

        public void UpdateGroupFounder(UUID groupID, UUID newOwner, bool keepOldOwnerInGroup)

        {

            /*object remoteValue = DoRemote(groupID, newOwner, keepOldOwnerInGroup);

            if (remoteValue != null || m_doRemoteOnly)

                return;*/



            GroupRecord record = GetGroupRecord(UUID.Zero, groupID, "");

            bool newUserExists = GetAgentGroupMemberData(newOwner, groupID, newOwner) != null;



            Dictionary<string, object> values = new Dictionary<string, object>(1);

            values["FounderID"] = newOwner;

            QueryFilter filter = new QueryFilter();

            filter.andFilters["GroupID"] = groupID;



            data.Update("osgroup", values, null, filter, null, null);



            if (!newUserExists)

                AddAgentToGroup(newOwner, newOwner, groupID, record.OwnerRoleID);

            else

                AddAgentToRole(newOwner, newOwner, groupID, record.OwnerRoleID);



            if (!keepOldOwnerInGroup)

                RemoveAgentFromGroup(newOwner, record.FounderID, groupID);

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public void UpdateGroup(UUID requestingAgentID, UUID groupID, string charter, int showInList, UUID insigniaID,

                                int membershipFee, int openEnrollment, int allowPublish, int maturePublish)

        {

            object remoteValue = DoRemote(requestingAgentID, groupID, charter, showInList, insigniaID, membershipFee,

                                          openEnrollment, allowPublish, maturePublish);

            if (remoteValue != null || m_doRemoteOnly)

                return;



            if (CheckGroupPermissions(requestingAgentID, groupID,

                                      (ulong) (GroupPowers.ChangeOptions | GroupPowers.ChangeIdentity)))

            {

                Dictionary<string, object> values = new Dictionary<string, object>(6);

                values["Charter"] = charter;

                values["InsigniaID"] = insigniaID;

                values["MembershipFee"] = membershipFee;

                values["OpenEnrollment"] = openEnrollment;

                values["ShowInList"] = showInList;

                values["AllowPublish"] = allowPublish;

                values["MaturePublish"] = maturePublish;



                QueryFilter filter = new QueryFilter();

                filter.andFilters["GroupID"] = groupID;



                data.Update("osgroup", values, null, filter, null, null);

            }

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public void AddGroupNotice(UUID requestingAgentID, UUID groupID, UUID noticeID, string fromName, string subject,

                                   string message, UUID ItemID, int AssetType, string ItemName)

        {

            object remoteValue = DoRemote(requestingAgentID, groupID, noticeID, fromName, subject, message, ItemID,

                                          AssetType, ItemName);

            if (remoteValue != null || m_doRemoteOnly)

                return;



            if (CheckGroupPermissions(requestingAgentID, groupID, (ulong) GroupPowers.SendNotices))

            {

                Dictionary<string, object> row = new Dictionary<string, object>(10);

                row["GroupID"] = groupID;

                row["NoticeID"] = noticeID == UUID.Zero ? UUID.Random() : noticeID;

                row["Timestamp"] = ((uint) Util.UnixTimeSinceEpoch());

                row["FromName"] = fromName;

                row["Subject"] = subject;

                row["Message"] = message;

                row["HasAttachment"] = (ItemID != UUID.Zero) ? 1 : 0;

                row["ItemID"] = ItemID;

                row["AssetType"] = AssetType;

                row["ItemName"] = ItemName == null ? "" : ItemName;



                data.Insert("osgroupnotice", row);

            }

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.High)]

        public bool EditGroupNotice(UUID requestingAgentID, UUID groupID, UUID noticeID, string subject, string message)

        {

            object remoteValue = DoRemote(requestingAgentID, groupID, noticeID, subject, message);

            if (remoteValue != null || m_doRemoteOnly)

            {

                return (bool) remoteValue;

            }



            if (!agentsCanBypassGroupNoticePermsCheck.Contains(requestingAgentID) &&

                !CheckGroupPermissions(requestingAgentID, groupID, (ulong) GroupPowers.SendNotices))

            {

                MainConsole.Instance.TraceFormat("Permission check failed when trying to edit group notice {0}.",

                                                 noticeID);

                return false;

            }



            GroupNoticeInfo GNI = GetGroupNotice(requestingAgentID, noticeID);

            if (GNI == null)

            {

                MainConsole.Instance.TraceFormat("Could not find group notice {0}", noticeID);

                return false;

            }

            else if (GNI.GroupID != groupID)

            {

                MainConsole.Instance.TraceFormat("Group notice {0} group ID {1} does not match supplied group ID {2}",

                                                 noticeID, GNI.GroupID, groupID);

                return false;

            }

            else if (subject.Trim() == string.Empty || message.Trim() == string.Empty)

            {

                MainConsole.Instance.TraceFormat("Could not edit group notice {0}, message or subject was empty",

                                                 noticeID);

                return false;

            }



            QueryFilter filter = new QueryFilter();

            filter.andFilters["GroupID"] = groupID;

            filter.andFilters["NoticeID"] = noticeID;



            Dictionary<string, object> update = new Dictionary<string, object>(2);

            update["Subject"] = subject.Trim();

            update["Message"] = message.Trim();



            return data.Update("osgroupnotice", update, null, filter, null, null);

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.High)]

        public bool RemoveGroupNotice(UUID requestingAgentID, UUID groupID, UUID noticeID)

        {

            object remoteValue = DoRemote(requestingAgentID, groupID, noticeID);

            if (remoteValue != null || m_doRemoteOnly)

            {

                return (bool) remoteValue;

            }



            if (!agentsCanBypassGroupNoticePermsCheck.Contains(requestingAgentID) &&

                !CheckGroupPermissions(requestingAgentID, groupID, (ulong) GroupPowers.SendNotices))

            {

                MainConsole.Instance.TraceFormat("Permission check failed when trying to edit group notice {0}.",

                                                 noticeID);

                return false;

            }



            GroupNoticeInfo GNI = GetGroupNotice(requestingAgentID, noticeID);

            if (GNI == null)

            {

                MainConsole.Instance.TraceFormat("Could not find group notice {0}", noticeID);

                return false;

            }

            else if (GNI.GroupID != groupID)

            {

                MainConsole.Instance.TraceFormat("Group notice {0} group ID {1} does not match supplied group ID {2}",

                                                 noticeID, GNI.GroupID, groupID);

                return false;

            }



            QueryFilter filter = new QueryFilter();

            filter.andFilters["GroupID"] = groupID;

            filter.andFilters["NoticeID"] = noticeID;



            return data.Delete("osgroupnotice", filter);

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public string SetAgentActiveGroup(UUID AgentID, UUID GroupID)

        {

            object remoteValue = DoRemote(AgentID, GroupID);

            if (remoteValue != null || m_doRemoteOnly)

                return (string) remoteValue;



            QueryFilter filter = new QueryFilter();

            filter.andFilters["AgentID"] = AgentID;

            if (data.Query(new[] {"*"}, "osagent", filter, null, null, null).Count != 0)

            {

                Dictionary<string, object> values = new Dictionary<string, object>(1);

                values["ActiveGroupID"] = GroupID;



                data.Update("osagent", values, null, filter, null, null);

            }

            else

            {

                Dictionary<string, object> row = new Dictionary<string, object>(2);

                row["AgentID"] = AgentID;

                row["ActiveGroupID"] = GroupID;

                data.Insert("osagent", row);

            }

            GroupMembersData gdata = GetAgentGroupMemberData(AgentID, GroupID, AgentID);

            return gdata == null ? "" : gdata.Title;

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public UUID GetAgentActiveGroup(UUID RequestingAgentID, UUID AgentID)

        {

            object remoteValue = DoRemote(RequestingAgentID, AgentID);

            if (remoteValue != null || m_doRemoteOnly)

                return (UUID) remoteValue; // note: this is bad, you can't cast a null object to a UUID



            QueryFilter filter = new QueryFilter();

            filter.andFilters["AgentID"] = AgentID;

            List<string> groups = data.Query(new string[1] {"ActiveGroupID"}, "osagent", filter, null, null, null);



            return (groups.Count != 0) ? UUID.Parse(groups[0]) : UUID.Zero;

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public string SetAgentGroupSelectedRole(UUID AgentID, UUID GroupID, UUID RoleID)

        {

            object remoteValue = DoRemote(AgentID, GroupID, RoleID);

            if (remoteValue != null || m_doRemoteOnly)

                return (string) remoteValue;



            Dictionary<string, object> values = new Dictionary<string, object>(1);

            values["SelectedRoleID"] = RoleID;



            QueryFilter filter = new QueryFilter();

            filter.andFilters["AgentID"] = AgentID;

            filter.andFilters["GroupID"] = GroupID;



            data.Update("osgroupmembership", values, null, filter, null, null);



            GroupMembersData gdata = GetAgentGroupMemberData(AgentID, GroupID, AgentID);

            return gdata == null ? "" : gdata.Title;

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public void AddAgentToGroup(UUID requestingAgentID, UUID AgentID, UUID GroupID, UUID RoleID)

        {

            object remoteValue = DoRemote(requestingAgentID, AgentID, GroupID, RoleID);

            if (remoteValue != null || m_doRemoteOnly)

                return;



            Dictionary<string, object> where = new Dictionary<string, object>(2);

            where["AgentID"] = AgentID;

            where["GroupID"] = GroupID;



            if (data.Query(new[] {"*"}, "osgroupmembership", new QueryFilter

                                                                 {

                                                                     andFilters = where

                                                                 }, null, null, null).Count != 0)

            {

                MainConsole.Instance.Error("[AGM]: Agent " + AgentID + " is already in " + GroupID);

                return;

            }

            Dictionary<string, object> row = new Dictionary<string, object>(6);

            row["GroupID"] = GroupID;

            row["AgentID"] = AgentID;

            row["SelectedRoleID"] = RoleID;

            row["Contribution"] = 0;

            row["ListInProfile"] = 1;

            row["AcceptNotices"] = 1;

            data.Insert("osgroupmembership", row);



            // Make sure they're in the Everyone role

            AddAgentToRole(requestingAgentID, AgentID, GroupID, UUID.Zero);

            // Make sure they're in specified role, if they were invited

            if (RoleID != UUID.Zero)

                AddAgentToRole(requestingAgentID, AgentID, GroupID, RoleID);

            //Set the role they were invited to as their selected role

            SetAgentGroupSelectedRole(AgentID, GroupID, RoleID);

            SetAgentActiveGroup(AgentID, GroupID);

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public bool RemoveAgentFromGroup(UUID requestingAgentID, UUID AgentID, UUID GroupID)

        {

            //Allow kicking yourself

            object remoteValue = DoRemote(requestingAgentID, AgentID, GroupID);

            if (remoteValue != null || m_doRemoteOnly)

                return remoteValue != null && (bool) remoteValue;



            if ((CheckGroupPermissions(requestingAgentID, GroupID, (ulong) GroupPowers.RemoveMember)) ||

                (requestingAgentID == AgentID))

            {

                QueryFilter filter = new QueryFilter();

                filter.andFilters["AgentID"] = AgentID;

                filter.andFilters["ActiveGroupID"] = GroupID;



                Dictionary<string, object> values = new Dictionary<string, object>(1);

                values["ActiveGroupID"] = UUID.Zero;



                // 1. If group is agent's active group, change active group to uuidZero

                data.Update("osagent", values, null, filter, null, null);



                filter.andFilters.Remove("ActiveGroupID");

                filter.andFilters["GroupID"] = GroupID;



                // 2. Remove Agent from group (osgroupmembership)

                data.Delete("osgrouprolemembership", filter);



                // 3. Remove Agent from all of the groups roles (osgrouprolemembership)

                data.Delete("osgroupmembership", filter);



                return true;

            }

            return false;

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public void AddRoleToGroup(UUID requestingAgentID, UUID GroupID, UUID RoleID, string NameOf, string Description,

                                   string Title, ulong Powers)

        {

            object remoteValue = DoRemote(requestingAgentID, GroupID, RoleID, NameOf, Description, Title, Powers);

            if (remoteValue != null || m_doRemoteOnly)

                return;



            if (CheckGroupPermissions(requestingAgentID, GroupID, (ulong) GroupPowers.CreateRole))

            {

                Dictionary<string, object> row = new Dictionary<string, object>(6);

                row["GroupID"] = GroupID;

                row["RoleID"] = RoleID;

                row["Name"] = NameOf;

                row["Description"] = Description != null ? Description : "";

                row["Title"] = Title;

                row["Powers"] = (long) Powers;

                data.Insert("osrole", row);

            }

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public void UpdateRole(UUID requestingAgentID, UUID GroupID, UUID RoleID, string NameOf, string Desc,

                               string Title, ulong Powers)

        {

            object remoteValue = DoRemote(requestingAgentID, GroupID, RoleID, NameOf, Desc, Title, Powers);

            if (remoteValue != null || m_doRemoteOnly)

                return;



            if (CheckGroupPermissions(requestingAgentID, GroupID, (ulong) GroupPowers.RoleProperties))

            {

                Dictionary<string, object> values = new Dictionary<string, object>();

                values["RoleID"] = RoleID;

                if (NameOf != null)

                {

                    values["Name"] = NameOf;

                }

                if (Desc != null)

                    values["Description"] = Desc;



                if (Title != null)

                {

                    values["Title"] = Title;

                }

                values["Powers"] = Powers.ToString();



                QueryFilter filter = new QueryFilter();

                filter.andFilters["GroupID"] = GroupID;

                filter.andFilters["RoleID"] = RoleID;



                data.Update("osrole", values, null, filter, null, null);

            }

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public void RemoveRoleFromGroup(UUID requestingAgentID, UUID RoleID, UUID GroupID)

        {

            object remoteValue = DoRemote(requestingAgentID, RoleID, GroupID);

            if (remoteValue != null || m_doRemoteOnly)

                return;



            if (CheckGroupPermissions(requestingAgentID, GroupID, (ulong) GroupPowers.DeleteRole))

            {

                Dictionary<string, object> values = new Dictionary<string, object>(1);

                values["SelectedRoleID"] = UUID.Zero;



                QueryFilter ufilter = new QueryFilter();

                ufilter.andFilters["GroupID"] = GroupID;

                ufilter.andFilters["SelectedRoleID"] = RoleID;



                QueryFilter dfilter = new QueryFilter();

                dfilter.andFilters["GroupID"] = GroupID;

                dfilter.andFilters["RoleID"] = RoleID;



                data.Delete("osgrouprolemembership", dfilter);

                data.Update("osgroupmembership", values, null, ufilter, null, null);

                data.Delete("osrole", dfilter);

            }

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public void AddAgentToRole(UUID requestingAgentID, UUID AgentID, UUID GroupID, UUID RoleID)

        {

            object remoteValue = DoRemote(requestingAgentID, AgentID, GroupID, RoleID);

            if (remoteValue != null || m_doRemoteOnly)

                return;



            if (!CheckGroupPermissions(requestingAgentID, GroupID, (ulong) GroupPowers.AssignMember))

            {

                //This isn't an open and shut case, they could be setting the agent to their role, which would allow for AssignMemberLimited

                if (!CheckGroupPermissions(requestingAgentID, GroupID, (ulong) GroupPowers.AssignMemberLimited))

                {

                    GroupProfileData profile = GetGroupProfile(requestingAgentID, GroupID);

                    if (profile == null || !profile.OpenEnrollment || RoleID != UUID.Zero) //For open enrollment adding

                    {

                        MainConsole.Instance.Warn("[AGM]: User " + requestingAgentID + " attempted to add user " +

                                                  AgentID +

                                                  " to group " + GroupID + ", but did not have permissions to do so!");

                        return;

                    }

                }

            }



            QueryFilter filter = new QueryFilter();

            filter.andFilters["GroupID"] = GroupID;

            filter.andFilters["RoleID"] = RoleID;

            filter.andFilters["AgentID"] = AgentID;

            //Make sure they arn't already in this role

            if (

                uint.Parse(data.Query(new[] {"COUNT(AgentID)"}, "osgrouprolemembership", filter, null, null, null)[0]) ==

                0)

            {

                Dictionary<string, object> row = new Dictionary<string, object>(3);

                row["GroupID"] = GroupID;

                row["RoleID"] = RoleID;

                row["AgentID"] = AgentID;

                data.Insert("osgrouprolemembership", row);

            }

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public void RemoveAgentFromRole(UUID requestingAgentID, UUID AgentID, UUID GroupID, UUID RoleID)

        {

            object remoteValue = DoRemote(requestingAgentID, AgentID, GroupID, RoleID);

            if (remoteValue != null || m_doRemoteOnly)

                return;



            if (CheckGroupPermissions(requestingAgentID, GroupID, (ulong) GroupPowers.AssignMember))

            {

                Dictionary<string, object> values = new Dictionary<string, object>(1);

                values["SelectedRoleID"] = UUID.Zero;



                QueryFilter filter = new QueryFilter();

                filter.andFilters["AgentID"] = AgentID;

                filter.andFilters["GroupID"] = GroupID;

                filter.andFilters["SelectedRoleID"] = RoleID;



                data.Update("osgroupmembership", values, null, filter, null, null);



                filter.andFilters.Remove("SelectedRoleID");

                filter.andFilters["RoleID"] = RoleID;

                data.Delete("osgrouprolemembership", filter);

            }

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public void SetAgentGroupInfo(UUID requestingAgentID, UUID AgentID, UUID GroupID, int AcceptNotices,

                                      int ListInProfile)

        {

            object remoteValue = DoRemote(requestingAgentID, AgentID, GroupID, AcceptNotices, ListInProfile);

            if (remoteValue != null || m_doRemoteOnly)

                return;



            if (!CheckGroupPermissions(requestingAgentID, GroupID, (ulong) GroupPowers.ChangeIdentity))

            {

                return;

            }



            Dictionary<string, object> values = new Dictionary<string, object>(3);

            values["AgentID"] = AgentID;

            values["AcceptNotices"] = AcceptNotices;

            values["ListInProfile"] = ListInProfile;



            QueryFilter filter = new QueryFilter();

            // these look the wrong way around ~ SignpostMarv

            filter.andFilters["GroupID"] = AgentID;

            filter.andFilters["AgentID"] = GroupID;



            data.Update("osgroupmembership", values, null, filter, null, null);

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public void AddAgentGroupInvite(UUID requestingAgentID, UUID inviteID, UUID GroupID, UUID roleID, UUID AgentID,

                                        string FromAgentName)

        {

            object remoteValue = DoRemote(requestingAgentID, inviteID, GroupID, roleID, AgentID, FromAgentName);

            if (remoteValue != null || m_doRemoteOnly)

                return;



            if (CheckGroupPermissions(requestingAgentID, GroupID, (ulong) GroupPowers.Invite))

            {

                QueryFilter filter = new QueryFilter();

                filter.andFilters["AgentID"] = AgentID;

                filter.andFilters["GroupID"] = GroupID;

                data.Delete("osgroupinvite", filter);



                Dictionary<string, object> row = new Dictionary<string, object>(6);

                row["InviteID"] = inviteID;

                row["GroupID"] = GroupID;

                row["RoleID"] = roleID;

                row["AgentID"] = AgentID;

                row["TMStamp"] = Util.UnixTimeSinceEpoch();

                row["FromAgentName"] = FromAgentName;

                data.Insert("osgroupinvite", row);

            }

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public void RemoveAgentInvite(UUID requestingAgentID, UUID inviteID)

        {

            object remoteValue = DoRemote(requestingAgentID, inviteID);

            if (remoteValue != null || m_doRemoteOnly)

                return;



            QueryFilter filter = new QueryFilter();

            filter.andFilters["InviteID"] = inviteID;

            data.Delete("osgroupinvite", filter);

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public void AddGroupProposal(UUID agentID, GroupProposalInfo info)

        {

            object remoteValue = DoRemote(agentID, info);

            if (remoteValue != null || m_doRemoteOnly)

                return;



            if (CheckGroupPermissions(agentID, info.GroupID, (ulong) GroupPowers.StartProposal))

                GenericUtils.AddGeneric(info.GroupID, "Proposal", info.VoteID.ToString(), info.ToOSD(), data);

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public List<GroupProposalInfo> GetActiveProposals(UUID agentID, UUID groupID)

        {

            object remoteValue = DoRemote(agentID, groupID);

            if (remoteValue != null || m_doRemoteOnly)

                return (List<GroupProposalInfo>) remoteValue;



            if (!CheckGroupPermissions(agentID, groupID, (ulong) GroupPowers.VoteOnProposal))

                return new List<GroupProposalInfo>();



            List<GroupProposalInfo> proposals = GenericUtils.GetGenerics<GroupProposalInfo>(groupID, "Proposal", data);

            proposals = (from p in proposals where p.Ending > DateTime.Now select p).ToList();

            foreach (GroupProposalInfo p in proposals)

                p.VoteCast = GetHasVoted(agentID, p);



            return proposals; //Return only ones that are still running

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public List<GroupProposalInfo> GetInactiveProposals(UUID agentID, UUID groupID)

        {

            object remoteValue = DoRemote(agentID, groupID);

            if (remoteValue != null || m_doRemoteOnly)

                return (List<GroupProposalInfo>) remoteValue;



            if (!CheckGroupPermissions(agentID, groupID, (ulong) GroupPowers.VoteOnProposal))

                return new List<GroupProposalInfo>();



            List<GroupProposalInfo> proposals = GenericUtils.GetGenerics<GroupProposalInfo>(groupID, "Proposal", data);

            proposals = (from p in proposals where p.Ending < DateTime.Now select p).ToList();

            List<GroupProposalInfo> proposalsNeedingResults =

                (from p in proposals where !p.HasCalculatedResult select p).ToList();

            foreach (GroupProposalInfo p in proposalsNeedingResults)

            {

                List<OpenMetaverse.StructuredData.OSDMap> maps = GenericUtils.GetGenerics(p.GroupID, p.VoteID.ToString(),

                                                                                          data);

                int yes = 0;

                int no = 0;

                foreach (OpenMetaverse.StructuredData.OSDMap vote in maps)

                {

                    if (vote["Vote"].AsString().ToLower() == "yes")

                        yes++;

                    else if (vote["Vote"].AsString().ToLower() == "no")

                        no++;

                }

                if (yes + no < p.Quorum)

                    p.Result = false;

                /*if (yes > no)

                    p.Result = true;

                else

                    p.Result = false;*/

                p.HasCalculatedResult = true;

                GenericUtils.AddGeneric(p.GroupID, "Proposal", p.VoteID.ToString(), p.ToOSD(), data);

            }

            foreach (GroupProposalInfo p in proposals)

                p.VoteCast = GetHasVoted(agentID, p);



            return proposals; //Return only ones that are still running

        }



        private string GetHasVoted(UUID agentID, GroupProposalInfo p)

        {

            OpenMetaverse.StructuredData.OSDMap map = GenericUtils.GetGeneric(p.GroupID, p.VoteID.ToString(),

                                                                              agentID.ToString(), data);

            if (map != null)

                return map["Vote"];

            return "";

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public void VoteOnActiveProposals(UUID agentID, UUID groupID, UUID proposalID, string vote)

        {

            object remoteValue = DoRemote(agentID, groupID, proposalID, vote);

            if (remoteValue != null || m_doRemoteOnly)

                return;



            if (!CheckGroupPermissions(agentID, groupID, (ulong) GroupPowers.VoteOnProposal))

                return;



            OpenMetaverse.StructuredData.OSDMap map = new OpenMetaverse.StructuredData.OSDMap();

            map["Vote"] = vote;

            GenericUtils.AddGeneric(groupID, proposalID.ToString(), agentID.ToString(), map, data);

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public uint GetNumberOfGroupNotices(UUID requestingAgentID, UUID GroupID)

        {

            object remoteValue = DoRemote(requestingAgentID, GroupID);

            if (remoteValue != null || m_doRemoteOnly)

                return (uint) remoteValue; // note: this is bad, you can't cast a null object to a uint



            List<UUID> GroupIDs = new List<UUID> {GroupID};

            return GetNumberOfGroupNotices(requestingAgentID, GroupIDs);

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public uint GetNumberOfGroupNotices(UUID requestingAgentID, List<UUID> GroupIDs)

        {

            object remoteValue = DoRemote(requestingAgentID, GroupIDs);

            if (remoteValue != null || m_doRemoteOnly)

                return (uint) remoteValue; // note: this is bad, you can't cast a null object to a uint



            bool had = GroupIDs.Count > 0;



            List<UUID> groupIDs = new List<UUID>();

            if (!agentsCanBypassGroupNoticePermsCheck.Contains(requestingAgentID))

            {

#if (!ISWIN)

                foreach (UUID GroupID in GroupIDs)

                {

                    if (CheckGroupPermissions(requestingAgentID, GroupID, (ulong)GroupPowers.ReceiveNotices))

                        groupIDs.Add(GroupID);

                }

#else

                groupIDs.AddRange(

                    GroupIDs.Where(

                        GroupID => CheckGroupPermissions(requestingAgentID, GroupID, (ulong) GroupPowers.ReceiveNotices)));

#endif

            }

            else

            {

                groupIDs = GroupIDs;

            }



            if (had && groupIDs.Count == 0)

            {

                return 0;

            }



            QueryFilter filter = new QueryFilter();

            List<object> filterGroupIDs = new List<object>(groupIDs.Count);

            filterGroupIDs.AddRange(groupIDs.Cast<object>());

            if (filterGroupIDs.Count > 0)

            {

                filter.orMultiFilters["GroupID"] = filterGroupIDs;

            }



            return uint.Parse(data.Query(new[] {"COUNT(NoticeID)"}, "osgroupnotice", filter, null, null, null)[0]);

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public uint GetNumberOfGroups(UUID requestingAgentID, Dictionary<string, bool> boolFields)

        {

            object remoteValue = DoRemote(requestingAgentID, boolFields);

            if (remoteValue != null || m_doRemoteOnly)

                return (uint) remoteValue; // note: this is bad, you can't cast a null object to a uint



            QueryFilter filter = new QueryFilter();



            string[] BoolFields = {"OpenEnrollment", "ShowInList", "AllowPublish", "MaturePublish"};

            foreach (string field in BoolFields)

            {

                if (boolFields.ContainsKey(field))

                {

                    filter.andFilters[field] = boolFields[field] ? "1" : "0";

                }

            }



            return uint.Parse(data.Query(new[] {"COUNT(GroupID)"}, "osgroup", filter, null, null, null)[0]);

        }



        private static GroupRecord GroupRecordQueryResult2GroupRecord(List<String> result)

        {

            return new GroupRecord

                       {

                           GroupID = UUID.Parse(result[0]),

                           GroupName = result[1],

                           Charter = result[2],

                           GroupPicture = UUID.Parse(result[3]),

                           FounderID = UUID.Parse(result[4]),

                           MembershipFee = int.Parse(result[5]),

                           OpenEnrollment = int.Parse(result[6]) == 1,

                           ShowInList = int.Parse(result[7]) == 1,

                           AllowPublish = int.Parse(result[8]) == 1,

                           MaturePublish = int.Parse(result[9]) == 1,

                           OwnerRoleID = UUID.Parse(result[10])

                       };

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public GroupRecord GetGroupRecord(UUID requestingAgentID, UUID GroupID, string GroupName)

        {

            object remoteValue = DoRemote(requestingAgentID, GroupID, GroupName);

            if (remoteValue != null || m_doRemoteOnly)

                return (GroupRecord) remoteValue;



            QueryFilter filter = new QueryFilter();



            if (GroupID != UUID.Zero)

            {

                filter.andFilters["GroupID"] = GroupID;

            }

            if (!string.IsNullOrEmpty(GroupName))

            {

                filter.andFilters["Name"] = GroupName;

            }

            if (filter.Count == 0)

            {

                return null;

            }

            List<string> osgroupsData = data.Query(new[]

                                                       {

                                                           "GroupID",

                                                           "Name",

                                                           "Charter",

                                                           "InsigniaID",

                                                           "FounderID",

                                                           "MembershipFee",

                                                           "OpenEnrollment",

                                                           "ShowInList",

                                                           "AllowPublish",

                                                           "MaturePublish",

                                                           "OwnerRoleID"

                                                       }, "osgroup", filter, null, null, null);

            return (osgroupsData.Count == 0) ? null : GroupRecordQueryResult2GroupRecord(osgroupsData);

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public List<GroupRecord> GetGroupRecords(UUID requestingAgentID, uint start, uint count,

                                                 Dictionary<string, bool> sort, Dictionary<string, bool> boolFields)

        {

            //            List<string> filter = new List<string>();



            object remoteValue = DoRemote(requestingAgentID, start, count, boolFields);

            if (remoteValue != null || m_doRemoteOnly)

                return (List<GroupRecord>) remoteValue;



            string[] sortAndBool = {"OpenEnrollment", "MaturePublish"};

            string[] BoolFields = {"OpenEnrollment", "ShowInList", "AllowPublish", "MaturePublish"};



            foreach (string field in sortAndBool)

            {

                if (boolFields.ContainsKey(field) && sort.ContainsKey(field))

                {

                    sort.Remove(field);

                }

            }



            QueryFilter filter = new QueryFilter();



            foreach (string field in BoolFields)

            {

                if (boolFields.ContainsKey(field))

                {

                    filter.andFilters[field] = boolFields[field] ? "1" : "0";

                }

            }



            List<GroupRecord> Reply = new List<GroupRecord>();



            List<string> osgroupsData = data.Query(new[]

                                                       {

                                                           "GroupID",

                                                           "Name",

                                                           "Charter",

                                                           "InsigniaID",

                                                           "FounderID",

                                                           "MembershipFee",

                                                           "OpenEnrollment",

                                                           "ShowInList",

                                                           "AllowPublish",

                                                           "MaturePublish",

                                                           "OwnerRoleID"

                                                       }, "osgroup", filter, sort, start, count);



            if (osgroupsData.Count < 11)

            {

                return Reply;

            }

            for (int i = 0; i < osgroupsData.Count; i += 11)

            {

                Reply.Add(GroupRecordQueryResult2GroupRecord(osgroupsData.GetRange(i, 11)));

            }

            return Reply;

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public List<GroupRecord> GetGroupRecords(UUID requestingAgentID, List<UUID> GroupIDs)

        {

            object remoteValue = DoRemote(requestingAgentID, GroupIDs);

            if (remoteValue != null || m_doRemoteOnly)

                return (List<GroupRecord>) remoteValue;



            List<GroupRecord> Reply = new List<GroupRecord>(0);

            if (GroupIDs.Count <= 0)

            {

                return Reply;

            }



            QueryFilter filter = new QueryFilter();

            filter.orMultiFilters["GroupID"] = new List<object>();

            foreach (UUID groupID in GroupIDs)

            {

                filter.orMultiFilters["GroupID"].Add(groupID);

            }



            List<string> osgroupsData = data.Query(new[]

                                                       {

                                                           "GroupID",

                                                           "Name",

                                                           "Charter",

                                                           "InsigniaID",

                                                           "FounderID",

                                                           "MembershipFee",

                                                           "OpenEnrollment",

                                                           "ShowInList",

                                                           "AllowPublish",

                                                           "MaturePublish",

                                                           "OwnerRoleID"

                                                       }, "osgroup", filter, null, null, null);



            if (osgroupsData.Count < 11)

            {

                return Reply;

            }

            for (int i = 0; i < osgroupsData.Count; i += 11)

            {

                Reply.Add(GroupRecordQueryResult2GroupRecord(osgroupsData.GetRange(i, 11)));

            }

            return Reply;

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public GroupProfileData GetMemberGroupProfile(UUID requestingAgentID, UUID GroupID, UUID AgentID)

        {

            object remoteValue = DoRemote(requestingAgentID, GroupID, AgentID);

            if (remoteValue != null || m_doRemoteOnly)

                return (GroupProfileData) remoteValue;



            if (!CheckGroupPermissions(requestingAgentID, GroupID, (ulong) GroupPowers.MemberVisible))

                return new GroupProfileData();



            GroupProfileData GPD = new GroupProfileData();

            GroupRecord record = GetGroupRecord(requestingAgentID, GroupID, null);



            QueryFilter filter1 = new QueryFilter();

            filter1.andFilters["GroupID"] = AgentID; // yes these look the wrong way around

            filter1.andFilters["AgentID"] = GroupID; // but they were like that when I got here! ~ SignpostMarv



            QueryFilter filter2 = new QueryFilter();

            filter2.andFilters["GroupID"] = GroupID;



            List<string> Membership = data.Query(new[]

                                                     {

                                                         "Contribution",

                                                         "ListInProfile",

                                                         "SelectedRoleID"

                                                     }, "osgroupmembership", filter1, null, null, null);



            int GroupMemCount =

                int.Parse(data.Query(new[] {"COUNT(AgentID)"}, "osgroupmembership", filter2, null, null, null)[0]);



            int GroupRoleCount = int.Parse(data.Query(new[] {"COUNT(RoleID)"}, "osrole", filter2, null, null, null)[0]);



            QueryFilter filter3 = new QueryFilter();

            filter3.andFilters["RoleID"] = Membership[2];

            List<string> GroupRole = data.Query(new[]

                                                    {

                                                        "Name",

                                                        "Powers"

                                                    }, "osrole", filter3, null, null, null);



            GPD.AllowPublish = record.AllowPublish;

            GPD.Charter = record.Charter;

            GPD.FounderID = record.FounderID;

            GPD.GroupID = record.GroupID;

            GPD.GroupMembershipCount = GroupMemCount;

            GPD.GroupRolesCount = GroupRoleCount;

            GPD.InsigniaID = record.GroupPicture;

            GPD.MaturePublish = record.MaturePublish;

            GPD.MembershipFee = record.MembershipFee;

            GPD.MemberTitle = GroupRole[0];

            GPD.Money = 0;



            GPD.Name = record.GroupName;

            GPD.OpenEnrollment = record.OpenEnrollment;

            GPD.OwnerRole = record.OwnerRoleID;

            GPD.PowersMask = ulong.Parse(GroupRole[1]);

            GPD.ShowInList = int.Parse(Membership[2]) == 1;



            return GPD;

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public GroupMembershipData GetGroupMembershipData(UUID requestingAgentID, UUID GroupID, UUID AgentID)

        {

            object remoteValue = DoRemote(requestingAgentID, GroupID, AgentID);

            if (remoteValue != null || m_doRemoteOnly)

                return (GroupMembershipData) remoteValue;



            if (GroupID == UUID.Zero)

                GroupID = GetAgentActiveGroup(requestingAgentID, AgentID);

            if (GroupID == UUID.Zero)

                return null;



            QueryTables tables = new QueryTables();

            tables.AddTable("osgroup", "osg");

            tables.AddTable("osgroupmembership", "osgm", JoinType.Inner, new[,] {{"osg.GroupID", "osgm.GroupID"}});

            tables.AddTable("osrole", "osr", JoinType.Inner,

                            new[,] {{"osgm.SelectedRoleID", "osr.RoleID"}, {"osr.GroupID", "osg.GroupID"}});



            QueryFilter filter = new QueryFilter();

            filter.andFilters["osg.GroupID"] = GroupID;

            filter.andFilters["osgm.AgentID"] = AgentID;



            string[] fields = new[]

                                  {

                                      "osgm.AcceptNotices",

                                      "osgm.Contribution",

                                      "osgm.ListInProfile",

                                      "osgm.SelectedRoleID",

                                      "osr.Title",

                                      "osr.Powers",

                                      "osg.AllowPublish",

                                      "osg.Charter",

                                      "osg.FounderID",

                                      "osg.Name",

                                      "osg.InsigniaID",

                                      "osg.MaturePublish",

                                      "osg.MembershipFee",

                                      "osg.OpenEnrollment",

                                      "osg.ShowInList"

                                  };

            List<string> Membership = data.Query(fields, tables, filter, null, null, null);



            if (fields.Length != Membership.Count)

                return null;



            GroupMembershipData GMD = new GroupMembershipData

                                          {

                                              AcceptNotices = int.Parse(Membership[0]) == 1,

                                              Active = true, //TODO: Figure out what this is and its effects if false

                                              ActiveRole = UUID.Parse(Membership[3]),

                                              AllowPublish = int.Parse(Membership[6]) == 1,

                                              Charter = Membership[7],

                                              Contribution = int.Parse(Membership[1]),

                                              FounderID = UUID.Parse(Membership[8]),

                                              GroupID = GroupID,

                                              GroupName = Membership[9],

                                              GroupPicture = UUID.Parse(Membership[10]),

                                              GroupPowers = ulong.Parse(Membership[5]),

                                              GroupTitle = Membership[4],

                                              ListInProfile = int.Parse(Membership[2]) == 1,

                                              MaturePublish = int.Parse(Membership[11]) == 1,

                                              MembershipFee = int.Parse(Membership[12]),

                                              OpenEnrollment = int.Parse(Membership[13]) == 1,

                                              ShowInList = int.Parse(Membership[14]) == 1

                                          };





            return GMD;

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public List<GroupTitlesData> GetGroupTitles(UUID requestingAgentID, UUID GroupID)

        {

            object remoteValue = DoRemote(requestingAgentID, GroupID);

            if (remoteValue != null || m_doRemoteOnly)

                return (List<GroupTitlesData>) remoteValue;



            QueryTables tables = new QueryTables();

            tables.AddTable("osgroupmembership", "osgm");

            tables.AddTable("osgrouprolemembership", "osgrm", JoinType.Inner,

                            new[,] {{"osgm.AgentID", "osgrm.AgentID"}, {"osgm.GroupID", "osgrm.GroupID"}});

            tables.AddTable("osrole", "osr", JoinType.Inner,

                            new[,] {{"osgrm.RoleID", "osr.RoleID"}, {"osgm.GroupID", "osr.GroupID"}});





            QueryFilter filter = new QueryFilter();

            filter.andFilters["osgm.AgentID"] = requestingAgentID;

            filter.andFilters["osgm.GroupID"] = GroupID;



            List<string> Membership = data.Query(new[]

                                                     {

                                                         "osgm.SelectedRoleID",

                                                         "osgrm.RoleID",

                                                         "osr.Name"

                                                     }, tables, filter, null, null, null);





            List<GroupTitlesData> titles = new List<GroupTitlesData>();

            for (int loop = 0; loop < Membership.Count(); loop += 3)

            {

                titles.Add(new GroupTitlesData

                               {

                                   Name = Membership[loop + 2],

                                   UUID = UUID.Parse(Membership[loop + 1]),

                                   Selected = Membership[loop + 0] == Membership[loop + 1]

                               });

            }

            return titles;

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public List<GroupMembershipData> GetAgentGroupMemberships(UUID requestingAgentID, UUID AgentID)

        {

            object remoteValue = DoRemote(requestingAgentID, AgentID);

            if (remoteValue != null || m_doRemoteOnly)

                return (List<GroupMembershipData>) remoteValue;



            QueryTables tables = new QueryTables();

            tables.AddTable("osgroup", "osg");

            tables.AddTable("osgroupmembership", "osgm", JoinType.Inner, new[,] {{"osg.GroupID", "osgm.GroupID"}});

            tables.AddTable("osrole", "osr", JoinType.Inner, new[,] {{"osgm.SelectedRoleID", "osr.RoleID"}});



            QueryFilter filter = new QueryFilter();

            filter.andFilters["osgm.AgentID"] = AgentID;



            string[] fields = new[]

                                  {

                                      "osgm.AcceptNotices",

                                      "osgm.Contribution",

                                      "osgm.ListInProfile",

                                      "osgm.SelectedRoleID",

                                      "osr.Title",

                                      "osr.Powers",

                                      "osg.AllowPublish",

                                      "osg.Charter",

                                      "osg.FounderID",

                                      "osg.Name",

                                      "osg.InsigniaID",

                                      "osg.MaturePublish",

                                      "osg.MembershipFee",

                                      "osg.OpenEnrollment",

                                      "osg.ShowInList",

                                      "osg.GroupID"

                                  };

            List<string> Membership = data.Query(fields, tables, filter, null, null, null);

            List<GroupMembershipData> results = new List<GroupMembershipData>();

            for (int loop = 0; loop < Membership.Count; loop += fields.Length)

            {

                results.Add(new GroupMembershipData

                                {

                                    AcceptNotices = int.Parse(Membership[loop + 0]) == 1,

                                    Active = true,

                                    //TODO: Figure out what this is and its effects if false

                                    ActiveRole = UUID.Parse(Membership[loop + 3]),

                                    AllowPublish = int.Parse(Membership[loop + 6]) == 1,

                                    Charter = Membership[loop + 7],

                                    Contribution = int.Parse(Membership[loop + 1]),

                                    FounderID = UUID.Parse(Membership[loop + 8]),

                                    GroupID = UUID.Parse(Membership[loop + 15]),

                                    GroupName = Membership[loop + 9],

                                    GroupPicture = UUID.Parse(Membership[loop + 10]),

                                    GroupPowers = ulong.Parse(Membership[loop + 5]),

                                    GroupTitle = Membership[loop + 4],

                                    ListInProfile = int.Parse(Membership[loop + 2]) == 1,

                                    MaturePublish = int.Parse(Membership[loop + 11]) == 1,

                                    MembershipFee = int.Parse(Membership[loop + 12]),

                                    OpenEnrollment = int.Parse(Membership[loop + 13]) == 1,

                                    ShowInList = int.Parse(Membership[loop + 14]) == 1

                                });

            }

            return results;

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public GroupInviteInfo GetAgentToGroupInvite(UUID requestingAgentID, UUID inviteID)

        {

            object remoteValue = DoRemote(requestingAgentID, inviteID);

            if (remoteValue != null || m_doRemoteOnly)

                return (GroupInviteInfo) remoteValue;



            GroupInviteInfo invite = new GroupInviteInfo();



            Dictionary<string, object> where = new Dictionary<string, object>(2);

            where["AgentID"] = requestingAgentID;

            where["InviteID"] = inviteID;



            List<string> groupInvite = data.Query(new[] {"*"}, "osgroupinvite", new QueryFilter

                                                                                    {

                                                                                        andFilters = where

                                                                                    }, null, null, null);



            if (groupInvite.Count == 0)

            {

                return null;

            }

            invite.AgentID = UUID.Parse(groupInvite[3]);

            invite.GroupID = UUID.Parse(groupInvite[1]);

            invite.InviteID = UUID.Parse(groupInvite[0]);

            invite.RoleID = UUID.Parse(groupInvite[2]);

            invite.FromAgentName = groupInvite[5];



            return invite;

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public List<GroupInviteInfo> GetGroupInvites(UUID requestingAgentID)

        {

            QueryFilter filter = new QueryFilter();

            filter.andFilters["AgentID"] = requestingAgentID;



            object remoteValue = DoRemote(requestingAgentID);

            if (remoteValue != null || m_doRemoteOnly)

                return (List<GroupInviteInfo>) remoteValue;



            List<string> groupInvite = data.Query(new[] {"*"}, "osgroupinvite", filter, null, null, null);



            List<GroupInviteInfo> invites = new List<GroupInviteInfo>();



            for (int i = 0; i < groupInvite.Count; i += 6)

            {

                invites.Add(new GroupInviteInfo

                                {

                                    AgentID = UUID.Parse(groupInvite[i + 3]),

                                    GroupID = UUID.Parse(groupInvite[i + 1]),

                                    InviteID = UUID.Parse(groupInvite[i]),

                                    RoleID = UUID.Parse(groupInvite[i + 2]),

                                    FromAgentName = groupInvite[i + 5]

                                });

            }



            return invites;

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public GroupMembersData GetAgentGroupMemberData(UUID requestingAgentID, UUID GroupID, UUID AgentID)

        {

            object remoteValue = DoRemote(requestingAgentID, GroupID, AgentID);

            if (remoteValue != null || m_doRemoteOnly)

                return (GroupMembersData) remoteValue;





            QueryFilter filter = new QueryFilter();

            filter.andFilters["GroupID"] = GroupID;

            filter.andFilters["AgentID"] = AgentID;



            List<string> Membership = data.Query(new string[4]

                                                     {

                                                         "AcceptNotices",

                                                         "Contribution",

                                                         "ListInProfile",

                                                         "SelectedRoleID"

                                                     }, "osgroupmembership", filter, null, null, null);



            if (Membership.Count != 4)

            {

                return null;

            }



            filter.andFilters.Remove("AgentID");

            filter.andFilters["RoleID"] = Membership[3];



            List<string> GroupRole = data.Query(new string[2]

                                                    {

                                                        "Title",

                                                        "Powers"

                                                    }, "osrole", filter, null, null, null);



            if (GroupRole.Count != 2)

            {

                return null;

            }



            filter.andFilters.Remove("RoleID");



            List<string> OwnerRoleID = data.Query(new string[1]

                                                      {

                                                          "OwnerRoleID"

                                                      }, "osgroup", filter, null, null, null);



            filter.andFilters["RoleID"] = OwnerRoleID[0];

            filter.andFilters["AgentID"] = AgentID;



            bool IsOwner = uint.Parse(data.Query(new string[1]

                                                     {

                                                         "COUNT(AgentID)"

                                                     }, "osgrouprolemembership", filter, null, null, null)[0]) == 1;



            return new GroupMembersData

                       {

                           AcceptNotices = (Membership[0]) == "1",

                           AgentID = AgentID,

                           Contribution = int.Parse(Membership[1]),

                           IsOwner = IsOwner,

                           ListInProfile = (Membership[2]) == "1",

                           AgentPowers = ulong.Parse(GroupRole[1]),

                           Title = GroupRole[0],

                           OnlineStatus = "(Online)"

                       };

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public List<GroupMembersData> GetGroupMembers(UUID requestingAgentID, UUID GroupID)

        {

            object remoteValue = DoRemote(requestingAgentID, GroupID);

            if (remoteValue != null || m_doRemoteOnly)

                return (List<GroupMembersData>) remoteValue;



            QueryFilter filter = new QueryFilter();

            filter.andFilters["GroupID"] = GroupID;

            List<string> Agents = data.Query(new[] {"AgentID"}, "osgroupmembership", filter, null, null, null);



            List<GroupMembersData> list = new List<GroupMembersData>();

            foreach (string agent in Agents)

            {

                GroupMembersData d = GetAgentGroupMemberData(requestingAgentID, GroupID, UUID.Parse(agent));

                if (d == null) continue;

                UserInfo info =

                    m_registry.RequestModuleInterface<IAgentInfoService>().GetUserInfo(

                        d.AgentID.ToString());

                if (info != null && !info.IsOnline)

                    d.OnlineStatus = info.LastLogin.ToShortDateString();

                else if (info == null)

                    d.OnlineStatus = "Unknown";

                else

                    d.OnlineStatus = "Online";

                list.Add(d);

            }

            return list;

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public List<DirGroupsReplyData> FindGroups(UUID requestingAgentID, string search, uint? start, uint? count,

                                                   uint queryflags)

        {

            object remoteValue = DoRemote(requestingAgentID, search, start, count, queryflags);

            if (remoteValue != null || m_doRemoteOnly)

                return (List<DirGroupsReplyData>) remoteValue;



            QueryFilter filter = new QueryFilter();

            filter.andLikeFilters["Name"] = "%" + search + "%";



            List<string> retVal = data.Query(new[]

                                                 {

                                                     "GroupID",

                                                     "Name",

                                                     "ShowInList",

                                                     "AllowPublish",

                                                     "MaturePublish"

                                                 }, "osgroup", filter, null, start, count);



            List<DirGroupsReplyData> Reply = new List<DirGroupsReplyData>();



            for (int i = 0; i < retVal.Count; i += 5)

            {

                if (retVal[i + 2] == "0") // (ShowInList param) They don't want to be shown in search.. respect this

                {

                    continue;

                }



                if ((queryflags & (uint) DirectoryManager.DirFindFlags.IncludeMature) !=

                    (uint) DirectoryManager.DirFindFlags.IncludeMature)

                {

                    if (retVal[i + 4] == "1") // (MaturePublish param) Check for pg,mature

                    {

                        continue;

                    }

                }



                DirGroupsReplyData dirgroup = new DirGroupsReplyData

                                                  {

                                                      groupID = UUID.Parse(retVal[i]),

                                                      groupName = retVal[i + 1]

                                                  };

                filter = new QueryFilter();

                filter.andFilters["GroupID"] = dirgroup.groupID;

                dirgroup.members =

                    int.Parse(data.Query(new[] {"COUNT(AgentID)"}, "osgroupmembership", filter, null, null, null)[0]);



                Reply.Add(dirgroup);

            }

            return Reply;

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public List<GroupRolesData> GetAgentGroupRoles(UUID requestingAgentID, UUID AgentID, UUID GroupID)

        {

            // I couldn't actually get this function to call when testing changes

            object remoteValue = DoRemote(requestingAgentID, AgentID, GroupID);

            if (remoteValue != null || m_doRemoteOnly)

                return (List<GroupRolesData>) remoteValue;



            //No permissions check necessary, we are checking only roles that they are in, so if they arn't in the group, that isn't a problem



            QueryTables tables = new QueryTables();

            tables.AddTable("osgrouprolemembership", "osgm");

            tables.AddTable("osrole", "osr", JoinType.Inner, new[,] {{"osgm.RoleID", "osr.RoleID"}});



            QueryFilter filter = new QueryFilter();

            filter.andFilters["osgm.AgentID"] = AgentID;

            filter.andFilters["osgm.GroupID"] = GroupID;



            string[] fields = new[]

                                  {

                                      "osr.Name",

                                      "osr.Description",

                                      "osr.Title",

                                      "osr.Powers",

                                      "osr.RoleID"

                                  };

            List<string> Roles = data.Query(fields, tables, filter, null, null, null);



            filter = new QueryFilter();



            List<GroupRolesData> RolesData = new List<GroupRolesData>();



            for (int loop = 0; loop < Roles.Count; loop += fields.Length)

            {

                RolesData.Add(new GroupRolesData

                                  {

                                      RoleID = UUID.Parse(Roles[loop + 4]),

                                      Name = Roles[loop + 0],

                                      Description = Roles[loop + 1],

                                      Powers = ulong.Parse(Roles[loop + 3]),

                                      Title = Roles[loop + 2]

                                  });

            }



            return RolesData;

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public List<GroupRolesData> GetGroupRoles(UUID requestingAgentID, UUID GroupID)

        {

            // Can't use joins here without a group by as well

            object remoteValue = DoRemote(requestingAgentID, GroupID);

            if (remoteValue != null || m_doRemoteOnly)

                return (List<GroupRolesData>) remoteValue;



            if (!CheckGroupPermissions(requestingAgentID, GroupID, (ulong) GroupPowers.None))

            {

                return new List<GroupRolesData>(0);

            }



            List<GroupRolesData> GroupRoles = new List<GroupRolesData>();



            QueryFilter rolesFilter = new QueryFilter();

            rolesFilter.andFilters["GroupID"] = GroupID;

            List<string> Roles = data.Query(new[]

                                                {

                                                    "Name",

                                                    "Description",

                                                    "Title",

                                                    "Powers",

                                                    "RoleID"

                                                }, "osrole", rolesFilter, null, null, null);



            QueryFilter filter = new QueryFilter();

            filter.andFilters["GroupID"] = GroupID;



            for (int i = 0; i < Roles.Count; i += 5)

            {

                filter.andFilters["RoleID"] = UUID.Parse(Roles[i + 4]);

                int Count =

                    int.Parse(data.Query(new[] {"COUNT(AgentID)"}, "osgrouprolemembership", filter, null, null, null)[0]);



                GroupRoles.Add(new GroupRolesData

                                   {

                                       Members = Count,

                                       RoleID = UUID.Parse(Roles[i + 4]),

                                       Name = Roles[i + 0],

                                       Description = Roles[i + 1],

                                       Powers = ulong.Parse(Roles[i + 3]),

                                       Title = Roles[i + 2]

                                   });

            }

            return GroupRoles;

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public List<GroupRoleMembersData> GetGroupRoleMembers(UUID requestingAgentID, UUID GroupID)

        {

            object remoteValue = DoRemote(requestingAgentID, GroupID);

            if (remoteValue != null || m_doRemoteOnly)

                return (List<GroupRoleMembersData>) remoteValue;



            List<GroupRoleMembersData> RoleMembers = new List<GroupRoleMembersData>();



            QueryTables tables = new QueryTables();

            tables.AddTable("osgrouprolemembership", "osgrm");

            tables.AddTable("osrole", "osr", JoinType.Inner, new[,] {{"osr.RoleID", "osgrm.RoleID"}});



            QueryFilter filter = new QueryFilter();

            filter.andFilters["osgrm.GroupID"] = GroupID;

            string[] fields = new[]

                                  {

                                      "osgrm.RoleID",

                                      "osgrm.AgentID",

                                      "osr.Powers"

                                  };

            List<string> Roles = data.Query(fields, tables, filter, null, null, null);



            GroupMembersData GMD = GetAgentGroupMemberData(requestingAgentID, GroupID, requestingAgentID);

            const long canViewMemebersBit = 140737488355328L;

            for (int i = 0; i < Roles.Count; i += fields.Length)

            {

                GroupRoleMembersData RoleMember = new GroupRoleMembersData

                                                      {

                                                          RoleID = UUID.Parse(Roles[i]),

                                                          MemberID = UUID.Parse(Roles[i + 1])

                                                      };



                // if they are a member, they can see everyone, otherwise, only the roles that are supposed to be shown

                if (GMD != null ||

                    ((long.Parse(Roles[i + 2]) & canViewMemebersBit) == canViewMemebersBit ||

                     RoleMember.MemberID == requestingAgentID))

                    RoleMembers.Add(RoleMember);

            }



            return RoleMembers;

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public GroupNoticeData GetGroupNoticeData(UUID requestingAgentID, UUID noticeID)

        {

            object remoteValue = DoRemote(requestingAgentID, noticeID);

            if (remoteValue != null || m_doRemoteOnly)

            {

                return (GroupNoticeData) remoteValue;

            }



            QueryFilter filter = new QueryFilter();

            filter.andFilters["NoticeID"] = noticeID;

            string[] fields = new string[9]

                                  {

                                      "GroupID",

                                      "Timestamp",

                                      "FromName",

                                      "Subject",

                                      "ItemID",

                                      "HasAttachment",

                                      "Message",

                                      "AssetType",

                                      "ItemName"

                                  };

            List<string> notice = data.Query(fields, "osgroupnotice", filter, null, null, null);



            if (notice.Count != fields.Length)

            {

                return null;

            }



            GroupNoticeData GND = new GroupNoticeData

                                      {

                                          GroupID = UUID.Parse(notice[0]),

                                          NoticeID = noticeID,

                                          Timestamp = uint.Parse(notice[1]),

                                          FromName = notice[2],

                                          Subject = notice[3],

                                          HasAttachment = int.Parse(notice[5]) == 1

                                      };

            if (GND.HasAttachment)

            {

                GND.ItemID = UUID.Parse(notice[4]);

                GND.AssetType = (byte) int.Parse(notice[7]);

                GND.ItemName = notice[8];

            }



            return GND;

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public GroupNoticeInfo GetGroupNotice(UUID requestingAgentID, UUID noticeID)

        {

            object remoteValue = DoRemote(requestingAgentID, noticeID);

            if (remoteValue != null || m_doRemoteOnly)

                return (GroupNoticeInfo) remoteValue;



            QueryFilter filter = new QueryFilter();

            filter.andFilters["NoticeID"] = noticeID;

            string[] fields = new string[9]

                                  {

                                      "GroupID",

                                      "Timestamp",

                                      "FromName",

                                      "Subject",

                                      "ItemID",

                                      "HasAttachment",

                                      "Message",

                                      "AssetType",

                                      "ItemName"

                                  };

            List<string> notice = data.Query(fields, "osgroupnotice", filter, null, null, null);



            if (notice.Count != fields.Length)

            {

                return null;

            }



            GroupNoticeData GND = new GroupNoticeData

                                      {

                                          NoticeID = noticeID,

                                          Timestamp = uint.Parse(notice[1]),

                                          FromName = notice[2],

                                          Subject = notice[3],

                                          HasAttachment = int.Parse(notice[5]) == 1

                                      };

            if (GND.HasAttachment)

            {

                GND.ItemID = UUID.Parse(notice[4]);

                GND.AssetType = (byte) int.Parse(notice[7]);

                GND.ItemName = notice[8];

            }



            GroupNoticeInfo info = new GroupNoticeInfo

                                       {

                                           BinaryBucket = new byte[0],

                                           GroupID = UUID.Parse(notice[0]),

                                           Message = notice[6],

                                           noticeData = GND

                                       };



            return (!agentsCanBypassGroupNoticePermsCheck.Contains(requestingAgentID) &&

                    !CheckGroupPermissions(requestingAgentID, info.GroupID, (ulong) GroupPowers.ReceiveNotices))

                       ? null

                       : info;

        }



        private static GroupNoticeData GroupNoticeQueryResult2GroupNoticeData(List<string> result)

        {

            GroupNoticeData GND = new GroupNoticeData

                                      {

                                          GroupID = UUID.Parse(result[0]),

                                          NoticeID = UUID.Parse(result[6]),

                                          Timestamp = uint.Parse(result[1]),

                                          FromName = result[2],

                                          Subject = result[3],

                                          HasAttachment = int.Parse(result[5]) == 1

                                      };

            if (GND.HasAttachment)

            {

                GND.ItemID = UUID.Parse(result[4]);

                GND.AssetType = (byte) int.Parse(result[8]);

                GND.ItemName = result[9];

            }

            return GND;

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public List<GroupNoticeData> GetGroupNotices(UUID requestingAgentID, uint start, uint count, UUID GroupID)

        {

            object remoteValue = DoRemote(requestingAgentID, start, count, GroupID);

            if (remoteValue != null || m_doRemoteOnly)

                return (List<GroupNoticeData>) remoteValue;



            return GetGroupNotices(requestingAgentID, start, count, new List<UUID>(new[] {GroupID}));

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public List<GroupNoticeData> GetGroupNotices(UUID requestingAgentID, uint start, uint count, List<UUID> GroupIDs)

        {

            object remoteValue = DoRemote(requestingAgentID, start, count, GroupIDs);

            if (remoteValue != null || m_doRemoteOnly)

                return (List<GroupNoticeData>) remoteValue;



            List<UUID> groupIDs = new List<UUID>();

            if (!agentsCanBypassGroupNoticePermsCheck.Contains(requestingAgentID))

            {

#if (!ISWIN)

                foreach (UUID GroupID in GroupIDs)

                {

                    if (CheckGroupPermissions(requestingAgentID, GroupID, (ulong)GroupPowers.ReceiveNotices))

                    {

                        groupIDs.Add(GroupID);

                    }

                }

#else

                groupIDs.AddRange(

                    GroupIDs.Where(

                        GroupID => CheckGroupPermissions(requestingAgentID, GroupID, (ulong) GroupPowers.ReceiveNotices)));

#endif

            }

            else

            {

                groupIDs = GroupIDs;

            }



            List<GroupNoticeData> AllNotices = new List<GroupNoticeData>();

            if (groupIDs.Count > 0)

            {

                QueryFilter filter = new QueryFilter();

                filter.orMultiFilters["GroupID"] = new List<object>(groupIDs.Count);

                foreach (UUID groupID in groupIDs)

                {

                    filter.orMultiFilters["GroupID"].Add(groupID);

                }



                Dictionary<string, bool> sort = new Dictionary<string, bool>(1);

                sort["Timestamp"] = false;



                uint? s = null;

                if (start != 0)

                    s = start;

                uint? c = null;

                if (count != 0)

                    c = count;



                List<string> notice = data.Query(new[]

                                                     {

                                                         "GroupID",

                                                         "Timestamp",

                                                         "FromName",

                                                         "Subject",

                                                         "ItemID",

                                                         "HasAttachment",

                                                         "NoticeID",

                                                         "Message",

                                                         "AssetType",

                                                         "ItemName"

                                                     }, "osgroupnotice", filter, sort, s, c);



                for (int i = 0; i < notice.Count; i += 10)

                {

                    AllNotices.Add(GroupNoticeQueryResult2GroupNoticeData(notice.GetRange(i, 10)));

                }

            }

            return AllNotices;

        }



        [CanBeReflected(ThreatLevel = ThreatLevel.Low)]

        public GroupProfileData GetGroupProfile(UUID requestingAgentID, UUID GroupID)

        {

            object remoteValue = DoRemote(requestingAgentID, GroupID);

            if (remoteValue != null || m_doRemoteOnly)

                return (GroupProfileData) remoteValue;



            GroupProfileData profile = new GroupProfileData();



            GroupRecord groupInfo = GetGroupRecord(requestingAgentID, GroupID, null);

            if (groupInfo != null)

            {

                profile.AllowPublish = groupInfo.AllowPublish;

                profile.Charter = groupInfo.Charter;

                profile.FounderID = groupInfo.FounderID;

                profile.GroupID = GroupID;

                profile.GroupMembershipCount =

                    GetGroupMembers(requestingAgentID, GroupID).Count;

                profile.GroupRolesCount = GetGroupRoles(requestingAgentID, GroupID).Count;

                profile.InsigniaID = groupInfo.GroupPicture;

                profile.MaturePublish = groupInfo.MaturePublish;

                profile.MembershipFee = groupInfo.MembershipFee;

                profile.Money = 0; // TODO: Get this from the currency server?

                profile.Name = groupInfo.GroupName;

                profile.OpenEnrollment = groupInfo.OpenEnrollment;

                profile.OwnerRole = groupInfo.OwnerRoleID;

                profile.ShowInList = groupInfo.ShowInList;

            }



            GroupMembershipData memberInfo = GetGroupMembershipData(requestingAgentID,

                                                                    GroupID,

                                                                    requestingAgentID);

            if (memberInfo != null)

            {

                profile.MemberTitle = memberInfo.GroupTitle;

                profile.PowersMask = memberInfo.GroupPowers;

            }



            return profile;

        }



        #endregion



        public void Dispose()

        {

        }



        public bool CheckGroupPermissions(UUID AgentID, UUID GroupID, ulong Permissions)

        {

            if (GroupID == UUID.Zero)

                return false;



            if (AgentID == UUID.Zero)

                return false;



            GroupMembersData GMD = GetAgentGroupMemberData(AgentID, GroupID, AgentID);

            GroupRecord record = GetGroupRecord(AgentID, GroupID, null);

            if (Permissions == 0)

            {

                if (GMD != null || record.FounderID == AgentID || record.OpenEnrollment)

                    return true;

                return false;

            }



            if (record != null && record.FounderID == AgentID)

                return true;



            if (GMD == null)

                return false;



            if ((GMD.AgentPowers & Permissions) != Permissions)

                return false;



            return true;

        }

    }

}