public bool AddOfflineMessage (GridInstantMessage message)
{
List<string> serverURIs = m_registry.RequestModuleInterface<IConfigurationService> ().FindValueOf (message.toAgentID.ToString (), "FriendsServerURI");
if (serverURIs.Count > 0) //Remote user... or should be
return m_remoteService.AddOfflineMessage (message);
return m_localService.AddOfflineMessage (message);
}
public void AddOfflineMessage(GridInstantMessage message)
{
foreach (string m_ServerURI in m_ServerURIs)
{
SimianUtils.AddGeneric(new UUID(message.toAgentID), "OfflineMessages", UUID.Random().ToString(), message.ToOSD(), m_ServerURI);
}
}
private OSDMap syncRecievedService_OnMessageReceived(OSDMap message)
{
string method = message["Method"];
if (method == "SendInstantMessages")
{
List<GridInstantMessage> messages =
((OSDArray) message["Messages"]).ConvertAll<GridInstantMessage>((o) =>
{
GridInstantMessage im =
new GridInstantMessage();
im.FromOSD((OSDMap) o);
return im;
});
ISceneManager manager = m_registry.RequestModuleInterface<ISceneManager>();
if (manager != null)
{
IMessageTransferModule messageTransfer =
manager.Scene.RequestModuleInterface<IMessageTransferModule>();
if (messageTransfer != null)
{
foreach (GridInstantMessage im in messages)
messageTransfer.SendInstantMessage(im);
}
}
}
return null;
}
public GridInstantMessage[] GetOfflineMessages(UUID PrincipalID)
{
OSDMap map = new OSDMap();
map["PrincipalID"] = PrincipalID;
map["Method"] = "getofflinemessages";
List<GridInstantMessage> Messages = new List<GridInstantMessage>();
try
{
List<string> urls =
m_registry.RequestModuleInterface<IConfigurationService>().FindValueOf(PrincipalID.ToString(),
"RemoteServerURI");
foreach (string url in urls)
{
OSDMap result = WebUtils.PostToService(url + "osd", map, true, false);
OSDArray array = (OSDArray) OSDParser.DeserializeJson(result["_RawResult"]);
foreach (OSD o in array)
{
GridInstantMessage message = new GridInstantMessage();
message.FromOSD((OSDMap) o);
Messages.Add(message);
}
}
return Messages.ToArray();
}
catch (Exception e)
{
MainConsole.Instance.DebugFormat("[AuroraRemoteOfflineMessagesConnector]: Exception when contacting server: {0}", e);
}
return Messages.ToArray();
}
public bool AddOfflineMessage(GridInstantMessage message)
{
foreach (string m_ServerURI in m_ServerURIs)
{
SimianUtils.AddGeneric(message.toAgentID, "OfflineMessages", UUID.Random().ToString(), message.ToOSD(),
m_ServerURI);
}
return true;
}
public GridInstantMessage[] GetOfflineMessages(UUID PrincipalID)
{
List<GridInstantMessage> Messages = new List<GridInstantMessage>();
Dictionary<string, OSDMap> Maps = new Dictionary<string,OSDMap>();
if(SimianUtils.GetGenericEntries(PrincipalID, "OfflineMessages", m_ServerURI, out Maps))
{
GridInstantMessage baseMessage = new GridInstantMessage();
foreach(OSDMap map in Maps.Values)
{
baseMessage.FromOSD(map);
Messages.Add(baseMessage);
}
}
return Messages.ToArray();
}
public bool AddOfflineMessage(GridInstantMessage message)
{
object remoteValue = DoRemote(message);
if (remoteValue != null || m_doRemoteOnly)
return remoteValue == null ? false : (bool) remoteValue;
if (m_maxOfflineMessages <= 0 ||
GenericUtils.GetGenericCount(message.ToAgentID, "OfflineMessages", GD) < m_maxOfflineMessages)
{
GenericUtils.AddGeneric(message.ToAgentID, "OfflineMessages", UUID.Random().ToString(),
message.ToOSD(), GD);
return true;
}
return false;
}
/// <summary>
/// This actually does the XMLRPC Request
/// </summary>
/// <param name="url">URL we pull the data out of to send the request to</param>
/// <param name="im">The Instant Message </param>
/// <returns>Bool if the message was successfully delivered at the other side.</returns>
public static bool SendInstantMessage(string url, GridInstantMessage im, string messageKey)
{
Hashtable xmlrpcdata = ConvertGridInstantMessageToXMLRPC(im, messageKey);
xmlrpcdata["region_handle"] = 0;
ArrayList SendParams = new ArrayList();
SendParams.Add(xmlrpcdata);
XmlRpcRequest GridReq = new XmlRpcRequest("grid_instant_message", SendParams);
try
{
XmlRpcResponse GridResp = GridReq.Send(url, 10000);
Hashtable responseData = (Hashtable)GridResp.Value;
if (responseData.ContainsKey("success"))
{
if ((string)responseData["success"] == "TRUE")
{
//m_log.DebugFormat("[XXX] Success");
return(true);
}
else
{
//m_log.DebugFormat("[XXX] Fail");
return(false);
}
}
else
{
m_log.DebugFormat("[GRID INSTANT MESSAGE]: No response from {0}", url);
return(false);
}
}
catch (WebException e)
{
m_log.ErrorFormat("[GRID INSTANT MESSAGE]: Error sending message to {0} the host didn't respond " + e.ToString(), url);
}
return(false);
}
public bool StoreMessage(GridInstantMessage im, out string reason)
{
reason = string.Empty;
// TODO Check limits
UUID principalID = new UUID(im.toAgentID);
long count = m_Database.GetCount("PrincipalID", principalID.ToString());
if (count >= MAX_IM)
{
reason = "Number of offline IMs has maxed out";
return(false);
}
string imXml = string.Empty;
using (MemoryStream mstream = new MemoryStream())
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.Encoding = Encoding.UTF8;
using (XmlWriter writer = XmlWriter.Create(mstream, settings))
{
m_serializer.Serialize(writer, im);
writer.Flush();
mstream.Position = 0;
using (StreamReader sreader = new StreamReader(mstream))
{
imXml = sreader.ReadToEnd();
}
}
}
OfflineIMData data = new OfflineIMData();
data.PrincipalID = principalID;
data.Data = new Dictionary <string, string>();
data.Data["Message"] = imXml;
return(m_Database.Store(data));
}
protected void OfferInventory(string itemName)
{
SceneObjectPart sop = ButtonMap[m_playerId].Part;
TaskInventoryItem item = sop.Inventory.GetInventoryItems(itemName)[0];
// destination is an avatar
InventoryItemBase agentItem
= sop.ParentGroup.Scene.MoveTaskInventoryItem(m_playerId, UUID.Zero, sop, item.ItemID);
byte[] bucket = new byte[17];
bucket[0] = (byte)agentItem.InvType;
byte[] objBytes = agentItem.ID.GetBytes();
Array.Copy(objBytes, 0, bucket, 1, 16);
GridInstantMessage msg
= new GridInstantMessage(
sop.ParentGroup.Scene,
sop.UUID,
sop.Name,
m_playerId,
(byte)InstantMessageDialog.InventoryOffered,
false,
item.Name + "\n" + sop.Name + " is located at " +
sop.ParentGroup.Scene.RegionInfo.RegionName + " " +
sop.AbsolutePosition.ToString(),
agentItem.ID,
true,
sop.AbsolutePosition,
bucket,
true);
m_log.InfoFormat("[WATER WARS]: IMSessionId on sending inventory offer [{0}]", agentItem.ID);
IMessageTransferModule module = sop.ParentGroup.Scene.RequestModuleInterface <IMessageTransferModule>();
if (module != null)
{
IClientAPI client = sop.ParentGroup.Scene.GetScenePresence(m_playerId).ControllingClient;
client.OnInstantMessage += OnInstantMessage;
module.SendInstantMessage(msg, delegate(bool success) {});
}
}
public void OfflineFriendRequest(IClientAPI client)
{
UUID agentID = client.AgentId;
var friendRequests = FriendsService.GetFriendsRequest(agentID);
if (friendRequests.Count == 0)
{
return;
}
FriendInfo [] friends = friendRequests.ToArray();
GridInstantMessage im = new GridInstantMessage()
{
ToAgentID = agentID,
Dialog = (byte)InstantMessageDialog.FriendshipOffered,
Message = "Will you be my friend?",
Offline = 1,
RegionID = client.Scene.RegionInfo.RegionID
};
foreach (FriendInfo fi in friends)
{
if (fi.MyFlags == 0)
{
UUID fromAgentID;
if (!UUID.TryParse(fi.Friend, out fromAgentID))
{
continue;
}
UserAccount userAcct = m_scene.UserAccountService.GetUserAccount(
client.Scene.RegionInfo.AllScopeIDs, fromAgentID);
im.FromAgentID = fromAgentID;
im.FromAgentName = userAcct.Name;
im.Offline = 1;
im.SessionID = im.FromAgentID;
LocalFriendshipOffered(agentID, im);
}
}
}
bool SendIMToRegion(PresenceInfo upd, GridInstantMessage im, UUID toAgentID, bool foreigner)
{
bool imresult = false;
GridRegion reginfo = null;
if (!m_RegionCache.TryGetValue(upd.RegionID, out reginfo))
{
reginfo = m_GridService.GetRegionByUUID(UUID.Zero /*!!!*/, upd.RegionID);
if (reginfo != null)
{
m_RegionCache.AddOrUpdate(upd.RegionID, reginfo, CACHE_EXPIRATION_SECONDS);
}
}
if (reginfo != null)
{
imresult = InstantMessageServiceConnector.SendInstantMessage(reginfo.ServerURI, im);
}
else
{
m_log.DebugFormat("[HG IM SERVICE]: Failed to deliver message to {0}", reginfo.ServerURI);
return(false);
}
if (imresult)
{
// IM delivery successful, so store the Agent's location in our local cache.
m_UserLocationMap[toAgentID] = upd;
return(true);
}
else
{
// try again, but lookup user this time.
// Warning, this must call the Async version
// of this method or we'll be making thousands of threads
// The version within the spawned thread is SendGridInstantMessageViaXMLRPCAsync
// The version that spawns the thread is SendGridInstantMessageViaXMLRPC
// This is recursive!!!!!
return(TrySendInstantMessage(im, upd, false, foreigner));
}
}
public GridInstantMessage[] GetOfflineMessages(UUID PrincipalID)
{
Dictionary<string, object> sendData = new Dictionary<string, object>();
sendData["PRINCIPALID"] = PrincipalID;
sendData["METHOD"] = "getofflinemessages";
string reqString = WebUtils.BuildQueryString(sendData);
List<GridInstantMessage> Messages = new List<GridInstantMessage>();
try
{
List<string> m_ServerURIs = m_registry.RequestModuleInterface<IConfigurationService>().FindValueOf(PrincipalID.ToString(), "RemoteServerURI");
foreach (string m_ServerURI in m_ServerURIs)
{
string reply = SynchronousRestFormsRequester.MakeRequest("POST",
m_ServerURI + "/auroradata",
reqString);
if (reply != string.Empty)
{
Dictionary<string, object> replyData = WebUtils.ParseXmlResponse(reply);
foreach (object f in replyData)
{
KeyValuePair<string, object> value = (KeyValuePair<string, object>)f;
if (value.Value is Dictionary<string, object>)
{
Dictionary<string, object> valuevalue = value.Value as Dictionary<string, object>;
GridInstantMessage message = new GridInstantMessage();
message.FromKVP(valuevalue);
Messages.Add(message);
}
}
}
}
return Messages.ToArray();
}
catch (Exception e)
{
m_log.DebugFormat("[AuroraRemoteOfflineMessagesConnector]: Exception when contacting server: {0}", e.ToString());
}
return Messages.ToArray();
}
public void OfflineFriendRequest(IClientAPI client)
{
// Barrowed a few lines from SendFriendsOnlineIfNeeded() above.
UUID agentID = client.AgentId;
FriendInfo[] friends = FriendsService.GetFriendsRequest(agentID).ToArray();
GridInstantMessage im = new GridInstantMessage(client.Scene, UUID.Zero, String.Empty, agentID,
(byte)InstantMessageDialog.FriendshipOffered,
"Will you be my friend?", true, Vector3.Zero);
foreach (FriendInfo fi in friends)
{
if (fi.MyFlags == 0)
{
UUID fromAgentID;
string url = "", first = "", last = "", secret = "";
if (!UUID.TryParse(fi.Friend, out fromAgentID))
{
if (
!HGUtil.ParseUniversalUserIdentifier(fi.Friend, out fromAgentID, out url, out first, out last, out secret))
{
continue;
}
}
UserAccount account = m_Scenes[0].UserAccountService.GetUserAccount(client.Scene.RegionInfo.AllScopeIDs, fromAgentID);
im.fromAgentID = fromAgentID;
if (account != null)
{
im.fromAgentName = account.Name;
}
else
{
im.fromAgentName = first + " " + last;
}
im.offline = 1;
im.imSessionID = im.fromAgentID;
LocalFriendshipOffered(agentID, im);
}
}
}
///<summary>
///</summary>
///<param name = "msg"></param>
private void OnGridInstantMessage(GridInstantMessage msg)
{
byte dialog = msg.dialog;
if (dialog != (byte)InstantMessageDialog.MessageFromAgent &&
dialog != (byte)InstantMessageDialog.StartTyping &&
dialog != (byte)InstantMessageDialog.StopTyping &&
dialog != (byte)InstantMessageDialog.MessageFromObject)
{
return;
}
if (m_TransferModule != null)
{
UserAccount account = m_scenes[0].UserAccountService.GetUserAccount(m_scenes[0].RegionInfo.AllScopeIDs,
msg.fromAgentID);
if (account != null)
{
msg.fromAgentName = account.Name;
}
else
{
msg.fromAgentName = msg.fromAgentName + "(No account found for this user)";
}
foreach (IScene scene in m_scenes)
{
IScenePresence presence = null;
if (scene.TryGetScenePresence(msg.toAgentID, out presence))
{
presence.ControllingClient.SendInstantMessage(msg);
return;
}
}
if (dialog == (uint)InstantMessageDialog.StartTyping ||
dialog == (uint)InstantMessageDialog.StopTyping ||
dialog == (uint)InstantMessageDialog.MessageFromObject)
{
return;
}
}
}
void OnIncomingInstantMessage(GridInstantMessage im)
{
if (im.dialog == (byte)InstantMessageDialog.RequestTeleport)
{
UUID sessionID = new UUID(im.imSessionID);
if (!m_PendingLures.Contains(sessionID))
{
m_log.DebugFormat("[HG LURE MODULE]: RequestTeleport sessionID={0}, regionID={1}, message={2}", im.imSessionID, im.RegionID, im.message);
m_PendingLures.Add(sessionID, im, 7200); // 2 hours
}
// Forward. We do this, because the IM module explicitly rejects
// IMs of this type
if (m_TransferModule != null)
{
m_TransferModule.SendInstantMessage(im, delegate(bool success) { });
}
}
}
private void DebugStoreIM(GridInstantMessage im)
{
MemoryStream buffer = new MemoryStream();
Type type = typeof(GridInstantMessage);
XmlWriterSettings settings = new XmlWriterSettings();
settings.Encoding = Encoding.UTF8;
using (XmlWriter writer = XmlWriter.Create(buffer, settings))
{
XmlSerializer serializer = new XmlSerializer(type);
serializer.Serialize(writer, im);
writer.Flush();
}
string debug = buffer.ToString();
m_DummyOffline = buffer;
}
public static Dictionary <string, object> GridInstantMessage(GridInstantMessage im)
{
Dictionary <string, object> dict = new Dictionary <string, object>();
dict["BinaryBucket"] = OpenMetaverse.Utils.BytesToHexString(im.binaryBucket, im.binaryBucket.Length, null);
dict["Dialog"] = im.dialog.ToString();
dict["FromAgentID"] = im.fromAgentID.ToString();
dict["FromAgentName"] = im.fromAgentName == null ? string.Empty : im.fromAgentName;
dict["FromGroup"] = im.fromGroup.ToString();
dict["SessionID"] = im.imSessionID.ToString();
dict["Message"] = im.message == null ? string.Empty : im.message;
dict["Offline"] = im.offline.ToString();
dict["EstateID"] = im.ParentEstateID.ToString();
dict["Position"] = im.Position.ToString();
dict["RegionID"] = im.RegionID.ToString();
dict["Timestamp"] = im.timestamp.ToString();
dict["ToAgentID"] = im.toAgentID.ToString();
return(dict);
}
private void SendGridInstantMessageViaXMLRPC(GridInstantMessage im, MessageResultNotification result)
{
lock (pendingInstantMessages)
{
if (numInstantMessageThreads >= 4)
{
GIM gim = new GIM();
gim.im = im;
gim.result = result;
pendingInstantMessages.Enqueue(gim);
}
else
{
++numInstantMessageThreads;
//m_log.DebugFormat("[SendGridInstantMessageViaXMLRPC]: ++numInstantMessageThreads={0}", numInstantMessageThreads);
GridInstantMessageDelegate d = SendGridInstantMessageViaXMLRPCAsyncMain;
d.BeginInvoke(im, result, GridInstantMessageCompleted, d);
}
}
}
public bool LocalFriendshipApproved(UUID userID, string userName, UUID friendID)
{
IClientAPI friendClient = LocateClientObject(friendID);
if (friendClient != null)
{
// the prospective friend in this sim as root agent
GridInstantMessage im = new GridInstantMessage(Scene, userID, userName, friendID,
(byte)OpenMetaverse.InstantMessageDialog.FriendshipAccepted, userID.ToString(), false, Vector3.Zero);
friendClient.SendInstantMessage(im);
// Update the local cache
UpdateFriendsCache(friendID);
// we're done
return(true);
}
return(false);
}
private bool SendAgentGodKillToRegion(UUID scopeID, UUID agentID, GridUserInfo guinfo)
{
UUID regionID = guinfo.LastRegionID;
GridRegion regInfo = m_GridService.GetRegionByUUID(scopeID, regionID);
if (regInfo == null)
{
return(false);
}
string regURL = regInfo.ServerURI;
if (string.IsNullOrEmpty(regURL))
{
return(false);
}
GridInstantMessage msg = new GridInstantMessage();
msg.imSessionID = UUID.Zero.Guid;
msg.fromAgentID = Constants.servicesGodAgentID.Guid;
msg.toAgentID = agentID.Guid;
msg.timestamp = (uint)Util.UnixTimeSinceEpoch();
msg.fromAgentName = "GRID";
msg.message = string.Format("New login detected");
msg.dialog = 250; // God kick
msg.fromGroup = false;
msg.offline = (byte)0;
msg.ParentEstateID = 0;
msg.Position = Vector3.Zero;
msg.RegionID = scopeID.Guid;
msg.binaryBucket = new byte[1] {
0
};
InstantMessageServiceConnector.SendInstantMessage(regURL, msg, m_messageKey);
m_GridUserService.LoggedOut(agentID.ToString(),
UUID.Zero, guinfo.LastRegionID, guinfo.LastPosition, guinfo.LastLookAt);
return(true);
}
public void OnStartLure(byte lureType, string message, UUID targetid, IClientAPI client)
{
IScenePresence presence = client.Scene.GetScenePresence(client.AgentId);
Vector3 position = presence.AbsolutePosition + new Vector3(2, 0, 0) * presence.Rotation;
UUID dest = Util.BuildFakeParcelID(
client.Scene.RegionInfo.RegionHandle,
(uint)position.X,
(uint)position.Y,
(uint)position.Z);
string mainGridURL = GetMainGridURL();
message += "@" + mainGridURL;//Add it to the message
GridInstantMessage m;
if (m_allowGodTeleports && client.Scene.Permissions.CanGodTeleport(client.AgentId, targetid))//if we are an admin and are in god mode
{
//God tp them
m = new GridInstantMessage(client.Scene, client.AgentId,
client.FirstName + " " + client.LastName, targetid,
(byte)InstantMessageDialog.GodLikeRequestTeleport, false,
"", dest, false, presence.AbsolutePosition,
new Byte[0]);
}
else
{
//Not a god, so no god tp
m = new GridInstantMessage(client.Scene, client.AgentId,
client.FirstName + " " + client.LastName, targetid,
(byte)InstantMessageDialog.RequestTeleport, false,
message, dest, false, presence.AbsolutePosition,
new Byte[0]);
}
m_PendingLures.Add(m.imSessionID, m, 7200); // 2 hours
if (m_TransferModule != null)
{
m_TransferModule.SendInstantMessage(m);
}
}
public bool LocalFriendshipApproved(UUID userID, string name, IClientAPI us, UUID friendID)
{
IClientAPI friendClient = LocateClientObject(friendID);
if (friendClient != null)
{
//They are online, send the online message
if (us != null)
{
us.SendAgentOnline(new[] { friendID });
}
// the prospective friend in this sim as root agent
GridInstantMessage im = new GridInstantMessage(m_scene, userID, name, friendID,
(byte)InstantMessageDialog.FriendshipAccepted,
userID.ToString(), false, Vector3.Zero);
friendClient.SendInstantMessage(im);
// Update the local cache
UpdateFriendsCache(friendID);
//
// put a calling card into the inventory of the friend
//
ICallingCardModule ccmodule = friendClient.Scene.RequestModuleInterface <ICallingCardModule>();
if (ccmodule != null)
{
UserAccount account = friendClient.Scene.UserAccountService.GetUserAccount(friendClient.AllScopeIDs,
userID);
UUID folderID =
friendClient.Scene.InventoryService.GetFolderForType(friendID, InventoryType.Unknown,
AssetType.CallingCard).ID;
ccmodule.CreateCallingCard(friendClient, userID, folderID, account.Name);
}
// we're done
return(true);
}
return(false);
}
public void OnTeleportLureRequest(UUID lureID, uint teleportFlags, IClientAPI client)
{
if (!(client.Scene is Scene))
{
return;
}
// Scene scene = (Scene)(client.Scene);
GridInstantMessage im = null;
if (m_PendingLures.TryGetValue(lureID, out im))
{
m_PendingLures.Remove(lureID);
Lure(client, teleportFlags, im);
}
else
{
m_log.DebugFormat("[HG LURE MODULE]: pending lure {0} not found", lureID);
}
}
byte[] HandleStore(Dictionary <string, object> request)
{
Dictionary <string, object> result = new Dictionary <string, object>();
GridInstantMessage im = OfflineIMDataUtils.GridInstantMessage(request);
string reason = string.Empty;
bool success = m_OfflineIMService.StoreMessage(im, out reason);
result["RESULT"] = success.ToString();
if (!success)
{
result["REASON"] = reason;
}
string xmlString = ServerUtils.BuildXmlResponse(result);
//m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
return(Util.UTF8NoBomEncoding.GetBytes(xmlString));
}
private void ForwardFriendshipOffer(UUID agentID, UUID friendID, GridInstantMessage im)
{
// !!!!!!!! This is a hack so that we don't have to keep state (transactionID/imSessionID)
// We stick this agent's ID as imSession, so that it's directly available on the receiving end
im.SessionID = im.FromAgentID;
// Try the local sim
UserAccount account = UserAccountService.GetUserAccount(m_scene.RegionInfo.AllScopeIDs, agentID);
im.FromAgentName = (account == null) ? "Unknown" : account.Name;
if (LocalFriendshipOffered(friendID, im))
{
return;
}
// The prospective friend is not here [as root]. Let's4 forward.
SyncMessagePosterService.PostToServer(SyncMessageHelper.FriendshipOffered(agentID, friendID, im,
m_scene.RegionInfo.RegionID));
// If the prospective friend is not online, he'll get the message upon login.
}
private void UndeliveredMessage(GridInstantMessage im)
{
if (im.dialog != (byte)InstantMessageDialog.MessageFromObject &&
im.dialog != (byte)InstantMessageDialog.MessageFromAgent &&
im.dialog != (byte)InstantMessageDialog.GroupNotice &&
im.dialog != (byte)InstantMessageDialog.GroupInvitation &&
im.dialog != (byte)InstantMessageDialog.InventoryOffered)
{
return;
}
if (!m_ForwardOfflineGroupMessages)
{
if (im.dialog == (byte)InstantMessageDialog.GroupNotice ||
im.dialog == (byte)InstantMessageDialog.GroupInvitation)
{
return;
}
}
bool success = SynchronousRestObjectRequester.MakeRequest <GridInstantMessage, bool>(
"POST", m_RestURL + "/SaveMessage/", im, 10000);
if (im.dialog == (byte)InstantMessageDialog.MessageFromAgent)
{
IClientAPI client = FindClient(new UUID(im.fromAgentID));
if (client == null)
{
return;
}
client.SendInstantMessage(new GridInstantMessage(
null, new UUID(im.toAgentID),
"System", new UUID(im.fromAgentID),
(byte)InstantMessageDialog.MessageFromAgent,
"User is not logged in. " +
(success ? "Message saved." : "Message not saved"),
false, new Vector3()));
}
}
/// <summary>
/// Takes a GridInstantMessage and converts it into a Hashtable for XMLRPC
/// </summary>
/// <param name="msg">The GridInstantMessage object</param>
/// <returns>Hashtable containing the XMLRPC request</returns>
protected static Hashtable ConvertGridInstantMessageToXMLRPC(GridInstantMessage msg, string messageKey)
{
Hashtable gim = new Hashtable();
gim["from_agent_id"] = msg.fromAgentID.ToString();
// Kept for compatibility
gim["from_agent_session"] = UUID.Zero.ToString();
gim["to_agent_id"] = msg.toAgentID.ToString();
gim["im_session_id"] = msg.imSessionID.ToString();
gim["timestamp"] = msg.timestamp.ToString();
gim["from_agent_name"] = msg.fromAgentName;
gim["message"] = msg.message;
byte[] dialogdata = new byte[1]; dialogdata[0] = msg.dialog;
gim["dialog"] = Convert.ToBase64String(dialogdata, Base64FormattingOptions.None);
if (msg.fromGroup)
{
gim["from_group"] = "TRUE";
}
else
{
gim["from_group"] = "FALSE";
}
byte[] offlinedata = new byte[1]; offlinedata[0] = msg.offline;
gim["offline"] = Convert.ToBase64String(offlinedata, Base64FormattingOptions.None);
gim["parent_estate_id"] = msg.ParentEstateID.ToString();
gim["position_x"] = msg.Position.X.ToString();
gim["position_y"] = msg.Position.Y.ToString();
gim["position_z"] = msg.Position.Z.ToString();
gim["region_id"] = msg.RegionID.ToString();
gim["binary_bucket"] = Convert.ToBase64String(msg.binaryBucket, Base64FormattingOptions.None);
gim["region_id"] = new UUID(msg.RegionID).ToString();
if (messageKey != String.Empty)
{
gim["message_key"] = messageKey;
}
return(gim);
}
private void UndeliveredMessage(GridInstantMessage im)
{
if (im.dialog != (byte)InstantMessageDialog.MessageFromObject &&
im.dialog != (byte)InstantMessageDialog.MessageFromAgent &&
im.dialog != (byte)InstantMessageDialog.GroupNotice &&
im.dialog != (byte)InstantMessageDialog.GroupInvitation &&
im.dialog != (byte)InstantMessageDialog.InventoryOffered)
{
return;
}
if (!m_ForwardOfflineGroupMessages)
{
if (im.dialog == (byte)InstantMessageDialog.GroupNotice ||
im.dialog == (byte)InstantMessageDialog.GroupInvitation)
{
return;
}
}
string reason = string.Empty;
bool success = m_OfflineIMService.StoreMessage(im, out reason);
if (im.dialog == (byte)InstantMessageDialog.MessageFromAgent)
{
IClientAPI client = FindClient(new UUID(im.fromAgentID));
if (client == null)
{
return;
}
client.SendInstantMessage(new GridInstantMessage(
null, new UUID(im.toAgentID),
"System", new UUID(im.fromAgentID),
(byte)InstantMessageDialog.MessageFromAgent,
"User is not logged in. " +
(success ? "Message saved." : "Message not saved: " + reason),
false, new Vector3()));
}
}
private void SendInstantMessages(object message)
{
GridInstantMessage msg = message as GridInstantMessage;
List <GroupMembersData> members = m_groupData.GetGroupMembers(UUID.Parse(msg.fromAgentID.ToString()), UUID.Parse(msg.imSessionID.ToString()));
List <UUID> agentsToSendTo = new List <UUID>();
foreach (GroupMembersData member in members)
{
if (m_groupData.hasAgentDroppedGroupChatSession(member.AgentID, UUID.Parse(msg.imSessionID.ToString())))
{
// 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;
}
agentsToSendTo.Add(member.AgentID);
}
m_msgTransferModule.SendInstantMessages(msg, agentsToSendTo);
/*foreach (GroupMembersData member in m_groupData.GetGroupMembers(UUID.Parse(msg.fromAgentID.ToString()), UUID.Parse(msg.imSessionID.ToString())))
* {
* if (m_groupData.hasAgentDroppedGroupChatSession(member.AgentID, UUID.Parse(msg.imSessionID.ToString())))
* {
* // 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;
* }
*
* msg.toAgentID = member.AgentID.Guid;
*
* m_log.DebugFormat("[GROUPS-MESSAGING]: Delivering to {0}", member.AgentID);
* m_msgTransferModule.SendInstantMessage(msg, delegate(bool success)
* {
* if (!success && m_removeOfflineAgentsFromGroupIMs)
* m_groupData.AgentDroppedFromGroupChatSession(member.AgentID, UUID.Parse(msg.imSessionID.ToString()));
* });
* }*/
}
private OSDMap syncRecievedService_OnMessageReceived(OSDMap message)
{
string method = message["Method"];
if (method == "SendInstantMessages")
{
List <GridInstantMessage> messages =
((OSDArray)message["Messages"]).ConvertAll <GridInstantMessage>((o) =>
{
GridInstantMessage im =
new GridInstantMessage();
im.FromOSD((OSDMap)o);
return(im);
});
ISceneManager manager = m_registry.RequestModuleInterface <ISceneManager>();
if (manager != null)
{
foreach (GridInstantMessage im in messages)
{
Framework.PresenceInfo.IScenePresence UserPresence;
foreach (IScene scene in manager.Scenes)
{
UserPresence = scene.GetScenePresence(im.ToAgentID);
//AR: Do not fire for child agents or group messages are sent for every region
if (UserPresence != null && UserPresence.IsChildAgent == false)
{
IMessageTransferModule messageTransfer = scene.RequestModuleInterface <IMessageTransferModule>();
if (messageTransfer != null)
{
messageTransfer.SendInstantMessage(im);
}
}
}
}
}
}
return(null);
}
/// <summary>
/// Guests are not allowed to send instant messages
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
bool EventManager_OnBeforeSendInstantMessage(GridInstantMessage message)
{
if (!m_enabled)
{
return(true);
}
if (message.message == "" || message.fromAgentID == message.toAgentID)
{
return(true);
}
if (message.message.Length < m_minWordLength)
{
return(true); //too small, nothing to filter, dont waste time
}
StringBuilder result = new StringBuilder(message.message);
DoFilteringOnStatement(result);
message.message = result.ToString();
return(true);
}
public bool StoreMessage(GridInstantMessage im, out string reason)
{
reason = string.Empty;
// Check limits
UUID principalID = new UUID(im.toAgentID);
long count = m_Database.GetCount("PrincipalID", principalID.ToString());
if (count >= MAX_IM)
{
reason = "Number of offline IMs has maxed out";
return(false);
}
string imXml;
using (MemoryStream mstream = new MemoryStream())
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.Encoding = Util.UTF8NoBomEncoding;
using (XmlWriter writer = XmlWriter.Create(mstream, settings))
{
m_serializer.Serialize(writer, im);
writer.Flush();
}
imXml = Util.UTF8NoBomEncoding.GetString(mstream.ToArray());
}
OfflineIMData data = new OfflineIMData();
data.PrincipalID = principalID;
data.FromID = new UUID(im.fromAgentID);
data.Data = new Dictionary <string, string>();
data.Data["Message"] = imXml;
return(m_Database.Store(data));
}
/// <summary>
/// Send a message to the water wars group.
/// </summary>
/// <param name="message"></param>
public void SendMessageToGroup(string message)
{
if (!WaterWarsConstants.ENABLE_GROUPS)
{
return;
}
UUID myAgentId = m_systemAccount.PrincipalID;
UUID groupId = WaterWarsGroup.GroupID;
m_groupsMessagingModule.StartGroupChatSession(myAgentId, groupId);
GridInstantMessage msg = new GridInstantMessage();
msg.imSessionID = groupId.Guid;
msg.fromAgentID = myAgentId.Guid;
msg.fromAgentName = WaterWarsConstants.SYSTEM_ANNOUNCEMENT_NAME;
msg.message = message;
msg.dialog = (byte)InstantMessageDialog.SessionSend;
m_groupsMessagingModule.SendMessageToGroup(msg, groupId);
}
private void TaskInventoryOfferAccept(IClientAPI client, Scene scene, GridInstantMessage im)
{
InventoryFolderBase folder = null;
InventoryItemBase item = null;
// The inventory item/folder, back from it's trip
UUID inventoryEntityID = new UUID(im.imSessionID);
// Here, the recipient is local and we can assume that the inventory is loaded.
// Courtesy of the above bulk update, it will have been pushed to the client, too.
CachedUserInfo userInfo = scene.CommsManager.UserService.GetUserDetails(client.AgentId);
if (userInfo != null)
{
// Is it a folder or an item?
if (userInfo.QueryItem(inventoryEntityID))
{ // It's an item.
item = userInfo.FindItem(inventoryEntityID);
if (item == null)
{
client.SendAgentAlertMessage("Unable to accept received inventory: item/folder not found.", false);
return;
}
client.SendInventoryItemCreateUpdate(item, 0);
}
else
{ // It's a folder.
folder = userInfo.GetFolder(inventoryEntityID);
if (folder != null)
{
client.SendBulkUpdateInventory(folder);
// If we don't send the descendents, viewer shows "Loading..." on the trash item.
userInfo.SendInventoryDecendents(client, folder.ID, false, true);
}
}
}
// RelayInventoryOfferIM(scene, im); // we don't need to notify a box that the user accepted this
}
private void OnInstantMessage(IClientAPI client, GridInstantMessage im)
{
if ((InstantMessageDialog)im.dialog == InstantMessageDialog.FriendshipOffered)
{
// we got a friendship offer
UUID principalID = im.fromAgentID;
UUID friendID = im.toAgentID;
//Can't trust the incoming name for friend offers, so we have to find it ourselves.
UserAccount sender = m_Scenes[0].UserAccountService.GetUserAccount(UUID.Zero, principalID);
im.fromAgentName = sender.Name;
UserAccount reciever = m_Scenes[0].UserAccountService.GetUserAccount(UUID.Zero, friendID);
MainConsole.Instance.DebugFormat("[FRIENDS]: {0} offered friendship to {1}", sender.Name, reciever.Name);
// This user wants to be friends with the other user.
// Let's add the relation backwards, in case the other is not online
FriendsService.StoreFriend(friendID, principalID.ToString(), 0);
// Now let's ask the other user to be friends with this user
ForwardFriendshipOffer(principalID, friendID, im);
}
}
public void OfflineFriendRequest(IClientAPI client)
{
// Barrowed a few lines from SendFriendsOnlineIfNeeded() above.
UUID agentID = client.AgentId;
FriendInfo[] friends = FriendsService.GetFriendsRequest(agentID).ToArray();
GridInstantMessage im = new GridInstantMessage()
{
ToAgentID = agentID,
Dialog = (byte)InstantMessageDialog.FriendshipOffered,
Message = "Will you be my friend?",
Offline = 1,
RegionID = client.Scene.RegionInfo.RegionID
};
foreach (FriendInfo fi in friends)
{
if (fi.MyFlags == 0)
{
UUID fromAgentID;
if (!UUID.TryParse(fi.Friend, out fromAgentID))
{
continue;
}
UserAccount account = m_scene.UserAccountService.GetUserAccount(
client.Scene.RegionInfo.AllScopeIDs, fromAgentID);
im.FromAgentID = fromAgentID;
if (account != null)
{
im.FromAgentName = account.Name;
}
im.Offline = 1;
im.SessionID = im.FromAgentID;
LocalFriendshipOffered(agentID, im);
}
}
}
byte[] FriendshipOffered(Dictionary <string, object> request)
{
UUID fromID = UUID.Zero;
UUID toID = UUID.Zero;
string message = string.Empty;
if (!request.ContainsKey("FromID") || !request.ContainsKey("ToID"))
{
return(FailureResult());
}
message = request["Message"].ToString();
if (!UUID.TryParse(request["FromID"].ToString(), out fromID))
{
return(FailureResult());
}
if (!UUID.TryParse(request["ToID"].ToString(), out toID))
{
return(FailureResult());
}
UserAccount account = m_FriendsModule.UserAccountService.GetUserAccount(UUID.Zero, fromID);
string name = (account == null) ? "Unknown" : account.FirstName + " " + account.LastName;
GridInstantMessage im = new GridInstantMessage(m_FriendsModule.Scene, fromID, name, toID,
(byte)InstantMessageDialog.FriendshipOffered, message, false, Vector3.Zero);
// !! HACK
im.imSessionID = im.fromAgentID;
if (m_FriendsModule.LocalFriendshipOffered(toID, im))
{
return(SuccessResult());
}
return(FailureResult());
}
public virtual void SendInstantMessages(GridInstantMessage im, List<UUID> AgentsToSendTo)
{
//Check for local users first
List<UUID> RemoveUsers = new List<UUID>();
foreach (UUID t in AgentsToSendTo)
{
IScenePresence user;
if (!RemoveUsers.Contains(t) &&
m_Scene.TryGetScenePresence(t, out user))
{
// Local message
user.ControllingClient.SendInstantMessage(im);
RemoveUsers.Add(t);
}
}
//Clear the local users out
foreach (UUID agentID in RemoveUsers)
{
AgentsToSendTo.Remove(agentID);
}
SendMultipleGridInstantMessageViaXMLRPC(im, AgentsToSendTo);
}
/// <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 bool LocalFriendshipOffered(UUID toID, GridInstantMessage im)
{
IClientAPI friendClient = LocateClientObject(toID);
if (friendClient != null)
{
// the prospective friend in this sim as root agent
friendClient.SendInstantMessage(im);
// we're done
return true;
}
return false;
}
public void llGiveInventoryList(string destination, string category, LSL_List inventory)
{
ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL");
UUID destID;
if (!UUID.TryParse(destination, out destID))
return;
List<UUID> itemList = new List<UUID>();
foreach (Object item in inventory.Data)
{
UUID itemID;
if (UUID.TryParse(item.ToString(), out itemID))
{
itemList.Add(itemID);
}
else
{
itemID = GetTaskInventoryItem(item.ToString());
if (itemID != UUID.Zero)
itemList.Add(itemID);
}
}
if (itemList.Count == 0)
return;
UUID folderID = UUID.Zero;
ILLClientInventory inventoryModule = World.RequestModuleInterface<ILLClientInventory>();
if (inventoryModule != null)
folderID = inventoryModule.MoveTaskInventoryItemsToUserInventory(destID, category, m_host, itemList);
if (folderID == UUID.Zero)
return;
byte[] bucket = new byte[17];
bucket[0] = (byte)AssetType.Folder;
byte[] objBytes = folderID.GetBytes();
Array.Copy(objBytes, 0, bucket, 1, 16);
GridInstantMessage msg = new GridInstantMessage(World,
m_host.UUID, m_host.Name+", an object owned by "+
resolveName(m_host.OwnerID)+",", destID,
(byte)InstantMessageDialog.InventoryOffered,
false, category+"\n"+m_host.Name+" is located at "+
World.RegionInfo.RegionName+" "+
m_host.AbsolutePosition.ToString(),
folderID, true, m_host.AbsolutePosition,
bucket);
if (m_TransferModule != null)
m_TransferModule.SendInstantMessage(msg);
}
public DateTime llGiveInventory(string destination, string inventory)
{
ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL");
bool found = false;
UUID destId = UUID.Zero;
UUID objId = UUID.Zero;
int assetType = 0;
string objName = String.Empty;
if (!UUID.TryParse(destination, out destId))
{
llSay(0, "Could not parse key " + destination);
return DateTime.Now;
}
// move the first object found with this inventory name
lock (m_host.TaskInventory)
{
foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
{
if (inv.Value.Name == inventory)
{
found = true;
objId = inv.Key;
assetType = inv.Value.Type;
objName = inv.Value.Name;
break;
}
}
}
if (!found)
{
llSay(0, String.Format("Could not find object '{0}'", inventory));
throw new Exception(String.Format("The inventory object '{0}' could not be found", inventory));
}
GridUserInfo info = m_host.ParentGroup.Scene.GridUserService.GetGridUserInfo(destId.ToString());
// check if destination is an avatar
if ((info != null && info.Online) || World.GetScenePresence(destId) != null)
{
// destination is an avatar
InventoryItemBase agentItem = null;
ILLClientInventory inventoryModule = World.RequestModuleInterface<ILLClientInventory>();
if(inventoryModule != null)
agentItem = inventoryModule.MoveTaskInventoryItemToUserInventory(destId, UUID.Zero, m_host, objId);
if (agentItem == null)
return DateTime.Now;
byte[] bucket = new byte[17];
bucket[0] = (byte)assetType;
byte[] objBytes = agentItem.ID.GetBytes();
Array.Copy(objBytes, 0, bucket, 1, 16);
OpenSim.Framework.Console.MainConsole.Instance.Output("Giving inventory to " + destId + " from " + m_host.Name, "None");
GridInstantMessage msg = new GridInstantMessage(World,
m_host.UUID, m_host.Name+", an object owned by "+
resolveName(m_host.OwnerID)+",", destId,
(byte)InstantMessageDialog.InventoryOffered,
false, objName+"'\n'"+m_host.Name+"' is located at "+
m_host.AbsolutePosition.ToString() + " in '" + World.RegionInfo.RegionName,
agentItem.ID, true, m_host.AbsolutePosition,
bucket);
if (m_TransferModule != null)
m_TransferModule.SendInstantMessage(msg);
}
else
{
// destination is an object
ILLClientInventory inventoryModule = World.RequestModuleInterface<ILLClientInventory>();
if (inventoryModule != null)
inventoryModule.MoveTaskInventoryItemToObject(destId, m_host, objId);
}
return PScriptSleep(3000);
}
/// <summary>
/// If its a message we deal with, pull it from the client here
/// </summary>
/// <param name="client"></param>
/// <param name="im"></param>
private void OnInstantMessage(IClientAPI client, GridInstantMessage im)
{
byte dialog = im.Dialog;
switch (dialog)
{
case (byte) InstantMessageDialog.SessionGroupStart:
m_imService.CreateGroupChat(client.AgentId, im);
break;
case (byte) InstantMessageDialog.SessionSend:
m_imService.SendChatToSession(client.AgentId, im);
break;
case (byte) InstantMessageDialog.SessionDrop:
m_imService.DropMemberFromSession(client.AgentId, im);
break;
}
}
private void ForwardFriendshipOffer(UUID agentID, UUID friendID, GridInstantMessage im)
{
// !!!!!!!! This is a hack so that we don't have to keep state (transactionID/imSessionID)
// We stick this agent's ID as imSession, so that it's directly available on the receiving end
im.imSessionID = im.fromAgentID;
// Try the local sim
UserAccount account = UserAccountService.GetUserAccount(m_Scenes[0].RegionInfo.ScopeID, agentID);
im.fromAgentName = (account == null) ? "Unknown" : account.Name;
if (LocalFriendshipOffered(friendID, im))
return;
// The prospective friend is not here [as root]. Let's forward.
SyncMessagePosterService.Post(SyncMessageHelper.FriendshipOffered(
agentID, friendID, im, m_Scenes[0].RegionInfo.RegionHandle), m_Scenes[0].RegionInfo.RegionHandle);
// If the prospective friend is not online, he'll get the message upon login.
}
/// <summary>
/// If its a message we deal with, pull it from the client here
/// </summary>
/// <param name = "client"></param>
/// <param name = "im"></param>
public void OnInstantMessage(IClientAPI client, GridInstantMessage im)
{
byte dialog = im.dialog;
//We only deal with friend IM sessions here, groups module handles group IM sessions
if (dialog == (byte) InstantMessageDialog.SessionSend)
SendChatToSession(client, im);
if (dialog == (byte) InstantMessageDialog.SessionDrop)
DropMemberFromSession(client, im);
}
public bool LocalFriendshipApproved(UUID userID, string name, IClientAPI us, UUID friendID)
{
IClientAPI friendClient = LocateClientObject(friendID);
if (friendClient != null)
{
//They are online, send the online message
if(us != null)
us.SendAgentOnline(new UUID[] { friendID });
// the prospective friend in this sim as root agent
GridInstantMessage im = new GridInstantMessage(m_Scenes[0], userID, name, friendID,
(byte)OpenMetaverse.InstantMessageDialog.FriendshipAccepted, userID.ToString(), false, Vector3.Zero);
friendClient.SendInstantMessage(im);
// Update the local cache
UpdateFriendsCache(friendID);
//
// put a calling card into the inventory of the friend
//
ICallingCardModule ccmodule = friendClient.Scene.RequestModuleInterface<ICallingCardModule>();
if (ccmodule != null)
{
UserAccount account = friendClient.Scene.UserAccountService.GetUserAccount(UUID.Zero, userID);
UUID folderID = friendClient.Scene.InventoryService.GetFolderForType(friendID, InventoryType.Unknown, AssetType.CallingCard).ID;
ccmodule.CreateCallingCard(friendClient, userID, folderID, account.Name);
}
// we're done
return true;
}
return false;
}
public bool LocalFriendshipDenied(UUID userID, string userName, UUID friendID)
{
IClientAPI friendClient = LocateClientObject(friendID);
if (friendClient != null)
{
// the prospective friend in this sim as root agent
GridInstantMessage im = new GridInstantMessage(m_Scenes[0], userID, userName, friendID,
(byte)OpenMetaverse.InstantMessageDialog.FriendshipDeclined, userID.ToString(), false, Vector3.Zero);
friendClient.SendInstantMessage(im);
// we're done
return true;
}
return false;
}
private void UndeliveredMessage(GridInstantMessage im, string reason)
{
if (OfflineMessagesConnector == null || im == null)
return;
IClientAPI client = FindClient(im.fromAgentID);
if (client == null)
return;
if (!OfflineMessagesConnector.AddOfflineMessage (im))
{
if (!im.fromGroup)
client.SendInstantMessage (new GridInstantMessage (
null, im.toAgentID,
"System", im.fromAgentID,
(byte)InstantMessageDialog.MessageFromAgent,
"User has too many IMs already, please try again later.",
false, Vector3.Zero));
}
else if ((im.offline != 0)
&& (!im.fromGroup || (im.fromGroup && m_ForwardOfflineGroupMessages)))
{
if (im.dialog == 32) //Group notice
{
IGroupsModule module = m_SceneList[0].RequestModuleInterface<IGroupsModule>();
if (module != null)
im = module.BuildOfflineGroupNotice(im);
}
IEmailModule emailModule = m_SceneList[0].RequestModuleInterface<IEmailModule> ();
if (emailModule != null && m_SendOfflineMessagesToEmail)
{
IUserProfileInfo profile = Aurora.DataManager.DataManager.RequestPlugin<IProfileConnector> ().GetUserProfile (im.toAgentID);
if (profile != null && profile.IMViaEmail)
{
UserAccount account = m_SceneList[0].UserAccountService.GetUserAccount (UUID.Zero, im.toAgentID.ToString ());
if (account != null && account.Email != "" && account.Email != null)
{
emailModule.SendEmail (UUID.Zero, account.Email, string.Format ("Offline Message from {0}", im.fromAgentName),
string.Format ("Time: {0}\n", Util.ToDateTime (im.timestamp).ToShortDateString ()) +
string.Format ("From: {0}\n", im.fromAgentName) +
string.Format ("Message: {0}\n", im.message));
}
}
}
if(im.dialog == (byte)InstantMessageDialog.MessageFromAgent && !im.fromGroup)
{
client.SendInstantMessage(new GridInstantMessage(
null, im.toAgentID,
"System", im.fromAgentID,
(byte)InstantMessageDialog.MessageFromAgent,
"Message saved, reason: " + reason,
false, new Vector3()));
}
if (im.dialog == (byte)InstantMessageDialog.InventoryOffered)
client.SendAlertMessage("User is not online. Inventory has been saved");
}
else if (im.offline == 0)
{
if(im.dialog == (byte)InstantMessageDialog.MessageFromAgent && !im.fromGroup)
{
client.SendInstantMessage(new GridInstantMessage(
null, im.toAgentID,
"System", im.fromAgentID,
(byte)InstantMessageDialog.MessageFromAgent,
"Message saved, reason: " + reason,
false, new Vector3()));
}
if (im.dialog == (byte)InstantMessageDialog.InventoryOffered)
client.SendAlertMessage("User not able to be found. Inventory has been saved");
}
}
public void SendInstantMessage(GridInstantMessage im)
{
IMessageTransferModule m_TransferModule =
m_object.Scene.RequestModuleInterface<IMessageTransferModule>();
if (m_TransferModule != null)
m_TransferModule.SendInstantMessage(im);
}
public void AddOfflineMessage(GridInstantMessage message)
{
Dictionary<string, object> sendData = message.ToKeyValuePairs();
sendData["METHOD"] = "addofflinemessage";
string reqString = ServerUtils.BuildQueryString(sendData);
try
{
string reply = SynchronousRestFormsRequester.MakeRequest("POST",
m_ServerURI + "/auroradata",
reqString);
}
catch (Exception e)
{
m_log.DebugFormat("[AuroraRemoteOfflineMessagesConnector]: Exception when contacting server: {0}", e.Message);
}
}
/// <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(im.imSessionID, 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;
im.binaryBucket = Utils.StringToBytes(session.Name);
im.RegionID = UUID.Zero;
im.ParentEstateID = 0;
//im.timestamp = 0;
m_TransferModule.SendInstantMessage(im);
}
else
{
im.toAgentID = member.AvatarKey;
eq.ChatterboxInvitation(
session.SessionID
, session.Name
, im.fromAgentID
, im.message
, im.toAgentID
, im.fromAgentName
, im.dialog
, im.timestamp
, im.offline == 1
, (int) im.ParentEstateID
, im.Position
, 1
, im.imSessionID
, false
, Utils.StringToBytes(session.Name)
, findScene(member.AvatarKey).RegionInfo.RegionHandle
);
}
}
}
private void OnGridInstantMessage(GridInstantMessage msg)
{
OnInstantMessage(findScenePresence(msg.toAgentID).ControllingClient, msg);
}
public void OnStartLure(byte lureType, string message, UUID targetid, IClientAPI client)
{
IScenePresence presence = client.Scene.GetScenePresence(client.AgentId);
Vector3 position = presence.AbsolutePosition + new Vector3(2, 0, 0)*presence.Rotation;
UUID dest = Util.BuildFakeParcelID(
client.Scene.RegionInfo.RegionHandle,
(uint) position.X,
(uint) position.Y,
(uint) position.Z);
GridInstantMessage m = new GridInstantMessage()
{
FromAgentID = client.AgentId,
FromAgentName = client.Name,
ToAgentID = targetid,
Dialog = (byte)InstantMessageDialog.RequestTeleport,
Message = "",
SessionID = dest,
Offline = 0,
Position = presence.AbsolutePosition,
BinaryBucket = new Byte[0],
RegionID = client.Scene.RegionInfo.RegionID
};
if (m_allowGodTeleports && client.Scene.Permissions.CanGodTeleport(client.AgentId, targetid))
//if we are an admin and are in god mode
{
//God tp them
m.Dialog = (byte)InstantMessageDialog.GodLikeRequestTeleport;
}
if (m_TransferModule != null)
m_TransferModule.SendInstantMessage(m);
}
/// <summary>
/// This deals with sending the return IMs as well as actually returning the objects
/// </summary>
protected internal void CheckFrameEvents()
{
// Go through all updates and check for temp and auto return
CheckPrimForAutoReturn();
CheckPrimForTemperary();
lock (m_returns)
{
foreach (KeyValuePair<UUID, ReturnInfo> ret in m_returns)
{
if (ret.Value.reason != "")
{
UUID transaction = UUID.Random();
GridInstantMessage msg = new GridInstantMessage
{
fromAgentID = UUID.Zero,
toAgentID = ret.Key,
imSessionID = transaction,
timestamp = (uint) Util.UnixTimeSinceEpoch(),
fromAgentName = "Server",
dialog = 19,
fromGroup = false,
offline = 1,
ParentEstateID =
m_scene.RegionInfo.EstateSettings.ParentEstateID,
Position = Vector3.Zero,
RegionID = m_scene.RegionInfo.RegionID,
binaryBucket = Util.StringToBytes256("\0")
};
// From server
// Object msg
// We must fill in a null-terminated 'empty' string here since bytes[0] will crash viewer 3.
if (ret.Value.count > 1)
msg.message =
string.Format("Your {0} objects were returned from {1} in region {2} due to {3}",
ret.Value.count, ret.Value.location.ToString(),
m_scene.RegionInfo.RegionName, ret.Value.reason);
else
msg.message = string.Format(
"Your object {0} was returned from {1} in region {2} due to {3}", ret.Value.objectName,
ret.Value.location.ToString(), m_scene.RegionInfo.RegionName, ret.Value.reason);
IMessageTransferModule tr = m_scene.RequestModuleInterface<IMessageTransferModule>();
if (tr != null)
tr.SendInstantMessage(msg);
if (ret.Value.Groups.Count > 1)
MainConsole.Instance.InfoFormat(
"[LandManagement]: Returning {0} objects due to parcel auto return.",
ret.Value.Groups.Count);
else
MainConsole.Instance.Info("[LandManagement]: Returning 1 object due to parcel auto return.");
}
IAsyncSceneObjectGroupDeleter asyncDelete =
m_scene.RequestModuleInterface<IAsyncSceneObjectGroupDeleter>();
if (asyncDelete != null)
{
asyncDelete.DeleteToInventory(
DeRezAction.Return, ret.Value.Groups[0].RootChild.OwnerID, ret.Value.Groups,
ret.Value.Groups[0].RootChild.OwnerID,
true, true);
}
}
m_returns.Clear();
}
}
private void OnGridInstantMessage(GridInstantMessage im)
{
if (im.Dialog == (byte) InstantMessageDialog.RequestTeleport)
{
MainConsole.Instance.DebugFormat(
"[HG LURE MODULE]: RequestTeleport sessionID={0}, regionID={1}, message={2}", im.SessionID,
im.RegionID, im.Message);
// Forward. We do this, because the IM module explicitly rejects
// IMs of this type
if (m_TransferModule != null)
m_TransferModule.SendInstantMessage(im);
}
}
public DateTime llInstantMessage(string user, string message)
{
ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL");
// We may be able to use ClientView.SendInstantMessage here, but we need a client instance.
// InstantMessageModule.OnInstantMessage searches through a list of scenes for a client matching the toAgent,
// but I don't think we have a list of scenes available from here.
// (We also don't want to duplicate the code in OnInstantMessage if we can avoid it.)
UUID friendTransactionID = UUID.Random();
GridInstantMessage msg = new GridInstantMessage();
msg.fromAgentID = new Guid(m_host.UUID.ToString());
msg.toAgentID = new Guid(user);
msg.imSessionID = new Guid(friendTransactionID.ToString()); // This is the item we're mucking with here
msg.timestamp = (uint)Util.UnixTimeSinceEpoch();
msg.fromAgentName = m_host.Name;
// Cap the message length at 1024.
if (message != null && message.Length > 1024)
msg.message = message.Substring(0, 1024);
else
msg.message = message;
msg.dialog = (byte)InstantMessageDialog.MessageFromObject;
msg.fromGroup = false;
msg.offline = (byte)0;
msg.ParentEstateID = 0;
msg.Position = m_host.AbsolutePosition;
msg.RegionID = World.RegionInfo.RegionID.Guid;
msg.binaryBucket
= Util.StringToBytes256(
"{0}/{1}/{2}/{3}",
World.RegionInfo.RegionName,
(int)Math.Floor(m_host.AbsolutePosition.X),
(int)Math.Floor(m_host.AbsolutePosition.Y),
(int)Math.Floor(m_host.AbsolutePosition.Z));
if (m_TransferModule != null)
{
m_TransferModule.SendInstantMessage(msg, delegate(bool success) {});
}
return PScriptSleep(2000);
}
public byte[] AddOfflineMessage(Dictionary<string, object> request)
{
Dictionary<string, object> result = new Dictionary<string, object>();
GridInstantMessage message = new GridInstantMessage();
message.FromKVP(request);
OfflineMessagesConnector.AddOfflineMessage(message);
return SuccessResult();
}
private void OnInstantMessage(IClientAPI client, GridInstantMessage im)
{
if ((InstantMessageDialog)im.dialog == InstantMessageDialog.FriendshipOffered)
{
// we got a friendship offer
UUID principalID = im.fromAgentID;
UUID friendID = im.toAgentID;
//Can't trust the incoming name for friend offers, so we have to find it ourselves.
UserAccount sender = m_Scenes[0].UserAccountService.GetUserAccount(UUID.Zero, principalID);
im.fromAgentName = sender.Name;
UserAccount reciever = m_Scenes[0].UserAccountService.GetUserAccount(UUID.Zero, friendID);
m_log.DebugFormat("[FRIENDS]: {0} offered friendship to {1}", sender.Name, reciever.Name);
// This user wants to be friends with the other user.
// Let's add the relation backwards, in case the other is not online
FriendsService.StoreFriend(friendID, principalID.ToString(), 0);
// Now let's ask the other user to be friends with this user
ForwardFriendshipOffer(principalID, friendID, im);
}
}
/// <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 };
foreach (ChatSessionMember testmember in session.Members)
{
if (member.AvatarKey == im.fromAgentID)
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);
}
}
