public Task UpdateAsync(SettlementTrade settlementTrade)
{
return(_storage.MergeAsync(GetPartitionKey(), GetRowKey(settlementTrade.Id), entity =>
{
Mapper.Map(settlementTrade, entity);
return entity;
}));
}
public async Task InsertAsync(SettlementTrade settlementTrade)
{
var entity = new SettlementTradeEntity(GetPartitionKey(), GetRowKey(settlementTrade.Id));
Mapper.Map(settlementTrade, entity);
await _storage.InsertAsync(entity);
}
public async Task ExecuteAsync(string settlementTradeId, string userId)
{
string walletId = await _settingsService.GetWalletIdAsync();
SettlementTrade settlementTrade = (await _settlementTradeService.GetByIdAsync(settlementTradeId)).Copy();
if (settlementTrade == null)
{
throw new EntityNotFoundException();
}
Domain.AssetSettings baseAssetSettings =
await _assetSettingsService.GetByIdAsync(settlementTrade.BaseAsset);
Domain.AssetSettings quoteAssetSettings =
await _assetSettingsService.GetByIdAsync(settlementTrade.QuoteAsset);
string baseAssetId = baseAssetSettings != null
? baseAssetSettings.LykkeAssetId
: settlementTrade.BaseAsset;
string quoteAssetId = quoteAssetSettings != null
? quoteAssetSettings.LykkeAssetId
: settlementTrade.QuoteAsset;
Asset baseAsset = await _assetsServiceWithCache.TryGetAssetAsync(baseAssetId);
Asset quoteAsset = await _assetsServiceWithCache.TryGetAssetAsync(quoteAssetId);
if (baseAsset == null)
{
_log.WarningWithDetails("Can not map external asset id", new
{
settlementTradeId,
userId,
baseAssetId
});
throw new InvalidOperationException("Unknown asset");
}
if (quoteAsset == null)
{
_log.WarningWithDetails("Can not map external asset id", new
{
settlementTradeId,
userId,
quoteAssetId
});
throw new InvalidOperationException("Unknown asset");
}
settlementTrade.Complete();
string comment =
$"rebalance; {settlementTrade.Type} {settlementTrade.Volume} {settlementTrade.BaseAsset} for {settlementTrade.OppositeVolume} {settlementTrade.QuoteAsset} by price {settlementTrade.Price} ({settlementTrade.AssetPair})";
int sign = settlementTrade.Type == TradeType.Sell ? 1 : -1;
var balanceOperations = new[]
{
new BalanceOperation
{
Time = DateTime.UtcNow,
AssetId = baseAsset.Id,
Type = "Settlement",
Amount = Math.Abs(settlementTrade.Volume) * sign,
Comment = $"{comment}, for close position in {settlementTrade.BaseAsset}",
UserId = userId
},
new BalanceOperation
{
Time = DateTime.UtcNow,
AssetId = quoteAsset.Id,
Type = "Settlement",
Amount = Math.Abs(settlementTrade.OppositeVolume) * -1 * sign,
Comment = $"{comment}, for close position in {settlementTrade.QuoteAsset}",
UserId = userId
}
};
foreach (BalanceOperation balanceOperation in balanceOperations.OrderBy(o => o.Amount))
{
if (balanceOperation.Amount > 0)
{
await _lykkeExchangeService.CashInAsync(walletId, balanceOperation.AssetId,
Math.Abs(balanceOperation.Amount), userId, comment);
}
else
{
await _lykkeExchangeService.CashOutAsync(walletId, balanceOperation.AssetId,
Math.Abs(balanceOperation.Amount), userId, comment);
}
await _balanceOperationService.AddAsync(balanceOperation);
_log.InfoWithDetails("Settlement was executed", balanceOperation);
}
await _settlementTradeService.UpdateAsync(settlementTrade);
}
private async Task <IReadOnlyCollection <SettlementTrade> > GetTradesAsync()
{
ResponceDataSet response = await RetriesWrapper.RunWithRetriesAsync(() =>
_dwhClient.Call(new Dictionary <string, string>
{
["fromTime"] = "2018-01-01"
},
_tradesSpName, _database));
var settlementTrades = new List <SettlementTrade>();
if (response.Data == null)
{
return(settlementTrades);
}
List <Trade> trades;
List <Transaction> transactions;
using (DataTableReader reader = response.Data.Tables[0].CreateDataReader())
trades = Mapper.Map <List <Trade> >(reader);
using (DataTableReader reader = response.Data.Tables[1].CreateDataReader())
transactions = Mapper.Map <List <Transaction> >(reader);
foreach (Trade trade in trades)
{
TradeType tradeType;
if (trade.Direction == "sell")
{
tradeType = TradeType.Sell;
}
else if (trade.Direction == "buy")
{
tradeType = TradeType.Buy;
}
else
{
continue;
}
Transaction[] tradeTransactions = transactions.Where(o => o.TradeId == trade.TradeId).ToArray();
if (tradeTransactions.Length != 2)
{
continue;
}
if (tradeTransactions.All(o => !trade.AssetPair.StartsWith(o.Asset)) &&
tradeTransactions.All(o => !trade.AssetPair.EndsWith(o.Asset)))
{
continue;
}
var settlementTrade = new SettlementTrade
{
Id = trade.TradeId,
Type = tradeType,
AssetPair = trade.AssetPair,
Price = (decimal)trade.Price,
Timestamp = trade.Timestamp,
IsCompleted = false
};
foreach (Transaction transaction in tradeTransactions)
{
if (settlementTrade.AssetPair.StartsWith(transaction.Asset))
{
settlementTrade.BaseAsset = transaction.Asset;
settlementTrade.Volume = (decimal)Math.Abs(transaction.Amount);
}
else if (settlementTrade.AssetPair.EndsWith(transaction.Asset))
{
settlementTrade.QuoteAsset = transaction.Asset;
settlementTrade.OppositeVolume = (decimal)Math.Abs(transaction.Amount);
}
}
settlementTrades.Add(settlementTrade);
}
return(settlementTrades);
}
public async Task UpdateAsync(SettlementTrade settlementTrade)
{
await _settlementTradeRepository.UpdateAsync(settlementTrade);
_cache.Set(settlementTrade);
}
private static string GetKey(SettlementTrade settlementTrade) => GetKey(settlementTrade.Id);
