public async Task <IActionResult> UpdateRealAssets(string exchangeId)
{
var userId = HttpContext.User.GetUserId();
if (string.IsNullOrEmpty(userId))
{
return(BadRequest("User not found"));
}
var userAssets = await _exchangeFactory.GetExchange(exchangeId).GetRealBalances(userId);
var originalAssets = _assetRepository.GetByUserAndExchange(userId, exchangeId).Where(o => o.TradingMode == TradingMode.Real);
foreach (var asset in userAssets)
{
var reservedFromAsset = originalAssets.Where(o => o.Currency == asset.Currency && o.StrategyId != null).Sum(o => o.Amount);
var originalFreeAsset = originalAssets.FirstOrDefault(o => o.Currency == asset.Currency && o.StrategyId == null);
if (originalFreeAsset == null)
{
if (asset.Amount != reservedFromAsset) // In order to NOT create empty asset
{
asset.Amount = asset.Amount - reservedFromAsset;
_assetRepository.AddNotSave(asset);
}
}
else
{
originalFreeAsset.Amount = asset.Amount - reservedFromAsset;
_assetRepository.EditNotSave(originalFreeAsset);
}
}
_assetRepository.Save();
return(Ok());
}
public async Task <IActionResult> StopStrategy(string strategyId)
{
var userId = HttpContext.User.GetUserId();
if (string.IsNullOrEmpty(userId))
{
return(BadRequest("User not found"));
}
var strategy = _strategyRepository.GetByUserId(userId).FirstOrDefault(o => o.Id == strategyId);
if (strategy == null)
{
return(BadRequest("Strategy not found"));
}
if (strategy.StrategyState != StrategyState.Running)
{
return(BadRequest("Strategy is not running"));
}
strategy.Stop = DateTime.Now;
strategy.StrategyState = StrategyState.Stopped;
var userAssets = _assetRepository.GetByUserId(userId);
var strategyAssets = userAssets.Where(o => o.StrategyId == strategyId);
foreach (var asset in strategyAssets)
{
var assetOrigin = userAssets.FirstOrDefault(o =>
!o.IsReserved && o.IsActive &&
o.Currency == asset.Currency && o.TradingMode == asset.TradingMode &&
string.IsNullOrEmpty(o.StrategyId) && o.Exchange == asset.Exchange);
if (assetOrigin != null)
{
assetOrigin.Amount += asset.Amount;
_assetRepository.EditNotSave(assetOrigin);
}
else
{
_assetRepository.AddNotSave(new Asset(asset));
}
asset.IsActive = false;
_assetRepository.EditNotSave(asset);
}
var finalEvaluation = await _marketDataService
.EvaluateAssetSet(strategyAssets.Select(o => (currency: o.Currency, amount: o.Amount)), "binance");
finalEvaluation.StrategyId = strategyId;
finalEvaluation.IsFinal = true;
_evaluationRepository.AddNotSave(finalEvaluation);
_strategyRepository.Edit(strategy);
_assetRepository.Save();
_strategyRepository.Save(); //TODO piece of work?
_evaluationRepository.Save();
return(Ok());
}
private string ManageAssets(Asset soldAsset, TradeOrder order, OrderType orderType, string uuid)
{
var reserverAsset = new Asset(soldAsset)
{
Amount = order.Amount,
IsReserved = true,
StrategyId = soldAsset.StrategyId,
};
soldAsset.Amount -= order.Amount;
_assetRepository.AddNotSave(reserverAsset);
if (soldAsset.Amount < 0.00000001m)
{
_assetRepository.DeleteNotSave(soldAsset);
}
else
{
_assetRepository.EditNotSave(soldAsset);
}
var quantity = orderType == OrderType.Buy ? order.Amount / order.Rate.Value : order.Amount;
var trade = new Trade
{
MarketId = order.Symbol,
Opened = DateTime.Now,
Quantity = quantity,
OrderType = orderType,
StrategyId = soldAsset.StrategyId,
TradeState = TradeState.New,
Price = order.Rate.Value,
QuantityRemaining = quantity,
ReservedAsset = reserverAsset,
Total = orderType == OrderType.Buy ? order.Amount : order.Amount * order.Rate.Value,
ExchangeUuid = uuid,
Exchange = order.Exchange,
};
_tradeRepository.Add(trade);
_assetRepository.Save();
return(trade.Id);
}
public Result ExecuteTrade(Trade trade, decimal rate)
{
var strategyAssets = _assetRepository.GetByStrategyId(trade.StrategyId);
var coins = trade.MarketId.Split('_');
var boughtCoin = coins[trade.OrderType == OrderType.Buy ? 1 : 0];
var boughtCoinAsset = strategyAssets.FirstOrDefault(o =>
!o.IsReserved && o.Exchange == trade.ReservedAsset.Exchange &&
o.Currency == boughtCoin);
if (boughtCoinAsset == null)
{
_assetRepository.AddNotSave(new Asset
{
Amount = trade.OrderType == OrderType.Buy ? trade.Quantity : trade.Total,
Currency = boughtCoin,
IsActive = true,
IsReserved = false,
StrategyId = trade.ReservedAsset.StrategyId,
TradingMode = trade.ReservedAsset.TradingMode,
UserId = trade.ReservedAsset.UserId,
Exchange = trade.ReservedAsset.Exchange,
});
}
else
{
boughtCoinAsset.Amount += trade.OrderType == OrderType.Buy ? trade.Quantity : trade.Total;
_assetRepository.EditNotSave(boughtCoinAsset);
}
trade.Closed = DateTime.Now;
trade.TradeState = TradeState.Fulfilled;
_assetRepository.DeleteNotSave(trade.ReservedAsset);
trade.ReservedAsset = null;
_tradeRepository.EditNotSave(trade);
_tradeRepository.Save();
_assetRepository.Save();
return(new Result(true, null));
}
