public void RegisterCaps(IRegionClientCapsService service)
{
IConfig displayNamesConfig = service.ClientCaps.Registry.RequestModuleInterface<ISimulationBase>().ConfigSource.Configs["DisplayNamesModule"];
if (displayNamesConfig != null)
{
if (!displayNamesConfig.GetBoolean ("Enabled", true))
return;
string bannedNamesString = displayNamesConfig.GetString ("BannedUserNames", "");
if (bannedNamesString != "")
bannedNames = new List<string> (bannedNamesString.Split (','));
}
m_service = service;
m_profileConnector = Aurora.DataManager.DataManager.RequestPlugin<IProfileConnector> ();
m_eventQueue = service.Registry.RequestModuleInterface<IEventQueueService> ();
m_userService = service.Registry.RequestModuleInterface<IUserAccountService> ();
string post = CapsUtil.CreateCAPS ("SetDisplayName", "");
service.AddCAPS ("SetDisplayName", post);
service.AddStreamHandler ("SetDisplayName", new RestHTTPHandler ("POST", post,
ProcessSetDisplayName));
post = CapsUtil.CreateCAPS ("GetDisplayNames", "");
service.AddCAPS ("GetDisplayNames", post);
service.AddStreamHandler ("GetDisplayNames", new StreamHandler ("GET", post,
ProcessGetDisplayName));
}
public void RegisterCaps (IRegionClientCapsService service)
{
var cfgservice = service.ClientCaps.Registry.RequestModuleInterface<ISimulationBase> ();
var displayNamesConfig = cfgservice.ConfigSource.Configs ["DisplayNames"];
if (displayNamesConfig != null) {
if (!displayNamesConfig.GetBoolean ("Enabled", true))
return;
string bannedNamesString = displayNamesConfig.GetString ("BannedUserNames", "");
if (bannedNamesString != "")
bannedNames = new List<string> (bannedNamesString.Split (','));
m_update_days = displayNamesConfig.GetDouble ("UpdateDays", m_update_days);
}
m_service = service;
m_profileConnector = Framework.Utilities.DataManager.RequestPlugin<IProfileConnector> ();
m_eventQueue = service.Registry.RequestModuleInterface<IEventQueueService> ();
m_userService = service.Registry.RequestModuleInterface<IUserAccountService> ();
string post = CapsUtil.CreateCAPS ("SetDisplayName", "");
service.AddStreamHandler ("SetDisplayName", new GenericStreamHandler ("POST", post, ProcessSetDisplayName));
post = CapsUtil.CreateCAPS ("GetDisplayNames", "");
service.AddStreamHandler ("GetDisplayNames", new GenericStreamHandler ("GET", post, ProcessGetDisplayName));
}
private void MuteUser(UUID sessionid, IEventQueueService eq, UUID AgentID, ChatSessionMember thismember,
bool forward)
{
ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock block =
new ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock
{
AgentID = thismember.AvatarKey,
CanVoiceChat = thismember.CanVoiceChat,
IsModerator = thismember.IsModerator,
MuteText = thismember.MuteText,
MuteVoice = thismember.MuteVoice,
Transition = "ENTER"
};
// Send an update to the affected user
IClientAPI affectedUser = GetActiveClient(thismember.AvatarKey);
if (affectedUser != null)
{
eq.ChatterBoxSessionAgentListUpdates(sessionid, new[] { block }, AgentID, "ENTER",
affectedUser.Scene.RegionInfo.RegionHandle);
}
else if (forward)
{
SendMutedUserIM(thismember, sessionid);
}
}
public void OpenRegionInfo(IScenePresence presence)
{
OSD item = BuildOpenRegionInfo(presence);
IEventQueueService eq = presence.Scene.RequestModuleInterface<IEventQueueService>();
if (eq != null)
eq.Enqueue(item, presence.UUID, presence.Scene.RegionInfo.RegionID);
}
private byte[] GetObjectPhysicsData(UUID agentID, Stream request)
{
OSDMap rm = (OSDMap)OSDParser.DeserializeLLSDXml(request);
OSDArray keys = (OSDArray)rm["object_ids"];
IEventQueueService eqs = m_scene.RequestModuleInterface <IEventQueueService>();
if (eqs != null)
{
#if (!ISWIN)
List <ISceneChildEntity> list = new List <ISceneChildEntity>();
foreach (OSD key in keys)
{
list.Add(m_scene.GetSceneObjectPart(key.AsUUID()));
}
eqs.ObjectPhysicsProperties(list.ToArray(),
agentID, m_scene.RegionInfo.RegionHandle);
#else
eqs.ObjectPhysicsProperties(keys.Select(key => m_scene.GetSceneObjectPart(key.AsUUID())).ToArray(), agentID, m_scene.RegionInfo.RegionHandle);
#endif
}
//Send back data
return(new byte[0]);
}
public void RegisterCaps(IRegionClientCapsService service)
{
IConfig displayNamesConfig =
service.ClientCaps.Registry.RequestModuleInterface <ISimulationBase>().ConfigSource.Configs[
"DisplayNamesModule"];
if (displayNamesConfig != null)
{
if (!displayNamesConfig.GetBoolean("Enabled", true))
{
return;
}
string bannedNamesString = displayNamesConfig.GetString("BannedUserNames", "");
if (bannedNamesString != "")
{
bannedNames = new List <string>(bannedNamesString.Split(','));
}
}
m_service = service;
m_profileConnector = Framework.Utilities.DataManager.RequestPlugin <IProfileConnector>();
m_eventQueue = service.Registry.RequestModuleInterface <IEventQueueService>();
m_userService = service.Registry.RequestModuleInterface <IUserAccountService>();
string post = CapsUtil.CreateCAPS("SetDisplayName", "");
service.AddStreamHandler("SetDisplayName", new GenericStreamHandler("POST", post,
ProcessSetDisplayName));
post = CapsUtil.CreateCAPS("GetDisplayNames", "");
service.AddStreamHandler("GetDisplayNames", new GenericStreamHandler("GET", post,
ProcessGetDisplayName));
}
private Hashtable GetObjectPhysicsData(UUID agentID, Hashtable mDhttpMethod)
{
OSDMap rm = (OSDMap)OSDParser.DeserializeLLSDXml((string)mDhttpMethod["requestbody"]);
OSDArray keys = (OSDArray)rm["object_ids"];
IEventQueueService eqs = m_scene.RequestModuleInterface <IEventQueueService>();
if (eqs != null)
{
#if (!ISWIN)
List <ISceneChildEntity> list = new List <ISceneChildEntity>();
foreach (OSD key in keys)
{
list.Add(m_scene.GetSceneObjectPart(key.AsUUID()));
}
eqs.ObjectPhysicsProperties(list.ToArray(),
agentID, m_scene.RegionInfo.RegionHandle);
#else
eqs.ObjectPhysicsProperties(keys.Select(key => m_scene.GetSceneObjectPart(key.AsUUID())).ToArray(), agentID, m_scene.RegionInfo.RegionHandle);
#endif
}
//Send back data
Hashtable responsedata = new Hashtable();
responsedata["int_response_code"] = 200; //501; //410; //404;
responsedata["content_type"] = "text/plain";
responsedata["keepalive"] = false;
responsedata["str_response_string"] = "";
return(responsedata);
}
public DeviceBatchManagementController(IEventQueueService eventQueueService,
IOptions <CapBusOptions> capBusOptions,
IDeviceService deviceService,
ICurrent current,
IDbContext dbContext,
IConfiguration configuration,
IMemoryCache memoryCache,
IBackgroundJobManager backgroundJobManager,
ILogger <DeviceBatchManagementController> logger,
IMediator mediator,
ICapPublisher capPublisher,
TracerFactory tracerFactor,
Tracer tracer,
DbContextFactory dbContextFactory,
ICache cache)
{
_eventQueueService = eventQueueService;
_capBusOptions = capBusOptions?.Value;
_deviceService = deviceService;
_current = current;
_dbContext = dbContext;
_configuration = configuration;
_logger = logger;
_backgroundJobManager = backgroundJobManager;
_mediator = mediator;
_capBus = capPublisher;
_tracerFactory = tracerFactor;
_tracer = tracer;
_dbContextFactory = dbContextFactory;
_cache = cache;
}
public EQMEventPoster(string url, IEventQueueService handler, ICapsService capsService, ulong handle, IRegistryCore registry) :
base("POST", url)
{
m_eventQueueService = handler;
m_capsService = capsService;
m_ourRegionHandle = handle;
m_registry = registry;
}
/// <summary>
/// Create forwarder
/// </summary>
/// <param name="queue"></param>
public UnknownTelemetryForwarder(IEventQueueService queue)
{
if (queue == null)
{
throw new ArgumentNullException(nameof(queue));
}
_client = queue.OpenAsync().Result;
}
/// <summary>
/// Create forwarder
/// </summary>
/// <param name="queue"></param>
public MonitoredItemSampleForwarder(IEventQueueService queue)
{
if (queue == null)
{
throw new ArgumentNullException(nameof(queue));
}
_client = queue.OpenAsync().Result;
}
private void OnInstantMessage(IClientAPI remoteClient, GridInstantMessage im)
{
if (m_debugEnabled)
{
m_log.DebugFormat("[GROUPS-MESSAGING]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
DebugGridInstantMessage(im);
}
// Start group IM session
if ((im.dialog == (byte)InstantMessageDialog.SessionGroupStart))
{
if (m_debugEnabled)
{
m_log.InfoFormat("[GROUPS-MESSAGING]: imSessionID({0}) toAgentID({1})", im.imSessionID, im.toAgentID);
}
UUID GroupID = new UUID(im.imSessionID);
UUID AgentID = new UUID(im.fromAgentID);
GroupRecord groupInfo = m_groupData.GetGroupRecord(UUID.Zero, GroupID, null);
if (groupInfo != null)
{
m_groupData.AgentInvitedToGroupChatSession(AgentID, GroupID);
ChatterBoxSessionStartReplyViaCaps(remoteClient, groupInfo.GroupName, GroupID);
IEventQueueService queue = remoteClient.Scene.RequestModuleInterface <IEventQueueService>();
queue.ChatterBoxSessionAgentListUpdates(
GroupID
, AgentID
, new UUID(im.toAgentID)
, false //canVoiceChat
, false //isModerator
, false //text mute
, remoteClient.Scene.RegionInfo.RegionHandle
);
}
}
// Send a message from locally connected client to a group
if ((im.dialog == (byte)InstantMessageDialog.SessionSend) && im.message != "")
{
UUID GroupID = new UUID(im.imSessionID);
UUID AgentID = new UUID(im.fromAgentID);
if (m_debugEnabled)
{
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, GroupID);
SendMessageToGroup(im, GroupID);
}
}
/// <summary>
/// Remove the member from this session
/// </summary>
/// <param name = "client"></param>
/// <param name = "im"></param>
public void DropMemberFromSession(IClientAPI client, GridInstantMessage im)
{
ChatSession session;
ChatSessions.TryGetValue(im.imSessionID, out session);
if (session == null)
{
return;
}
ChatSessionMember member = new ChatSessionMember {
AvatarKey = UUID.Zero
};
#if (!ISWIN)
foreach (ChatSessionMember testmember in session.Members)
{
if (testmember.AvatarKey == im.fromAgentID)
{
member = testmember;
}
}
#else
foreach (ChatSessionMember testmember in session.Members.Where(testmember => testmember.AvatarKey == im.fromAgentID))
{
member = testmember;
}
#endif
if (member.AvatarKey != UUID.Zero)
{
session.Members.Remove(member);
}
if (session.Members.Count == 0)
{
ChatSessions.Remove(session.SessionID);
return;
}
ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock block =
new ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock
{
AgentID = member.AvatarKey,
CanVoiceChat = member.CanVoiceChat,
IsModerator = member.IsModerator,
MuteText = member.MuteText,
MuteVoice = member.MuteVoice,
Transition = "LEAVE"
};
IEventQueueService eq = client.Scene.RequestModuleInterface <IEventQueueService>();
foreach (ChatSessionMember sessionMember in session.Members)
{
eq.ChatterBoxSessionAgentListUpdates(session.SessionID, new[] { block }, sessionMember.AvatarKey, "LEAVE",
findScene(sessionMember.AvatarKey).RegionInfo.RegionHandle);
}
}
public void SendProfileToClientEQ(IScenePresence presence, RegionLightShareData wl)
{
OSD item = BuildSendEQMessage(wl.ToOSD());
IEventQueueService eq = presence.Scene.RequestModuleInterface <IEventQueueService>();
if (eq != null)
{
eq.Enqueue(item, presence.UUID, presence.Scene.RegionInfo.RegionHandle);
}
}
/// <summary>
/// Create forwarder
/// </summary>
/// <param name="queue"></param>
/// <param name="serializer"></param>
public MonitoredItemSampleForwarder(IEventQueueService queue,
IJsonSerializer serializer)
{
_serializer = serializer ??
throw new ArgumentNullException(nameof(serializer));
if (queue == null)
{
throw new ArgumentNullException(nameof(queue));
}
_client = queue.OpenAsync().Result;
}
public void FinishedStartup ()
{
m_eventQueueService = m_registry.RequestModuleInterface<IEventQueueService> ();
ISyncMessageRecievedService syncRecievedService =
m_registry.RequestModuleInterface<ISyncMessageRecievedService> ();
if (syncRecievedService != null)
syncRecievedService.OnMessageReceived += syncRecievedService_OnMessageReceived;
m_groupData = Framework.Utilities.DataManager.RequestPlugin<IGroupsServiceConnector> ();
m_registry.RequestModuleInterface<ISimulationBase> ().EventManager.RegisterEventHandler ("UserStatusChange",
OnGenericEvent);
}
public void TriggerWindlightUpdate(int interpolate)
{
foreach (IScenePresence presence in m_scene.GetScenePresences())
{
OSD item = BuildEQM(interpolate);
IEventQueueService eq = presence.Scene.RequestModuleInterface <IEventQueueService>();
if (eq != null)
{
eq.Enqueue(item, presence.UUID, presence.Scene.RegionInfo.RegionID);
}
}
}
/// <summary>
/// Send a console message to the viewer
/// </summary>
/// <param name="AgentID"></param>
/// <param name="text"></param>
private void SendConsoleEventEQM(UUID AgentID, string text)
{
OSDMap item = new OSDMap {
{ "body", text }, { "message", OSD.FromString("SimConsoleResponse") }
};
IEventQueueService eq = m_Scene.RequestModuleInterface <IEventQueueService>();
if (eq != null)
{
eq.Enqueue(item, AgentID, m_Scene.RegionInfo.RegionID);
}
}
public EventQueueJob(ILogger <EventQueueJob> logger, ICache cache, ICurrent current, IDataContainer dataContainer, ITypeFinder typeFinder, ITypeResolve typeResolve, IDeviceService deviceService, IDbContext dbContext, IEventQueueService eventQueueService, ICapPublisher capPublisher)
{
_logger = logger;
_cache = cache;
_current = current;
_dataContainer = dataContainer;
_typeFinder = typeFinder;
_typeResolve = typeResolve;
_deviceService = deviceService;
_dbContext = dbContext;
_eventQueueService = eventQueueService;
_capBus = capPublisher;
}
public void FinishedStartup()
{
m_eventQueueService = m_registry.RequestModuleInterface <IEventQueueService> ();
ISyncMessageRecievedService syncRecievedService = m_registry.RequestModuleInterface <ISyncMessageRecievedService> ();
if (syncRecievedService != null)
{
syncRecievedService.OnMessageReceived += syncRecievedService_OnMessageReceived;
}
m_groupData = Framework.Utilities.DataManager.RequestPlugin <IGroupsServiceConnector> ();
m_registry.RequestModuleInterface <ISimulationBase> ().EventManager.RegisterEventHandler("UserStatusChange",
OnGenericEvent);
}
/// <summary>
/// Send a console message to the viewer
/// </summary>
/// <param name="AgentID"></param>
/// <param name="text"></param>
private void SendConsoleEventEQM(UUID AgentID, string text)
{
OSDMap item = new OSDMap();
item.Add("body", text);
item.Add("message", OSD.FromString("SimConsoleResponse"));
IEventQueueService eq = m_scenes[0].RequestModuleInterface <IEventQueueService> ();
if (eq != null)
{
eq.Enqueue(item, AgentID, findScene(AgentID).RegionInfo.RegionHandle);
}
}
private void ChatterBoxSessionStartReplyViaCaps(IClientAPI remoteClient, string groupName, UUID groupID)
{
if (m_debugEnabled)
{
MainConsole.Instance.DebugFormat("[GROUPS-MESSAGING]: {0} called", MethodBase.GetCurrentMethod().Name);
}
IEventQueueService queue = remoteClient.Scene.RequestModuleInterface <IEventQueueService>();
if (queue != null)
{
queue.ChatterBoxSessionStartReply(groupName, groupID,
remoteClient.AgentId, remoteClient.Scene.RegionInfo.RegionHandle);
}
}
private byte[] GetObjectPhysicsData(UUID agentID, Stream request)
{
OSDMap rm = (OSDMap)OSDParser.DeserializeLLSDXml(HttpServerHandlerHelpers.ReadFully(request));
OSDArray keys = (OSDArray)rm["object_ids"];
IEventQueueService eqs = m_scene.RequestModuleInterface <IEventQueueService>();
if (eqs != null)
{
eqs.ObjectPhysicsProperties(keys.Select(key => m_scene.GetSceneObjectPart(key.AsUUID())).ToArray(),
agentID, m_scene.RegionInfo.RegionID);
}
//Send back data
return(new byte[0]);
}
/// <summary>
/// Remove the member from this session
/// </summary>
/// <param name="client"></param>
/// <param name="im"></param>
public void DropMemberFromSession(IClientAPI client, GridInstantMessage im)
{
ChatSession session;
ChatSessions.TryGetValue(UUID.Parse(im.imSessionID.ToString()), out session);
if (session == null)
{
return;
}
ChatSessionMember member = new ChatSessionMember()
{
AvatarKey = UUID.Zero
};
foreach (ChatSessionMember testmember in session.Members)
{
if (member.AvatarKey == UUID.Parse(im.fromAgentID.ToString()))
{
member = testmember;
}
}
if (member.AvatarKey != UUID.Zero)
{
session.Members.Remove(member);
}
if (session.Members.Count == 0)
{
ChatSessions.Remove(session.SessionID);
return;
}
OpenMetaverse.Messages.Linden.ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock block = new OpenMetaverse.Messages.Linden.ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock();
block.AgentID = member.AvatarKey;
block.CanVoiceChat = member.CanVoiceChat;
block.IsModerator = member.IsModerator;
block.MuteText = member.MuteText;
block.MuteVoice = member.MuteVoice;
block.Transition = "LEAVE";
IEventQueueService eq = client.Scene.RequestModuleInterface <IEventQueueService>();
foreach (ChatSessionMember sessionMember in session.Members)
{
eq.ChatterBoxSessionAgentListUpdates(session.SessionID, new OpenMetaverse.Messages.Linden.ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock[] { block }, sessionMember.AvatarKey, "LEAVE", findScene(sessionMember.AvatarKey).RegionInfo.RegionHandle);
}
}
/// <summary>
/// Send chat to all the members of this friend conference
/// </summary>
/// <param name="client"></param>
/// <param name="im"></param>
public void SendChatToSession(IClientAPI client, GridInstantMessage im)
{
ChatSession session;
ChatSessions.TryGetValue(UUID.Parse(im.imSessionID.ToString()), out session);
if (session == null)
{
return;
}
IEventQueueService eq = client.Scene.RequestModuleInterface <IEventQueueService>();
foreach (ChatSessionMember member in session.Members)
{
if (member.HasBeenAdded)
{
im.toAgentID = member.AvatarKey.Guid;
im.binaryBucket = OpenMetaverse.Utils.StringToBytes(session.Name);
im.RegionID = Guid.Empty;
im.ParentEstateID = 0;
//im.timestamp = 0;
m_TransferModule.SendInstantMessage(im);
}
else
{
im.toAgentID = member.AvatarKey.Guid;
eq.ChatterboxInvitation(
session.SessionID
, session.Name
, new UUID(im.fromAgentID)
, im.message
, new UUID(im.toAgentID)
, im.fromAgentName
, im.dialog
, im.timestamp
, im.offline == 1
, (int)im.ParentEstateID
, im.Position
, 1
, new UUID(im.imSessionID)
, false
, OpenMetaverse.Utils.StringToBytes(session.Name)
, findScene(member.AvatarKey).RegionInfo.RegionHandle
);
}
}
}
public EQMEventPoster(string url, IEventQueueService handler, ICapsService capsService, string SessionID,
IRegistryCore registry) :
base("POST", url)
{
m_eventQueueService = handler;
m_capsService = capsService;
m_SessionID = SessionID;
if (!ulong.TryParse(SessionID, out m_ourRegionHandle))
{
string[] split = SessionID.Split('|');
if (split.Length == 2)
{
ulong.TryParse(split[1], out m_ourRegionHandle);
}
}
m_registry = registry;
}
public void AddRegion(IScene scene)
{
if (!m_enabled)
{
return;
}
m_Scene = scene;
// set up event queue for messaging
msgQ = m_Scene.RequestModuleInterface <IEventQueueService> ();
if (msgQ == null)
{
m_enabled = false; // no point if we cannot send messages
MainConsole.Instance.Warn("[Sim console]: Disabled as no message queue is available.");
return;
}
scene.EventManager.OnRegisterCaps += OnRegisterCaps;
scene.EventManager.OnMakeRootAgent += EventManager_OnMakeRootAgent;
scene.EventManager.OnMakeChildAgent += EventManager_OnMakeChildAgent;
}
public void PostInitialize(IConfigSource config, IRegistryCore registry)
{
service = registry.RequestModuleInterface<IEventQueueService>();
capsService = registry.RequestModuleInterface<ICapsService>();
}
public void RegionLoaded(Scene scene)
{
m_eventQueue = scene.RequestModuleInterface<IEventQueueService>();
m_profileConnector = Aurora.DataManager.DataManager.RequestPlugin<IProfileConnector>();
}
public EQMEventPoster(string url, IEventQueueService handler, ICapsService capsService, string SessionID,
IRegistryCore registry) :
base("POST", url)
{
m_eventQueueService = handler;
m_capsService = capsService;
m_SessionID = SessionID;
if (!ulong.TryParse(SessionID, out m_ourRegionHandle))
{
string[] split = SessionID.Split('|');
if (split.Length == 2)
ulong.TryParse(split[1], out m_ourRegionHandle);
}
m_registry = registry;
}
private void MuteUser(UUID sessionid, IEventQueueService eq, UUID AgentID, ChatSessionMember thismember,
bool forward)
{
ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock block =
new ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock
{
AgentID = thismember.AvatarKey,
CanVoiceChat = thismember.CanVoiceChat,
IsModerator = thismember.IsModerator,
MuteText = thismember.MuteText,
MuteVoice = thismember.MuteVoice,
Transition = "ENTER"
};
// Send an update to the affected user
IClientAPI affectedUser = GetActiveClient(thismember.AvatarKey);
if (affectedUser != null)
eq.ChatterBoxSessionAgentListUpdates(sessionid, new[] {block}, AgentID, "ENTER",
affectedUser.Scene.RegionInfo.RegionHandle);
else if (forward)
SendMutedUserIM(thismember, sessionid);
}
public bool CrossAgent(GridRegion crossingRegion, Vector3 pos,
Vector3 velocity, AgentCircuitData circuit, AgentData cAgent, UUID AgentID, ulong requestingRegion, out string reason)
{
try
{
IClientCapsService clientCaps = m_registry.RequestModuleInterface <ICapsService>().GetClientCapsService(AgentID);
IRegionClientCapsService requestingRegionCaps = clientCaps.GetCapsService(requestingRegion);
ISimulationService SimulationService = m_registry.RequestModuleInterface <ISimulationService>();
if (SimulationService != null)
{
//Note: we have to pull the new grid region info as the one from the region cannot be trusted
IGridService GridService = m_registry.RequestModuleInterface <IGridService>();
if (GridService != null)
{
//Set the user in transit so that we block duplicate tps and reset any cancelations
if (!SetUserInTransit(AgentID))
{
reason = "Already in a teleport";
return(false);
}
bool result = false;
crossingRegion = GridService.GetRegionByUUID(UUID.Zero, crossingRegion.RegionID);
if (!SimulationService.UpdateAgent(crossingRegion, cAgent))
{
m_log.Warn("[AgentProcessing]: Failed to cross agent " + AgentID + " because region did not accept it. Resetting.");
reason = "Failed to update an agent";
}
else
{
IEventQueueService EQService = m_registry.RequestModuleInterface <IEventQueueService>();
//Add this for the viewer, but not for the sim, seems to make the viewer happier
int XOffset = crossingRegion.RegionLocX - requestingRegionCaps.RegionX;
pos.X += XOffset;
int YOffset = crossingRegion.RegionLocY - requestingRegionCaps.RegionY;
pos.Y += YOffset;
IRegionClientCapsService otherRegion = clientCaps.GetCapsService(crossingRegion.RegionHandle);
//Tell the client about the transfer
EQService.CrossRegion(crossingRegion.RegionHandle, pos, velocity, crossingRegion.ExternalEndPoint, otherRegion.CapsUrl,
AgentID, circuit.SessionID,
crossingRegion.RegionSizeX, crossingRegion.RegionSizeY,
requestingRegion);
result = WaitForCallback(AgentID);
if (!result)
{
m_log.Warn("[AgentProcessing]: Callback never came in crossing agent " + circuit.AgentID + ". Resetting.");
reason = "Crossing timed out";
}
else
{
// Next, let's close the child agent connections that are too far away.
INeighborService service = m_registry.RequestModuleInterface <INeighborService>();
if (service != null)
{
//Fix the root agent status
otherRegion.RootAgent = true;
requestingRegionCaps.RootAgent = false;
CloseNeighborAgents(requestingRegionCaps.Region, crossingRegion, AgentID);
}
reason = "";
}
}
//All done
ResetFromTransit(AgentID);
return(result);
}
else
{
reason = "Could not find the GridService";
}
}
else
{
reason = "Could not find the SimulationService";
}
}
catch (Exception ex)
{
m_log.WarnFormat("[AgentProcessing]: Failed to cross an agent into a new region. {0}", ex.ToString());
}
ResetFromTransit(AgentID);
reason = "Exception occured";
return(false);
}
/// <summary>
/// Async component for informing client of which neighbors exist
/// </summary>
/// <remarks>
/// This needs to run asynchronously, as a network timeout may block the thread for a long while
/// </remarks>
/// <param name="remoteClient"></param>
/// <param name="a"></param>
/// <param name="regionHandle"></param>
/// <param name="endPoint"></param>
private bool InformClientOfNeighbor(UUID AgentID, ulong requestingRegion, AgentCircuitData circuitData, GridRegion neighbor,
uint TeleportFlags, AgentData agentData, out string reason)
{
if (neighbor == null)
{
reason = "Could not find neighbor to inform";
return(false);
}
m_log.Info("[AgentProcessing]: Starting to inform client about neighbor " + neighbor.RegionName);
//Notes on this method
// 1) the SimulationService.CreateAgent MUST have a fixed CapsUrl for the region, so we have to create (if needed)
// a new Caps handler for it.
// 2) Then we can call the methods (EnableSimulator and EstatablishAgentComm) to tell the client the new Urls
// 3) This allows us to make the Caps on the grid server without telling any other regions about what the
// Urls are.
ISimulationService SimulationService = m_registry.RequestModuleInterface <ISimulationService>();
if (SimulationService != null)
{
ICapsService capsService = m_registry.RequestModuleInterface <ICapsService>();
IClientCapsService clientCaps = capsService.GetClientCapsService(AgentID);
IRegionClientCapsService oldRegionService = clientCaps.GetCapsService(neighbor.RegionHandle);
//If its disabled, it should be removed, so kill it!
if (oldRegionService != null && oldRegionService.Disabled)
{
clientCaps.RemoveCAPS(neighbor.RegionHandle);
oldRegionService = null;
}
bool newAgent = oldRegionService == null;
IRegionClientCapsService otherRegionService = clientCaps.GetOrCreateCapsService(neighbor.RegionHandle,
CapsUtil.GetCapsSeedPath(CapsUtil.GetRandomCapsObjectPath()), circuitData);
if (!newAgent)
{
//Note: if the agent is already there, send an agent update then
bool result = true;
if (agentData != null)
{
result = SimulationService.UpdateAgent(neighbor, agentData);
if (result)
{
oldRegionService.Disabled = false;
}
}
reason = "";
return(result);
}
ICommunicationService commsService = m_registry.RequestModuleInterface <ICommunicationService>();
if (commsService != null)
{
circuitData.OtherInformation["UserUrls"] = commsService.GetUrlsForUser(neighbor, circuitData.AgentID);
}
#region OpenSim teleport compatibility!
if (!m_useCallbacks)
{
circuitData.CapsPath = CapsUtil.GetRandomCapsObjectPath();
circuitData.startpos.X += (neighbor.RegionLocX - clientCaps.GetRootCapsService().RegionX);
circuitData.startpos.Y += (neighbor.RegionLocY - clientCaps.GetRootCapsService().RegionY);
}
#endregion
bool regionAccepted = SimulationService.CreateAgent(neighbor, circuitData,
TeleportFlags, agentData, out reason);
if (regionAccepted)
{
string otherRegionsCapsURL;
//If the region accepted us, we should get a CAPS url back as the reason, if not, its not updated or not an Aurora region, so don't touch it.
if (reason != "")
{
OSDMap responseMap = (OSDMap)OSDParser.DeserializeJson(reason);
OSDMap SimSeedCaps = (OSDMap)responseMap["CapsUrls"];
otherRegionService.AddCAPS(SimSeedCaps);
otherRegionsCapsURL = otherRegionService.CapsUrl;
}
else
{
//We are assuming an OpenSim region now!
#region OpenSim teleport compatibility!
otherRegionsCapsURL = "http://" + otherRegionService.Region.ExternalEndPoint.ToString() +
CapsUtil.GetCapsSeedPath(circuitData.CapsPath);
otherRegionService.CapsUrl = otherRegionsCapsURL;
#endregion
}
IEventQueueService EQService = m_registry.RequestModuleInterface <IEventQueueService>();
EQService.EnableSimulator(neighbor.RegionHandle,
neighbor.ExternalEndPoint.Address.GetAddressBytes(),
neighbor.ExternalEndPoint.Port, AgentID,
neighbor.RegionSizeX, neighbor.RegionSizeY, requestingRegion);
// EnableSimulator makes the client send a UseCircuitCode message to the destination,
// which triggers a bunch of things there.
// So let's wait
Thread.Sleep(300);
EQService.EstablishAgentCommunication(AgentID, neighbor.RegionHandle,
neighbor.ExternalEndPoint.Address.GetAddressBytes(),
neighbor.ExternalEndPoint.Port, otherRegionsCapsURL, neighbor.RegionSizeX,
neighbor.RegionSizeY,
requestingRegion);
if (!m_useCallbacks)
{
Thread.Sleep(3000); //Give it a bit of time
}
m_log.Info("[AgentProcessing]: Completed inform client about neighbor " + neighbor.RegionName);
}
else
{
m_log.Error("[AgentProcessing]: Failed to inform client about neighbor " + neighbor.RegionName + ", reason: " + reason);
return(false);
}
return(true);
}
reason = "SimulationService does not exist";
m_log.Error("[AgentProcessing]: Failed to inform client about neighbor " + neighbor.RegionName + ", reason: " + reason + "!");
return(false);
}
public bool TeleportAgent(GridRegion destination, uint TeleportFlags, int DrawDistance,
AgentCircuitData circuit, AgentData agentData, UUID AgentID, ulong requestingRegion,
out string reason)
{
IClientCapsService clientCaps = m_registry.RequestModuleInterface <ICapsService>().GetClientCapsService(AgentID);
IRegionClientCapsService regionCaps = clientCaps.GetCapsService(requestingRegion);
if (regionCaps == null || !regionCaps.RootAgent)
{
reason = "";
return(false);
}
bool result = false;
try
{
bool callWasCanceled = false;
ISimulationService SimulationService = m_registry.RequestModuleInterface <ISimulationService>();
if (SimulationService != null)
{
//Set the user in transit so that we block duplicate tps and reset any cancelations
if (!SetUserInTransit(AgentID))
{
reason = "Already in a teleport";
return(false);
}
//Note: we have to pull the new grid region info as the one from the region cannot be trusted
IGridService GridService = m_registry.RequestModuleInterface <IGridService>();
if (GridService != null)
{
destination = GridService.GetRegionByUUID(UUID.Zero, destination.RegionID);
//Inform the client of the neighbor if needed
circuit.child = false; //Force child status to the correct type
if (!InformClientOfNeighbor(AgentID, requestingRegion, circuit, destination, TeleportFlags,
agentData, out reason))
{
ResetFromTransit(AgentID);
return(false);
}
}
else
{
reason = "Could not find the grid service";
ResetFromTransit(AgentID);
return(false);
}
IEventQueueService EQService = m_registry.RequestModuleInterface <IEventQueueService>();
IRegionClientCapsService otherRegion = clientCaps.GetCapsService(destination.RegionHandle);
EQService.TeleportFinishEvent(destination.RegionHandle, destination.Access, destination.ExternalEndPoint, otherRegion.CapsUrl,
4, AgentID, TeleportFlags,
destination.RegionSizeX, destination.RegionSizeY,
requestingRegion);
// TeleportFinish makes the client send CompleteMovementIntoRegion (at the destination), which
// trigers a whole shebang of things there, including MakeRoot. So let's wait for confirmation
// that the client contacted the destination before we send the attachments and close things here.
result = WaitForCallback(AgentID, out callWasCanceled);
if (!result)
{
//It says it failed, lets call the sim and check
IAgentData data = null;
result = SimulationService.RetrieveAgent(destination, AgentID, out data);
}
if (!result)
{
if (!callWasCanceled)
{
m_log.Warn("[AgentProcessing]: Callback never came for teleporting agent " +
AgentID + ". Resetting.");
}
INeighborService service = m_registry.RequestModuleInterface <INeighborService>();
if (service != null)
{
//Close the agent at the place we just created if it isn't a neighbor
if (service.IsOutsideView(regionCaps.RegionX, destination.RegionLocX, regionCaps.Region.RegionSizeX, destination.RegionSizeX,
regionCaps.RegionY, destination.RegionLocY, regionCaps.Region.RegionSizeY, destination.RegionSizeY))
{
SimulationService.CloseAgent(destination, AgentID);
}
}
clientCaps.RemoveCAPS(destination.RegionHandle);
if (!callWasCanceled)
{
reason = "The teleport timed out";
}
else
{
reason = "Cancelled";
}
}
else
{
//Fix the root agent status
otherRegion.RootAgent = true;
regionCaps.RootAgent = false;
// Next, let's close the child agent connections that are too far away.
CloseNeighborAgents(regionCaps.Region, destination, AgentID);
reason = "";
}
}
else
{
reason = "No SimulationService found!";
}
}
catch (Exception ex)
{
m_log.WarnFormat("[AgentProcessing]: Exception occured during agent teleport, {0}", ex.ToString());
reason = "Exception occured.";
}
//All done
ResetFromTransit(AgentID);
return(result);
}
public EQMEventPoster(string url, IEventQueueService handler, ICapsService capsService, ulong handle, IRegistryCore registry) :
base("POST", url)
{
m_eventQueueService = handler;
m_capsService = capsService;
m_ourRegionHandle = handle;
m_registry = registry;
}
protected OSDMap OnMessageReceived(OSDMap message)
{
//We need to check and see if this is an GroupSessionAgentUpdate
if (message.ContainsKey("Method") && message ["Method"] == "GroupSessionAgentUpdate")
{
//COMES IN ON WhiteCore.SERVER SIDE
//Send it on to whomever it concerns
OSDMap innerMessage = (OSDMap)message ["Message"];
if (innerMessage ["message"] == "ChatterBoxSessionAgentListUpdates")
// ONLY forward on this type of message
{
UUID agentID = message ["AgentID"];
IEventQueueService eqs = m_registry.RequestModuleInterface <IEventQueueService> ();
IAgentInfoService agentInfo = m_registry.RequestModuleInterface <IAgentInfoService> ();
if (agentInfo != null)
{
UserInfo user = agentInfo.GetUserInfo(agentID.ToString());
if (user != null && user.IsOnline)
{
eqs.Enqueue(innerMessage, agentID, user.CurrentRegionID);
}
}
}
}
else if (message.ContainsKey("Method") && message ["Method"] == "FixGroupRoleTitles")
{
// This message comes in on WhiteCore.Server side from the region
UUID groupID = message ["GroupID"].AsUUID();
UUID agentID = message ["AgentID"].AsUUID();
UUID roleID = message ["RoleID"].AsUUID();
byte type = (byte)message ["Type"].AsInteger();
IGroupsServiceConnector con = Framework.Utilities.DataManager.RequestPlugin <IGroupsServiceConnector> ();
List <GroupRoleMembersData> members = con.GetGroupRoleMembers(agentID, groupID);
List <GroupRolesData> roles = con.GetGroupRoles(agentID, groupID);
GroupRolesData everyone = null;
foreach (GroupRolesData role in roles.Where(role => role.Name == "Everyone"))
{
everyone = role;
}
List <UserInfo> regionsToBeUpdated = new List <UserInfo> ();
foreach (GroupRoleMembersData data in members)
{
if (data.RoleID == roleID)
{
// They were affected by the change
switch ((GroupRoleUpdate)type)
{
case GroupRoleUpdate.Create:
case GroupRoleUpdate.NoUpdate: // No changes...
break;
case GroupRoleUpdate.UpdatePowers: // Possible we don't need to send this?
case GroupRoleUpdate.UpdateAll:
case GroupRoleUpdate.UpdateData:
case GroupRoleUpdate.Delete:
if (type == (byte)GroupRoleUpdate.Delete)
{
// Set them to the most limited role since their role is gone
con.SetAgentGroupSelectedRole(data.MemberID, groupID, everyone.RoleID);
}
// Need to update their title inworld
IAgentInfoService agentInfoService = m_registry.RequestModuleInterface <IAgentInfoService> ();
UserInfo info;
if (agentInfoService != null &&
(info = agentInfoService.GetUserInfo(agentID.ToString())) != null && info.IsOnline)
{
// Forward the message
regionsToBeUpdated.Add(info);
}
break;
}
}
}
if (regionsToBeUpdated.Count != 0)
{
ISyncMessagePosterService messagePost = m_registry.RequestModuleInterface <ISyncMessagePosterService> ();
if (messagePost != null)
{
foreach (UserInfo userInfo in regionsToBeUpdated)
{
OSDMap outgoingMessage = new OSDMap();
outgoingMessage ["Method"] = "ForceUpdateGroupTitles";
outgoingMessage ["GroupID"] = groupID;
outgoingMessage ["RoleID"] = roleID;
outgoingMessage ["RegionID"] = userInfo.CurrentRegionID;
messagePost.Post(userInfo.CurrentRegionURI, outgoingMessage);
}
}
}
}
else if (message.ContainsKey("Method") && message ["Method"] == "ForceUpdateGroupTitles")
{
// This message comes in on the region side from WhiteCore.Server
UUID groupID = message ["GroupID"].AsUUID();
UUID roleID = message ["RoleID"].AsUUID();
UUID regionID = message ["RegionID"].AsUUID();
IGroupsModule gm = m_registry.RequestModuleInterface <IGroupsModule> ();
if (gm != null)
{
gm.UpdateUsersForExternalRoleUpdate(groupID, roleID, regionID);
}
}
return(null);
}
public EQMEventPoster(IEventQueueService handler, ICapsService capsService) :
base("POST", "/CAPS/EQMPOSTER")
{
m_eventQueueService = handler;
m_capsService = capsService;
}
protected OSDMap OnMessageReceived(OSDMap message)
{
//We need to check and see if this is an GroupSessionAgentUpdate
if (message.ContainsKey("Method") && message["Method"] == "GroupSessionAgentUpdate")
{
//COMES IN ON AURORA.SERVER SIDE
//Send it on to whomever it concerns
OSDMap innerMessage = (OSDMap)message["Message"];
if (innerMessage["message"] == "ChatterBoxSessionAgentListUpdates")
//ONLY forward on this type of message
{
UUID agentID = message["AgentID"];
IEventQueueService eqs = m_registry.RequestModuleInterface <IEventQueueService>();
ICapsService caps = m_registry.RequestModuleInterface <ICapsService>();
if (caps != null)
{
IClientCapsService clientCaps = caps.GetClientCapsService(agentID);
if (clientCaps != null && clientCaps.GetRootCapsService() != null)
{
eqs.Enqueue(innerMessage, agentID, clientCaps.GetRootCapsService().RegionHandle);
}
}
}
}
else if (message.ContainsKey("Method") && message["Method"] == "FixGroupRoleTitles")
{
//COMES IN ON AURORA.SERVER SIDE FROM REGION
UUID groupID = message["GroupID"].AsUUID();
UUID agentID = message["AgentID"].AsUUID();
UUID roleID = message["RoleID"].AsUUID();
byte type = (byte)message["Type"].AsInteger();
IGroupsServiceConnector con = DataManager.RequestPlugin <IGroupsServiceConnector>();
List <GroupRoleMembersData> members = con.GetGroupRoleMembers(agentID, groupID);
List <GroupRolesData> roles = con.GetGroupRoles(agentID, groupID);
GroupRolesData everyone = null;
#if (!ISWIN)
foreach (GroupRolesData role in roles)
{
if (role.Name == "Everyone")
{
everyone = role;
}
}
#else
foreach (GroupRolesData role in roles.Where(role => role.Name == "Everyone"))
{
everyone = role;
}
#endif
List <ulong> regionsToBeUpdated = new List <ulong>();
foreach (GroupRoleMembersData data in members)
{
if (data.RoleID == roleID)
{
//They were affected by the change
switch ((GroupRoleUpdate)type)
{
case GroupRoleUpdate.Create:
case GroupRoleUpdate.NoUpdate:
//No changes...
break;
case GroupRoleUpdate.UpdatePowers: //Possible we don't need to send this?
case GroupRoleUpdate.UpdateAll:
case GroupRoleUpdate.UpdateData:
case GroupRoleUpdate.Delete:
if (type == (byte)GroupRoleUpdate.Delete)
{
//Set them to the most limited role since their role is gone
con.SetAgentGroupSelectedRole(data.MemberID, groupID, everyone.RoleID);
}
//Need to update their title inworld
ICapsService caps = m_registry.RequestModuleInterface <ICapsService>();
if (caps != null)
{
IClientCapsService clientCaps = caps.GetClientCapsService(agentID);
if (clientCaps != null && clientCaps.GetRootCapsService() != null)
{
regionsToBeUpdated.Add(clientCaps.GetRootCapsService().RegionHandle);
}
}
break;
}
}
}
if (regionsToBeUpdated.Count != 0)
{
IAsyncMessagePostService messagePost = m_registry.RequestModuleInterface <IAsyncMessagePostService>();
if (messagePost != null)
{
foreach (ulong regionhandle in regionsToBeUpdated)
{
OSDMap outgoingMessage = new OSDMap();
outgoingMessage["Method"] = "ForceUpdateGroupTitles";
outgoingMessage["GroupID"] = groupID;
outgoingMessage["RoleID"] = roleID;
outgoingMessage["RegionID"] = regionhandle;
messagePost.Post(regionhandle, outgoingMessage);
}
}
}
}
else if (message.ContainsKey("Method") && message["Method"] == "ForceUpdateGroupTitles")
{
//COMES IN ON REGION SIDE FROM AURORA.SERVER
UUID groupID = message["GroupID"].AsUUID();
UUID roleID = message["RoleID"].AsUUID();
ulong regionID = message["RegionID"].AsULong();
IGroupsModule gm = m_registry.RequestModuleInterface <IGroupsModule>();
if (gm != null)
{
gm.UpdateUsersForExternalRoleUpdate(groupID, roleID, regionID);
}
}
else if (message.ContainsKey("Method") && message["Method"] == "SendGroupNoticeToUsers")
{
//COMES IN ON REGION SIDE FROM AURORA.SERVER
GroupNoticeInfo notice = new GroupNoticeInfo();
notice.FromOSD((OSDMap)message["Notice"]);
IGroupsModule gm = m_registry.RequestModuleInterface <IGroupsModule>();
if (gm != null)
{
gm.SendGroupNoticeToUsers(null, notice, true);
}
}
return(null);
}
private Hashtable ProcessChatSessionRequest(Hashtable mDhttpMethod, UUID Agent)
{
OSDMap rm = (OSDMap)OSDParser.DeserializeLLSDXml((string)mDhttpMethod["requestbody"]);
string method = rm["method"].AsString();
UUID sessionid = UUID.Parse(rm["session-id"].AsString());
IScenePresence SP = findScenePresence(Agent);
IEventQueueService eq = SP.Scene.RequestModuleInterface <IEventQueueService>();
if (method == "start conference")
{
//Create the session.
CreateSession(new ChatSession()
{
Members = new List <ChatSessionMember>(),
SessionID = sessionid,
Name = SP.Name + " Conference"
});
OSDArray parameters = (OSDArray)rm["params"];
//Add other invited members.
foreach (OSD param in parameters)
{
AddDefaultPermsMemberToSession(param.AsUUID(), sessionid);
}
//Add us to the session!
AddMemberToGroup(new ChatSessionMember()
{
AvatarKey = Agent,
CanVoiceChat = true,
IsModerator = true,
MuteText = false,
MuteVoice = false,
HasBeenAdded = true
}, sessionid);
//Inform us about our room
OpenMetaverse.Messages.Linden.ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock block = new OpenMetaverse.Messages.Linden.ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock();
block.AgentID = Agent;
block.CanVoiceChat = true;
block.IsModerator = true;
block.MuteText = false;
block.MuteVoice = false;
block.Transition = "ENTER";
eq.ChatterBoxSessionAgentListUpdates(sessionid, new OpenMetaverse.Messages.Linden.ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock[] { block }, Agent, "ENTER", findScene(Agent).RegionInfo.RegionHandle);
OpenMetaverse.Messages.Linden.ChatterBoxSessionStartReplyMessage cs = new OpenMetaverse.Messages.Linden.ChatterBoxSessionStartReplyMessage();
cs.VoiceEnabled = true;
cs.TempSessionID = UUID.Random();
cs.Type = 1;
cs.Success = true;
cs.SessionID = sessionid;
cs.SessionName = SP.Name + " Conference";
cs.ModeratedVoice = true;
Hashtable responsedata = new Hashtable();
responsedata["int_response_code"] = 200; //501; //410; //404;
responsedata["content_type"] = "text/plain";
responsedata["keepalive"] = false;
OSDMap map = cs.Serialize();
responsedata["str_response_string"] = map.ToString();
return(responsedata);
}
else if (method == "accept invitation")
{
//They would like added to the group conversation
List <OpenMetaverse.Messages.Linden.ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock> Us = new List <OpenMetaverse.Messages.Linden.ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock>();
List <OpenMetaverse.Messages.Linden.ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock> NotUsAgents = new List <OpenMetaverse.Messages.Linden.ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock>();
ChatSession session = GetSession(sessionid);
if (session != null)
{
ChatSessionMember thismember = FindMember(sessionid, Agent);
//Tell all the other members about the incoming member
foreach (ChatSessionMember sessionMember in session.Members)
{
OpenMetaverse.Messages.Linden.ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock block = new OpenMetaverse.Messages.Linden.ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock();
block.AgentID = sessionMember.AvatarKey;
block.CanVoiceChat = sessionMember.CanVoiceChat;
block.IsModerator = sessionMember.IsModerator;
block.MuteText = sessionMember.MuteText;
block.MuteVoice = sessionMember.MuteVoice;
block.Transition = "ENTER";
if (sessionMember.AvatarKey == thismember.AvatarKey)
{
Us.Add(block);
}
else
{
if (sessionMember.HasBeenAdded) // Don't add not joined yet agents. They don't watn to be here.
{
NotUsAgents.Add(block);
}
}
}
thismember.HasBeenAdded = true;
foreach (ChatSessionMember member in session.Members)
{
if (member.AvatarKey == thismember.AvatarKey)
{
//Tell 'us' about all the other agents in the group
eq.ChatterBoxSessionAgentListUpdates(session.SessionID, NotUsAgents.ToArray(), member.AvatarKey, "ENTER", findScene(Agent).RegionInfo.RegionHandle);
}
else
{
//Tell 'other' agents about the new agent ('us')
eq.ChatterBoxSessionAgentListUpdates(session.SessionID, Us.ToArray(), member.AvatarKey, "ENTER", findScene(Agent).RegionInfo.RegionHandle);
}
}
}
Hashtable responsedata = new Hashtable();
responsedata["int_response_code"] = 200; //501; //410; //404;
responsedata["content_type"] = "text/plain";
responsedata["keepalive"] = false;
responsedata["str_response_string"] = "Accepted";
return(responsedata);
}
else if (method == "mute update")
{
//Check if the user is a moderator
Hashtable responsedata = new Hashtable();
if (!CheckModeratorPermission(Agent, sessionid))
{
responsedata["int_response_code"] = 200; //501; //410; //404;
responsedata["content_type"] = "text/plain";
responsedata["keepalive"] = false;
responsedata["str_response_string"] = "Accepted";
return(responsedata);
}
OSDMap parameters = (OSDMap)rm["params"];
UUID AgentID = parameters["agent_id"].AsUUID();
OSDMap muteInfoMap = (OSDMap)parameters["mute_info"];
ChatSessionMember thismember = FindMember(sessionid, Agent);
if (muteInfoMap.ContainsKey("text"))
{
thismember.MuteText = muteInfoMap["text"].AsBoolean();
}
if (muteInfoMap.ContainsKey("voice"))
{
thismember.MuteVoice = muteInfoMap["voice"].AsBoolean();
}
OpenMetaverse.Messages.Linden.ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock block = new OpenMetaverse.Messages.Linden.ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock();
block.AgentID = thismember.AvatarKey;
block.CanVoiceChat = thismember.CanVoiceChat;
block.IsModerator = thismember.IsModerator;
block.MuteText = thismember.MuteText;
block.MuteVoice = thismember.MuteVoice;
block.Transition = "ENTER";
// Send an update to the affected user
eq.ChatterBoxSessionAgentListUpdates(sessionid, new OpenMetaverse.Messages.Linden.ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock[] { block }, AgentID, "", findScene(Agent).RegionInfo.RegionHandle);
responsedata["int_response_code"] = 200; //501; //410; //404;
responsedata["content_type"] = "text/plain";
responsedata["keepalive"] = false;
responsedata["str_response_string"] = "Accepted";
return(responsedata);
}
else
{
m_log.Warn("ChatSessionRequest : " + method);
Hashtable responsedata = new Hashtable();
responsedata["int_response_code"] = 200; //501; //410; //404;
responsedata["content_type"] = "text/plain";
responsedata["keepalive"] = false;
responsedata["str_response_string"] = "Accepted";
return(responsedata);
}
}