docker files fixes from liaqat

src/Managing.Application/Trading/OpenPositionCommandHandler.cs

@@ -0,0 +1,128 @@
+using Managing.Application.Abstractions;
+using Managing.Application.Abstractions.Services;
+using Managing.Application.Trading.Commands;
+using Managing.Domain.Shared.Helpers;
+using Managing.Domain.Trades;
+using static Managing.Common.Enums;
+
+namespace Managing.Application.Trading
+{
+    public class OpenPositionCommandHandler : ICommandHandler<OpenPositionRequest, Position>
+    {
+        private readonly IExchangeService _exchangeService;
+        private readonly IAccountService _accountService;
+        private readonly ITradingService _tradingService;
+
+        public OpenPositionCommandHandler(
+            IExchangeService exchangeService,
+            IAccountService accountService,
+            ITradingService tradingService)
+        {
+            _exchangeService = exchangeService;
+            _accountService = accountService;
+            _tradingService = tradingService;
+        }
+
+        public Task<Position> Handle(OpenPositionRequest request)
+        {
+            var account = _accountService.GetAccount(request.AccountName, hideSecrets: false, getBalance: false).Result;
+            if (!request.IsForPaperTrading && !_exchangeService.CancelOrder(account, request.Ticker).Result)
+            {
+                throw new Exception($"Not able to close all orders for {request.Ticker}");
+            }
+
+            var initiator = request.IsForPaperTrading ? PositionInitiator.PaperTrading : request.Initiator;
+            var position = new Position(request.AccountName, request.Direction, request.Ticker, request.MoneyManagement, initiator, request.Date);
+            var balance = request.IsForPaperTrading ? request.Balance.GetValueOrDefault() : _exchangeService.GetBalance(account, request.IsForPaperTrading).Result;
+            var balanceAtRisk = RiskHelpers.GetBalanceAtRisk(balance, request.MoneyManagement);
+
+            if (balanceAtRisk < 13)
+            {
+                throw new Exception($"Try to risk {balanceAtRisk} $ but inferior to minimum to trade");
+            }
+
+            var price = request.IsForPaperTrading && request.Price.HasValue ?
+                request.Price.Value :
+                _exchangeService.GetPrice(account, request.Ticker, DateTime.Now);
+            var quantity = balanceAtRisk / price;
+            var fee = request.IsForPaperTrading ? request.Fee.GetValueOrDefault() : _tradingService.GetFee(account, request.IsForPaperTrading);
+
+            var expectedStatus = GetExpectedStatus(request);
+            position.Open = TradingPolicies.OpenPosition(expectedStatus).Execute(
+                () =>
+                {
+                    var openPrice = request.IsForPaperTrading || request.Price.HasValue
+                        ? request.Price.Value
+                        : _exchangeService.GetBestPrice(account, request.Ticker, price, quantity, request.Direction);
+
+                    var trade = _exchangeService.OpenTrade(
+                           account,
+                           request.Ticker,
+                           request.Direction,
+                           openPrice,
+                           quantity,
+                           request.MoneyManagement.Leverage,
+                           TradeType.Limit,
+                           isForPaperTrading: request.IsForPaperTrading,
+                           currentDate: request.Date).Result;
+
+                    trade.Fee = TradingHelpers.GetFeeAmount(fee, openPrice * quantity, account.Exchange);
+                    return trade;
+                });
+
+
+            if (IsOpenTradeHandled(position.Open.Status, account.Exchange) && !request.IgnoreSLTP.GetValueOrDefault())
+            {
+
+                var closeDirection = request.Direction == TradeDirection.Long ? TradeDirection.Short : TradeDirection.Long;
+
+                // Stop loss
+                position.StopLoss = _exchangeService.BuildEmptyTrade(
+                    request.Ticker,
+                    RiskHelpers.GetStopLossPrice(request.Direction, position.Open.Price, request.MoneyManagement),
+                    position.Open.Quantity,
+                    closeDirection,
+                    request.MoneyManagement.Leverage,
+                    TradeType.StopLoss,
+                    request.Date,
+                    TradeStatus.PendingOpen);
+
+                position.StopLoss.Fee = TradingHelpers.GetFeeAmount(fee, position.StopLoss.Price * position.StopLoss.Quantity, account.Exchange);
+
+                // Take profit
+                position.TakeProfit1 = _exchangeService.BuildEmptyTrade(
+                    request.Ticker,
+                    RiskHelpers.GetTakeProfitPrice(request.Direction, position.Open.Price, request.MoneyManagement),
+                    quantity,
+                    closeDirection,
+                    request.MoneyManagement.Leverage,
+                    TradeType.TakeProfit,
+                    request.Date,
+                    TradeStatus.PendingOpen);
+
+                position.TakeProfit1.Fee = TradingHelpers.GetFeeAmount(fee, position.TakeProfit1.Price * position.TakeProfit1.Quantity, account.Exchange);
+            }
+
+            position.Status = IsOpenTradeHandled(position.Open.Status, account.Exchange) ? position.Status : PositionStatus.Rejected;
+            _tradingService.InsertPosition(position);
+
+            return Task.FromResult(position);
+        }
+
+        private static TradeStatus GetExpectedStatus(OpenPositionRequest request)
+        {
+            if (request.IsForPaperTrading)
+            {
+                return TradeStatus.Filled;
+            }
+
+            return TradeStatus.Requested;
+        }
+
+        private static bool IsOpenTradeHandled(TradeStatus tradeStatus, TradingExchanges exchange)
+        {
+            return tradeStatus == TradeStatus.Filled
+                            || (exchange == TradingExchanges.Evm && tradeStatus == TradeStatus.Requested);
+        }
+    }
+}