OpenSim
/
OpenSimMirror
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Pare the groups module down to basics. Adjust dependent files so that a 

real groups module can even be implemented.
0.6.0-stable
Melanie Thielker 2008-10-21 22:54:31 +00:00
parent 6df1517b1f
commit f44742f75f
6 changed files with 101 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
OpenSim/Framework/LLGroup.cs → OpenSim/Framework/GroupData.cs
View File

@ -34,47 +34,24 @@ using System.Text;
namespace OpenSim.Framework
{
public class GroupData
public class GroupMembershipData
{
public string ActiveGroupTitle;
// Group base data
//
public UUID GroupID;
public List<UUID> GroupMembers;
public string groupName;
public uint groupPowers = (uint)(GroupPowers.AllowLandmark | GroupPowers.AllowSetHome);
public List<string> GroupTitles;
public bool AcceptNotices = true;
public string GroupName;
public bool AllowPublish = true;
public string Charter = "Cool Group Yeah!";
public int contribution = 0;
public UUID FounderID = UUID.Zero;
public int groupMembershipCost = 0;
public int groupRollsCount = 1;
public UUID GroupPicture = UUID.Zero;
public bool MaturePublish = true;
public UUID Charter = UUID.Zero;
public UUID FounderID = UUID.Zero;
public UUID GroupPicture = UUID.Zero;
public int MembershipFee = 0;
public bool OpenEnrollment = true;
public bool ShowInList = true;
public GroupData()
{
GroupTitles = new List<string>();
GroupMembers = new List<UUID>();
}
public GroupPowers ActiveGroupPowers
{
set { groupPowers = (uint)value; }
get { return (GroupPowers)groupPowers; }
}
}
public class GroupList
{
public List<UUID> m_GroupList;
public GroupList()
{
m_GroupList = new List<UUID>();
}
// Per user data
//
public bool AcceptNotices = true;
public int Contribution = 0;
public uint GroupPowers = 0;
}
}

2
OpenSim/Framework/IClientAPI.cs
View File

@ -845,7 +845,7 @@ namespace OpenSim.Framework
void SendAdminResponse(UUID Token, uint AdminLevel);
void SendGroupMembership(GroupData[] GroupMembership);
void SendGroupMembership(GroupMembershipData[] GroupMembership);
void SendGroupNameReply(UUID groupLLUID, string GroupName);

8
OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
View File

