public void Start(IConfigSource config, IRegistryCore registry)
{
if (config.Configs["Currency"] == null ||
config.Configs["Currency"].GetString("Module", "") != "SimpleCurrency")
{
return;
}
if (!config.Configs["Currency"].GetBoolean("RunServer", false))
{
return;
}
m_connector = DataManager.RequestPlugin <ISimpleCurrencyConnector>() as SimpleCurrencyConnector;
if (m_connector.GetConfig().ClientPort == 0 && MainServer.Instance == null)
{
return;
}
IHttpServer server =
registry.RequestModuleInterface <ISimulationBase>()
.GetHttpServer((uint)m_connector.GetConfig().ClientPort);
server.AddXmlRPCHandler("getCurrencyQuote", QuoteFunc);
server.AddXmlRPCHandler("buyCurrency", BuyFunc);
server.AddXmlRPCHandler("preflightBuyLandPrep", PreflightBuyLandPrepFunc);
server.AddXmlRPCHandler("buyLandPrep", LandBuyFunc);
server.AddXmlRPCHandler("getBalance", GetbalanceFunc);
server.AddXmlRPCHandler("/currency.php", GetbalanceFunc);
server.AddXmlRPCHandler("/landtool.php", GetbalanceFunc);
m_syncMessagePoster = registry.RequestModuleInterface <ISyncMessagePosterService>();
m_agentInfoService = registry.RequestModuleInterface <IAgentInfoService>();
}
public OSDMap FireMessageReceived(string SessionID, OSDMap message)
{
OSDMap result = null;
ulong reg;
if (ulong.TryParse(SessionID, out reg)) //Local region
{
if (OnMessageReceived != null)
{
MessageReceived eventCopy = OnMessageReceived;
foreach (OSDMap r in from MessageReceived messagedelegate in eventCopy.GetInvocationList() select messagedelegate(message) into r where r != null select r)
{
result = r;
}
}
}
else //IWC
{
string[] session = SessionID.Split('|');
ISyncMessagePosterService smps = m_registry.RequestModuleInterface <ISyncMessagePosterService>();
//Forward it on
result = smps.Get(message, UUID.Parse(session[0]), ulong.Parse(session[1]));
}
return(result);
}
public void SendFriendOnlineStatuses(UUID user, bool isOnline)
{
ISyncMessagePosterService asyncPoster = m_registry.RequestModuleInterface <ISyncMessagePosterService>();
if (asyncPoster != null)
{
List <FriendInfo> friends = GetFriends(user);
foreach (FriendInfo friend in friends)
{
if (friend.TheirFlags == -1 || friend.MyFlags == -1)
{
continue; //Not validiated yet!
}
UUID FriendToInform = UUID.Zero;
if (!UUID.TryParse(friend.Friend, out FriendToInform))
{
continue;
}
if ((friend.MyFlags & (int)FriendRights.CanSeeOnline) != (int)FriendRights.CanSeeOnline)
{
continue;//if we haven't given them the rights to see our online status, don't send the online status
}
UserInfo friendToInformUser = m_agentInfoService.GetUserInfo(friend.Friend);
//Now find their caps service so that we can find where they are root (and if they are logged in)
if (friendToInformUser != null && friendToInformUser.IsOnline)
{
//Post!
asyncPoster.Post(friendToInformUser.CurrentRegionURI,
SyncMessageHelper.AgentStatusChange(user, FriendToInform, isOnline));
}
}
}
}
public void FinishedStartup()
{
//Also look for incoming messages to display
m_messagePost = m_registry.RequestModuleInterface<ISyncMessagePosterService>();
m_capsService = m_registry.RequestModuleInterface<ICapsService>();
m_registry.RequestModuleInterface<ISyncMessageRecievedService>().OnMessageReceived += OnMessageReceived;
}
public virtual void InternalCross(IScenePresence agent, Vector3 attemptedPos, bool isFlying,
GridRegion crossingRegion)
{
MainConsole.Instance.DebugFormat("[Entity transfer]: Crossing agent {0} to region {1}",
agent.Name, crossingRegion.RegionName);
try {
agent.SetAgentLeaving(crossingRegion);
AgentData cAgent = new AgentData();
agent.CopyTo(cAgent);
cAgent.Position = attemptedPos;
if (isFlying)
{
cAgent.ControlFlags |= (uint)AgentManager.ControlFlags.AGENT_CONTROL_FLY;
}
AgentCircuitData agentCircuit = BuildCircuitDataForPresence(agent, attemptedPos);
agentCircuit.TeleportFlags = (uint)TeleportFlags.ViaRegionID;
//This does UpdateAgent and closing of child agents
// messages if they need to be called
ISyncMessagePosterService syncPoster =
agent.Scene.RequestModuleInterface <ISyncMessagePosterService> ();
if (syncPoster != null)
{
syncPoster.PostToServer(SyncMessageHelper.CrossAgent(crossingRegion, attemptedPos,
agent.Velocity, agentCircuit, cAgent,
agent.Scene.RegionInfo.RegionID));
}
} catch (Exception ex) {
MainConsole.Instance.Warn("[Entity transfer]: Exception in crossing: " + ex);
}
}
/// <summary>
/// Server side
/// </summary>
/// <param name="FunctionName"></param>
/// <param name="parameters"></param>
/// <returns></returns>
protected object OnGenericEvent(string FunctionName, object parameters)
{
if (FunctionName == "EstateUpdated")
{
EstateSettings es = (EstateSettings)parameters;
IEstateConnector estateConnector = Framework.Utilities.DataManager.RequestPlugin <IEstateConnector>();
ISyncMessagePosterService asyncPoster =
m_registry.RequestModuleInterface <ISyncMessagePosterService>();
IGridService gridService = m_registry.RequestModuleInterface <IGridService>();
if (estateConnector != null)
{
List <UUID> regions = estateConnector.GetRegions((int)es.EstateID);
if (regions != null)
{
foreach (UUID region in regions)
{
//Send the message to update all regions that are in this estate, as a setting changed
if (gridService != null && asyncPoster != null)
{
GridRegion r = gridService.GetRegionByUUID(null, region);
if (r != null)
{
asyncPoster.Post(r.ServerURI,
SyncMessageHelper.UpdateEstateInfo(es.EstateID, region));
}
}
}
}
}
}
return(null);
}
public void FinishedStartup()
{
//Also look for incoming messages to display
m_messagePost = m_registry.RequestModuleInterface <ISyncMessagePosterService>();
m_capsService = m_registry.RequestModuleInterface <ICapsService>();
m_registry.RequestModuleInterface <ISyncMessageRecievedService>().OnMessageReceived += OnMessageReceived;
}
public void Start(IConfigSource config, IRegistryCore registry)
{
if (config.Configs["Currency"] == null ||
config.Configs["Currency"].GetString("Module", "") != "SimpleCurrency")
return;
if (!config.Configs["Currency"].GetBoolean("RunServer", false))
return;
m_connector = DataManager.RequestPlugin<ISimpleCurrencyConnector>() as SimpleCurrencyConnector;
if (m_connector.GetConfig().ClientPort == 0 && MainServer.Instance == null)
return;
IHttpServer server =
registry.RequestModuleInterface<ISimulationBase>()
.GetHttpServer((uint) m_connector.GetConfig().ClientPort);
server.AddXmlRPCHandler("getCurrencyQuote", QuoteFunc);
server.AddXmlRPCHandler("buyCurrency", BuyFunc);
server.AddXmlRPCHandler("preflightBuyLandPrep", PreflightBuyLandPrepFunc);
server.AddXmlRPCHandler("buyLandPrep", LandBuyFunc);
server.AddXmlRPCHandler("getBalance", GetbalanceFunc);
server.AddXmlRPCHandler("/currency.php", GetbalanceFunc);
server.AddXmlRPCHandler("/landtool.php", GetbalanceFunc);
m_syncMessagePoster = registry.RequestModuleInterface<ISyncMessagePosterService>();
m_agentInfoService = registry.RequestModuleInterface<IAgentInfoService>();
}
public void CancelTeleport(UUID AgentID, ulong RegionHandle)
{
ISyncMessagePosterService syncPoster = m_scenes[0].RequestModuleInterface <ISyncMessagePosterService>();
if (syncPoster != null)
{
syncPoster.Post(SyncMessageHelper.CancelTeleport(AgentID, RegionHandle), RegionHandle);
}
}
public void CancelTeleport(UUID agentID, UUID regionID)
{
ISyncMessagePosterService syncPoster = m_scene.RequestModuleInterface <ISyncMessagePosterService> ();
if (syncPoster != null)
{
syncPoster.PostToServer(SyncMessageHelper.CancelTeleport(agentID, regionID));
}
}
void EventManager_OnStartupFullyComplete(IScene scene, List <string> data)
{
//Just send the RegionIsOnline message, it will log out all the agents for the region as well
ISyncMessagePosterService syncMessage = scene.RequestModuleInterface <ISyncMessagePosterService> ();
if (syncMessage != null)
{
syncMessage.PostToServer(SyncMessageHelper.RegionIsOnline(scene.RegionInfo.RegionID));
}
}
protected object OnGenericEvent(string FunctionName, object parameters)
{
if (FunctionName == "UserStatusChange")
{
//A user has logged in or out... we need to update friends lists across the grid
ISyncMessagePosterService asyncPoster = m_registry.RequestModuleInterface <ISyncMessagePosterService>();
IFriendsService friendsService = m_registry.RequestModuleInterface <IFriendsService>();
if (asyncPoster != null && friendsService != null)
{
//Get all friends
object[] info = (object[])parameters;
UUID us = UUID.Parse(info[0].ToString());
bool isOnline = bool.Parse(info[1].ToString());
List <FriendInfo> friends = friendsService.GetFriends(us);
List <UUID> OnlineFriends = new List <UUID>();
foreach (FriendInfo friend in friends)
{
if (friend.TheirFlags == -1 || friend.MyFlags == -1)
{
continue; //Not validiated yet!
}
UUID FriendToInform = UUID.Zero;
if (!UUID.TryParse(friend.Friend, out FriendToInform))
{
continue;
}
UserInfo user = m_agentInfoService.GetUserInfo(friend.Friend);
//Now find their caps service so that we can find where they are root (and if they are logged in)
if (user != null && user.IsOnline)
{
//Find the root agent
OnlineFriends.Add(FriendToInform);
//Post!
asyncPoster.Post(user.CurrentRegionURI,
SyncMessageHelper.AgentStatusChange(us, FriendToInform, isOnline));
}
}
//If the user is coming online, send all their friends online statuses to them
if (isOnline)
{
UserInfo user = m_agentInfoService.GetUserInfo(us.ToString());
if (user != null)
{
asyncPoster.Post(user.CurrentRegionURI,
SyncMessageHelper.AgentStatusChanges(OnlineFriends, us, true));
}
}
}
}
return(null);
}
void SendInstantMessages(string uri, List <GridInstantMessage> ims)
{
ISyncMessagePosterService syncMessagePoster = m_registry.RequestModuleInterface <ISyncMessagePosterService> ();
if (syncMessagePoster != null)
{
OSDMap map = new OSDMap();
map ["Method"] = "SendInstantMessages";
map ["Messages"] = ims.ToOSDArray();
syncMessagePoster.Post(uri, map);
}
}
public void RemoveRegion(Scene scene)
{
ISyncMessagePosterService syncMessage = scene.RequestModuleInterface <ISyncMessagePosterService>();
if (syncMessage != null)
{
syncMessage.Post(SyncMessageHelper.LogoutRegionAgents(scene.RegionInfo.RegionHandle), scene.RegionInfo.RegionHandle);
}
scene.EventManager.OnNewClient -= OnNewClient;
scene.EventManager.OnClosingClient -= OnClosingClient;
m_scenes.Remove(scene);
}
public void FinishedStartup()
{
m_currencyService = m_registry.RequestModuleInterface <IStarDustCurrencyService>();
if (m_currencyService == null)
{
return;
}
m_registry.RegisterModuleInterface <IStarDustRegionPostHandler>(this);
m_syncMessagePosterService = m_registry.RequestModuleInterface <ISyncMessagePosterService>();
m_syncMessageReceivedService = m_registry.RequestModuleInterface <ISyncMessageRecievedService>();
m_syncMessageReceivedService.OnMessageReceived += m_syncMessageReceivedService_OnMessageReceived;
}
public void AddMoney(IScene scene, string[] cmd)
{
string name = MainConsole.Instance.Prompt("User Name: ");
uint amount = 0;
while (!uint.TryParse(MainConsole.Instance.Prompt("Amount: ", "0"), out amount))
{
MainConsole.Instance.Info("Bad input, must be a number > 0");
}
UserAccount account =
m_registry.RequestModuleInterface <IUserAccountService>()
.GetUserAccount(new List <UUID> {
UUID.Zero
}, name);
if (account == null)
{
MainConsole.Instance.Info("No account found");
return;
}
var currency = GetUserCurrency(account.PrincipalID);
m_gd.Update(_REALM,
new Dictionary <string, object>
{
{
"Amount", currency.Amount + amount
}
}, null, new QueryFilter()
{
andFilters =
new Dictionary <string, object> {
{ "PrincipalID", account.PrincipalID }
}
}, null, null);
MainConsole.Instance.Info(account.Name + " now has $" + (currency.Amount + amount));
if (m_syncMessagePoster == null)
{
m_syncMessagePoster = m_registry.RequestModuleInterface <ISyncMessagePosterService>();
m_userInfoService = m_registry.RequestModuleInterface <IAgentInfoService>();
}
if (m_syncMessagePoster != null)
{
UserInfo toUserInfo = m_userInfoService.GetUserInfo(account.PrincipalID.ToString());
if (toUserInfo != null && toUserInfo.IsOnline)
{
SendUpdateMoneyBalanceToClient(account.PrincipalID, UUID.Zero, toUserInfo.CurrentRegionURI, (currency.Amount + amount), "");
}
}
}
public void IncomingCapsRequest (UUID agentID, GridRegion region, ISimulationBase simbase, ref OSDMap capURLs)
{
m_syncMessage = simbase.ApplicationRegistry.RequestModuleInterface<ISyncMessagePosterService> ();
m_appearanceService = simbase.ApplicationRegistry.RequestModuleInterface<IAgentAppearanceService> ();
m_region = region;
m_agentID = agentID;
if (m_appearanceService == null)
return;//Can't bake!
m_uri = "/CAPS/UpdateAvatarAppearance/" + UUID.Random () + "/";
MainServer.Instance.AddStreamHandler (new GenericStreamHandler ("POST", m_uri, UpdateAvatarAppearance));
capURLs ["UpdateAvatarAppearance"] = MainServer.Instance.ServerURI + m_uri;
}
public void RemoveRegion(IScene scene)
{
if (!scene.CloseQuietly)
{
ISyncMessagePosterService syncMessage = scene.RequestModuleInterface <ISyncMessagePosterService> ();
if (syncMessage != null)
{
syncMessage.PostToServer(SyncMessageHelper.LogoutRegionAgents(scene.RegionInfo.RegionID));
}
}
scene.EventManager.OnNewClient -= OnNewClient;
scene.EventManager.OnClosingClient -= OnClosingClient;
m_scene = null;
}
public void IncomingCapsRequest(UUID agentID, GridRegion region, ISimulationBase simbase, ref OSDMap capURLs)
{
m_syncMessage = simbase.ApplicationRegistry.RequestModuleInterface <ISyncMessagePosterService> ();
m_appearanceService = simbase.ApplicationRegistry.RequestModuleInterface <IAgentAppearanceService> ();
m_region = region;
m_agentID = agentID;
if (m_appearanceService == null)
{
return;//Can't bake!
}
m_uri = "/CAPS/UpdateAvatarAppearance/" + UUID.Random() + "/";
MainServer.Instance.AddStreamHandler(new GenericStreamHandler("POST", m_uri, UpdateAvatarAppearance));
capURLs ["UpdateAvatarAppearance"] = MainServer.Instance.ServerURI + m_uri;
}
public void Start (IConfigSource config, IRegistryCore registry)
{
IConfig externalConfig = config.Configs ["ExternalCaps"];
if (externalConfig == null)
return;
m_allowedCapsModules = Util.ConvertToList (externalConfig.GetString ("CapsHandlers"), true);
ISyncMessageRecievedService service = registry.RequestModuleInterface<ISyncMessageRecievedService> ();
service.OnMessageReceived += service_OnMessageReceived;
m_syncPoster = registry.RequestModuleInterface<ISyncMessagePosterService> ();
m_registry = registry;
registry.RegisterModuleInterface<IExternalCapsHandler> (this);
Init (registry, GetType ().Name);
}
private void m_timer_Elapsed(object sender, ElapsedEventArgs e)
{
ISyncMessagePosterService syncMessagePoster =
m_scenes[0].RequestModuleInterface <ISyncMessagePosterService>();
if (syncMessagePoster != null)
{
List <IScene> FailedScenes = new List <IScene>();
foreach (IScene scene in m_scenes)
{
OSDMap map = new OSDMap();
map["Method"] = "RegisterHandlers";
map["SessionID"] = scene.RegionInfo.RegionHandle.ToString();
OSDMap resp = syncMessagePoster.Get(map, UUID.Zero, scene.RegionInfo.RegionHandle);
if (resp != null && resp["Reregistered"].AsBoolean())
{
MainConsole.Instance.Info("[GridRegService]: Successfully reregistered with the grid service");
}
else
{
//It failed
MainConsole.Instance.Error("[GridRegService]: Failed to successfully reregistered with the grid service");
IGridService GridService = scene.RequestModuleInterface <IGridService>();
if (
!GridService.DeregisterRegion(scene.RegionInfo.RegionHandle, scene.RegionInfo.RegionID,
scene.RegionInfo.GridSecureSessionID))
{
MainConsole.Instance.Error("------------- REGION " + scene.RegionInfo.RegionName +
" IS DEAD ---------------");
}
else
{
//Register again...
MainConsole.Instance.Error("[GridRegService]: Forcefully reregistered with the grid service... standby");
if (!RegisterRegionWithGrid(scene, true))
{
MainConsole.Instance.Error("------------- REGION " + scene.RegionInfo.RegionName +
" IS DEAD ---------------");
}
}
}
}
}
else
{
MainConsole.Instance.ErrorFormat("[RegisterRegionWithGrid]: ISyncMessagePosterService was null in m_timer_Elapsed;");
}
}
public virtual void DoTeleport(IScenePresence sp, GridRegion finalDestination, Vector3 position, Vector3 lookAt,
uint teleportFlags)
{
sp.ControllingClient.SendTeleportProgress(teleportFlags, "sending_dest");
if (finalDestination == null)
{
sp.ControllingClient.SendTeleportFailed("Unable to locate destination");
return;
}
MainConsole.Instance.DebugFormat("[Entity transfer]: Request Teleport to {0}:{1}/{2}",
finalDestination.ServerURI, finalDestination.RegionName, position);
sp.ControllingClient.SendTeleportProgress(teleportFlags, "arriving");
sp.SetAgentLeaving(finalDestination);
// Fixing a bug where teleporting while sitting results in the avatar ending up removed from
// both regions
if (sp.ParentID != UUID.Zero)
{
sp.StandUp();
}
AgentCircuitData agentCircuit = BuildCircuitDataForPresence(sp, position);
AgentData agent = new AgentData();
sp.CopyTo(agent);
// Fix the position
agent.Position = position;
ISyncMessagePosterService syncPoster = sp.Scene.RequestModuleInterface <ISyncMessagePosterService> ();
if (syncPoster != null)
{
// This does CreateAgent and sends the EnableSimulator/EstablishAgentCommunication/TeleportFinish
// messages if they need to be called and deals with the callback
syncPoster.PostToServer(SyncMessageHelper.TeleportAgent((int)sp.DrawDistance,
agentCircuit,
agent,
teleportFlags,
finalDestination,
sp.Scene.RegionInfo.RegionID));
}
}
void m_timer_Elapsed(object sender, ElapsedEventArgs e)
{
ISyncMessagePosterService syncMessagePoster = m_scenes[0].RequestModuleInterface <ISyncMessagePosterService>();
if (syncMessagePoster != null)
{
foreach (Scene scene in m_scenes)
{
OSDMap map = new OSDMap();
map["Method"] = "RegisterHandlers";
syncMessagePoster.Post(map, scene.RegionInfo.RegionHandle);
}
}
else
{
m_log.ErrorFormat("[RegisterRegionWithGrid]: ISyncMessagePosterService was null in m_timer_Elapsed;");
}
}
public void SendUpdateMoneyBalanceToClient(UUID toID, UUID transactionID, string serverURI, uint balance, string message)
{
if (m_syncMessagePoster == null)
{
m_syncMessagePoster = m_registry.RequestModuleInterface <ISyncMessagePosterService>();
}
if (m_syncMessagePoster != null)
{
OSDMap map = new OSDMap();
map ["Method"] = "UpdateMoneyBalance";
map ["AgentID"] = toID;
map ["Amount"] = balance;
map ["Message"] = message;
map ["TransactionID"] = transactionID;
m_syncMessagePoster.Post(serverURI, map);
}
}
public void SetMoney(IScene scene, string[] cmd)
{
string name = MainConsole.Instance.Prompt("User Name: ");
UserAccount account =
m_registry.RequestModuleInterface <IUserAccountService>()
.GetUserAccount(new List <UUID> {
UUID.Zero
}, name);
if (account == null)
{
MainConsole.Instance.Info("No account found");
return;
}
uint amount = 0;
while (!uint.TryParse(MainConsole.Instance.Prompt("Set User's Money Amount: ", "0"), out amount))
{
MainConsole.Instance.Info("Bad input, must be a number > 0");
}
// log the transfer
UserCurrencyTransfer(account.PrincipalID, UUID.Zero, amount, "Set user money", TransactionType.SystemGenerated, UUID.Zero);
var currency = GetUserCurrency(account.PrincipalID);
MainConsole.Instance.Info(account.Name + " now has $" + currency.Amount);
if (m_syncMessagePoster == null)
{
m_syncMessagePoster = m_registry.RequestModuleInterface <ISyncMessagePosterService>();
m_userInfoService = m_registry.RequestModuleInterface <IAgentInfoService>();
}
if (m_syncMessagePoster != null)
{
UserInfo toUserInfo = m_userInfoService.GetUserInfo(account.PrincipalID.ToString());
if (toUserInfo != null && toUserInfo.IsOnline)
{
SendUpdateMoneyBalanceToClient(account.PrincipalID, UUID.Zero, toUserInfo.CurrentRegionURI, currency.Amount, "");
}
}
}
public void Start(IConfigSource config, IRegistryCore registry)
{
if (config.Configs["Currency"] == null ||
config.Configs["Currency"].GetString("Module", "") != "SimpleCurrency")
{
return;
}
// we only want this if we are local..
bool remoteCalls = false;
IConfig connectorConfig = config.Configs["UniverseConnectors"];
if ((connectorConfig != null) && connectorConfig.Contains("DoRemoteCalls"))
{
remoteCalls = connectorConfig.GetBoolean("DoRemoteCalls", false);
}
if (remoteCalls)
{
return;
}
m_connector = Framework.Utilities.DataManager.RequestPlugin <ISimpleCurrencyConnector>() as BaseCurrencyConnector;
var curPort = m_connector.GetConfig().ClientPort;
if (curPort == 0 && MainServer.Instance == null)
{
return;
}
IHttpServer server = registry.RequestModuleInterface <ISimulationBase>().GetHttpServer((uint)curPort);
server.AddXmlRPCHandler("getCurrencyQuote", QuoteFunc);
server.AddXmlRPCHandler("buyCurrency", BuyFunc);
server.AddXmlRPCHandler("preflightBuyLandPrep", PreflightBuyLandPrepFunc);
server.AddXmlRPCHandler("buyLandPrep", LandBuyFunc);
server.AddXmlRPCHandler("getBalance", GetbalanceFunc);
server.AddXmlRPCHandler("/currency.php", GetbalanceFunc);
server.AddXmlRPCHandler("/landtool.php", GetbalanceFunc);
m_syncMessagePoster = registry.RequestModuleInterface <ISyncMessagePosterService>();
m_agentInfoService = registry.RequestModuleInterface <IAgentInfoService>();
}
public void Start(IConfigSource config, IRegistryCore registry)
{
IConfig externalConfig = config.Configs ["ExternalCaps"];
if (externalConfig == null)
{
return;
}
m_allowedCapsModules = Util.ConvertToList(externalConfig.GetString("CapsHandlers"), true);
ISyncMessageRecievedService service = registry.RequestModuleInterface <ISyncMessageRecievedService> ();
service.OnMessageReceived += service_OnMessageReceived;
m_syncPoster = registry.RequestModuleInterface <ISyncMessagePosterService> ();
m_registry = registry;
registry.RegisterModuleInterface <IExternalCapsHandler> (this);
Init(registry, GetType().Name);
}
public void AddMoney(string[] cmd)
{
string name = MainConsole.Instance.Prompt("User Name: ");
uint amount = 0;
while (!uint.TryParse(MainConsole.Instance.Prompt("Amount: ", "0"), out amount))
MainConsole.Instance.Info("Bad input, must be a number > 0");
UserAccount account =
m_registry.RequestModuleInterface<IUserAccountService>()
.GetUserAccount(new List<UUID> {UUID.Zero}, name);
if (account == null)
{
MainConsole.Instance.Info("No account found");
return;
}
var currency = GetUserCurrency(account.PrincipalID);
m_gd.Update(_REALM,
new Dictionary<string, object>
{
{
"Amount", currency.Amount + amount
}
}, null, new QueryFilter()
{
andFilters =
new Dictionary<string, object> {{"PrincipalID", account.PrincipalID}}
}, null, null);
MainConsole.Instance.Info(account.Name + " now has $" + (currency.Amount + amount));
if (m_syncMessagePoster == null)
{
m_syncMessagePoster = m_registry.RequestModuleInterface<ISyncMessagePosterService>();
m_userInfoService = m_registry.RequestModuleInterface<IAgentInfoService>();
}
if (m_syncMessagePoster != null)
{
UserInfo toUserInfo = m_userInfoService.GetUserInfo(account.PrincipalID.ToString());
if (toUserInfo != null && toUserInfo.IsOnline)
SendUpdateMoneyBalanceToClient(account.PrincipalID, UUID.Zero, toUserInfo.CurrentRegionURI, (currency.Amount + amount), "");
}
}
/// <summary>
/// Tell a single agent to disconnect from the region.
/// </summary>
/// <param name="regionHandle"></param>
/// <param name="agentID"></param>
public bool IncomingCloseAgent(IScene scene, UUID agentID)
{
//m_log.DebugFormat("[SCENE]: Processing incoming close agent for {0}", agentID);
IScenePresence presence = scene.GetScenePresence(agentID);
if (presence != null)
{
bool RetVal = scene.RemoveAgent(presence);
ISyncMessagePosterService syncPoster = scene.RequestModuleInterface <ISyncMessagePosterService> ();
if (syncPoster != null)
{
//Tell the grid that we are logged out
syncPoster.Post(SyncMessageHelper.DisableSimulator(presence.UUID, scene.RegionInfo.RegionHandle), scene.RegionInfo.RegionHandle);
}
return(RetVal);
}
return(false);
}
public void SendUpdateMoneyBalanceToClient(UUID toID, UUID transactionID, string serverURI, uint balance, string message)
{
if (m_syncMessagePoster == null)
{
m_syncMessagePoster = m_registry.RequestModuleInterface<ISyncMessagePosterService>();
}
if (m_syncMessagePoster != null)
{
OSDMap map = new OSDMap ();
map ["Method"] = "UpdateMoneyBalance";
map ["AgentID"] = toID;
map ["Amount"] = balance;
map ["Message"] = message;
map ["TransactionID"] = transactionID;
m_syncMessagePoster.Post (serverURI, map);
}
}
protected OSDMap OnMessageReceived(OSDMap message)
{
if (!message.ContainsKey("Method"))
{
return(null); // nothing to do here...
}
var method = message ["Method"].AsString();
ISyncMessagePosterService asyncPost = m_registry.RequestModuleInterface <ISyncMessagePosterService> ();
//We need to check and see if this is an AgentStatusChange
if (method == "AgentStatusChange")
{
OSDMap innerMessage = (OSDMap)message ["Message"];
//We got a message, now pass it on to the clients that need it
UUID AgentID = innerMessage ["AgentID"].AsUUID();
UUID FriendToInformID = innerMessage ["FriendToInformID"].AsUUID();
bool NewStatus = innerMessage ["NewStatus"].AsBoolean();
//Do this since IFriendsModule is a scene module, not a ISimulationBase module (not interchangeable)
ISceneManager manager = m_registry.RequestModuleInterface <ISceneManager> ();
if (manager != null)
{
foreach (IScene scene in manager.Scenes)
{
if (scene.GetScenePresence(FriendToInformID) != null &&
!scene.GetScenePresence(FriendToInformID).IsChildAgent)
{
IFriendsModule friendsModule = scene.RequestModuleInterface <IFriendsModule> ();
if (friendsModule != null)
{
//Send the message
friendsModule.SendFriendsStatusMessage(FriendToInformID, new [] { AgentID }, NewStatus);
}
}
}
}
}
else if (method == "AgentStatusChanges")
{
OSDMap innerMessage = (OSDMap)message ["Message"];
//We got a message, now pass it on to the clients that need it
List <UUID> AgentIDs = ((OSDArray)innerMessage ["AgentIDs"]).ConvertAll <UUID> ((o) => o);
UUID FriendToInformID = innerMessage ["FriendToInformID"].AsUUID();
bool NewStatus = innerMessage ["NewStatus"].AsBoolean();
//Do this since IFriendsModule is a scene module, not a ISimulationBase module (not interchangeable)
ISceneManager manager = m_registry.RequestModuleInterface <ISceneManager> ();
if (manager != null)
{
foreach (IScene scene in manager.Scenes)
{
if (scene.GetScenePresence(FriendToInformID) != null &&
!scene.GetScenePresence(FriendToInformID).IsChildAgent)
{
IFriendsModule friendsModule = scene.RequestModuleInterface <IFriendsModule> ();
if (friendsModule != null)
{
//Send the message
friendsModule.SendFriendsStatusMessage(FriendToInformID, AgentIDs.ToArray(), NewStatus);
}
}
}
}
}
else if (method == "FriendGrantRights")
{
OSDMap body = (OSDMap)message ["Message"];
UUID targetID = body ["Target"].AsUUID();
IAgentInfoService agentInfoService = m_registry.RequestModuleInterface <IAgentInfoService> ();
UserInfo info;
if (agentInfoService != null && (info = agentInfoService.GetUserInfo(targetID.ToString())) != null &&
info.IsOnline)
{
//Forward the message
asyncPost.Post(info.CurrentRegionURI, message);
}
}
else if (method == "FriendshipOffered")
{
OSDMap body = (OSDMap)message ["Message"];
UUID targetID = body ["Friend"].AsUUID();
IAgentInfoService agentInfoService = m_registry.RequestModuleInterface <IAgentInfoService> ();
UserInfo info;
if (agentInfoService != null &&
(info = agentInfoService.GetUserInfo(targetID.ToString())) != null &&
info.IsOnline)
{
//Forward the message
asyncPost.Post(info.CurrentRegionURI, message);
}
}
else if (method == "FriendTerminated")
{
OSDMap body = (OSDMap)message ["Message"];
UUID targetID = body ["ExFriend"].AsUUID();
IAgentInfoService agentInfoService = m_registry.RequestModuleInterface <IAgentInfoService> ();
UserInfo info;
if (agentInfoService != null &&
(info = agentInfoService.GetUserInfo(targetID.ToString())) != null &&
info.IsOnline)
{
//Forward the message
asyncPost.Post(info.CurrentRegionURI, message);
}
}
else if (method == "FriendshipDenied")
{
OSDMap body = (OSDMap)message ["Message"];
UUID targetID = body ["FriendID"].AsUUID();
IAgentInfoService agentInfoService = m_registry.RequestModuleInterface <IAgentInfoService> ();
UserInfo info;
if (agentInfoService != null &&
(info = agentInfoService.GetUserInfo(targetID.ToString())) != null &&
info.IsOnline)
{
//Forward the message
asyncPost.Post(info.CurrentRegionURI, message);
}
}
else if (method == "FriendshipApproved")
{
OSDMap body = (OSDMap)message ["Message"];
UUID targetID = body ["FriendID"].AsUUID();
IAgentInfoService agentInfoService = m_registry.RequestModuleInterface <IAgentInfoService> ();
UserInfo info;
if (agentInfoService != null &&
(info = agentInfoService.GetUserInfo(targetID.ToString())) != null &&
info.IsOnline)
{
//Forward the message
asyncPost.Post(info.CurrentRegionURI, message);
}
}
return(null);
}
public void AddMoney(IScene scene, string[] cmd)
{
string name = MainConsole.Instance.Prompt("User Name: ");
UserAccount account =
m_registry.RequestModuleInterface<IUserAccountService>()
.GetUserAccount(new List<UUID> {UUID.Zero}, name);
if (account == null)
{
MainConsole.Instance.Info("No account found");
return;
}
uint amount = 0;
while (!uint.TryParse(MainConsole.Instance.Prompt("Amount: ", "0"), out amount))
MainConsole.Instance.Info("Bad input, must be a number > 0");
// log the transfer
UserCurrencyTransfer(account.PrincipalID, UUID.Zero, amount, "Money transfer", TransactionType.SystemGenerated, UUID.Zero);
var currency = GetUserCurrency(account.PrincipalID);
MainConsole.Instance.Info(account.Name + " now has $" + (currency.Amount));
if (m_syncMessagePoster == null)
{
m_syncMessagePoster = m_registry.RequestModuleInterface<ISyncMessagePosterService>();
m_userInfoService = m_registry.RequestModuleInterface<IAgentInfoService>();
}
if (m_syncMessagePoster != null)
{
UserInfo toUserInfo = m_userInfoService.GetUserInfo(account.PrincipalID.ToString());
if (toUserInfo != null && toUserInfo.IsOnline)
SendUpdateMoneyBalanceToClient(account.PrincipalID, UUID.Zero, toUserInfo.CurrentRegionURI, (currency.Amount), "");
}
}
public virtual void Start (IConfigSource config, IRegistryCore registry)
{
m_syncMessagePoster = registry.RequestModuleInterface<ISyncMessagePosterService> ();
}
private void OnInstantMessage(IClientAPI remoteClient, GridInstantMessage im)
{
IScenePresence presence;
if ((presence = remoteClient.Scene.GetScenePresence(remoteClient.AgentId)) == null || presence.IsChildAgent)
{
return; //Must exist and not be a child
}
if (m_debugEnabled)
{
MainConsole.Instance.DebugFormat("[GROUPS-MESSAGING]: {0} called", MethodBase.GetCurrentMethod().Name);
DebugGridInstantMessage(im);
}
// Start group IM session
if ((im.dialog == (byte)InstantMessageDialog.SessionGroupStart))
{
if (m_debugEnabled)
{
MainConsole.Instance.InfoFormat("[GROUPS-MESSAGING]: imSessionID({0}) toAgentID({1})", im.imSessionID, im.toAgentID);
}
UUID GroupID = im.imSessionID;
UUID AgentID = im.fromAgentID;
GroupRecord groupInfo = m_groupData.GetGroupRecord(AgentID, GroupID, null);
if (groupInfo != null)
{
if (!m_groupsModule.GroupPermissionCheck(AgentID, GroupID, GroupPowers.JoinChat))
{
return; //They have to be able to join to create a group chat
}
//Create the session.
IEventQueueService queue = remoteClient.Scene.RequestModuleInterface <IEventQueueService>();
if (m_groupData.CreateSession(new ChatSession
{
Members = new List <ChatSessionMember>(),
SessionID = GroupID,
Name = groupInfo.GroupName
}))
{
m_groupData.AddMemberToGroup(new ChatSessionMember
{
AvatarKey = AgentID,
CanVoiceChat = false,
IsModerator = GetIsModerator(AgentID, GroupID),
MuteText = false,
MuteVoice = false,
HasBeenAdded = true
}, GroupID);
#if (!ISWIN)
foreach (GroupMembersData gmd in m_groupData.GetGroupMembers(AgentID, GroupID))
{
if (gmd.AgentID != AgentID)
{
if ((gmd.AgentPowers & (ulong)GroupPowers.JoinChat) == (ulong)GroupPowers.JoinChat)
{
m_groupData.AddMemberToGroup(new ChatSessionMember
{
AvatarKey = gmd.AgentID,
CanVoiceChat = false,
IsModerator =
GetIsModerator(gmd.AgentID, GroupID),
MuteText = false,
MuteVoice = false,
HasBeenAdded = false
}, GroupID);
}
}
}
#else
foreach (GroupMembersData gmd in m_groupData.GetGroupMembers(AgentID, GroupID).Where(gmd => gmd.AgentID != AgentID).Where(gmd => (gmd.AgentPowers & (ulong)GroupPowers.JoinChat) == (ulong)GroupPowers.JoinChat))
{
m_groupData.AddMemberToGroup(new ChatSessionMember
{
AvatarKey = gmd.AgentID,
CanVoiceChat = false,
IsModerator =
GetIsModerator(gmd.AgentID, GroupID),
MuteText = false,
MuteVoice = false,
HasBeenAdded = false
}, GroupID);
}
#endif
//Tell us that it was made successfully
ChatterBoxSessionStartReplyViaCaps(remoteClient, groupInfo.GroupName, GroupID);
}
else
{
ChatSession thisSession = m_groupData.GetSession(GroupID);
//A session already exists
//Add us
m_groupData.AddMemberToGroup(new ChatSessionMember
{
AvatarKey = AgentID,
CanVoiceChat = false,
IsModerator = GetIsModerator(AgentID, GroupID),
MuteText = false,
MuteVoice = false,
HasBeenAdded = true
}, GroupID);
//Tell us that we entered successfully
ChatterBoxSessionStartReplyViaCaps(remoteClient, groupInfo.GroupName, GroupID);
List <ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock> Us =
new List <ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock>();
List <ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock> NotUsAgents =
new List <ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock>();
foreach (ChatSessionMember sessionMember in thisSession.Members)
{
ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock block =
new ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock
{
AgentID = sessionMember.AvatarKey,
CanVoiceChat = sessionMember.CanVoiceChat,
IsModerator = sessionMember.IsModerator,
MuteText = sessionMember.MuteText,
MuteVoice = sessionMember.MuteVoice,
Transition = "ENTER"
};
if (AgentID == sessionMember.AvatarKey)
{
Us.Add(block);
}
if (sessionMember.HasBeenAdded)
{
// Don't add not joined yet agents. They don't want to be here.
NotUsAgents.Add(block);
}
}
foreach (ChatSessionMember member in thisSession.Members)
{
if (member.AvatarKey == AgentID)
{
//Tell 'us' about all the other agents in the group
queue.ChatterBoxSessionAgentListUpdates(GroupID, NotUsAgents.ToArray(), member.AvatarKey,
"ENTER",
remoteClient.Scene.RegionInfo.RegionHandle);
}
else
{
//Tell 'other' agents about the new agent ('us')
IClientAPI otherAgent = GetActiveClient(member.AvatarKey);
if (otherAgent != null) //Local, so we can send it directly
{
queue.ChatterBoxSessionAgentListUpdates(GroupID, Us.ToArray(), member.AvatarKey,
"ENTER",
otherAgent.Scene.RegionInfo.RegionHandle);
}
else
{
ISyncMessagePosterService amps =
m_sceneList[0].RequestModuleInterface <ISyncMessagePosterService>();
if (amps != null)
{
OSDMap message = new OSDMap();
message["Method"] = "GroupSessionAgentUpdate";
message["AgentID"] = AgentID;
message["Message"] = ChatterBoxSessionAgentListUpdates(GroupID, Us.ToArray(),
"ENTER");
amps.Post(message, remoteClient.Scene.RegionInfo.RegionHandle);
}
}
}
}
}
//Tell us that we entered
ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock ourblock =
new ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock
{
AgentID = AgentID,
CanVoiceChat = true,
IsModerator = true,
MuteText = false,
MuteVoice = false,
Transition = "ENTER"
};
queue.ChatterBoxSessionAgentListUpdates(GroupID, new[] { ourblock }, AgentID, "ENTER",
remoteClient.Scene.RegionInfo.RegionHandle);
}
}
// Send a message from locally connected client to a group
else if ((im.dialog == (byte)InstantMessageDialog.SessionSend) && im.message != "")
{
UUID GroupID = im.imSessionID;
UUID AgentID = im.fromAgentID;
if (m_debugEnabled)
{
MainConsole.Instance.DebugFormat("[GROUPS-MESSAGING]: Send message to session for group {0} with session ID {1}",
GroupID, im.imSessionID.ToString());
}
ChatSessionMember memeber = m_groupData.FindMember(im.imSessionID, AgentID);
if (memeber == null || memeber.MuteText)
{
return; //Not in the chat or muted
}
SendMessageToGroup(im, GroupID);
}
else if (im.dialog == (byte)InstantMessageDialog.SessionDrop)
{
DropMemberFromSession(remoteClient, im, true);
}
else if (im.dialog == 212) //Forwarded sessionDrop
{
DropMemberFromSession(remoteClient, im, false);
}
}
public void OnConnectionClose(IClientAPI client)
{
IScenePresence sp = null;
client.Scene.TryGetScenePresence(client.AgentId, out sp);
if (client.IsLoggingOut && sp != null & !sp.IsChildAgent)
{
MainConsole.Instance.InfoFormat("[ActivityDetector]: Detected logout of user {0} in region {1}", client.Name,
client.Scene.RegionInfo.RegionName);
//Inform the grid service about it
if (m_zombieAgents.Contains(client.AgentId))
{
m_zombieAgents.Remove(client.AgentId);
return; //They are a known zombie, just clear them out and go on with life!
}
AgentPosition agentpos = new AgentPosition
{
AgentID = sp.UUID,
AtAxis = sp.CameraAtAxis,
Center = sp.CameraPosition,
Far = sp.DrawDistance,
LeftAxis = Vector3.Zero,
Position = sp.AbsolutePosition
};
if (agentpos.Position.X > sp.Scene.RegionInfo.RegionSizeX)
{
agentpos.Position.X = sp.Scene.RegionInfo.RegionSizeX;
}
if (agentpos.Position.Y > sp.Scene.RegionInfo.RegionSizeY)
{
agentpos.Position.Y = sp.Scene.RegionInfo.RegionSizeY;
}
if (agentpos.Position.Z > sp.Scene.RegionInfo.RegionSizeZ)
{
agentpos.Position.Z = sp.Scene.RegionInfo.RegionSizeZ;
}
if (agentpos.Position.X < 0)
{
agentpos.Position.X = 0;
}
if (agentpos.Position.Y < 0)
{
agentpos.Position.Y = 0;
}
if (agentpos.Position.Z < 0)
{
agentpos.Position.Z = 0;
}
agentpos.RegionHandle = sp.Scene.RegionInfo.RegionHandle;
agentpos.Size = sp.PhysicsActor != null ? sp.PhysicsActor.Size : new Vector3(0, 0, 1.8f);
agentpos.UpAxis = Vector3.Zero;
agentpos.Velocity = sp.Velocity;
agentpos.UserGoingOffline = true; //Don't attempt to add us into other regions
//Send the child agent data update
ISyncMessagePosterService syncPoster = sp.Scene.RequestModuleInterface <ISyncMessagePosterService>();
if (syncPoster != null)
{
syncPoster.Post(SyncMessageHelper.SendChildAgentUpdate(agentpos, sp.Scene.RegionInfo.RegionHandle),
sp.Scene.RegionInfo.RegionHandle);
}
client.Scene.RequestModuleInterface <ISyncMessagePosterService>().Get(
SyncMessageHelper.AgentLoggedOut(client.AgentId, client.Scene.RegionInfo.RegionHandle),
client.AgentId, client.Scene.RegionInfo.RegionHandle);
}
}
public void Start(IConfigSource config, IRegistryCore registry)
{
if (config.Configs["Currency"] == null ||
config.Configs["Currency"].GetString("Module", "") != "SimpleCurrency")
return;
// we only want this if we are local..
bool remoteCalls = false;
IConfig connectorConfig = config.Configs["UniverseConnectors"];
if ((connectorConfig != null) && connectorConfig.Contains("DoRemoteCalls"))
remoteCalls = connectorConfig.GetBoolean("DoRemoteCalls", false);
if (remoteCalls)
return;
m_connector = Framework.Utilities.DataManager.RequestPlugin<ISimpleCurrencyConnector>() as BaseCurrencyConnector;
var curPort = m_connector.GetConfig().ClientPort;
if (curPort == 0 && MainServer.Instance == null)
return;
IHttpServer server = registry.RequestModuleInterface<ISimulationBase>().GetHttpServer((uint)curPort);
server.AddXmlRPCHandler("getCurrencyQuote", QuoteFunc);
server.AddXmlRPCHandler("buyCurrency", BuyFunc);
server.AddXmlRPCHandler("preflightBuyLandPrep", PreflightBuyLandPrepFunc);
server.AddXmlRPCHandler("buyLandPrep", LandBuyFunc);
server.AddXmlRPCHandler("getBalance", GetbalanceFunc);
server.AddXmlRPCHandler("/currency.php", GetbalanceFunc);
server.AddXmlRPCHandler("/landtool.php", GetbalanceFunc);
m_syncMessagePoster = registry.RequestModuleInterface<ISyncMessagePosterService>();
m_agentInfoService = registry.RequestModuleInterface<IAgentInfoService>();
}
protected OSDMap OnMessageReceived(OSDMap message)
{
//We need to check and see if this is an GroupSessionAgentUpdate
if (message.ContainsKey("Method") && message ["Method"] == "GroupSessionAgentUpdate")
{
//COMES IN ON WhiteCore.SERVER SIDE
//Send it on to whomever it concerns
OSDMap innerMessage = (OSDMap)message ["Message"];
if (innerMessage ["message"] == "ChatterBoxSessionAgentListUpdates")
// ONLY forward on this type of message
{
UUID agentID = message ["AgentID"];
IEventQueueService eqs = m_registry.RequestModuleInterface <IEventQueueService> ();
IAgentInfoService agentInfo = m_registry.RequestModuleInterface <IAgentInfoService> ();
if (agentInfo != null)
{
UserInfo user = agentInfo.GetUserInfo(agentID.ToString());
if (user != null && user.IsOnline)
{
eqs.Enqueue(innerMessage, agentID, user.CurrentRegionID);
}
}
}
}
else if (message.ContainsKey("Method") && message ["Method"] == "FixGroupRoleTitles")
{
// This message comes in on WhiteCore.Server side from the region
UUID groupID = message ["GroupID"].AsUUID();
UUID agentID = message ["AgentID"].AsUUID();
UUID roleID = message ["RoleID"].AsUUID();
byte type = (byte)message ["Type"].AsInteger();
IGroupsServiceConnector con = Framework.Utilities.DataManager.RequestPlugin <IGroupsServiceConnector> ();
List <GroupRoleMembersData> members = con.GetGroupRoleMembers(agentID, groupID);
List <GroupRolesData> roles = con.GetGroupRoles(agentID, groupID);
GroupRolesData everyone = null;
foreach (GroupRolesData role in roles.Where(role => role.Name == "Everyone"))
{
everyone = role;
}
List <UserInfo> regionsToBeUpdated = new List <UserInfo> ();
foreach (GroupRoleMembersData data in members)
{
if (data.RoleID == roleID)
{
// They were affected by the change
switch ((GroupRoleUpdate)type)
{
case GroupRoleUpdate.Create:
case GroupRoleUpdate.NoUpdate: // No changes...
break;
case GroupRoleUpdate.UpdatePowers: // Possible we don't need to send this?
case GroupRoleUpdate.UpdateAll:
case GroupRoleUpdate.UpdateData:
case GroupRoleUpdate.Delete:
if (type == (byte)GroupRoleUpdate.Delete)
{
// Set them to the most limited role since their role is gone
con.SetAgentGroupSelectedRole(data.MemberID, groupID, everyone.RoleID);
}
// Need to update their title inworld
IAgentInfoService agentInfoService = m_registry.RequestModuleInterface <IAgentInfoService> ();
UserInfo info;
if (agentInfoService != null &&
(info = agentInfoService.GetUserInfo(agentID.ToString())) != null && info.IsOnline)
{
// Forward the message
regionsToBeUpdated.Add(info);
}
break;
}
}
}
if (regionsToBeUpdated.Count != 0)
{
ISyncMessagePosterService messagePost = m_registry.RequestModuleInterface <ISyncMessagePosterService> ();
if (messagePost != null)
{
foreach (UserInfo userInfo in regionsToBeUpdated)
{
OSDMap outgoingMessage = new OSDMap();
outgoingMessage ["Method"] = "ForceUpdateGroupTitles";
outgoingMessage ["GroupID"] = groupID;
outgoingMessage ["RoleID"] = roleID;
outgoingMessage ["RegionID"] = userInfo.CurrentRegionID;
messagePost.Post(userInfo.CurrentRegionURI, outgoingMessage);
}
}
}
}
else if (message.ContainsKey("Method") && message ["Method"] == "ForceUpdateGroupTitles")
{
// This message comes in on the region side from WhiteCore.Server
UUID groupID = message ["GroupID"].AsUUID();
UUID roleID = message ["RoleID"].AsUUID();
UUID regionID = message ["RegionID"].AsUUID();
IGroupsModule gm = m_registry.RequestModuleInterface <IGroupsModule> ();
if (gm != null)
{
gm.UpdateUsersForExternalRoleUpdate(groupID, roleID, regionID);
}
}
return(null);
}
public bool UserCurrencyTransfer(UUID toID, UUID fromID, UUID toObjectID, UUID fromObjectID, uint amount,
string description, TransactionType type, UUID transactionID)
{
object remoteValue = DoRemoteByURL("CurrencyServerURI", toID, fromID, toObjectID, fromObjectID, amount,
description, type, transactionID);
if (remoteValue != null || m_doRemoteOnly)
return (bool) remoteValue;
UserCurrency toCurrency = GetUserCurrency(toID);
UserCurrency fromCurrency = fromID == UUID.Zero ? null : GetUserCurrency(fromID);
if (toCurrency == null)
return false;
if (fromCurrency != null)
{
//Check to see whether they have enough money
if ((int) fromCurrency.Amount - (int) amount < 0)
return false; //Not enough money
fromCurrency.Amount -= amount;
UserCurrencyUpdate(fromCurrency, true);
}
if (fromID == toID) toCurrency = GetUserCurrency(toID);
//Update the user whose getting paid
toCurrency.Amount += amount;
UserCurrencyUpdate(toCurrency, true);
//Must send out noficiations to the users involved so that they get the updates
if (m_syncMessagePoster == null)
{
m_syncMessagePoster = m_registry.RequestModuleInterface<ISyncMessagePosterService>();
m_userInfoService = m_registry.RequestModuleInterface<IAgentInfoService>();
}
if (m_syncMessagePoster != null)
{
UserInfo toUserInfo = m_userInfoService.GetUserInfo(toID.ToString());
UserInfo fromUserInfo = fromID == UUID.Zero ? null : m_userInfoService.GetUserInfo(fromID.ToString());
UserAccount toAccount = m_registry.RequestModuleInterface<IUserAccountService>()
.GetUserAccount(null, toID);
UserAccount fromAccount = m_registry.RequestModuleInterface<IUserAccountService>()
.GetUserAccount(null, fromID);
if (fromID == toID)
{
if (toUserInfo != null && toUserInfo.IsOnline)
SendUpdateMoneyBalanceToClient(toID, transactionID, toUserInfo.CurrentRegionURI, toCurrency.Amount,
toAccount == null ? "" : (toAccount.Name + " paid you $" + amount + (description == "" ? "" : ": " + description)));
}
else
{
if (toUserInfo != null && toUserInfo.IsOnline)
{
SendUpdateMoneyBalanceToClient(toID, transactionID, toUserInfo.CurrentRegionURI, toCurrency.Amount,
fromAccount == null ? "" : (fromAccount.Name + " paid you $" + amount + (description == "" ? "" : ": " + description)));
}
if (fromUserInfo != null && fromUserInfo.IsOnline)
{
SendUpdateMoneyBalanceToClient(fromID, transactionID, fromUserInfo.CurrentRegionURI, fromCurrency.Amount,
"You paid " + (toAccount == null ? "" : toAccount.Name) + " $" + amount);
}
}
}
return true;
}
public virtual void Start(IConfigSource config, IRegistryCore registry)
{
m_syncMessagePoster = registry.RequestModuleInterface <ISyncMessagePosterService> ();
}
public virtual void Initialize(IConfigSource config, IRegistryCore registry)
{
IConfig handlers = config.Configs["Handlers"];
if (handlers.GetString("SimulationHandler", "") == "SimulationServiceConnector")
registry.RegisterModuleInterface<ISimulationService>(this);
m_registry = registry;
m_syncMessagePoster = registry.RequestModuleInterface<ISyncMessagePosterService>();
}
public bool UserCurrencyTransfer(UUID toID, UUID fromID, UUID toObjectID, string toObjectName, UUID fromObjectID,
string fromObjectName, uint amount, string description, TransactionType type, UUID transactionID)
{
object remoteValue = DoRemoteByURL("CurrencyServerURI", toID, fromID, toObjectID, toObjectName, fromObjectID,
fromObjectName, amount, description, type, transactionID);
if (remoteValue != null || m_doRemoteOnly)
{
return((bool)remoteValue);
}
UserCurrency toCurrency = GetUserCurrency(toID);
UserCurrency fromCurrency = fromID == UUID.Zero ? null : GetUserCurrency(fromID);
if (toCurrency == null)
{
return(false);
}
if (fromCurrency != null)
{
//Check to see whether they have enough money
if ((int)fromCurrency.Amount - (int)amount < 0)
{
return(false); //Not enough money
}
fromCurrency.Amount -= amount;
UserCurrencyUpdate(fromCurrency, true);
}
if (fromID == toID)
{
toCurrency = GetUserCurrency(toID);
}
//Update the user whose getting paid
toCurrency.Amount += amount;
UserCurrencyUpdate(toCurrency, true);
//Must send out noficiations to the users involved so that they get the updates
if (m_syncMessagePoster == null)
{
m_syncMessagePoster = m_registry.RequestModuleInterface <ISyncMessagePosterService>();
m_userInfoService = m_registry.RequestModuleInterface <IAgentInfoService>();
}
if (m_syncMessagePoster != null)
{
UserInfo toUserInfo = m_userInfoService.GetUserInfo(toID.ToString());
UserInfo fromUserInfo = fromID == UUID.Zero ? null : m_userInfoService.GetUserInfo(fromID.ToString());
UserAccount toAccount = m_registry.RequestModuleInterface <IUserAccountService>()
.GetUserAccount(null, toID);
UserAccount fromAccount = m_registry.RequestModuleInterface <IUserAccountService>()
.GetUserAccount(null, fromID);
if (m_config.SaveTransactionLogs)
{
AddTransactionRecord((transactionID == UUID.Zero ? UUID.Random() : transactionID),
description, toID, fromID, amount, type, (toCurrency == null ? 0 : toCurrency.Amount),
(fromCurrency == null ? 0 : fromCurrency.Amount), (toAccount == null ? "System" : toAccount.Name),
(fromAccount == null ? "System" : fromAccount.Name), toObjectName, fromObjectName, (fromUserInfo == null ?
UUID.Zero : fromUserInfo.CurrentRegionID));
}
if (fromID == toID)
{
if (toUserInfo != null && toUserInfo.IsOnline)
{
SendUpdateMoneyBalanceToClient(toID, transactionID, toUserInfo.CurrentRegionURI, toCurrency.Amount,
toAccount == null ? "" : (toAccount.Name + " paid you $" + amount + (description == "" ? "" : ": " + description)));
}
}
else
{
if (toUserInfo != null && toUserInfo.IsOnline)
{
SendUpdateMoneyBalanceToClient(toID, transactionID, toUserInfo.CurrentRegionURI, toCurrency.Amount,
fromAccount == null ? "" : (fromAccount.Name + " paid you $" + amount + (description == "" ? "" : ": " + description)));
}
if (fromUserInfo != null && fromUserInfo.IsOnline)
{
SendUpdateMoneyBalanceToClient(fromID, transactionID, fromUserInfo.CurrentRegionURI, fromCurrency.Amount,
"You paid " + (toAccount == null ? "" : toAccount.Name) + " $" + amount);
}
}
}
return(true);
}
