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); } }