internal bool requestAssetPurchase(String token, long assetID, int expectedPrice, CurrencyType currency, String cookies)
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create("https://m.roblox.com/Catalog/ProcessPurchase");
request.KeepAlive = true;
request.Accept = "text/html, */*; q=0.01";
request.Headers.Add("Origin", @"https://m.roblox.com");
request.Headers.Add("X-Requested-With", @"XMLHttpRequest");
request.UserAgent = "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.2454.85 Safari/537.36";
request.ContentType = "application/x-www-form-urlencoded; charset=UTF-8";
request.Referer = "https://m.roblox.com/items/295133189";
request.Headers.Set(HttpRequestHeader.AcceptEncoding, "gzip, deflate");
request.Headers.Set(HttpRequestHeader.AcceptLanguage, "en-US,en;q=0.8");
request.Headers.Set(HttpRequestHeader.Cookie, cookies);
request.Method = "POST";
request.ServicePoint.Expect100Continue = false;
string body = @"__RequestVerificationToken=" + token + "&CurrencyType=" + ((currency == CurrencyType.ROBUX) ? "1" : "2") + "&AssetID="+assetID+"&UserAssetOptionID=0&ExpectedPrice="+expectedPrice;
byte[] postBytes = System.Text.Encoding.UTF8.GetBytes(body);
request.ContentLength = postBytes.Length;
Stream stream = request.GetRequestStream();
stream.Write(postBytes, 0, postBytes.Length);
stream.Close();
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
using (BufferedStream receiveStream = new BufferedStream(response.GetResponseStream()))
{
using (StreamReader readStream = new StreamReader(receiveStream, Encoding.UTF8))
{
String s = readStream.ReadToEnd();
return s.Contains("successfully");
}
}
}
public ActionResult ConvertCurrency(double amount, CurrencyType convertFrom, CurrencyType convertTo)
{
double multiplier = GetMultiplier(convertFrom, convertTo);
double convertedAmount = amount * multiplier;
return Json(convertedAmount, JsonRequestBehavior.AllowGet);
}
public LimitedPurchaseResponse requestLimitedPurchase(String XRSFToken, int productID, CurrencyType currency, int expectedPrice, int expectedSellerID, int userAssetID, String cookies)
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create("http://www.roblox.com/api/item.ashx?rqtype=purchase&productID=" + productID + "&expectedCurrency=" + ((currency == CurrencyType.ROBUX) ? "1" : "2") + "&expectedPrice=" + expectedPrice + "&expectedSellerID=" + expectedSellerID + "&userAssetID=" + userAssetID);
request.KeepAlive = true;
request.Accept = "*/*";
request.Headers.Add("Origin", @"http://www.roblox.com");
request.Headers.Add("X-CSRF-TOKEN", XRSFToken);
request.UserAgent = RobloxUtils.UserAgent;
request.ContentType = "application/json; charset=utf-8";
request.Headers.Set(HttpRequestHeader.AcceptEncoding, "gzip, deflate");
request.Headers.Set(HttpRequestHeader.AcceptLanguage, "en-US,en;q=0.8");
request.Headers.Set(HttpRequestHeader.Cookie, cookies);
request.Method = "POST";
request.ServicePoint.Expect100Continue = false;
string body = @"";
byte[] postBytes = Encoding.UTF8.GetBytes(body);
request.ContentLength = postBytes.Length;
Stream stream = request.GetRequestStream();
stream.Write(postBytes, 0, postBytes.Length);
stream.Close();
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
using (Stream receiveStream = RobloxUtils.decodeStream(response))
{
using (StreamReader readStream = new StreamReader(receiveStream, Encoding.UTF8))
{
String s = readStream.ReadToEnd();
return JsonConvert.DeserializeObject<LimitedPurchaseResponse>(s);
}
}
}
public AccountDTO(Int32 accountID, Decimal balance, CurrencyType currency, Int32 client_ClientID)
{
this.AccountID = accountID;
this.Balance = balance;
this.Currency = currency;
this.Client_ClientID = client_ClientID;
}
public QuerySettings(string origin, string destination = "-", DateTime? departDate = null, DateTime? returnDate = null, CurrencyType currency = CurrencyType.RUB)
: this(origin, destination)
{
Currency = currency;
DepartDate = departDate;
ReturnDate = returnDate;
}
public static void RaiseRateChanging(CurrencyType currencyRiseChanger)
{
((System.Collections.Generic.IEnumerable<CurrencyWapper>)CurrencyTable).ForEach<CurrencyWapper>(delegate(CurrencyWapper p)
{
p.RaiseRateChanged();
});
}
public static decimal ConvertTo(decimal fromAmount, CurrencyType fromCurrencyType, CurrencyType toCurrencyType, Currency[] currencies)
{
if (fromCurrencyType == toCurrencyType)
return fromAmount;
if ((fromCurrencyType != CurrencyType.CZK && currencies.All(c => c.CurrencyType != fromCurrencyType)) ||
toCurrencyType != CurrencyType.CZK && currencies.All(c => c.CurrencyType != toCurrencyType))
{
throw new Exception(String.Format(ValidationResource.Currency_CannotProccessCurrencyChange_ErrorMessage, fromCurrencyType, toCurrencyType));
}
decimal amountTo = fromAmount;
Currency currency;
// Převod konta na CZK
if (fromCurrencyType != CurrencyType.CZK)
{
currency = currencies.Single(c => c.CurrencyType == fromCurrencyType);
amountTo = amountTo * currency.ExchangeRateToCZK;
}
// Převod konta na aktuální měnu
if (toCurrencyType != CurrencyType.CZK)
{
currency = currencies.Single(c => c.CurrencyType == toCurrencyType);
amountTo = amountTo / currency.ExchangeRateToCZK;
}
return amountTo;
}
public PaymentTransactionConfirmed(int paymentTransactionID,string txID, int confirmations, CurrencyType currencyType, int byUserID = 0)
{
this.PaymentTransactionID = paymentTransactionID;
this.TxID = txID;
this.Confirmations = confirmations;
this.Currency = currencyType;
this.ByUserID = byUserID;
}
public CreateAccount(CurrencyType currency, int userID)
{
Check.Argument.IsNotNegativeOrZero(userID, "userID");
Check.Argument.IsNotNull(currency, "currency");
this.Currency = currency;
this.UserID = userID;
}
public override decimal GetRate(CurrencyType @from, CurrencyType to) {
if(ExchangeRates.ContainsKey(@from) && ExchangeRates[@from].ContainsKey(to))
return ExchangeRates[@from][to];
if(ExchangeRates.ContainsKey(to) && ExchangeRates[to].ContainsKey(@from))
return 1m / ExchangeRates[to][@from];
throw new UnknownExchangeRateException(String.Format("Exchange rate between '{0}' and '{1}' not known", @from.Code, to.Code));
}
public FixedFeeCurrencyWallet(decimal entryFixedFee, decimal exitFixedFee, CurrencyType currencyType, IExchange exchange)
{
_entryFixedFee = entryFixedFee;
_exitFixedFee = exitFixedFee;
Currency = currencyType;
_exchange = exchange;
}
public PercentageFeeCurrencyWallet(decimal entryPercentFee, decimal exitPercentFee, CurrencyType currencyWallet, IExchange exchange)
{
_exchange = exchange;
_entryPercentFee = entryPercentFee;
_exitPercentFee = exitPercentFee;
Currency = currencyWallet;
}
public GeneratePaymentAddress(int userID, CurrencyType currency)
{
Check.Argument.IsNotNegativeOrZero(userID, "userID");
Check.Argument.IsNotNegativeOrZero((int)currency, "currency");
this.UserID = userID;
this.Currency = currency;
}
public TinyMoneyManager.CurrencyConverterByWebService.Currency SwitchCurrency(CurrencyType localVer)
{
TinyMoneyManager.CurrencyConverterByWebService.Currency cNY = TinyMoneyManager.CurrencyConverterByWebService.Currency.CNY;
switch (localVer)
{
case CurrencyType.CNY:
return cNY;
case CurrencyType.USD:
return TinyMoneyManager.CurrencyConverterByWebService.Currency.USD;
case CurrencyType.NTD:
return TinyMoneyManager.CurrencyConverterByWebService.Currency.TWD;
case CurrencyType.HKD:
return TinyMoneyManager.CurrencyConverterByWebService.Currency.HKD;
case CurrencyType.AUD:
return TinyMoneyManager.CurrencyConverterByWebService.Currency.AUD;
case CurrencyType.EUR:
return TinyMoneyManager.CurrencyConverterByWebService.Currency.EUR;
case CurrencyType.JPY:
return TinyMoneyManager.CurrencyConverterByWebService.Currency.JPY;
case CurrencyType.GBP:
return TinyMoneyManager.CurrencyConverterByWebService.Currency.GBP;
case CurrencyType.MYR:
return TinyMoneyManager.CurrencyConverterByWebService.Currency.MYR;
case CurrencyType.SGD:
return TinyMoneyManager.CurrencyConverterByWebService.Currency.SGD;
case CurrencyType.THP:
return TinyMoneyManager.CurrencyConverterByWebService.Currency.THB;
case CurrencyType.PKR:
return TinyMoneyManager.CurrencyConverterByWebService.Currency.PKR;
case CurrencyType.INR:
return TinyMoneyManager.CurrencyConverterByWebService.Currency.INR;
case CurrencyType.KRW:
return TinyMoneyManager.CurrencyConverterByWebService.Currency.KRW;
case CurrencyType.IDR:
return TinyMoneyManager.CurrencyConverterByWebService.Currency.IDR;
case CurrencyType.BYR:
return TinyMoneyManager.CurrencyConverterByWebService.Currency.RUB;
case CurrencyType.PHP:
return TinyMoneyManager.CurrencyConverterByWebService.Currency.PHP;
}
return cNY;
}
public VirtualCoinDepositCompleted(int depositID, int depositUserID, int accountID, decimal depositAmount, CurrencyType currency, int byUserID)
{
this.DepositID = depositID;
this.DepositUserID = depositUserID;
this.Currency = currency;
this.AccountID = accountID;
this.DepositAmount = depositAmount;
this.ByUserID = byUserID;
}
public AccountChangedByCancelDeposit(int userID, int accountID, decimal depositAmount, int depositID, CurrencyType currency)
{
this.UserID = userID;
this.AccountID = accountID;
this.DepositID = depositID;
this.DepositAmount = depositAmount;
this.Currency = currency;
this.ModifyType = Convert.ToInt32(AccountModifyType.Deposit.ToString("D") + currency.ToString("D"));
}
//user id 为兼容恒星币人工充值，以后开通自动就无保留必要了
public PaymentTransactionCreated(string txid, string address, CurrencyType currency, decimal amount, ReceivePaymentTransaction ptxEntity, int userID = 0)
{
this.UserID = userID;
this.PtxEntity = ptxEntity;
this.TxID = txid;
this.Currency = currency;
this.Address = address;
this.Amount = amount;
}
public ActionResult InsideTransferSuccess(CurrencyType currency, string orderID)
{
var transfer = IoC.Resolve<IInsideTransferQuery>().GetInsideTransferBySequenceNo(orderID, TransactionState.Success, currency);
var user = IoC.Resolve<IUserQuery>().GetUserByID(transfer.ToUserID);
ViewBag.Transfer = transfer;
ViewBag.Receiver = user;
return View("InsideTransferSuccess");
}
public static decimal GetGlobleMoneyFrom(CurrencyType fromCurrency, decimal money)
{
CurrencyType defaultCurrency = AppSetting.Instance.DefaultCurrency;
if (defaultCurrency == fromCurrency)
{
return money;
}
return (money * fromCurrency.GetConversionRateTo(defaultCurrency));
}
public double ConvertCurrency(CurrencyType from, CurrencyType to, double amount)
{
if (from == to && to == CurrencyType.AustralianDollar)
{
return amount;
}
throw new
NotSupportedException("Currency conversion for non-Australian dollars is not supported");
}
public static string GetValueString(decimal value, CurrencyType currency, CultureInfo cultureInfo)
{
if(value == 0)
{
return null;
}
return value.ToString("### ### ### ###", cultureInfo) + CurrencyName.Names[currency];
}
public InsideTransferModel GetInsideTransferBySequenceNo(string seqNo, TransactionState txstate, CurrencyType currency)
{
Check.Argument.IsNotEmpty(seqNo, "seqNo");
return this.Context.Sql(getInsideTransferBySequenceNo_Sql.FormatWith(currency.ToString()))
.Parameter("@seqNo", seqNo)
.Parameter("@state", txstate)
.QuerySingle<InsideTransferModel>();
}
public InsideTransferTransactionCreated(int fromUserID, int toUserID, CurrencyType currency, decimal amount, PayWay payway, string description, InsideTransferTransaction tx)
{
this.FromUserID = fromUserID;
this.ToUserID = toUserID;
this.Currency = currency;
this.Amount = amount;
this.PayWay = payway;
this.Description = description;
this.TransactionEntity = tx;
}
public CreatePaymentAddress(int userID, string paymentAddress, CurrencyType currency)
{
Check.Argument.IsNotNegativeOrZero(userID, "userID");
Check.Argument.IsNotEmpty(paymentAddress, "paymentAddress");
Check.Argument.IsNotNegativeOrZero((int)currency, "currency");
this.UserID = userID;
this.PaymentAddress = paymentAddress;
this.Currency = currency;
}
public static int GetPossion(CurrencyType currency)
{
if (!CurrencyPossion.ContainsKey(currency))
{
int num = (int)currency;
CurrencyPossion[currency] = num;
return num;
}
return CurrencyPossion[currency];
}
public static int Consume( Mobile from, int amount, bool bankbox, CurrencyType type, bool recurse )
{
Container[] containers = null;
if ( bankbox )
containers = new Container[]{ from.Backpack, from.BankBox };
else
containers = new Container[]{ from.Backpack };
return Consume( containers, amount, type, recurse );
}
public VirtualCoinDepositCreated(int userID, int accountID, string txid, CurrencyType currency, decimal amount, decimal fee, string memo, VirtualCoinDeposit deposit)
{
this.UserID = userID;
this.AccountID = accountID;
this.TxID = txid;
this.Currency = currency;
this.DepositAmount = amount;
this.DepositFee = fee;
this.Memo = memo;
this.DepositEntity = deposit;
}
public CreateInsideTransfer(int fromUserID, int toUserID, CurrencyType currency, decimal amount, string description)
{
Check.Argument.IsNotNegativeOrZero(fromUserID, "fromUserID");
Check.Argument.IsNotNegativeOrZero(toUserID, "toUserID");
Check.Argument.IsNotNegativeOrZero((int)currency, "currency");
this.FromUserID = fromUserID;
this.ToUserID = toUserID;
this.Currency = currency;
this.Amount = amount;
this.Description = description;
}
public AuthorizeCustomerServiceUserDepositAmount(int authTo, CurrencyType currency, decimal amount, int currentUserID)
{
Check.Argument.IsNotNegativeOrZero(authTo, "authTo");
Check.Argument.IsNotNegativeOrZero((int)currency, "currency");
Check.Argument.IsNotNegativeOrZero(amount, "amount");
Check.Argument.IsNotNegativeOrZero(currentUserID, "currentUserID");
this.UserID = authTo;
this.Currency = currency;
this.AuthrizeAmount = amount;
this.AuthrizeBy = currentUserID;
}
public ActionResult InsideTransferConfirm(CurrencyType currency, string orderID)
{
var transfer = IoC.Resolve<IInsideTransferQuery>().GetInsideTransferBySequenceNo(orderID, TransactionState.Pending, currency);
ViewBag.Transfer = transfer;
if (transfer != null)
{
var user = IoC.Resolve<IUserQuery>().GetUserByID(transfer.ToUserID);
ViewBag.Receiver = user;
}
return View("InsideConfirm");
}
/// <summary>
/// Get symbol crosses used for calculating pip values
/// </summary>
/// <param name="basecurrency"></param>
/// <returns></returns>
public static string GetPipValueSymbolCrosses(CurrencyType basecurrency, ISecurity basesecurity)
{
//Check for forex security
if (basesecurity.Type == SecurityType.Forex)
{
string ends = basesecurity.Name.Substring(3, 3);
return(basecurrency.ToString() + ends);
}
else if (basesecurity.Type == SecurityType.CFD)
{
return(basecurrency.ToString() + basesecurity.Currency.ToString());
}
else
{
return(string.Empty);
}
}
public static void HandleVendorPurchase(WorldSession session, ClientVendorPurchase vendorPurchase)
{
VendorInfo vendorInfo = session.Player.SelectedVendorInfo;
if (vendorInfo == null)
{
return;
}
EntityVendorItemModel vendorItem = vendorInfo.GetItemAtIndex(vendorPurchase.VendorIndex);
if (vendorItem == null)
{
return;
}
Item2Entry itemEntry = GameTableManager.Instance.Item.GetEntry(vendorItem.ItemId);
float costMultiplier = vendorInfo.BuyPriceMultiplier * vendorPurchase.VendorItemQty;
// do all sanity checks before modifying currency
var currencyChanges = new List <(CurrencyType CurrencyTypeId, ulong CurrencyAmount)>();
for (int i = 0; i < itemEntry.CurrencyTypeId.Length; i++)
{
CurrencyType currencyId = (CurrencyType)itemEntry.CurrencyTypeId[i];
if (currencyId == CurrencyType.None)
{
continue;
}
ulong currencyAmount = (ulong)(itemEntry.CurrencyAmount[i] * costMultiplier);
if (!session.Player.CurrencyManager.CanAfford(currencyId, currencyAmount))
{
return;
}
currencyChanges.Add((currencyId, currencyAmount));
}
foreach ((CurrencyType currencyTypeId, ulong currencyAmount) in currencyChanges)
{
session.Player.CurrencyManager.CurrencySubtractAmount(currencyTypeId, currencyAmount);
}
session.Player.Inventory.ItemCreate(itemEntry.Id, vendorPurchase.VendorItemQty * itemEntry.BuyFromVendorStackCount);
}
private string CurrencyStringMap(CurrencyType type)
{
switch (type)
{
case CurrencyType.RON:
return("RON");
case CurrencyType.USD:
return("USD");
case CurrencyType.EUR:
return("EUR");
default:
return("");
}
}
public async Task <IActionResult> OnPostAsync(Guid?id)
{
if (id == null)
{
return(NotFound());
}
CurrencyType = await _context.CurrencyTypes.FindAsync(id);
if (CurrencyType != null)
{
CurrencyType.IsDeleted = true;
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
public async Task <RaveResponse <ExchangeRateRes> > GetExchangeRate(CurrencyType originalCurrency, CurrencyType destinationCurrency, decimal amount)
{
var payload = new
{
SECKEY = Config.SecretKey,
origin_currency = Util.GetCurrencyStr(originalCurrency),
destination_currency = Util.GetCurrencyStr(destinationCurrency),
amount
};
var requestBody = new HttpRequestMessage(HttpMethod.Post, Endpoints.ExchangeRates)
{
Content = new StringContent(JsonConvert.SerializeObject(payload), Encoding.UTF8, "application/json")
};
return(await RaveApiRequest.Request(requestBody));
}
public int GetCurrency(CurrencyType currency)
{
switch (currency)
{
case CurrencyType.Gold:
return(Credits);
case CurrencyType.Fame:
return(CurrentFame);
case CurrencyType.Tokens:
return(Tokens);
default:
return(0);
}
}
public bool PopulateDataSource(CurrencyType currencyType, DateTime dateFrom, DateTime dateTo)
{
try
{
var currencyDataFromRange = ServiceConfiguration.DataProvider.GetCurrencyValueFromRange(currencyType, dateFrom, dateTo);
CurrencyRepository.RemoveAll(currencyType);
foreach (var currencyItem in currencyDataFromRange)
{
CurrencyRepository.Add(currencyItem);
}
return(true);
}
catch (Exception ex)
{
return(false);
}
}
/// <summary>
/// KRW_TYPE
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static string ToReversedCurrencyPair(this CurrencyType type)
{
if (type == CurrencyType.Bitcoin)
{
return("krw_btc");
}
else if (type == CurrencyType.Ethereum)
{
return("krw_eth");
}
else if (type == CurrencyType.EthereumClassic)
{
return("krw_etc");
}
throw new NotImplementedException($"{type}");
}
//Im asumming that all the external apis return the same structure
private async Task <Exchange> FillCurrency(HttpResponseMessage response, CurrencyType currency)
{
Exchange exchange = new Exchange();
if (response.StatusCode == HttpStatusCode.OK)
{
var content = await response.Content.ReadAsStringAsync();
//the response from the extenal api doesnt have a valid key/value pair, only the value, hence the parse into JObject
JArray jArray = JArray.Parse(content);
exchange.BuyValue = (double)jArray[0];
exchange.SellValue = (double)jArray[1];
exchange.Currency = currency;
}
return(exchange);
}
public static void HandleVendorSell(WorldSession session, ClientVendorSell vendorSell)
{
VendorInfo vendorInfo = session.Player.SelectedVendorInfo;
if (vendorInfo == null)
{
return;
}
ItemInfo info = session.Player.Inventory.GetItem(vendorSell.ItemLocation).Info;
if (info == null)
{
return;
}
float costMultiplier = vendorInfo.SellPriceMultiplier * vendorSell.Quantity;
// do all sanity checks before modifying currency
var currencyChange = new List <(CurrencyType CurrencyTypeId, ulong CurrencyAmount)>();
for (int i = 0; i < info.Entry.CurrencyTypeIdSellToVendor.Length; i++)
{
CurrencyType currencyId = (CurrencyType)info.Entry.CurrencyTypeIdSellToVendor[i];
if (currencyId == CurrencyType.None)
{
continue;
}
ulong currencyAmount = (ulong)(info.Entry.CurrencyAmountSellToVendor[i] * costMultiplier);
currencyChange.Add((currencyId, currencyAmount));
}
// TODO Insert calculation for cost here
foreach ((CurrencyType currencyTypeId, ulong currencyAmount) in currencyChange)
{
session.Player.CurrencyManager.CurrencyAddAmount(currencyTypeId, currencyAmount);
}
// TODO Figure out why this is showing "You deleted [item]"
Item soldItem = session.Player.Inventory.ItemDelete(vendorSell.ItemLocation);
BuybackManager.Instance.AddItem(session.Player, soldItem, vendorSell.Quantity, currencyChange);
}
/// <summary>
/// Synchronizes the cash positions compared to current account.
/// </summary>
/// <param name="currency">The currency.</param>
/// <param name="amount">The amount.</param>
private void SyncFunds(CurrencyType currency, decimal amount)
{
lock (_locker)
{
//Get all holders
decimal baseamount = GetBaseAccount(currency).TotalCash;
_log.Info($"Syncing funds for currency {currency} and received amount {amount}. Current base amount = {baseamount}, currently allocated = {TotalAllocatedCash}");
//If we have a lower amount
if (amount > TotalCash || TotalAllocatedCash < amount)
{
decimal adjust = amount - TotalCash;
GetBaseAccount(currency).AddCash(new SettledCash(adjust));
_log.Info($"Adjusted current base account with amount {adjust}");
}
//If we have more allocated than currently in funds, this should be reset proportionally
else if (TotalAllocatedCash > amount)
{
//Calculate proportions
_log.Warn($"The base account balance is lower than we have allocated in amount (base = {amount}, allocated = {TotalAllocatedCash}");
Dictionary <string, decimal> proportion = new Dictionary <string, decimal>();
_cashknown.Where(x => x.Key != BaseAccount).ForEach(x =>
{
decimal allocated = x.Value.Sum(funds => _conversion.Convert(funds.Value.TotalCash, funds.Value.BaseCurrency, currency));
proportion.Add(x.Key, allocated / amount);
});
//Adjust funds
proportion.ForEach(x =>
{
decimal current = _cashknown[x.Key][currency].TotalCash;
decimal adjusted = current - (current * x.Value);
_cashknown[x.Key][currency].AddCash(new SettledCash(adjusted));
_log.Warn($"Adjusting funds for quant fund with id {x.Key} current = {current} new amount = {current + adjusted}, adjusted amount = {adjusted}");
});
}
else
{
_log.Info($"Funds are all in sync, no actions needed");
}
//Logging
_log.Info($"Syncing of funds finished, TotalFunds = {TotalCash}, TotalAllocatedFunds = {TotalAllocatedCash}, #QuantFunds = {_cashknown.Count - 1}, TotalUnallocatedFunds = {TotalUnallocatedCash}");
}
}
private void DropItemByID(uint _id, uint _killer, CurrencyType _currency = CurrencyType.None, uint _value = 0)
{
var itemInfo = Database.ServerDatabase.Context.ItemInformation.GetById(_id);
if (itemInfo != null)
{
var loc = GetValidLocation();
if (Map.IsValidItemLocation(loc))
{
var coItem = new Structures.ConquerItem((uint)Map.ItemCounter.Counter, itemInfo);
if ((coItem.EquipmentSort == 1 || coItem.EquipmentSort == 3 || coItem.EquipmentSort == 4) && coItem.BaseItem.TypeDesc != "Earring")
{
coItem.Color = (byte)Common.Random.Next(3, 7);
}
if (coItem.EquipmentSort > 0 && coItem.EquipmentQuality > 3)
{
coItem.Durability = (ushort)Common.Random.Next(coItem.MaximumDurability);
}
else
{
coItem.Color = 3;
}
if (Common.PercentSuccess(Constants.CHANCE_PLUS))
{
coItem.Plus = 1;
}
if (coItem.IsWeapon)
{
if (Common.PercentSuccess(Constants.SOCKET_DROP))
{
coItem.Gem1 = 255;
if (Common.PercentSuccess(Constants.SOCKET_DROP))
{
coItem.Gem2 = 255;
}
}
}
var groundItem = new GroundItem(coItem, coItem.UniqueID, loc, Map, _killer, _currency, _value);
groundItem.AddToMap();
}
}
}
private void Show(CurrencyType currencyType)
{
if (UniversalInputManager.UsePhoneUI != null)
{
this.ShowImmediate(currencyType);
}
else
{
bool flag = currencyType != CurrencyType.NONE;
if (!DemoMgr.Get().IsCurrencyEnabled())
{
flag = false;
}
if (flag)
{
if ((this.m_state == State.SHOWN) || (this.m_state == State.ANIMATE_IN))
{
this.ShowCurrencyType(currencyType);
}
else
{
this.m_state = State.ANIMATE_IN;
base.gameObject.SetActive(true);
object[] args = new object[] { "amount", 1f, "delay", 0f, "time", 0.25f, "easeType", iTween.EaseType.easeOutCubic, "oncomplete", "ActivateCurrencyFrame", "oncompletetarget", base.gameObject };
Hashtable hashtable = iTween.Hash(args);
iTween.Stop(base.gameObject);
iTween.FadeTo(base.gameObject, hashtable);
this.ShowCurrencyType(currencyType);
}
}
else if ((this.m_state == State.HIDDEN) || (this.m_state == State.ANIMATE_OUT))
{
this.ShowCurrencyType(currencyType);
}
else
{
this.m_state = State.ANIMATE_OUT;
object[] objArray2 = new object[] { "amount", 0f, "delay", 0f, "time", 0.25f, "easeType", iTween.EaseType.easeOutCubic, "oncomplete", "DeactivateCurrencyFrame", "oncompletetarget", base.gameObject };
Hashtable hashtable2 = iTween.Hash(objArray2);
iTween.Stop(base.gameObject);
iTween.FadeTo(base.gameObject, hashtable2);
this.ShowCurrencyType(currencyType);
}
}
}
public NBURatesSource(string name, Uri baseSource, Dictionary <string, string> routeParams)
{
BaseSource = baseSource;
RouteParams = routeParams;
if (routeParams != null)
{
RouteParamString = routeParams.ToList().Aggregate("?", (key, value) => key + "=" + value + "&");
}
else
{
RouteParamString = string.Empty;
}
BaseCurrency = CurrencyType.UAH;
Name = name;
isInited = true;
Id = Guid.NewGuid();
BaseCurrency = CurrencyType.UAH;
}
public override int GetHashCode()
{
int hash = 1;
if (CurrencyType.Length != 0)
{
hash ^= CurrencyType.GetHashCode();
}
if (Price != 0)
{
hash ^= Price.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public Balance GetBalanceFor(CurrencyType currencyType)
{
if (currencyType == CurrencyType.Money)
{
var accountMoney = new MoneyAccountDecorator(this);
return(accountMoney.Balance);
}
if (currencyType == CurrencyType.Token)
{
var accountToken = new TokenAccountDecorator(this);
return(accountToken.Balance);
}
throw new ArgumentException(nameof(currencyType));
}
static void LoadingFromBinary(out Dictionary <CurrencyType, uint> loadedWallet)
{
loadedWallet = new Dictionary <CurrencyType, uint>();
using (FileStream fs = File.OpenRead(filePathBin))
using (BinaryReader reader = new BinaryReader(fs))
{
// Get count.
int count = reader.ReadInt32();
// Read in all pairs.
for (int i = 0; i < count; i++)
{
CurrencyType key = (CurrencyType)reader.ReadInt32();
uint value = reader.ReadUInt32();
loadedWallet.Add(key, value);
}
}
Debug.Log("Loaded from binary file " + filePathBin);
}
/// <summary>
/// 当前行情
/// </summary>
/// <param name="currency"></param>
/// <returns></returns>
public static TickerModel GetTicker(CurrencyType currency)
{
var json = string.Empty;
var url = BaseUrl + $"ticker?currency={currency}";
try
{
json = url.GetJsonFromUrl();
var model = JObject.Parse(json)["ticker"].ToObject <TickerModel>();
model.Date = JObject.Parse(json)["date"].ToObject <long>();
return(model);
}
catch (Exception ex)
{
Logger.ErrorFormat($"Response:{json},Parameters:{url},Ex:{ex}");
}
return(new TickerModel());
}
private static TimeSpan m_MaxBTCQueryTime = new TimeSpan(1, 0, 0); // Max query of every hour
/// <summary>
/// Gets the exchange rate for a given currency relative to USD
/// </summary>
/// <param name="target"></param>
/// <returns></returns>
public static decimal GetExchangeRate(CurrencyType target)
{
decimal exchangeRate = 1;
switch (target)
{
case CurrencyType.USD:
exchangeRate = 1;
break;
case CurrencyType.BTC:
// get BTC usd price
exchangeRate = GetBTCPrice();
break;
}
return(exchangeRate);
}
public static void CheckCache(DateTime date, CurrencyType currency, decimal value)
{
var key = $"{date}{currency}";
if (Cache.ContainsKey(key))
{
var cacheValue = Cache[key];
if (cacheValue != value)
{
throw new InvalidOperationException($"Kurs dla {currency} z dnia {date} jest sprzeczny: {cacheValue} != {value}");
}
return;
}
Cache.Add(key, value);
}
public bool checkCurrencyType_Select_IsMater(Session session, string currencyTypeId, bool isMaster)
{
try
{
CurrencyType currencyType = session.FindObject <CurrencyType>(
CriteriaOperator.And(
new BinaryOperator("CurrencyTypeId", currencyTypeId, BinaryOperatorType.Equal),
new BinaryOperator("IsMaster", isMaster, BinaryOperatorType.Equal),
new BinaryOperator("RowStatus", Utility.Constant.ROWSTATUS_ACTIVE, BinaryOperatorType.Equal)
));
if (currencyType != null)
{
return(true);
}
return(false);
}
catch (Exception) { throw; }
}
/// <summary>
/// 获取未成交或部份成交的买单和卖单，每次请求返回pageSize小于等于10条记录
/// </summary>
/// <param name="currency">交易类型（目前仅支持btc_cny/ltc_cny/eth_cny/eth_btc/etc_cny/bts_cny/eos_cny/bcc_cny/qtum_cny）</param>
/// <param name="pageIndex">当前页数</param>
/// <param name="pageSize">每页数量</param>
/// <returns></returns>
public static List <OrderModel> GetUnfinishedOrdersIgnoreTradeType(CurrencyType currency, int pageIndex, int pageSize)
{
var json = string.Empty;
var method = "getUnfinishedOrdersIgnoreTradeType";
var url = BaseUrl + method;
try
{
var queryString = new { method, GetApiKey().accesskey, currency, pageIndex, pageSize }.ToQueryString();
json = url.MakeUrl(queryString, GetApiKey().secretkey).GetJsonFromUrl();
return(JArray.Parse(json).ToObject <List <OrderModel> >());
}
catch (Exception ex)
{
Logger.ErrorFormat($"Response:{json},Parameters:{url},Ex:{ex}");
}
return(new List <OrderModel>());
}
/// <summary>
/// 获取委托买单或卖单
/// </summary>
/// <param name="orderId">委托挂单号</param>
/// <param name="currency">交易类型（目前仅支持btc_cny/ltc_cny/eth_cny/eth_btc/etc_cny/bts_cny/eos_cny/bcc_cny/qtum_cny）</param>
/// <returns></returns>
public static OrderModel GetOrder(string orderId, CurrencyType currency)
{
var json = string.Empty;
var method = "getOrder";
var url = BaseUrl + method;
try
{
var queryString = new { method, GetApiKey().accesskey, id = orderId, currency }.ToQueryString();
json = url.MakeUrl(queryString, GetApiKey().secretkey).GetJsonFromUrl();
return(json.FromJSON <OrderModel>());
}
catch (Exception ex)
{
Logger.ErrorFormat($"Response:{json},Parameters:{url},Ex:{ex}");
}
return(new OrderModel());
}
public override int GetHashCode()
{
int hash = 1;
if (CurrencyType != 0)
{
hash ^= CurrencyType.GetHashCode();
}
if (Usage != 0L)
{
hash ^= Usage.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
/// <summary>
/// 转换为货币
/// </summary>
/// <param name="param">带转换的金额</param>
/// <param name="currencyType">货币类型，默认人民币</param>
/// <returns></returns>
public static string ConvertToCurrency(this decimal param, CurrencyType currencyType = null)
{
if (currencyType == null)
{
currencyType = CurrencyType.Cny;
}
IEnumerable <ICurrencyProvider> list =
new ServiceProvider().GetServices <ICurrencyProvider>();
var provider = list.FirstOrDefault(x => x.GetCurrencyType.Equals(currencyType));
if (provider == null)
{
throw new BusinessException("暂不支持当前货币转换");
}
return(provider.ConvertToCurrency(param));
}
public TradeImpl(Trade copytrade)
{
// copy constructor, for copying using by-value (rather than by default of by-reference)
Id = copytrade.Id;
_cur = copytrade.Currency;
Security = copytrade.Security;
Exchange = copytrade.Exchange;
_accountid = copytrade.AccountName;
Symbol = copytrade.Symbol;
Direction = copytrade.Direction;
Commission = copytrade.Commission;
AgentId = copytrade.AgentId;
Xsize = copytrade.Xsize;
Xprice = copytrade.Xprice;
Xtime = copytrade.Xtime;
Xdate = copytrade.Xdate;
}
public override double ConvertCurrency(double startingAmount, CurrencyType convertedCurrencyType)
{
double finalAmount = 0.0;
if (convertedCurrencyType == CurrencyType.USD)
{
return(finalAmount = 1.54 * startingAmount);
}
else if (convertedCurrencyType == CurrencyType.Pounds)
{
return(finalAmount = startingAmount);
}
else if (convertedCurrencyType == CurrencyType.USD)
{
return(finalAmount = 1.35 * startingAmount);
}
return(0);
}
public bool Withdraw(CurrencyType currency, int amount)
{
if (amount <= (CurrencyType.Gold == currency ? Gold : Tokens))
{
if (CurrencyType.Gold == currency)
{
Gold -= amount;
}
else
{
Tokens -= amount;
}
return(true);
}
return(false);
}
public Customer(Guid guid, string name, long contact, CurrencyType currency, string shortName, string email, string firstName, string lastName, string url, ICollection <CustomerSubscriptionDetails> subscription, CustomerLoginDetails loginDetails, Partner partner, CustomerAddress address, string role)
: this()
{
CustomerId = guid;
CompanyName = name;
PrimaryContact = contact;
Currency = currency;
ShortName = shortName;
Email = email;
FirstName = firstName;
LastName = lastName;
WebsiteUrl = url;
Subscriptions = subscription;
LoginDetails = loginDetails;
Partner = partner;
CustomerAddress = address;
Role = role;
}
public void HomeLoanConstructor_WhenInitializedByConstructor_PropertiesAreSetCorrectly()
{
// Arrange
decimal loanAmount = 1000;
decimal loanInterestRate = 3.5m;
int loanTerm = 5;
CurrencyType loanCurrency = CurrencyType.UsDollars;
// Act
var loan = new HomeLoan(loanAmount, loanTerm, loanInterestRate, loanCurrency);
// Assert
Assert.AreEqual(loanAmount, loan.Principal, "Loan amount not set correctly by constructor");
Assert.AreEqual(loanTerm, loan.Term, "Loan term not set correctly by constructor");
Assert.AreEqual(loanInterestRate, loan.InterestRatePercentage, "Loan interest rate not set correctly by constructor");
Assert.AreEqual(loanCurrency, loan.Currency, "Loan currency type not set correctly by constructor");
}
