Bring Core Groups up to current version

1 files changed, 310 insertions, 120 deletions

diff --git a/OpenSim/Addons/Groups/GroupsMessagingModule.cs b/OpenSim/Addons/Groups/GroupsMessagingModule.cs
index d172d48..be59c62 100644
--- a/OpenSim/Addons/Groups/GroupsMessagingModule.cs
+++ b/OpenSim/Addons/Groups/GroupsMessagingModule.cs
@@ -39,6 +39,7 @@ using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Services.Interfaces;
 using PresenceInfo = OpenSim.Services.Interfaces.PresenceInfo;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
 
 namespace OpenSim.Groups
 {
@@ -51,7 +52,7 @@ namespace OpenSim.Groups
         private IPresenceService m_presenceService;
 
         private IMessageTransferModule m_msgTransferModule = null;
-
+        private IUserManagement m_UserManagement = null;
         private IGroupsServicesConnector m_groupData = null;
 
         // Config Options
@@ -79,6 +80,10 @@ namespace OpenSim.Groups
 
         private int m_usersOnlineCacheExpirySeconds = 20;
 
+        private Dictionary<UUID, List<string>> m_groupsAgentsDroppedFromChatSession = new Dictionary<UUID, List<string>>();
+        private Dictionary<UUID, List<string>> m_groupsAgentsInvitedToChatSession = new Dictionary<UUID, List<string>>();
+
+
         #region Region Module interfaceBase Members
 
         public void Initialise(IConfigSource config)
@@ -124,10 +129,12 @@ namespace OpenSim.Groups
             m_sceneList.Add(scene);
 
             scene.EventManager.OnNewClient += OnNewClient;
+            scene.EventManager.OnMakeRootAgent += OnMakeRootAgent;
+            scene.EventManager.OnMakeChildAgent += OnMakeChildAgent;
             scene.EventManager.OnIncomingInstantMessage += OnGridInstantMessage;
             scene.EventManager.OnClientLogin += OnClientLogin;
         }
-        
+
         public void RegionLoaded(Scene scene)
         {
             if (!m_groupMessagingEnabled)
@@ -155,6 +162,17 @@ namespace OpenSim.Groups
                 return;
             }
 
+            m_UserManagement = scene.RequestModuleInterface<IUserManagement>();
+
+            // No groups module, no groups messaging
+            if (m_UserManagement == null)
+            {
+                m_log.Error("[Groups.Messaging]: Could not get IUserManagement, GroupsMessagingModule is now disabled.");
+                RemoveRegion(scene);
+                return;
+            }
+
+
             if (m_presenceService == null)
                 m_presenceService = scene.PresenceService;
 
