public static AssetPairEntity Create(IAssetPair src)
{
return new AssetPairEntity
{
PartitionKey = GeneratePartitionKey(),
RowKey = GenerateRowKey(src.Id),
Accuracy = src.Accuracy,
BaseAssetId = src.BaseAssetId,
QuotingAssetId = src.QuotingAssetId
};
}
public static string RateToString(this double src, IAssetPair assetPair)
{
var mask = "0." + new string('#', assetPair.Accuracy);
return src.ToString(mask);
}
private async Task ChangeBalance(IAssetPair assetPair, TraderOrderBase order, double exchangedVolume)
{
if (order.Action == OrderAction.Buy)
{
await _srvBalanceAccess.ChangeBalance(order.TraderId, assetPair.QuotingAssetId, order.Volume);
await _srvBalanceAccess.ChangeBalance(order.TraderId, assetPair.BaseAssetId, -exchangedVolume);
}
else
{
await _srvBalanceAccess.ChangeBalance(order.TraderId, assetPair.QuotingAssetId, -order.Volume);
await _srvBalanceAccess.ChangeBalance(order.TraderId, assetPair.BaseAssetId, exchangedVolume);
}
await UpdateBalanceChange(order.TraderId);
}
private async Task<bool> CheckIfEnoughBalance(IAssetPair assetPair, TraderOrderBase order, double exchangedVolume)
{
var balances = await _srvBalanceAccess.GetCurrencyBalances(order.TraderId);
if (order.Action == OrderAction.Buy)
return (balances.GetBalance(assetPair.BaseAssetId) - exchangedVolume) >= 0;
return (balances.GetBalance(assetPair.QuotingAssetId) - order.Volume) >= 0;
}
public async Task EditAsync(string id, IAssetPair assetPair)
{
await _tableStorage.DeleteAsync(AssetPairEntity.GeneratePartitionKey(), AssetPairEntity.GenerateRowKey(id));
await AddAsync(assetPair);
}
public Task AddAsync(IAssetPair assetPair)
{
var newEntity = AssetPairEntity.Create(assetPair);
return _tableStorage.InsertOrReplaceAsync(newEntity);
}
public static string RateToString(this double src, IAssetPair assetPair)
{
var mask = "0." + new string('#', assetPair.Accuracy);
return(src.ToString(mask));
}
public static bool IsInverted(this IAssetPair assetPair, string targetAsset)
{
return(assetPair.QuotingAssetId == targetAsset);
}
public static int Multiplier(this IAssetPair assetPair)
{
return((int)Math.Pow(10, assetPair.Accuracy));
}
private static bool IsAssetMatches(string ruleAsset, OrderDirection?ruleType, IAssetPair instrument,
OrderDirection orderType)
{
if (IsAny(ruleAsset))
{
return(true);
}
switch (ruleType)
{
case OrderDirection.Buy:
return((orderType == OrderDirection.Buy && instrument.BaseAssetId == ruleAsset) ||
(orderType == OrderDirection.Sell && instrument.QuoteAssetId == ruleAsset));
case OrderDirection.Sell:
return((orderType == OrderDirection.Sell && instrument.BaseAssetId == ruleAsset) ||
(orderType == OrderDirection.Buy && instrument.QuoteAssetId == ruleAsset));
case null:
return(instrument.QuoteAssetId == ruleAsset || instrument.BaseAssetId == ruleAsset);
}
return(false);
}
public async Task UpdateAsync(IAssetPair assetPair)
{
await InvalidateCache(assetPair.Id);
await _assetPairService.UpdateAsync(assetPair);
}
public async Task EditAsync(string id, IAssetPair assetPair)
{
await _tableStorage.DeleteAsync(AssetPairEntity.GeneratePartitionKey(), AssetPairEntity.GenerateRowKey(id));
await AddAsync(assetPair);
}
public Task AddAsync(IAssetPair assetPair)
{
var newEntity = AssetPairEntity.Create(assetPair);
return(_tableStorage.InsertOrReplaceAsync(newEntity));
}
public async Task <double> GetRate(string neededAssetId, IAssetPair assetPair)
{
var rates = await _marketProfileService.GetFeedDataAsync(assetPair.Id);
return(GetRate(neededAssetId, assetPair, rates.Ask));
}
