public bool UserCurrencyUpdate(StarDustUserCurrency agent)
{
if (m_doRemoteCalls)
{
return((bool)DoRemote(agent));
}
return(m_database.UserCurrencyUpdate(agent));
}
private object RestrictedCurrencyPurchaseRemove_Event(string functionName, object parameters)
{
RestrictedCurrencyInfo pcri = new RestrictedCurrencyInfo();
pcri.FromOSD((OSDMap)OSDParser.DeserializeJson(parameters.ToString()));
StarDustUserCurrency starDustUserCurrency = UserCurrencyInfo(pcri.AgentID);
starDustUserCurrency.RestrictPurchaseAmount -= pcri.Amount;
m_database.UserCurrencyUpdate(starDustUserCurrency);
return(true);
}
public XmlRpcResponse QuoteFunc(XmlRpcRequest request, IPEndPoint ep)
{
Hashtable requestData = (Hashtable)request.Params[0];
XmlRpcResponse returnval = new XmlRpcResponse();
if (requestData.ContainsKey("agentId") && requestData.ContainsKey("currencyBuy"))
{
uint amount = uint.Parse(requestData["currencyBuy"].ToString());
UUID theagent = new UUID(requestData["agentId"].ToString());
StarDustUserCurrency currency = m_dustCurrencyService.UserCurrencyInfo(theagent);
bool successful = !(m_dustCurrencyService.m_options.MaxAmountPurchase < currency.RestrictPurchaseAmount + amount);
if (!successful)
{
m_dustCurrencyService.SendGridMessage(theagent, string.Format("Amount was over the limit. {0} is the max amount.", m_dustCurrencyService.m_options.MaxAmountPurchase - currency.RestrictPurchaseAmount), false, UUID.Zero);
}
returnval.Value = new Hashtable
{
{ "success", successful },
{
"currency",
new Hashtable
{
{
"estimatedCost",
Convert.ToInt32(
Math.Round(((float.Parse(amount.ToString()) /
m_dustCurrencyService.m_options.
RealCurrencyConversionFactor) +
((float.Parse(amount.ToString()) /
m_dustCurrencyService.m_options.
RealCurrencyConversionFactor) *
(m_dustCurrencyService.m_options.
AdditionPercentage / 10000.0)) +
(m_dustCurrencyService.m_options.
AdditionAmount / 100.0)) * 100))
},
{ "currencyBuy", (int)amount }
}
},
{ "confirm", "asdfad9fj39ma9fj" }
};
return(returnval);
}
returnval.Value = new Hashtable
{
{ "success", false },
{ "errorMessage", "Invalid parameters passed to the quote box" },
{ "errorURI", m_dustCurrencyService.m_options.ErrorURI }
};
return(returnval);
}
public bool UserCurrencyUpdate(StarDustUserCurrency agent)
{
m_gd.Update("stardust_currency",
new Dictionary <string, object>
{
{ "LandInUse", agent.LandInUse },
{ "Tier", agent.Tier },
{ "IsGroup", agent.IsGroup },
{ "RestrictedAmount", agent.RestrictedAmount },
{ "RestrictPurchaseAmount", agent.RestrictPurchaseAmount }
}, null,
new QueryFilter()
{
andFilters = new Dictionary <string, object> {
{ "PrincipalID", agent.PrincipalID }
}
}
, null, null);
return(true);
}
public StarDustUserCurrency GetUserCurrency(UUID agentId)
{
StarDustUserCurrency starDustUser = new StarDustUserCurrency {
PrincipalID = agentId, Amount = 0, LandInUse = 0, Tier = 0
};
Dictionary <string, object> where = new Dictionary <string, object>(1);
where["PrincipalID"] = agentId;
List <string> query = m_gd.Query(new string[] { "*" }, "stardust_currency", new QueryFilter()
{
andFilters = where
}, null, null, null);
if (query.Count == 0)
{
UserCurrencyCreate(agentId);
return(starDustUser);
}
starDustUser.FromArray(query);
return(starDustUser);
}
/// <summary>
///
/// </summary>
/// <param name="transaction"></param>
/// <param name="trans"></param>
/// <returns></returns>
private bool UserCurrencyTransaction(Transaction transaction, out Transaction trans)
{
// write the history
if (!WriteHistory(transaction, out transaction))
{
trans = transaction;
return(false);
}
// get users currency
StarDustUserCurrency fromBalance = GetUserCurrency(new UUID(transaction.FromID));
// Ensure sender has enough money
if ((!m_options.AllowBankerToHaveNoMoney ||
(m_options.AllowBankerToHaveNoMoney && m_options.BankerPrincipalID != transaction.FromID)) &&
fromBalance.Amount < transaction.Amount)
{
transaction.Complete = 0;
transaction.CompleteReason = "Send amount is greater than sender has";
WriteHistory(transaction, out transaction);
trans = transaction;
return(false);
}
if (transaction.FromID != m_options.BankerPrincipalID)
{
if ((fromBalance.RestrictedAmount > 0) && ((fromBalance.Amount - fromBalance.RestrictedAmount) < transaction.Amount))
{
transaction.Complete = 0;
transaction.CompleteReason = "Failed transaction. $" + fromBalance.RestrictedAmount + " of your currency is restricted for " + m_options.RestrictMoneyHoursAfterPurchase + " hours after purchase. You can spend " + (fromBalance.Amount - fromBalance.RestrictedAmount) + ". Sorry";
WriteHistory(transaction, out transaction);
trans = transaction;
return(false);
}
}
// update sender
m_gd.Update("stardust_currency",
(fromBalance.Amount - transaction.Amount) >= fromBalance.StipendsBalance
? new Dictionary <string, object> {
{ "Amount", fromBalance.Amount - transaction.Amount }
}
: new Dictionary <string, object>
{
{ "Amount", fromBalance.Amount - transaction.Amount },
{
"StipendsBalance",
fromBalance.StipendsBalance -
(fromBalance.StipendsBalance - (fromBalance.Amount - transaction.Amount))
}
}, null,
new QueryFilter()
{
andFilters = new Dictionary <string, object> {
{ "PrincipalID", transaction.FromID }
}
}, null,
null);
StarDustUserCurrency toBalance = GetUserCurrency(new UUID(transaction.ToID));
if (transaction.TypeOfTrans == TransactionType.StipendPayment)
{
m_gd.Update("stardust_currency",
new Dictionary <string, object> {
{ "Amount", toBalance.Amount + transaction.Amount }, { "StipendsBalance", toBalance.StipendsBalance + transaction.Amount }
}, null,
new QueryFilter()
{
andFilters = new Dictionary <string, object> {
{ "PrincipalID", transaction.ToID }
}
}, null,
null);
}
else
{
m_gd.Update("stardust_currency",
new Dictionary <string, object> {
{ "Amount", toBalance.Amount + transaction.Amount }
}, null,
new QueryFilter()
{
andFilters = new Dictionary <string, object> {
{ "PrincipalID", transaction.ToID }
}
}, null,
null);
}
// update logs
transaction.Complete = 1;
transaction.CompleteReason = "";
transaction.ToBalance = toBalance.Amount + transaction.Amount;
transaction.FromBalance = fromBalance.Amount - transaction.Amount;
WriteHistory(transaction, out transaction);
trans = transaction;
return(true);
}
public void RestrictCurrency(StarDustUserCurrency currency, Transaction transaction, UUID agentId)
{
if ((m_options.MaxAmountPurchaseDays > 0) && (m_options.MaxAmountPurchase > 0))
{
currency.RestrictPurchaseAmount += transaction.Amount;
Scheduler.Save(new SchedulerItem("RestrictedCurrencyPurchaseRemove",
OSDParser.SerializeJsonString(new RestrictedCurrencyInfo()
{
AgentID = agentId,
Amount = transaction.Amount,
FromTransactionID = transaction.TransactionID
}.ToOSD()),
true, DateTime.UtcNow,
m_options.MaxAmountPurchaseDays,
RepeatType.days, agentId)
{
HisotryKeep = true,
HistoryReciept = false,
RunOnce = true
});
UserCurrencyUpdate(currency);
}
if ((m_options.RestrictMoneyHoursAfterPurchase > 0) && (m_options.RestrictMoneyCanSpendAfterPurchase > 0))
{
uint amount2Restrict = 0;
if (currency.RestrictedAmount == 0)
{
if (transaction.Amount >= m_options.RestrictMoneyCanSpendAfterPurchase)
{
amount2Restrict = transaction.Amount - (uint)m_options.RestrictMoneyCanSpendAfterPurchase;
}
else //because its less than the amount we allow them to spend, we restricted it all.. why? because else they could buy over and over with no restrictions
{
amount2Restrict = transaction.Amount / 2;
}
}
else // if they already have money restricted we restrict everything
{
amount2Restrict = transaction.Amount;
}
currency.RestrictedAmount += amount2Restrict;
Scheduler.Save(new SchedulerItem("RestrictedCurrencySpendRemove",
OSDParser.SerializeJsonString(new RestrictedCurrencyInfo()
{
AgentID = agentId,
Amount = amount2Restrict,
FromTransactionID = transaction.TransactionID
}.ToOSD()),
true, DateTime.UtcNow,
m_options.RestrictMoneyHoursAfterPurchase,
RepeatType.hours, agentId)
{
HisotryKeep = true,
HistoryReciept = false,
RunOnce = true
});
UserCurrencyUpdate(currency);
}
}
public UUID StartPurchaseOrATMTransfer(UUID agentId, uint amountBuying, PurchaseType purchaseType, string gridName)
{
bool success = false;
UserAccount ua = Registry.RequestModuleInterface <IUserAccountService>().GetUserAccount(null, agentId);
if (ua == null)
{
return(UUID.Zero);
}
string agentName = ua.Name;
UUID RegionID = UUID.Zero;
string RegionName = "";
if (purchaseType == PurchaseType.InWorldPurchaseOfCurrency)
{
IClientCapsService client = Registry.RequestModuleInterface <ICapsService>().GetClientCapsService(agentId);
if (client != null)
{
IRegionClientCapsService regionClient = client.GetRootCapsService();
RegionID = regionClient.Region.RegionID;
RegionName = regionClient.Region.RegionName;
}
}
else if (purchaseType == PurchaseType.ATMTransferFromAnotherGrid)
{
RegionName = "Grid:" + gridName;
}
else
{
RegionName = "Unknown";
}
UUID purchaseID = UUID.Random();
success = m_database.UserCurrencyBuy(purchaseID, agentId, agentName, amountBuying, m_options.RealCurrencyConversionFactor,
new RegionTransactionDetails
{
RegionID = RegionID,
RegionName = RegionName
}, (int)purchaseType);
StarDustUserCurrency currency = UserCurrencyInfo(agentId);
if (m_options.AutoApplyCurrency && success)
{
Transaction transaction;
m_database.UserCurrencyBuyComplete(purchaseID, 1, "AutoComplete",
m_options
.AutoApplyCurrency.ToString
(), "Auto Complete",
out transaction);
UserCurrencyTransfer(transaction.ToID,
m_options.
BankerPrincipalID, UUID.Zero, UUID.Zero,
transaction.Amount, "Currency Purchase",
TransactionType.SystemGenerated,
transaction.TransactionID);
RestrictCurrency(currency, transaction, agentId);
}
else if (success && (m_options.AfterCurrencyPurchaseMessage != string.Empty) && (purchaseType == PurchaseType.InWorldPurchaseOfCurrency))
{
SendGridMessage(agentId, String.Format(m_options.AfterCurrencyPurchaseMessage, purchaseID.ToString()), false, UUID.Zero);
}
if (success)
{
return(purchaseID);
}
return(UUID.Zero);
}
public XmlRpcResponse PreflightBuyLandPrepFunc(XmlRpcRequest request, IPEndPoint ep)
{
Hashtable requestData = (Hashtable)request.Params[0];
XmlRpcResponse ret = new XmlRpcResponse();
Hashtable retparam = new Hashtable();
Hashtable membershiplevels = new Hashtable();
membershiplevels.Add("levels", membershiplevels);
Hashtable landuse = new Hashtable();
Hashtable level = new Hashtable
{
{ "id", "00000000-0000-0000-0000-000000000000" },
{ m_dustCurrencyService.m_options.UpgradeMembershipUri, "Premium Membership" }
};
if (requestData.ContainsKey("agentId") && requestData.ContainsKey("currencyBuy"))
{
UUID agentId;
UUID.TryParse((string)requestData["agentId"], out agentId);
StarDustUserCurrency currency = m_dustCurrencyService.UserCurrencyInfo(agentId);
IUserProfileInfo profile = DataManager.RequestPlugin <IProfileConnector>("IProfileConnector").GetUserProfile(agentId);
IClientCapsService client = m_dustCurrencyService.Registry.RequestModuleInterface <ICapsService>().GetClientCapsService(agentId);
OSDMap replyData = m_dustCurrencyService.GetParcelDetails(agentId);
if (replyData == null)
{
landuse.Add("action", false);
retparam.Add("success", false);
retparam.Add("currency", currency);
retparam.Add("membership", level);
retparam.Add("landuse", landuse);
retparam.Add("confirm", "asdfajsdkfjasdkfjalsdfjasdf");
ret.Value = retparam;
}
else
{
if (client != null)
{
m_dustCurrencyService.SendGridMessage(agentId, String.Format(m_dustCurrencyService.m_options.MessgeBeforeBuyLand, profile.DisplayName, replyData.ContainsKey("SalePrice")), false, UUID.Zero);
}
if (replyData.ContainsKey("SalePrice"))
{
// I think, this might be usable if they don't have the money
// Hashtable currencytable = new Hashtable { { "estimatedCost", replyData["SalePrice"].AsInteger() } };
int landTierNeeded = (int)(currency.LandInUse + replyData["Area"].AsInteger());
bool needsUpgrade = false;
switch (profile.MembershipGroup)
{
case "Premium":
case "":
needsUpgrade = landTierNeeded >= currency.Tier;
break;
case "Banned":
needsUpgrade = true;
break;
}
// landuse.Add("action", m_DustCurrencyService.m_options.upgradeMembershipUri);
landuse.Add("action", needsUpgrade);
retparam.Add("success", true);
retparam.Add("currency", currency);
retparam.Add("membership", level);
retparam.Add("landuse", landuse);
retparam.Add("confirm", "asdfajsdkfjasdkfjalsdfjasdf");
ret.Value = retparam;
}
}
}
return(ret);
}