@@ -227,87 +245,107 @@ namespace OpenSim.Groups
         
         public void SendMessageToGroup(GridInstantMessage im, UUID groupID)
         {
-            List<GroupMembersData> groupMembers = m_groupData.GetGroupMembers(new UUID(im.fromAgentID).ToString(), groupID);
+            UUID fromAgentID = new UUID(im.fromAgentID);
+            List<GroupMembersData> groupMembers = m_groupData.GetGroupMembers(UUID.Zero.ToString(), groupID);
             int groupMembersCount = groupMembers.Count;
+            PresenceInfo[] onlineAgents = null;
 
-            if (m_messageOnlineAgentsOnly)
-            {
-                string[] t1 = groupMembers.ConvertAll<string>(gmd => gmd.AgentID.ToString()).ToArray();
+            // In V2 we always only send to online members.
+            // Sending to offline members is not an option.
+            string[] t1 = groupMembers.ConvertAll<string>(gmd => gmd.AgentID.ToString()).ToArray();
 
-                // We cache in order not to overwhlem the presence service on large grids with many groups.  This does
-                // mean that members coming online will not see all group members until after m_usersOnlineCacheExpirySeconds has elapsed.
-                // (assuming this is the same across all grid simulators).
-                PresenceInfo[] onlineAgents;
-                if (!m_usersOnlineCache.TryGetValue(groupID, out onlineAgents))
-                {
-                    onlineAgents = m_presenceService.GetAgents(t1);
-                    m_usersOnlineCache.Add(groupID, onlineAgents, m_usersOnlineCacheExpirySeconds);
-                }
+            // We cache in order not to overwhlem the presence service on large grids with many groups.  This does
+            // mean that members coming online will not see all group members until after m_usersOnlineCacheExpirySeconds has elapsed.
+            // (assuming this is the same across all grid simulators).
+            if (!m_usersOnlineCache.TryGetValue(groupID, out onlineAgents))
+            {
+                onlineAgents = m_presenceService.GetAgents(t1);
+                m_usersOnlineCache.Add(groupID, onlineAgents, m_usersOnlineCacheExpirySeconds);
+            }
 
-                HashSet<string> onlineAgentsUuidSet = new HashSet<string>();
-                Array.ForEach<PresenceInfo>(onlineAgents, pi => onlineAgentsUuidSet.Add(pi.UserID));
+            HashSet<string> onlineAgentsUuidSet = new HashSet<string>();
+            Array.ForEach<PresenceInfo>(onlineAgents, pi => onlineAgentsUuidSet.Add(pi.UserID));
 
-                groupMembers = groupMembers.Where(gmd => onlineAgentsUuidSet.Contains(gmd.AgentID.ToString())).ToList();
+            groupMembers = groupMembers.Where(gmd => onlineAgentsUuidSet.Contains(gmd.AgentID.ToString())).ToList();
 
-    //            if (m_debugEnabled)
+//            if (m_debugEnabled)
 //                    m_log.DebugFormat(
 //                        "[Groups.Messaging]: SendMessageToGroup called for group {0} with {1} visible members, {2} online",
 //                        groupID, groupMembersCount, groupMembers.Count());
-            }
-            else
+
+            int requestStartTick = Environment.TickCount;
+
+            im.imSessionID = groupID.Guid;
+            im.fromGroup = true;
+            IClientAPI thisClient = GetActiveClient(fromAgentID);
+            if (thisClient != null)
             {
-                if (m_debugEnabled)
-                    m_log.DebugFormat(
-                        "[Groups.Messaging]: SendMessageToGroup called for group {0} with {1} visible members",
-                        groupID, groupMembers.Count);
+                im.RegionID = thisClient.Scene.RegionInfo.RegionID.Guid;
             }
 
-            int requestStartTick = Environment.TickCount;
+            // Send to self first of all
+            im.toAgentID = im.fromAgentID;
+            im.fromGroup = true;
+            ProcessMessageFromGroupSession(im);
 
+            List<UUID> regions = new List<UUID>();
+            List<UUID> clientsAlreadySent = new List<UUID>();
+
+            // Then send to everybody else
             foreach (GroupMembersData member in groupMembers)
             {
-                if (m_groupData.hasAgentDroppedGroupChatSession(member.AgentID.ToString(), groupID))
+                if (member.AgentID.Guid == im.fromAgentID)
+                    continue;
+
+                if (clientsAlreadySent.Contains(member.AgentID))
+                    continue;
+                clientsAlreadySent.Add(member.AgentID);
+
+                if (hasAgentDroppedGroupChatSession(member.AgentID.ToString(), groupID))
                 {
                     // Don't deliver messages to people who have dropped this session
                     if (m_debugEnabled) m_log.DebugFormat("[Groups.Messaging]: {0} has dropped session, not delivering to them", member.AgentID);
                     continue;
                 }
 
-                // Copy Message
-                GridInstantMessage msg = new GridInstantMessage();
-                msg.imSessionID = groupID.Guid;
-                msg.fromAgentName = im.fromAgentName;
-                msg.message = im.message;
-                msg.dialog = im.dialog;
-                msg.offline = im.offline;
-                msg.ParentEstateID = im.ParentEstateID;
-                msg.Position = im.Position;
-                msg.RegionID = im.RegionID;
-                msg.binaryBucket = im.binaryBucket;
-                msg.timestamp = (uint)Util.UnixTimeSinceEpoch();
-
-                msg.fromAgentID = im.fromAgentID;
-                msg.fromGroup = true;
-
-                msg.toAgentID = member.AgentID.Guid;
+                im.toAgentID = member.AgentID.Guid;
 
                 IClientAPI client = GetActiveClient(member.AgentID);
                 if (client == null)
                 {
                     // If they're not local, forward across the grid
+                    // BUT do it only once per region, please! Sim would be even better!
                     if (m_debugEnabled) m_log.DebugFormat("[Groups.Messaging]: Delivering to {0} via Grid", member.AgentID);
-                    m_msgTransferModule.SendInstantMessage(msg, delegate(bool success) { });
+
+                    bool reallySend = true;
+                    if (onlineAgents != null)
+                    {
+                        PresenceInfo presence = onlineAgents.First(p => p.UserID == member.AgentID.ToString());
+                        if (regions.Contains(presence.RegionID))
+                            reallySend = false;
+                        else
+                            regions.Add(presence.RegionID);
+                    }
+
+                    if (reallySend)
+                    {
+                        // We have to create a new IM structure because the transfer module
+                        // uses async send
+                        GridInstantMessage msg = new GridInstantMessage(im, true);
+                        m_msgTransferModule.SendInstantMessage(msg, delegate(bool success) { });
+                    }
                 }
                 else
                 {
                     // Deliver locally, directly
                     if (m_debugEnabled) m_log.DebugFormat("[Groups.Messaging]: Passing to ProcessMessageFromGroupSession to deliver to {0} locally", client.Name);
-                    ProcessMessageFromGroupSession(msg);
+
+                    ProcessMessageFromGroupSession(im);
                 }
+
             }
 
-            // Temporary for assessing how long it still takes to send messages to large online groups.
-            if (m_messageOnlineAgentsOnly)
+            if (m_debugEnabled)
                 m_log.DebugFormat(
                     "[Groups.Messaging]: SendMessageToGroup for group {0} with {1} visible members, {2} online took {3}ms",
                     groupID, groupMembersCount, groupMembers.Count(), Environment.TickCount - requestStartTick);
@@ -324,9 +362,20 @@ namespace OpenSim.Groups
         {
             if (m_debugEnabled) m_log.DebugFormat("[Groups.Messaging]: OnInstantMessage registered for {0}", client.Name);
 
-            client.OnInstantMessage += OnInstantMessage;
+            ResetAgentGroupChatSessions(client.AgentId.ToString());
+        }
+
+        void OnMakeRootAgent(ScenePresence sp)
+        {
+            sp.ControllingClient.OnInstantMessage += OnInstantMessage;
+        }
+
+        void OnMakeChildAgent(ScenePresence sp)
+        {
+            sp.ControllingClient.OnInstantMessage -= OnInstantMessage;
         }
 
+
         private void OnGridInstantMessage(GridInstantMessage msg)
         {
             // The instant message module will only deliver messages of dialog types:
@@ -335,21 +384,91 @@ namespace OpenSim.Groups
             // Any other message type will not be delivered to a client by the 
             // Instant Message Module
 
-
+            UUID regionID = new UUID(msg.RegionID);
             if (m_debugEnabled)
             {
-                m_log.DebugFormat("[Groups.Messaging]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+                m_log.DebugFormat("[Groups.Messaging]: {0} called, IM from region {1}", 
+                    System.Reflection.MethodBase.GetCurrentMethod().Name, regionID);
 
                 DebugGridInstantMessage(msg);
             }
 
             // Incoming message from a group
-            if ((msg.fromGroup == true) && 
-                ((msg.dialog == (byte)InstantMessageDialog.SessionSend)
-                 || (msg.dialog == (byte)InstantMessageDialog.SessionAdd)
-                 || (msg.dialog == (byte)InstantMessageDialog.SessionDrop)))
+            if ((msg.fromGroup == true) && (msg.dialog == (byte)InstantMessageDialog.SessionSend))
             {
-                ProcessMessageFromGroupSession(msg);
+                // We have to redistribute the message across all members of the group who are here
+                // on this sim
+
+                UUID GroupID = new UUID(msg.imSessionID);
+
+                Scene aScene = m_sceneList[0];
+                GridRegion regionOfOrigin = aScene.GridService.GetRegionByUUID(aScene.RegionInfo.ScopeID, regionID);
+
+                List<GroupMembersData> groupMembers = m_groupData.GetGroupMembers(UUID.Zero.ToString(), GroupID);
+
+                //if (m_debugEnabled)
+                //    foreach (GroupMembersData m in groupMembers)
+                //        m_log.DebugFormat("[Groups.Messaging]: member {0}", m.AgentID);
+
+                foreach (Scene s in m_sceneList)
+                {
+                    s.ForEachScenePresence(sp =>
+                        {
+                            // If we got this via grid messaging, it's because the caller thinks
+                            // that the root agent is here. We should only send the IM to root agents.
+                            if (sp.IsChildAgent)
+                                return;
+
+                            GroupMembersData m = groupMembers.Find(gmd =>
+                                {
+                                    return gmd.AgentID == sp.UUID;
+                                });
+                            if (m.AgentID == UUID.Zero)
+                            {
+                                if (m_debugEnabled)
+                                    m_log.DebugFormat("[Groups.Messaging]: skipping agent {0} because he is not a member of the group", sp.UUID);
+                                return;
+                            }
+
+                            // Check if the user has an agent in the region where
+                            // the IM came from, and if so, skip it, because the IM
+                            // was already sent via that agent
+                            if (regionOfOrigin != null)
+                            {
+                                AgentCircuitData aCircuit = s.AuthenticateHandler.GetAgentCircuitData(sp.UUID);
+                                if (aCircuit != null)
+                                {
+                                    if (aCircuit.ChildrenCapSeeds.Keys.Contains(regionOfOrigin.RegionHandle))
+                                    {
+                                        if (m_debugEnabled)
+                                            m_log.DebugFormat("[Groups.Messaging]: skipping agent {0} because he has an agent in region of origin", sp.UUID);
+                                        return;
+                                    }
+                                    else                                
+                                    {
+                                        if (m_debugEnabled)
+                                            m_log.DebugFormat("[Groups.Messaging]: not skipping agent {0}", sp.UUID);
+                                    }
+                                }
+                            }
+
+                            UUID AgentID = sp.UUID;
+                            msg.toAgentID = AgentID.Guid;
+
+                            if (!hasAgentDroppedGroupChatSession(AgentID.ToString(), GroupID))
+                            {
+                                if (!hasAgentBeenInvitedToGroupChatSession(AgentID.ToString(), GroupID))
+                                    AddAgentToSession(AgentID, GroupID, msg);
+                                else
+                                {
+                                    if (m_debugEnabled) m_log.DebugFormat("[Groups.Messaging]: Passing to ProcessMessageFromGroupSession to deliver to {0} locally", sp.Name);
+
+                                    ProcessMessageFromGroupSession(msg);
+                                }
+                            }
+                        });
+                        
+                }
             }
         }
 
@@ -359,82 +478,40 @@ namespace OpenSim.Groups
 
             UUID AgentID = new UUID(msg.fromAgentID);
             UUID GroupID = new UUID(msg.imSessionID);
+            UUID toAgentID = new UUID(msg.toAgentID);
 
             switch (msg.dialog)
             {
                 case (byte)InstantMessageDialog.SessionAdd:
-                    m_groupData.AgentInvitedToGroupChatSession(AgentID.ToString(), GroupID);
+                    AgentInvitedToGroupChatSession(AgentID.ToString(), GroupID);
                     break;
 
                 case (byte)InstantMessageDialog.SessionDrop:
-                    m_groupData.AgentDroppedFromGroupChatSession(AgentID.ToString(), GroupID);
+                    AgentDroppedFromGroupChatSession(AgentID.ToString(), GroupID);
                     break;
 
                 case (byte)InstantMessageDialog.SessionSend:
-                    if (!m_groupData.hasAgentDroppedGroupChatSession(AgentID.ToString(), GroupID)
-                        && !m_groupData.hasAgentBeenInvitedToGroupChatSession(AgentID.ToString(), GroupID)
-                        )
+                    // User hasn't dropped, so they're in the session, 
+                    // maybe we should deliver it.
+                    IClientAPI client = GetActiveClient(new UUID(msg.toAgentID));
+                    if (client != null)
                     {
-                        // Agent not in session and hasn't dropped from session
-                        // Add them to the session for now, and Invite them
-                        m_groupData.AgentInvitedToGroupChatSession(AgentID.ToString(), GroupID);
+                        // Deliver locally, directly
+                        if (m_debugEnabled) m_log.DebugFormat("[Groups.Messaging]: Delivering to {0} locally", client.Name);
 
-                        UUID toAgentID = new UUID(msg.toAgentID);
-                        IClientAPI activeClient = GetActiveClient(toAgentID);
-                        if (activeClient != null)
+                        if (!hasAgentDroppedGroupChatSession(toAgentID.ToString(), GroupID))
                         {
-                            GroupRecord groupInfo = m_groupData.GetGroupRecord(UUID.Zero.ToString(), GroupID, null);
-                            if (groupInfo != null)
-                            {
-                                if (m_debugEnabled) m_log.DebugFormat("[Groups.Messaging]: Sending chatterbox invite instant message");
-
-                                // Force? open the group session dialog???
-                                // and simultanously deliver the message, so we don't need to do a seperate client.SendInstantMessage(msg);
-                                IEventQueue eq = activeClient.Scene.RequestModuleInterface<IEventQueue>();
-                                eq.ChatterboxInvitation(
-                                    GroupID
-                                    , groupInfo.GroupName
-                                    , new UUID(msg.fromAgentID)
-                                    , msg.message
-                                    , new UUID(msg.toAgentID)
-                                    , msg.fromAgentName
-                                    , msg.dialog
-                                    , msg.timestamp
-                                    , msg.offline == 1
-                                    , (int)msg.ParentEstateID
-                                    , msg.Position
-                                    , 1
-                                    , new UUID(msg.imSessionID)
-                                    , msg.fromGroup
-                                    , OpenMetaverse.Utils.StringToBytes(groupInfo.GroupName)
-                                    );
-
-                                eq.ChatterBoxSessionAgentListUpdates(
-                                    new UUID(GroupID)
-                                    , new UUID(msg.fromAgentID)
-                                    , new UUID(msg.toAgentID)
-                                    , false //canVoiceChat
-                                    , false //isModerator
-                                    , false //text mute
-                                    );
-                            }
+                            if (!hasAgentBeenInvitedToGroupChatSession(toAgentID.ToString(), GroupID))
+                                // This actually sends the message too, so no need to resend it
+                                // with client.SendInstantMessage
+                                AddAgentToSession(toAgentID, GroupID, msg);
+                            else
+                                client.SendInstantMessage(msg);
                         }
                     }
-                    else if (!m_groupData.hasAgentDroppedGroupChatSession(AgentID.ToString(), GroupID))
+                    else
                     {
-                        // User hasn't dropped, so they're in the session, 
-                        // maybe we should deliver it.
-                        IClientAPI client = GetActiveClient(new UUID(msg.toAgentID));
-                        if (client != null)
-                        {
-                            // Deliver locally, directly
-                            if (m_debugEnabled) m_log.DebugFormat("[Groups.Messaging]: Delivering to {0} locally", client.Name);
-                            client.SendInstantMessage(msg);
-                        }
-                        else
-                        {
-                            m_log.WarnFormat("[Groups.Messaging]: Received a message over the grid for a client that isn't here: {0}", msg.toAgentID);
-                        }
+                        m_log.WarnFormat("[Groups.Messaging]: Received a message over the grid for a client that isn't here: {0}", msg.toAgentID);
                     }
                     break;
 
@@ -444,6 +521,53 @@ namespace OpenSim.Groups
             }
         }
 
