public Result CancelTrade(Trade trade)
{
var reservedAsset = _assetRepository.GetById(trade.ReservedAssetId);
var strategyAssets = _assetRepository.GetByStrategyId(trade.StrategyId);
if (trade.TradeState == TradeState.New || trade.TradeState == TradeState.PartialyFulfilled)
{
trade.TradeState = trade.TradeState == TradeState.New ? TradeState.NewCanceled : TradeState.PartialyFulfilledCanceled;
trade.Closed = DateTime.Now;
var originAsset = strategyAssets.FirstOrDefault(o =>
!o.IsReserved && o.Exchange == reservedAsset.Exchange &&
o.Currency == reservedAsset.Currency);
if (originAsset == null)
{
reservedAsset.IsReserved = false;
_assetRepository.EditNotSave(reservedAsset);
}
else
{
originAsset.Amount += reservedAsset.Amount;
_assetRepository.EditNotSave(originAsset);
_assetRepository.DeleteNotSave(reservedAsset);
}
_tradeRepository.Edit(trade);
_assetRepository.Save();
return(new Result(true, trade.Id));
}
return(new Result(false, "Fulfilled or canceled already"));
}
public IActionResult UpdatePaperAssets([FromBody] IEnumerable <JsonAssetModel> assetModels)
{
var userId = HttpContext.User.GetUserId();
if (string.IsNullOrEmpty(userId))
{
return(BadRequest("User not found"));
}
var assets = assetModels.Select(_mapper.Map <Asset>);
var userAssets = _assetRepository.GetByUserId(userId).Where(o =>
o.TradingMode == TradingMode.PaperTesting &&
string.IsNullOrEmpty(o.StrategyId));
var toDelete = userAssets.Where(o => !assets.Any(p => p.Id == o.Id));
foreach (var item in toDelete)
{
_assetRepository.DeleteNotSave(item);
}
foreach (var item in assets)
{
if (string.IsNullOrEmpty(item.Id))
{
_assetRepository.Add(new Asset
{
Amount = item.Amount,
Currency = item.Currency,
Exchange = item.Exchange,
TradingMode = TradingMode.PaperTesting,
UserId = userId,
IsActive = true,
});
}
else
{
var originalAsset = userAssets.FirstOrDefault(o => o.Id == item.Id);
if (originalAsset == null)
{
return(BadRequest("Asset not found"));
}
originalAsset.Amount = item.Amount;
_assetRepository.EditNotSave(originalAsset);
}
}
_assetRepository.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 async Task <IActionResult> RegisterStrategy([FromBody] StrategyRegistrationModel model) //TODO: Move logic from controller
{
var userId = HttpContext.User.GetUserId();
if (userId == null)
{
return(BadRequest("User not found"));
}
if (model.assets == null || !model.assets.Any())
{
return(BadRequest("No asset selected"));
}
var assets = _assetRepository.GetByUserId(userId).Where(o =>
o.Exchange.Equals(model.exchange, StringComparison.InvariantCultureIgnoreCase) &&
o.TradingMode == model.tradingMode &&
string.IsNullOrEmpty(o.StrategyId));
var strategyAssets = new List <Asset>();
var currentPrices = await _marketDataService.GetCurrentPrices(model.exchange);
var firstEvaluation = new EvaluationTick();
foreach (var modelAsset in model.assets)
{
if (model.tradingMode == TradingMode.BackTesting)
{
strategyAssets.Add(new Asset
{
Amount = modelAsset.amount,
Currency = modelAsset.currency,
Exchange = modelAsset.exchange,
TradingMode = model.tradingMode,
UserId = userId,
});
if (!currentPrices.ContainsKey(modelAsset.currency))
{
return(BadRequest("Cannot estimate initial value"));
}
firstEvaluation.BtcValue += currentPrices[modelAsset.currency].BtcValue * modelAsset.amount;
firstEvaluation.UsdValue += currentPrices[modelAsset.currency].UsdValue * modelAsset.amount;
}
else
{
var asset = assets.FirstOrDefault(o => o.Id.Equals(modelAsset.id));
if (asset == null || (asset.Amount < modelAsset.amount))
{
return(BadRequest("Insufficient funds"));
}
asset.Amount -= modelAsset.amount;
strategyAssets.Add(new Asset
{
Amount = modelAsset.amount,
Currency = asset.Currency,
Exchange = asset.Exchange,
TradingMode = model.tradingMode,
UserId = userId,
});
if (!currentPrices.ContainsKey(asset.Currency))
{
return(BadRequest("Cannot estimate initial value"));
}
firstEvaluation.BtcValue += currentPrices[asset.Currency].BtcValue * modelAsset.amount;
firstEvaluation.UsdValue += currentPrices[asset.Currency].UsdValue * modelAsset.amount;
if (asset.Amount == 0)
{
_assetRepository.DeleteNotSave(asset);
}
}
}
var strategy = new Strategy
{
Name = model.name,
Description = model.description,
Start = DateTime.Now,
StrategyState = StrategyState.Running,
TradingMode = model.tradingMode,
IsOverview = false,
Assets = strategyAssets,
UserId = userId,
Evaluations = new List <EvaluationTick> {
firstEvaluation
}
};
_strategyRepository.Add(strategy);
_assetRepository.Save();
return(Ok(strategy.Id));
}