@ -6632,7 +6632,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
OutPacket(respondPacket, ThrottleOutPacketType.Task);
}
public void SendGroupMembership(GroupData[] GroupMembership)
public void SendGroupMembership(GroupMembershipData[] GroupMembership)
{
AgentGroupDataUpdatePacket Groupupdate = new AgentGroupDataUpdatePacket();
AgentGroupDataUpdatePacket.GroupDataBlock[] Groups = new AgentGroupDataUpdatePacket.GroupDataBlock[GroupMembership.Length];
@ -6640,11 +6640,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
{
AgentGroupDataUpdatePacket.GroupDataBlock Group = new AgentGroupDataUpdatePacket.GroupDataBlock();
Group.AcceptNotices = GroupMembership[i].AcceptNotices;
Group.Contribution = GroupMembership[i].contribution;
Group.Contribution = GroupMembership[i].Contribution;
Group.GroupID = GroupMembership[i].GroupID;
Group.GroupInsigniaID = GroupMembership[i].GroupPicture;
Group.GroupName = Utils.StringToBytes(GroupMembership[i].groupName);
Group.GroupPowers = GroupMembership[i].groupPowers;
Group.GroupName = Utils.StringToBytes(GroupMembership[i].GroupName);
Group.GroupPowers = GroupMembership[i].GroupPowers;
Groups[i] = Group;
Groupupdate.GroupData = Groups;

209
OpenSim/Region/Environment/Modules/Avatar/Groups/GroupsModule.cs
View File

@ -39,15 +39,22 @@ namespace OpenSim.Region.Environment.Modules.Avatar.Groups
{
public class GroupsModule : IRegionModule
{
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
private static readonly ILog m_log =
LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
private Dictionary<UUID, GroupList> m_grouplistmap = new Dictionary<UUID, GroupList>();
private Dictionary<UUID, GroupData> m_groupmap = new Dictionary<UUID, GroupData>();
private Dictionary<UUID, IClientAPI> m_iclientmap = new Dictionary<UUID, IClientAPI>();
private Dictionary<UUID, GroupData> m_groupUUIDGroup = new Dictionary<UUID, GroupData>();
private UUID opensimulatorGroupID = new UUID("00000000-68f9-1111-024e-222222111123");
private Dictionary<UUID, GroupMembershipData> m_GroupMap =
new Dictionary<UUID, GroupMembershipData>();
private List<Scene> m_scene = new List<Scene>();
private Dictionary<UUID, IClientAPI> m_ClientMap =
new Dictionary<UUID, IClientAPI>();
private UUID opensimulatorGroupID =
new UUID("00000000-68f9-1111-024e-222222111123");
private List<Scene> m_SceneList = new List<Scene>();
private static GroupMembershipData osGroup =
new GroupMembershipData();
#region IRegionModule Members
@ -73,26 +80,27 @@ namespace OpenSim.Region.Environment.Modules.Avatar.Groups
m_log.Info("[GROUPS] Activated default groups module");
lock (m_scene)
lock (m_SceneList)
{
m_scene.Add(scene);
if (!m_SceneList.Contains(scene))
{
if (m_SceneList.Count == 0)
{
osGroup.GroupID = opensimulatorGroupID;
osGroup.GroupName = "OpenSimulator Testing";
osGroup.GroupPowers =
(uint)(GroupPowers.AllowLandmark |
GroupPowers.AllowSetHome);
m_GroupMap[opensimulatorGroupID] = osGroup;
}
m_SceneList.Add(scene);
}
}
scene.EventManager.OnNewClient += OnNewClient;
scene.EventManager.OnClientClosed += OnClientClosed;
scene.EventManager.OnGridInstantMessageToGroupsModule += OnGridInstantMessage;
lock (m_groupUUIDGroup)
{
GroupData OpenSimulatorGroup = new GroupData();
OpenSimulatorGroup.ActiveGroupTitle = "OpenSimulator Tester";
OpenSimulatorGroup.GroupID = opensimulatorGroupID;
OpenSimulatorGroup.groupName = "OpenSimulator Testing";
OpenSimulatorGroup.ActiveGroupPowers = GroupPowers.AllowSetHome;
OpenSimulatorGroup.GroupTitles.Add("OpenSimulator Tester");
if (!m_groupUUIDGroup.ContainsKey(opensimulatorGroupID))
m_groupUUIDGroup.Add(opensimulatorGroupID, OpenSimulatorGroup);
}
//scene.EventManager.
scene.EventManager.OnGridInstantMessageToGroupsModule +=
OnGridInstantMessage;
}
public void PostInitialise()
@ -102,21 +110,15 @@ namespace OpenSim.Region.Environment.Modules.Avatar.Groups
public void Close()
{
m_log.Info("[GROUP]: Shutting down group module.");
lock (m_iclientmap)
lock (m_ClientMap)
{
m_iclientmap.Clear();
m_ClientMap.Clear();
}
lock (m_groupmap)
lock (m_GroupMap)
{
m_groupmap.Clear();
m_GroupMap.Clear();
}
lock (m_grouplistmap)
{
m_grouplistmap.Clear();
}
GC.Collect();
}
public string Name
@ -138,88 +140,42 @@ namespace OpenSim.Region.Environment.Modules.Avatar.Groups
client.OnInstantMessage += OnInstantMessage;
client.OnAgentDataUpdateRequest += OnAgentDataUpdateRequest;
client.OnUUIDGroupNameRequest += HandleUUIDGroupNameRequest;
lock (m_iclientmap)
lock (m_ClientMap)
{
if (!m_iclientmap.ContainsKey(client.AgentId))
if (!m_ClientMap.ContainsKey(client.AgentId))
{
m_iclientmap.Add(client.AgentId, client);
m_ClientMap.Add(client.AgentId, client);
}
}
GroupData OpenSimulatorGroup = null;
lock (m_groupUUIDGroup)
{
OpenSimulatorGroup = m_groupUUIDGroup[opensimulatorGroupID];
if (!OpenSimulatorGroup.GroupMembers.Contains(client.AgentId))
{
OpenSimulatorGroup.GroupMembers.Add(client.AgentId);
m_groupUUIDGroup[opensimulatorGroupID] = OpenSimulatorGroup;
}
}
m_log.Info("[GROUP]: Adding " + client.Name + " to " +
osGroup.GroupName + " ");
lock (m_groupmap)
{
if (!m_groupmap.ContainsKey(client.AgentId))
{
m_groupmap.Add(client.AgentId, OpenSimulatorGroup);
}
}
GroupList testGroupList = new GroupList();
testGroupList.m_GroupList.Add(OpenSimulatorGroup.GroupID);
lock (m_grouplistmap)
{
if (!m_grouplistmap.ContainsKey(client.AgentId))
{
m_grouplistmap.Add(client.AgentId, testGroupList);
}
}
m_log.Info("[GROUP]: Adding " + client.Name + " to " + OpenSimulatorGroup.groupName + " ");
GroupData[] updateGroups = new GroupData[1];
updateGroups[0] = OpenSimulatorGroup;
GroupMembershipData[] updateGroups = new GroupMembershipData[1];
updateGroups[0] = osGroup;
client.SendGroupMembership(updateGroups);
}
private void OnAgentDataUpdateRequest(IClientAPI remoteClient, UUID AgentID, UUID SessionID)
private void OnAgentDataUpdateRequest(IClientAPI remoteClient,
UUID AgentID, UUID SessionID)
{
// Adam, this is one of those impossible to refactor items without resorting to .Split hackery
UUID ActiveGroupID;
string ActiveGroupName;
uint ActiveGroupPowers;
string firstname = remoteClient.FirstName;
string lastname = remoteClient.LastName;
UUID ActiveGroupID = UUID.Zero;
uint ActiveGroupPowers = 0;
string ActiveGroupName = "OpenSimulator Tester";
string ActiveGroupTitle = "I IZ N0T";
bool foundUser = false;
ActiveGroupID = osGroup.GroupID;
ActiveGroupName = osGroup.GroupName;
ActiveGroupPowers = osGroup.GroupPowers;
lock (m_iclientmap)
{
if (m_iclientmap.ContainsKey(remoteClient.AgentId))
{
foundUser = true;
}
}
if (foundUser)
{
lock (m_groupmap)
{
if (m_groupmap.ContainsKey(remoteClient.AgentId))
{
GroupData grp = m_groupmap[remoteClient.AgentId];
if (grp != null)
{
ActiveGroupID = grp.GroupID;
ActiveGroupName = grp.groupName;
ActiveGroupPowers = grp.groupPowers;
ActiveGroupTitle = grp.ActiveGroupTitle;
}
remoteClient.SendAgentDataUpdate(AgentID, ActiveGroupID, firstname, lastname, ActiveGroupPowers, ActiveGroupName, ActiveGroupTitle);
}
}
}
remoteClient.SendAgentDataUpdate(AgentID, ActiveGroupID, firstname,
lastname, ActiveGroupPowers, ActiveGroupName,
ActiveGroupTitle);
}
private void OnInstantMessage(IClientAPI client, UUID fromAgentID,
@ -234,63 +190,54 @@ namespace OpenSim.Region.Environment.Modules.Avatar.Groups
private void OnGridInstantMessage(GridInstantMessage msg)
{
// Trigger the above event handler
OnInstantMessage(null, new UUID(msg.fromAgentID), new UUID(msg.fromAgentSession),
new UUID(msg.toAgentID), new UUID(msg.imSessionID), msg.timestamp, msg.fromAgentName,
msg.message, msg.dialog, msg.fromGroup, msg.offline, msg.ParentEstateID,
new Vector3(msg.Position.X, msg.Position.Y, msg.Position.Z), new UUID(msg.RegionID),
OnInstantMessage(null, new UUID(msg.fromAgentID),
new UUID(msg.fromAgentSession),
new UUID(msg.toAgentID), new UUID(msg.imSessionID),
msg.timestamp, msg.fromAgentName,
msg.message, msg.dialog, msg.fromGroup, msg.offline,
msg.ParentEstateID,
new Vector3(msg.Position.X, msg.Position.Y, msg.Position.Z),
new UUID(msg.RegionID),
msg.binaryBucket);
}
private void HandleUUIDGroupNameRequest(UUID id,IClientAPI remote_client)
{
string groupnamereply = "Unknown";
UUID groupUUID = UUID.Zero;
lock (m_groupUUIDGroup)
lock (m_GroupMap)
{
if (m_groupUUIDGroup.ContainsKey(id))
if (m_GroupMap.ContainsKey(id))
{
GroupData grp = m_groupUUIDGroup[id];
groupnamereply = grp.groupName;
GroupMembershipData grp = m_GroupMap[id];
groupnamereply = grp.GroupName;
groupUUID = grp.GroupID;
}
}
remote_client.SendGroupNameReply(groupUUID, groupnamereply);
}
private void OnClientClosed(UUID agentID)
{
lock (m_iclientmap)
lock (m_ClientMap)
{
if (m_iclientmap.ContainsKey(agentID))
if (m_ClientMap.ContainsKey(agentID))
{
IClientAPI cli = m_iclientmap[agentID];
IClientAPI cli = m_ClientMap[agentID];
if (cli != null)
{
m_log.Info("[GROUP]: Removing all reference to groups for " + cli.Name);
m_log.Info("[GROUP]: Removing all reference to groups "+
"for " + cli.Name);
}
else
{
m_log.Info("[GROUP]: Removing all reference to groups for " + agentID.ToString());
m_log.Info("[GROUP]: Removing all reference to groups "+
"for " + agentID.ToString());
}
m_ClientMap.Remove(agentID);
}
}
m_iclientmap.Remove(agentID);
}
}
lock (m_groupmap)
{
if (m_groupmap.ContainsKey(agentID))
{
m_groupmap.Remove(agentID);
}
}
lock (m_grouplistmap)
{
if (m_grouplistmap.ContainsKey(agentID))
{
m_grouplistmap.Remove(agentID);
}
}
GC.Collect();
}
}
}

2
OpenSim/Region/Environment/Modules/World/NPC/NPCAvatar.cs
View File

@ -109,7 +109,7 @@ namespace OpenSim.Region.Environment.Modules.World.NPC
}
public void SendGroupMembership(GroupData[] GroupMembership)
public void SendGroupMembership(GroupMembershipData[] GroupMembership)
{
}

2
OpenSim/Region/Examples/SimpleModule/MyNpcCharacter.cs
View File

@ -667,7 +667,7 @@ namespace OpenSim.Region.Examples.SimpleModule
}
public void SendGroupMembership(GroupData[] GroupMembership)
public void SendGroupMembership(GroupMembershipData[] GroupMembership)
{
}