+        private void AddAgentToSession(UUID AgentID, UUID GroupID, GridInstantMessage msg)
+        {
+            // Agent not in session and hasn't dropped from session
+            // Add them to the session for now, and Invite them
+            AgentInvitedToGroupChatSession(AgentID.ToString(), GroupID);
+
+            IClientAPI activeClient = GetActiveClient(AgentID);
+            if (activeClient != null)
+            {
+                GroupRecord groupInfo = m_groupData.GetGroupRecord(UUID.Zero.ToString(), GroupID, null);
+                if (groupInfo != null)
+                {
+                    if (m_debugEnabled) m_log.DebugFormat("[Groups.Messaging]: Sending chatterbox invite instant message");
+
+                    // Force? open the group session dialog???
+                    // and simultanously deliver the message, so we don't need to do a seperate client.SendInstantMessage(msg);
+                    IEventQueue eq = activeClient.Scene.RequestModuleInterface<IEventQueue>();
+                    eq.ChatterboxInvitation(
+                        GroupID
+                        , groupInfo.GroupName
+                        , new UUID(msg.fromAgentID)
+                        , msg.message
+                        , AgentID
+                        , msg.fromAgentName
+                        , msg.dialog
+                        , msg.timestamp
+                        , msg.offline == 1
+                        , (int)msg.ParentEstateID
+                        , msg.Position
+                        , 1
+                        , new UUID(msg.imSessionID)
+                        , msg.fromGroup
+                        , OpenMetaverse.Utils.StringToBytes(groupInfo.GroupName)
+                        );
+
+                    eq.ChatterBoxSessionAgentListUpdates(
+                        new UUID(GroupID)
+                        , AgentID
+                        , new UUID(msg.toAgentID)
+                        , false //canVoiceChat
+                        , false //isModerator
+                        , false //text mute
+                        );
+                }
+            }
+        }
+
         #endregion
 
 
