/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Reflection;
using System.Xml;
using log4net;
using Nini.Config;
using Nwc.XmlRpc;
using OpenMetaverse;
using OpenSim.Framework;
using OpenSim.Framework.Communications.Cache;
using OpenSim.Framework.Servers.HttpServer;
using OpenSim.Region.Framework.Interfaces;
using OpenSim.Region.Framework.Scenes;
namespace OpenSim.Region.CoreModules.Avatar.Currency.SampleMoney
{
///
/// Demo Economy/Money Module. This is not a production quality money/economy module!
/// This is a demo for you to use when making one that works for you.
/// // To use the following you need to add:
/// -helperuri
/// to the command line parameters you use to start up your client
/// This commonly looks like -helperuri http://127.0.0.1:9000/
///
/// Centralized grid structure example using OpenSimWi Redux revision 9+
/// svn co https://opensimwiredux.svn.sourceforge.net/svnroot/opensimwiredux
///
public class SampleMoneyModule : IMoneyModule, IRegionModule
{
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
///
/// Where Stipends come from and Fees go to.
///
// private UUID EconomyBaseAccount = UUID.Zero;
private float EnergyEfficiency = 0f;
private bool gridmode = false;
// private ObjectPaid handerOnObjectPaid;
private bool m_enabled = true;
private IConfigSource m_gConfig;
private bool m_keepMoneyAcrossLogins = true;
private Dictionary m_KnownClientFunds = new Dictionary();
// private string m_LandAddress = String.Empty;
private int m_minFundsBeforeRefresh = 100;
private string m_MoneyAddress = String.Empty;
///
/// Region UUIDS indexed by AgentID
///
private Dictionary m_rootAgents = new Dictionary();
///
/// Scenes by Region Handle
///
private Dictionary m_scenel = new Dictionary();
private int m_stipend = 1000;
private int ObjectCapacity = 45000;
private int ObjectCount = 0;
private int PriceEnergyUnit = 0;
private int PriceGroupCreate = 0;
private int PriceObjectClaim = 0;
private float PriceObjectRent = 0f;
private float PriceObjectScaleFactor = 0f;
private int PriceParcelClaim = 0;
private float PriceParcelClaimFactor = 0f;
private int PriceParcelRent = 0;
private int PricePublicObjectDecay = 0;
private int PricePublicObjectDelete = 0;
private int PriceRentLight = 0;
private int PriceUpload = 0;
private int TeleportMinPrice = 0;
private float TeleportPriceExponent = 0f;
// private int UserLevelPaysFees = 2;
// private Scene XMLRPCHandler;
#region IMoneyModule Members
public event ObjectPaid OnObjectPaid;
///
/// Startup
///
///
///
public void Initialise(Scene scene, IConfigSource config)
{
m_gConfig = config;
IConfig startupConfig = m_gConfig.Configs["Startup"];
IConfig economyConfig = m_gConfig.Configs["Economy"];
ReadConfigAndPopulate(scene, startupConfig, "Startup");
ReadConfigAndPopulate(scene, economyConfig, "Economy");
if (m_enabled)
{
scene.RegisterModuleInterface(this);
IHttpServer httpServer = scene.CommsManager.HttpServer;
lock (m_scenel)
{
if (m_scenel.Count == 0)
{
// XMLRPCHandler = scene;
// To use the following you need to add:
// -helperuri
// to the command line parameters you use to start up your client
// This commonly looks like -helperuri http://127.0.0.1:9000/
if (m_MoneyAddress.Length > 0)
{
// Centralized grid structure using OpenSimWi Redux revision 9+
// https://opensimwiredux.svn.sourceforge.net/svnroot/opensimwiredux
httpServer.AddXmlRPCHandler("balanceUpdateRequest", GridMoneyUpdate);
httpServer.AddXmlRPCHandler("userAlert", UserAlert);
}
else
{
// Local Server.. enables functionality only.
httpServer.AddXmlRPCHandler("getCurrencyQuote", quote_func);
httpServer.AddXmlRPCHandler("buyCurrency", buy_func);
httpServer.AddXmlRPCHandler("preflightBuyLandPrep", preflightBuyLandPrep_func);
httpServer.AddXmlRPCHandler("buyLandPrep", landBuy_func);
}
}
if (m_scenel.ContainsKey(scene.RegionInfo.RegionHandle))
{
m_scenel[scene.RegionInfo.RegionHandle] = scene;
}
else
{
m_scenel.Add(scene.RegionInfo.RegionHandle, scene);
}
}
scene.EventManager.OnNewClient += OnNewClient;
scene.EventManager.OnMoneyTransfer += MoneyTransferAction;
scene.EventManager.OnClientClosed += ClientClosed;
scene.EventManager.OnAvatarEnteringNewParcel += AvatarEnteringParcel;
scene.EventManager.OnMakeChildAgent += MakeChildAgent;
scene.EventManager.OnClientClosed += ClientLoggedOut;
scene.EventManager.OnValidateLandBuy += ValidateLandBuy;
scene.EventManager.OnLandBuy += processLandBuy;
}
}
// Please do not refactor these to be just one method
// Existing implementations need the distinction
//
public void ApplyUploadCharge(UUID agentID)
{
}
public void ApplyGroupCreationCharge(UUID agentID)
{
}
public void ApplyCharge(UUID agentID, int amount, string text)
{
}
public bool ObjectGiveMoney(UUID objectID, UUID fromID, UUID toID, int amount)
{
string description = String.Format("Object {0} pays {1}", resolveObjectName(objectID), resolveAgentName(toID));
bool give_result = doMoneyTransfer(fromID, toID, amount, 2, description);
if (m_MoneyAddress.Length == 0)
BalanceUpdate(fromID, toID, give_result, description);
return give_result;
}
public void PostInitialise()
{
}
public void Close()
{
}
public string Name
{
get { return "BetaGridLikeMoneyModule"; }
}
public bool IsSharedModule
{
get { return true; }
}
#endregion
///
/// Parse Configuration
///
///
///
///
private void ReadConfigAndPopulate(Scene scene, IConfig startupConfig, string config)
{
if (config == "Startup" && startupConfig != null)
{
gridmode = startupConfig.GetBoolean("gridmode", false);
m_enabled = (startupConfig.GetString("economymodule", "BetaGridLikeMoneyModule") == "BetaGridLikeMoneyModule");
}
if (config == "Economy" && startupConfig != null)
{
ObjectCapacity = startupConfig.GetInt("ObjectCapacity", 45000);
PriceEnergyUnit = startupConfig.GetInt("PriceEnergyUnit", 100);
PriceObjectClaim = startupConfig.GetInt("PriceObjectClaim", 10);
PricePublicObjectDecay = startupConfig.GetInt("PricePublicObjectDecay", 4);
PricePublicObjectDelete = startupConfig.GetInt("PricePublicObjectDelete", 4);
PriceParcelClaim = startupConfig.GetInt("PriceParcelClaim", 1);
PriceParcelClaimFactor = startupConfig.GetFloat("PriceParcelClaimFactor", 1f);
PriceUpload = startupConfig.GetInt("PriceUpload", 0);
PriceRentLight = startupConfig.GetInt("PriceRentLight", 5);
TeleportMinPrice = startupConfig.GetInt("TeleportMinPrice", 2);
TeleportPriceExponent = startupConfig.GetFloat("TeleportPriceExponent", 2f);
EnergyEfficiency = startupConfig.GetFloat("EnergyEfficiency", 1);
PriceObjectRent = startupConfig.GetFloat("PriceObjectRent", 1);
PriceObjectScaleFactor = startupConfig.GetFloat("PriceObjectScaleFactor", 10);
PriceParcelRent = startupConfig.GetInt("PriceParcelRent", 1);
PriceGroupCreate = startupConfig.GetInt("PriceGroupCreate", -1);
// string EBA = startupConfig.GetString("EconomyBaseAccount", UUID.Zero.ToString());
// Helpers.TryParse(EBA, out EconomyBaseAccount);
// UserLevelPaysFees = startupConfig.GetInt("UserLevelPaysFees", -1);
m_stipend = startupConfig.GetInt("UserStipend", 1000);
m_minFundsBeforeRefresh = startupConfig.GetInt("IssueStipendWhenClientIsBelowAmount", 10);
m_keepMoneyAcrossLogins = startupConfig.GetBoolean("KeepMoneyAcrossLogins", true);
m_MoneyAddress = startupConfig.GetString("CurrencyServer", String.Empty);
// m_LandAddress = startupConfig.GetString("LandServer", String.Empty);
}
// Send ObjectCapacity to Scene.. Which sends it to the SimStatsReporter.
scene.SetObjectCapacity(ObjectCapacity);
}
public EconomyData GetEconomyData()
{
EconomyData edata = new EconomyData();
edata.ObjectCapacity = ObjectCapacity;
edata.ObjectCount = ObjectCount;
edata.PriceEnergyUnit = PriceEnergyUnit;
edata.PriceGroupCreate = PriceGroupCreate;
edata.PriceObjectClaim = PriceObjectClaim;
edata.PriceObjectRent = PriceObjectRent;
edata.PriceObjectScaleFactor = PriceObjectScaleFactor;
edata.PriceParcelClaim = PriceParcelClaim;
edata.PriceParcelClaimFactor = PriceParcelClaimFactor;
edata.PriceParcelRent = PriceParcelRent;
edata.PricePublicObjectDecay = PricePublicObjectDecay;
edata.PricePublicObjectDelete = PricePublicObjectDelete;
edata.PriceRentLight = PriceRentLight;
edata.PriceUpload = PriceUpload;
edata.TeleportMinPrice = TeleportMinPrice;
return edata;
}
private void GetClientFunds(IClientAPI client)
{
// Here we check if we're in grid mode
// I imagine that the 'check balance'
// function for the client should be here or shortly after
if (gridmode)
{
if (m_MoneyAddress.Length == 0)
{
CheckExistAndRefreshFunds(client.AgentId);
}
else
{
bool childYN = true;
ScenePresence agent = null;
//client.SecureSessionId;
Scene s = LocateSceneClientIn(client.AgentId);
if (s != null)
{
agent = s.GetScenePresence(client.AgentId);
if (agent != null)
childYN = agent.IsChildAgent;
}
if (s != null && agent != null && childYN == false)
{
//s.RegionInfo.RegionHandle;
UUID agentID = UUID.Zero;
int funds = 0;
Hashtable hbinfo =
GetBalanceForUserFromMoneyServer(client.AgentId, client.SecureSessionId, s.RegionInfo.originRegionID,
s.RegionInfo.regionSecret);
if ((bool) hbinfo["success"] == true)
{
UUID.TryParse((string)hbinfo["agentId"], out agentID);
try
{
funds = (Int32) hbinfo["funds"];
}
catch (ArgumentException)
{
}
catch (FormatException)
{
}
catch (OverflowException)
{
m_log.ErrorFormat("[MONEY]: While getting the Currency for user {0}, the return funds overflowed.", agentID);
client.SendAlertMessage("Unable to get your money balance, money operations will be unavailable");
}
catch (InvalidCastException)
{
funds = 0;
}
m_KnownClientFunds[agentID] = funds;
}
else
{
m_log.WarnFormat("[MONEY]: Getting Money for user {0} failed with the following message:{1}", agentID,
(string) hbinfo["errorMessage"]);
client.SendAlertMessage((string) hbinfo["errorMessage"]);
}
SendMoneyBalance(client, agentID, client.SessionId, UUID.Zero);
}
}
}
else
{
CheckExistAndRefreshFunds(client.AgentId);
}
}
///
/// New Client Event Handler
///
///
private void OnNewClient(IClientAPI client)
{
GetClientFunds(client);
// Subscribe to Money messages
client.OnEconomyDataRequest += EconomyDataRequestHandler;
client.OnMoneyBalanceRequest += SendMoneyBalance;
client.OnRequestPayPrice += requestPayPrice;
client.OnObjectBuy += ObjectBuy;
client.OnLogout += ClientClosed;
}
///
/// Transfer money
///
///
///
///
///
private bool doMoneyTransfer(UUID Sender, UUID Receiver, int amount, int transactiontype, string description)
{
bool result = false;
if (amount >= 0)
{
lock (m_KnownClientFunds)
{
// If we don't know about the sender, then the sender can't
// actually be here and therefore this is likely fraud or outdated.
if (m_MoneyAddress.Length == 0)
{
if (m_KnownClientFunds.ContainsKey(Sender))
{
// Does the sender have enough funds to give?
if (m_KnownClientFunds[Sender] >= amount)
{
// Subtract the funds from the senders account
m_KnownClientFunds[Sender] -= amount;
// do we know about the receiver?
if (!m_KnownClientFunds.ContainsKey(Receiver))
{
// Make a record for them so they get the updated balance when they login
CheckExistAndRefreshFunds(Receiver);
}
if (m_enabled)
{
//Add the amount to the Receiver's funds
m_KnownClientFunds[Receiver] += amount;
result = true;
}
}
else
{
// These below are redundant to make this clearer to read
result = false;
}
}
else
{
result = false;
}
}
else
{
result = TransferMoneyonMoneyServer(Sender, Receiver, amount, transactiontype, description);
}
}
}
return result;
}
///
/// Sends the the stored money balance to the client
///
///
///
///
///
public void SendMoneyBalance(IClientAPI client, UUID agentID, UUID SessionID, UUID TransactionID)
{
if (client.AgentId == agentID && client.SessionId == SessionID)
{
int returnfunds = 0;
try
{
returnfunds = GetFundsForAgentID(agentID);
}
catch (Exception e)
{
client.SendAlertMessage(e.Message + " ");
}
client.SendMoneyBalance(TransactionID, true, new byte[0], returnfunds);
}
else
{
client.SendAlertMessage("Unable to send your money balance to you!");
}
}
///
/// Gets the current balance for the user from the Grid Money Server
///
///
///
///
///
///
public Hashtable GetBalanceForUserFromMoneyServer(UUID agentId, UUID secureSessionID, UUID regionId, string regionSecret)
{
Hashtable MoneyBalanceRequestParams = new Hashtable();
MoneyBalanceRequestParams["agentId"] = agentId.ToString();
MoneyBalanceRequestParams["secureSessionId"] = secureSessionID.ToString();
MoneyBalanceRequestParams["regionId"] = regionId.ToString();
MoneyBalanceRequestParams["secret"] = regionSecret;
MoneyBalanceRequestParams["currencySecret"] = ""; // per - region/user currency secret gotten from the money system
Hashtable MoneyRespData = genericCurrencyXMLRPCRequest(MoneyBalanceRequestParams, "simulatorUserBalanceRequest");
return MoneyRespData;
}
///
/// Generic XMLRPC client abstraction
///
/// Hashtable containing parameters to the method
/// Method to invoke
/// Hashtable with success=>bool and other values
public Hashtable genericCurrencyXMLRPCRequest(Hashtable ReqParams, string method)
{
ArrayList SendParams = new ArrayList();
SendParams.Add(ReqParams);
// Send Request
XmlRpcResponse MoneyResp;
try
{
XmlRpcRequest BalanceRequestReq = new XmlRpcRequest(method, SendParams);
MoneyResp = BalanceRequestReq.Send(m_MoneyAddress, 30000);
}
catch (WebException ex)
{
m_log.ErrorFormat(
"[MONEY]: Unable to connect to Money Server {0}. Exception {1}",
m_MoneyAddress, ex);
Hashtable ErrorHash = new Hashtable();
ErrorHash["success"] = false;
ErrorHash["errorMessage"] = "Unable to manage your money at this time. Purchases may be unavailable";
ErrorHash["errorURI"] = "";
return ErrorHash;
//throw (ex);
}
catch (SocketException ex)
{
m_log.ErrorFormat(
"[MONEY]: Unable to connect to Money Server {0}. Exception {1}",
m_MoneyAddress, ex);
Hashtable ErrorHash = new Hashtable();
ErrorHash["success"] = false;
ErrorHash["errorMessage"] = "Unable to manage your money at this time. Purchases may be unavailable";
ErrorHash["errorURI"] = "";
return ErrorHash;
//throw (ex);
}
catch (XmlException ex)
{
m_log.ErrorFormat(
"[MONEY]: Unable to connect to Money Server {0}. Exception {1}",
m_MoneyAddress, ex);
Hashtable ErrorHash = new Hashtable();
ErrorHash["success"] = false;
ErrorHash["errorMessage"] = "Unable to manage your money at this time. Purchases may be unavailable";
ErrorHash["errorURI"] = "";
return ErrorHash;
}
if (MoneyResp.IsFault)
{
Hashtable ErrorHash = new Hashtable();
ErrorHash["success"] = false;
ErrorHash["errorMessage"] = "Unable to manage your money at this time. Purchases may be unavailable";
ErrorHash["errorURI"] = "";
return ErrorHash;
}
Hashtable MoneyRespData = (Hashtable) MoneyResp.Value;
return MoneyRespData;
}
///
/// This informs the Money Grid Server that the avatar is in this simulator
///
///
///
///
///
///
public Hashtable claim_user(UUID agentId, UUID secureSessionID, UUID regionId, string regionSecret)
{
Hashtable MoneyBalanceRequestParams = new Hashtable();
MoneyBalanceRequestParams["agentId"] = agentId.ToString();
MoneyBalanceRequestParams["secureSessionId"] = secureSessionID.ToString();
MoneyBalanceRequestParams["regionId"] = regionId.ToString();
MoneyBalanceRequestParams["secret"] = regionSecret;
Hashtable MoneyRespData = genericCurrencyXMLRPCRequest(MoneyBalanceRequestParams, "simulatorClaimUserRequest");
IClientAPI sendMoneyBal = LocateClientObject(agentId);
if (sendMoneyBal != null)
{
SendMoneyBalance(sendMoneyBal, agentId, sendMoneyBal.SessionId, UUID.Zero);
}
return MoneyRespData;
}
private SceneObjectPart findPrim(UUID objectID)
{
lock (m_scenel)
{
foreach (Scene s in m_scenel.Values)
{
SceneObjectPart part = s.GetSceneObjectPart(objectID);
if (part != null)
{
return part;
}
}
}
return null;
}
private string resolveObjectName(UUID objectID)
{
SceneObjectPart part = findPrim(objectID);
if (part != null)
{
return part.Name;
}
return String.Empty;
}
private string resolveAgentName(UUID agentID)
{
// try avatar username surname
Scene scene = GetRandomScene();
CachedUserInfo profile = scene.CommsManager.UserProfileCacheService.GetUserDetails(agentID);
if (profile != null && profile.UserProfile != null)
{
string avatarname = profile.UserProfile.FirstName + " " + profile.UserProfile.SurName;
return avatarname;
}
else
{
m_log.ErrorFormat(
"[MONEY]: Could not resolve user {0}",
agentID);
}
return String.Empty;
}
private void BalanceUpdate(UUID senderID, UUID receiverID, bool transactionresult, string description)
{
IClientAPI sender = LocateClientObject(senderID);
IClientAPI receiver = LocateClientObject(receiverID);
if (senderID != receiverID)
{
if (sender != null)
{
sender.SendMoneyBalance(UUID.Random(), transactionresult, Utils.StringToBytes(description), GetFundsForAgentID(senderID));
}
if (receiver != null)
{
receiver.SendMoneyBalance(UUID.Random(), transactionresult, Utils.StringToBytes(description), GetFundsForAgentID(receiverID));
}
}
}
///
/// Informs the Money Grid Server of a transfer.
///
///
///
///
///
public bool TransferMoneyonMoneyServer(UUID sourceId, UUID destId, int amount, int transactiontype, string description)
{
int aggregatePermInventory = 0;
int aggregatePermNextOwner = 0;
int flags = 0;
bool rvalue = false;
IClientAPI cli = LocateClientObject(sourceId);
if (cli != null)
{
Scene userScene = null;
lock (m_rootAgents)
{
userScene = GetSceneByUUID(m_rootAgents[sourceId]);
}
if (userScene != null)
{
Hashtable ht = new Hashtable();
ht["agentId"] = sourceId.ToString();
ht["secureSessionId"] = cli.SecureSessionId.ToString();
ht["regionId"] = userScene.RegionInfo.originRegionID.ToString();
ht["secret"] = userScene.RegionInfo.regionSecret;
ht["currencySecret"] = " ";
ht["destId"] = destId.ToString();
ht["cash"] = amount;
ht["aggregatePermInventory"] = aggregatePermInventory;
ht["aggregatePermNextOwner"] = aggregatePermNextOwner;
ht["flags"] = flags;
ht["transactionType"] = transactiontype;
ht["description"] = description;
Hashtable hresult = genericCurrencyXMLRPCRequest(ht, "regionMoveMoney");
if ((bool) hresult["success"] == true)
{
int funds1 = 0;
int funds2 = 0;
try
{
funds1 = (Int32) hresult["funds"];
}
catch (InvalidCastException)
{
funds1 = 0;
}
SetLocalFundsForAgentID(sourceId, funds1);
if (m_KnownClientFunds.ContainsKey(destId))
{
try
{
funds2 = (Int32) hresult["funds2"];
}
catch (InvalidCastException)
{
funds2 = 0;
}
SetLocalFundsForAgentID(destId, funds2);
}
rvalue = true;
}
else
{
cli.SendAgentAlertMessage((string) hresult["errorMessage"], true);
}
}
}
else
{
m_log.ErrorFormat("[MONEY]: Client {0} not found", sourceId.ToString());
}
return rvalue;
}
public int GetRemoteBalance(UUID agentId)
{
int funds = 0;
IClientAPI aClient = LocateClientObject(agentId);
if (aClient != null)
{
Scene s = LocateSceneClientIn(agentId);
if (s != null)
{
if (m_MoneyAddress.Length > 0)
{
Hashtable hbinfo =
GetBalanceForUserFromMoneyServer(aClient.AgentId, aClient.SecureSessionId, s.RegionInfo.originRegionID,
s.RegionInfo.regionSecret);
if ((bool) hbinfo["success"] == true)
{
try
{
funds = (Int32) hbinfo["funds"];
}
catch (ArgumentException)
{
}
catch (FormatException)
{
}
catch (OverflowException)
{
m_log.ErrorFormat("[MONEY]: While getting the Currency for user {0}, the return funds overflowed.", agentId);
aClient.SendAlertMessage("Unable to get your money balance, money operations will be unavailable");
}
catch (InvalidCastException)
{
funds = 0;
}
}
else
{
m_log.WarnFormat("[MONEY]: Getting Money for user {0} failed with the following message:{1}", agentId,
(string) hbinfo["errorMessage"]);
aClient.SendAlertMessage((string) hbinfo["errorMessage"]);
}
}
SetLocalFundsForAgentID(agentId, funds);
SendMoneyBalance(aClient, agentId, aClient.SessionId, UUID.Zero);
}
else
{
m_log.Debug("[MONEY]: Got balance request update for agent that is here, but couldn't find which scene.");
}
}
else
{
m_log.Debug("[MONEY]: Got balance request update for agent that isn't here.");
}
return funds;
}
public XmlRpcResponse GridMoneyUpdate(XmlRpcRequest request)
{
m_log.Debug("[MONEY]: Dynamic balance update called.");
Hashtable requestData = (Hashtable) request.Params[0];
if (requestData.ContainsKey("agentId"))
{
UUID agentId = UUID.Zero;
UUID.TryParse((string) requestData["agentId"], out agentId);
if (agentId != UUID.Zero)
{
GetRemoteBalance(agentId);
}
else
{
m_log.Debug("[MONEY]: invalid agentId specified, dropping.");
}
}
else
{
m_log.Debug("[MONEY]: no agentId specified, dropping.");
}
XmlRpcResponse r = new XmlRpcResponse();
Hashtable rparms = new Hashtable();
rparms["success"] = true;
r.Value = rparms;
return r;
}
///
/// XMLRPC handler to send alert message and sound to client
///
public XmlRpcResponse UserAlert(XmlRpcRequest request)
{
XmlRpcResponse ret = new XmlRpcResponse();
Hashtable retparam = new Hashtable();
Hashtable requestData = (Hashtable) request.Params[0];
UUID agentId;
UUID soundId;
UUID regionId;
UUID.TryParse((string) requestData["agentId"], out agentId);
UUID.TryParse((string) requestData["soundId"], out soundId);
UUID.TryParse((string) requestData["regionId"], out regionId);
string text = (string) requestData["text"];
string secret = (string) requestData["secret"];
Scene userScene = GetSceneByUUID(regionId);
if (userScene != null)
{
if (userScene.RegionInfo.regionSecret == secret)
{
IClientAPI client = LocateClientObject(agentId);
if (client != null)
{
if (soundId != UUID.Zero)
client.SendPlayAttachedSound(soundId, UUID.Zero, UUID.Zero, 1.0f, 0);
client.SendBlueBoxMessage(UUID.Zero, "", text);
retparam.Add("success", true);
}
else
{
retparam.Add("success", false);
}
}
else
{
retparam.Add("success", false);
}
}
ret.Value = retparam;
return ret;
}
# region Standalone box enablers only
public XmlRpcResponse quote_func(XmlRpcRequest request)
{
Hashtable requestData = (Hashtable) request.Params[0];
UUID agentId = UUID.Zero;
int amount = 0;
Hashtable quoteResponse = new Hashtable();
XmlRpcResponse returnval = new XmlRpcResponse();
if (requestData.ContainsKey("agentId") && requestData.ContainsKey("currencyBuy"))
{
UUID.TryParse((string) requestData["agentId"], out agentId);
try
{
amount = (Int32) requestData["currencyBuy"];
}
catch (InvalidCastException)
{
}
Hashtable currencyResponse = new Hashtable();
currencyResponse.Add("estimatedCost", 0);
currencyResponse.Add("currencyBuy", amount);
quoteResponse.Add("success", true);
quoteResponse.Add("currency", currencyResponse);
quoteResponse.Add("confirm", "asdfad9fj39ma9fj");
returnval.Value = quoteResponse;
return returnval;
}
quoteResponse.Add("success", false);
quoteResponse.Add("errorMessage", "Invalid parameters passed to the quote box");
quoteResponse.Add("errorURI", "http://www.opensimulator.org/wiki");
returnval.Value = quoteResponse;
return returnval;
}
public XmlRpcResponse buy_func(XmlRpcRequest request)
{
Hashtable requestData = (Hashtable) request.Params[0];
UUID agentId = UUID.Zero;
int amount = 0;
if (requestData.ContainsKey("agentId") && requestData.ContainsKey("currencyBuy"))
{
UUID.TryParse((string) requestData["agentId"], out agentId);
try
{
amount = (Int32) requestData["currencyBuy"];
}
catch (InvalidCastException)
{
}
if (agentId != UUID.Zero)
{
lock (m_KnownClientFunds)
{
if (m_KnownClientFunds.ContainsKey(agentId))
{
m_KnownClientFunds[agentId] += amount;
}
else
{
m_KnownClientFunds.Add(agentId, amount);
}
}
IClientAPI client = LocateClientObject(agentId);
if (client != null)
{
SendMoneyBalance(client, agentId, client.SessionId, UUID.Zero);
}
}
}
XmlRpcResponse returnval = new XmlRpcResponse();
Hashtable returnresp = new Hashtable();
returnresp.Add("success", true);
returnval.Value = returnresp;
return returnval;
}
public XmlRpcResponse preflightBuyLandPrep_func(XmlRpcRequest request)
{
XmlRpcResponse ret = new XmlRpcResponse();
Hashtable retparam = new Hashtable();
Hashtable membershiplevels = new Hashtable();
ArrayList levels = new ArrayList();
Hashtable level = new Hashtable();
level.Add("id", "00000000-0000-0000-0000-000000000000");
level.Add("description", "some level");
levels.Add(level);
//membershiplevels.Add("levels",levels);
Hashtable landuse = new Hashtable();
landuse.Add("upgrade", false);
landuse.Add("action", "http://invaliddomaininvalid.com/");
Hashtable currency = new Hashtable();
currency.Add("estimatedCost", 0);
Hashtable membership = new Hashtable();
membershiplevels.Add("upgrade", false);
membershiplevels.Add("action", "http://invaliddomaininvalid.com/");
membershiplevels.Add("levels", membershiplevels);
retparam.Add("success", true);
retparam.Add("currency", currency);
retparam.Add("membership", membership);
retparam.Add("landuse", landuse);
retparam.Add("confirm", "asdfajsdkfjasdkfjalsdfjasdf");
ret.Value = retparam;
return ret;
}
public XmlRpcResponse landBuy_func(XmlRpcRequest request)
{
XmlRpcResponse ret = new XmlRpcResponse();
Hashtable retparam = new Hashtable();
Hashtable requestData = (Hashtable) request.Params[0];
UUID agentId = UUID.Zero;
int amount = 0;
if (requestData.ContainsKey("agentId") && requestData.ContainsKey("currencyBuy"))
{
UUID.TryParse((string) requestData["agentId"], out agentId);
try
{
amount = (Int32) requestData["currencyBuy"];
}
catch (InvalidCastException)
{
}
if (agentId != UUID.Zero)
{
lock (m_KnownClientFunds)
{
if (m_KnownClientFunds.ContainsKey(agentId))
{
m_KnownClientFunds[agentId] += amount;
}
else
{
m_KnownClientFunds.Add(agentId, amount);
}
}
IClientAPI client = LocateClientObject(agentId);
if (client != null)
{
SendMoneyBalance(client, agentId, client.SessionId, UUID.Zero);
}
}
}
retparam.Add("success", true);
ret.Value = retparam;
return ret;
}
#endregion
#region local Fund Management
///
/// Ensures that the agent accounting data is set up in this instance.
///
///
private void CheckExistAndRefreshFunds(UUID agentID)
{
lock (m_KnownClientFunds)
{
if (!m_KnownClientFunds.ContainsKey(agentID))
{
m_KnownClientFunds.Add(agentID, m_stipend);
}
else
{
if (m_KnownClientFunds[agentID] <= m_minFundsBeforeRefresh)
{
m_KnownClientFunds[agentID] = m_stipend;
}
}
}
}
///
/// Gets the amount of Funds for an agent
///
///
///
private int GetFundsForAgentID(UUID AgentID)
{
int returnfunds = 0;
lock (m_KnownClientFunds)
{
if (m_KnownClientFunds.ContainsKey(AgentID))
{
returnfunds = m_KnownClientFunds[AgentID];
}
else
{
//throw new Exception("Unable to get funds.");
}
}
return returnfunds;
}
private void SetLocalFundsForAgentID(UUID AgentID, int amount)
{
lock (m_KnownClientFunds)
{
if (m_KnownClientFunds.ContainsKey(AgentID))
{
m_KnownClientFunds[AgentID] = amount;
}
else
{
m_KnownClientFunds.Add(AgentID, amount);
}
}
}
#endregion
#region Utility Helpers
///
/// Locates a IClientAPI for the client specified
///
///
///
private IClientAPI LocateClientObject(UUID AgentID)
{
ScenePresence tPresence = null;
IClientAPI rclient = null;
lock (m_scenel)
{
foreach (Scene _scene in m_scenel.Values)
{
tPresence = _scene.GetScenePresence(AgentID);
if (tPresence != null)
{
if (!tPresence.IsChildAgent)
{
rclient = tPresence.ControllingClient;
}
}
if (rclient != null)
{
return rclient;
}
}
}
return null;
}
private Scene LocateSceneClientIn(UUID AgentId)
{
lock (m_scenel)
{
foreach (Scene _scene in m_scenel.Values)
{
ScenePresence tPresence = _scene.GetScenePresence(AgentId);
if (tPresence != null)
{
if (!tPresence.IsChildAgent)
{
return _scene;
}
}
}
}
return null;
}
///
/// Utility function Gets a Random scene in the instance. For when which scene exactly you're doing something with doesn't matter
///
///
public Scene GetRandomScene()
{
lock (m_scenel)
{
foreach (Scene rs in m_scenel.Values)
return rs;
}
return null;
}
///
/// Utility function to get a Scene by RegionID in a module
///
///
///
public Scene GetSceneByUUID(UUID RegionID)
{
lock (m_scenel)
{
foreach (Scene rs in m_scenel.Values)
{
if (rs.RegionInfo.originRegionID == RegionID)
{
return rs;
}
}
}
return null;
}
#endregion
#region event Handlers
public void requestPayPrice(IClientAPI client, UUID objectID)
{
Scene scene = LocateSceneClientIn(client.AgentId);
if (scene == null)
return;
SceneObjectPart task = scene.GetSceneObjectPart(objectID);
if (task == null)
return;
SceneObjectGroup group = task.ParentGroup;
SceneObjectPart root = group.RootPart;
client.SendPayPrice(objectID, root.PayPrice);
}
///
/// When the client closes the connection we remove their accounting info from memory to free up resources.
///
///
public void ClientClosed(UUID AgentID)
{
lock (m_KnownClientFunds)
{
if (m_keepMoneyAcrossLogins && m_MoneyAddress.Length == 0)
{
}
else
{
m_KnownClientFunds.Remove(AgentID);
}
}
}
///
/// Event called Economy Data Request handler.
///
///
public void EconomyDataRequestHandler(UUID agentId)
{
IClientAPI user = LocateClientObject(agentId);
if (user != null)
{
user.SendEconomyData(EnergyEfficiency, ObjectCapacity, ObjectCount, PriceEnergyUnit, PriceGroupCreate,
PriceObjectClaim, PriceObjectRent, PriceObjectScaleFactor, PriceParcelClaim, PriceParcelClaimFactor,
PriceParcelRent, PricePublicObjectDecay, PricePublicObjectDelete, PriceRentLight, PriceUpload,
TeleportMinPrice, TeleportPriceExponent);
}
}
private void ValidateLandBuy(Object osender, EventManager.LandBuyArgs e)
{
if (m_MoneyAddress.Length == 0)
{
lock (m_KnownClientFunds)
{
if (m_KnownClientFunds.ContainsKey(e.agentId))
{
// Does the sender have enough funds to give?
if (m_KnownClientFunds[e.agentId] >= e.parcelPrice)
{
lock (e)
{
e.economyValidated = true;
}
}
}
}
}
else
{
if (GetRemoteBalance(e.agentId) >= e.parcelPrice)
{
lock (e)
{
e.economyValidated = true;
}
}
}
}
private void processLandBuy(Object osender, EventManager.LandBuyArgs e)
{
lock (e)
{
if (e.economyValidated == true && e.transactionID == 0)
{
e.transactionID = Util.UnixTimeSinceEpoch();
if (doMoneyTransfer(e.agentId, e.parcelOwnerID, e.parcelPrice, 0, "Land purchase"))
{
lock (e)
{
e.amountDebited = e.parcelPrice;
}
}
}
}
}
///
/// THis method gets called when someone pays someone else as a gift.
///
///
///
private void MoneyTransferAction(Object osender, EventManager.MoneyTransferArgs e)
{
IClientAPI sender = null;
IClientAPI receiver = null;
if (m_MoneyAddress.Length > 0) // Handled on server
e.description = String.Empty;
if (e.transactiontype == 5008) // Object gets paid
{
sender = LocateClientObject(e.sender);
if (sender != null)
{
SceneObjectPart part = findPrim(e.receiver);
if (part == null)
return;
string name = resolveAgentName(part.OwnerID);
if (name == String.Empty)
name = "(hippos)";
receiver = LocateClientObject(part.OwnerID);
string description = String.Format("Paid {0} via object {1}", name, e.description);
bool transactionresult = doMoneyTransfer(e.sender, part.OwnerID, e.amount, e.transactiontype, description);
if (transactionresult)
{
ObjectPaid handlerOnObjectPaid = OnObjectPaid;
if (handlerOnObjectPaid != null)
{
handlerOnObjectPaid(e.receiver, e.sender, e.amount);
}
}
if (e.sender != e.receiver)
{
sender.SendMoneyBalance(UUID.Random(), transactionresult, Utils.StringToBytes(e.description), GetFundsForAgentID(e.sender));
}
if (receiver != null)
{
receiver.SendMoneyBalance(UUID.Random(), transactionresult, Utils.StringToBytes(e.description), GetFundsForAgentID(part.OwnerID));
}
}
return;
}
sender = LocateClientObject(e.sender);
if (sender != null)
{
receiver = LocateClientObject(e.receiver);
bool transactionresult = doMoneyTransfer(e.sender, e.receiver, e.amount, e.transactiontype, e.description);
if (e.sender != e.receiver)
{
if (sender != null)
{
sender.SendMoneyBalance(UUID.Random(), transactionresult, Utils.StringToBytes(e.description), GetFundsForAgentID(e.sender));
}
}
if (receiver != null)
{
receiver.SendMoneyBalance(UUID.Random(), transactionresult, Utils.StringToBytes(e.description), GetFundsForAgentID(e.receiver));
}
}
else
{
m_log.Warn("[MONEY]: Potential Fraud Warning, got money transfer request for avatar that isn't in this simulator - Details; Sender:" +
e.sender.ToString() + " Receiver: " + e.receiver.ToString() + " Amount: " + e.amount.ToString());
}
}
///
/// Event Handler for when a root agent becomes a child agent
///
///
private void MakeChildAgent(ScenePresence avatar)
{
lock (m_rootAgents)
{
if (m_rootAgents.ContainsKey(avatar.UUID))
{
if (m_rootAgents[avatar.UUID] == avatar.Scene.RegionInfo.originRegionID)
{
m_rootAgents.Remove(avatar.UUID);
// m_log.Debug("[MONEY]: Removing " + avatar.Firstname + " " + avatar.Lastname + " as a root agent");
}
}
}
}
///
/// Event Handler for when the client logs out.
///
///
private void ClientLoggedOut(UUID AgentId)
{
lock (m_rootAgents)
{
if (m_rootAgents.ContainsKey(AgentId))
{
m_rootAgents.Remove(AgentId);
//m_log.Info("[MONEY]: Removing " + AgentId + ". Agent logged out.");
}
}
}
///
/// Call this when the client disconnects.
///
///
public void ClientClosed(IClientAPI client)
{
ClientClosed(client.AgentId);
}
///
/// Event Handler for when an Avatar enters one of the parcels in the simulator.
///
///
///
///
private void AvatarEnteringParcel(ScenePresence avatar, int localLandID, UUID regionID)
{
lock (m_rootAgents)
{
if (m_rootAgents.ContainsKey(avatar.UUID))
{
if (avatar.Scene.RegionInfo.originRegionID != m_rootAgents[avatar.UUID])
{
m_rootAgents[avatar.UUID] = avatar.Scene.RegionInfo.originRegionID;
//m_log.Info("[MONEY]: Claiming " + avatar.Firstname + " " + avatar.Lastname + " in region:" + avatar.RegionHandle + ".");
// Claim User! my user! Mine mine mine!
if (m_MoneyAddress.Length > 0)
{
Scene RegionItem = GetSceneByUUID(regionID);
if (RegionItem != null)
{
Hashtable hresult =
claim_user(avatar.UUID, avatar.ControllingClient.SecureSessionId, regionID, RegionItem.RegionInfo.regionSecret);
if ((bool)hresult["success"] == true)
{
int funds = 0;
try
{
funds = (Int32)hresult["funds"];
}
catch (InvalidCastException)
{
}
SetLocalFundsForAgentID(avatar.UUID, funds);
}
else
{
avatar.ControllingClient.SendAgentAlertMessage((string)hresult["errorMessage"], true);
}
}
}
}
else
{
ILandObject obj = avatar.Scene.LandChannel.GetLandObject(avatar.AbsolutePosition.X, avatar.AbsolutePosition.Y);
if ((obj.landData.Flags & (uint)Parcel.ParcelFlags.AllowDamage) != 0)
{
avatar.Invulnerable = false;
}
else
{
avatar.Invulnerable = true;
}
}
}
else
{
lock (m_rootAgents)
{
m_rootAgents.Add(avatar.UUID, avatar.Scene.RegionInfo.originRegionID);
}
if (m_MoneyAddress.Length > 0)
{
Scene RegionItem = GetSceneByUUID(regionID);
if (RegionItem != null)
{
Hashtable hresult = claim_user(avatar.UUID, avatar.ControllingClient.SecureSessionId, regionID, RegionItem.RegionInfo.regionSecret);
if ((bool) hresult["success"] == true)
{
int funds = 0;
try
{
funds = (Int32) hresult["funds"];
}
catch (InvalidCastException)
{
}
SetLocalFundsForAgentID(avatar.UUID, funds);
}
else
{
avatar.ControllingClient.SendAgentAlertMessage((string) hresult["errorMessage"], true);
}
}
}
//m_log.Info("[MONEY]: Claiming " + avatar.Firstname + " " + avatar.Lastname + " in region:" + avatar.RegionHandle + ".");
}
}
//m_log.Info("[FRIEND]: " + avatar.Name + " status:" + (!avatar.IsChildAgent).ToString());
}
public int GetBalance(IClientAPI client)
{
GetClientFunds(client);
lock (m_KnownClientFunds)
{
if (!m_KnownClientFunds.ContainsKey(client.AgentId))
return 0;
return m_KnownClientFunds[client.AgentId];
}
}
// Please do not refactor these to be just one method
// Existing implementations need the distinction
//
public bool UploadCovered(IClientAPI client)
{
return AmountCovered(client, PriceUpload);
}
public bool GroupCreationCovered(IClientAPI client)
{
return AmountCovered(client, PriceGroupCreate);
}
public bool AmountCovered(IClientAPI client, int amount)
{
if (GetBalance(client) < amount)
return false;
return true;
}
#endregion
public void ObjectBuy(IClientAPI remoteClient, UUID agentID,
UUID sessionID, UUID groupID, UUID categoryID,
uint localID, byte saleType, int salePrice)
{
GetClientFunds(remoteClient);
if (!m_KnownClientFunds.ContainsKey(remoteClient.AgentId))
{
remoteClient.SendAgentAlertMessage("Unable to buy now. Your account balance was not found.", false);
return;
}
int funds = m_KnownClientFunds[remoteClient.AgentId];
if (salePrice != 0 && funds < salePrice)
{
remoteClient.SendAgentAlertMessage("Unable to buy now. You don't have sufficient funds.", false);
return;
}
Scene s = LocateSceneClientIn(remoteClient.AgentId);
SceneObjectPart part = s.GetSceneObjectPart(localID);
if (part == null)
{
remoteClient.SendAgentAlertMessage("Unable to buy now. The object was not found.", false);
return;
}
if (s.PerformObjectBuy(remoteClient, categoryID, localID, saleType))
doMoneyTransfer(remoteClient.AgentId, part.OwnerID, salePrice, 5000, "Object buy");
}
}
public enum TransactionType : int
{
SystemGenerated = 0,
RegionMoneyRequest = 1,
Gift = 2,
Purchase = 3
}
}