@@ -469,7 +593,7 @@ namespace OpenSim.Groups
     
                 if (groupInfo != null)
                 {
-                    m_groupData.AgentInvitedToGroupChatSession(AgentID.ToString(), GroupID);
+                    AgentInvitedToGroupChatSession(AgentID.ToString(), GroupID);
 
                     ChatterBoxSessionStartReplyViaCaps(remoteClient, groupInfo.GroupName, GroupID);
 
@@ -495,7 +619,7 @@ namespace OpenSim.Groups
                     m_log.DebugFormat("[Groups.Messaging]: Send message to session for group {0} with session ID {1}", GroupID, im.imSessionID.ToString());
 
                 //If this agent is sending a message, then they want to be in the session
-                m_groupData.AgentInvitedToGroupChatSession(AgentID.ToString(), GroupID);
+                AgentInvitedToGroupChatSession(AgentID.ToString(), GroupID);
 
                 SendMessageToGroup(im, GroupID);
             }
@@ -566,12 +690,12 @@ namespace OpenSim.Groups
                 {
                     if (!sp.IsChildAgent)
                     {
-                        if (m_debugEnabled) m_log.WarnFormat("[Groups.Messaging]: Found root agent for client : {0}", sp.ControllingClient.Name);
+                        if (m_debugEnabled) m_log.DebugFormat("[Groups.Messaging]: Found root agent for client : {0}", sp.ControllingClient.Name);
                         return sp.ControllingClient;
                     }
                     else
                     {
-                        if (m_debugEnabled) m_log.WarnFormat("[Groups.Messaging]: Found child agent for client : {0}", sp.ControllingClient.Name);
+                        if (m_debugEnabled) m_log.DebugFormat("[Groups.Messaging]: Found child agent for client : {0}", sp.ControllingClient.Name);
                         child = sp.ControllingClient;
                     }
                 }
@@ -590,5 +714,71 @@ namespace OpenSim.Groups
         }
 
         #endregion
+
+        #region GroupSessionTracking
+
+        public void ResetAgentGroupChatSessions(string agentID)
+        {
+            foreach (List<string> agentList in m_groupsAgentsDroppedFromChatSession.Values)
+                agentList.Remove(agentID);
+
+            foreach (List<string> agentList in m_groupsAgentsInvitedToChatSession.Values)
+                agentList.Remove(agentID);
+        }
+
+        public bool hasAgentBeenInvitedToGroupChatSession(string agentID, UUID groupID)
+        {
+            // If we're  tracking this group, and we can find them in the tracking, then they've been invited
+            return m_groupsAgentsInvitedToChatSession.ContainsKey(groupID)
+                && m_groupsAgentsInvitedToChatSession[groupID].Contains(agentID);
+        }
+
+        public bool hasAgentDroppedGroupChatSession(string agentID, UUID groupID)
+        {
+            // If we're tracking drops for this group,
+            // and we find them, well... then they've dropped
+            return m_groupsAgentsDroppedFromChatSession.ContainsKey(groupID)
+                && m_groupsAgentsDroppedFromChatSession[groupID].Contains(agentID);
+        }
+
+        public void AgentDroppedFromGroupChatSession(string agentID, UUID groupID)
+        {
+            if (m_groupsAgentsDroppedFromChatSession.ContainsKey(groupID))
+            {
+                // If not in dropped list, add
+                if (!m_groupsAgentsDroppedFromChatSession[groupID].Contains(agentID))
+                {
+                    m_groupsAgentsDroppedFromChatSession[groupID].Add(agentID);
+                }
+            }
+        }
+
+        public void AgentInvitedToGroupChatSession(string agentID, UUID groupID)
+        {
+            // Add Session Status if it doesn't exist for this session
+            CreateGroupChatSessionTracking(groupID);
+
+            // If nessesary, remove from dropped list
+            if (m_groupsAgentsDroppedFromChatSession[groupID].Contains(agentID))
+            {
+                m_groupsAgentsDroppedFromChatSession[groupID].Remove(agentID);
+            }
+
+            // Add to invited
+            if (!m_groupsAgentsInvitedToChatSession[groupID].Contains(agentID))
+                m_groupsAgentsInvitedToChatSession[groupID].Add(agentID);
+        }
+
+        private void CreateGroupChatSessionTracking(UUID groupID)
+        {
+            if (!m_groupsAgentsDroppedFromChatSession.ContainsKey(groupID))
+            {
+                m_groupsAgentsDroppedFromChatSession.Add(groupID, new List<string>());
+                m_groupsAgentsInvitedToChatSession.Add(groupID, new List<string>());
+            }
+
+        }
+        #endregion
+
     }
 }