docker files fixes from liaqat

This commit is contained in:
alirehmani
2024-05-03 16:39:25 +05:00
commit 464a8730e8
587 changed files with 44288 additions and 0 deletions

View File

@@ -0,0 +1,200 @@
using Managing.Application.Abstractions.Services;
using Managing.Application.Workers.Abstractions;
using Managing.Domain.Trades;
using static Managing.Common.Enums;
namespace Managing.Api.Workers.Workers;
public class PositionManagerWorker : BaseWorker<PositionManagerWorker>
{
private static readonly WorkerType _workerType = WorkerType.PositionManager;
private readonly ITradingService _tradingService;
private readonly IExchangeService _exchangeService;
private readonly IAccountService _accountService;
private readonly ILogger<PositionManagerWorker> _logger;
public PositionManagerWorker(
ILogger<PositionManagerWorker> logger,
IWorkerService workerService,
ITradingService tradingService,
IExchangeService exchangeService,
IAccountService accountService) : base(
_workerType,
logger,
TimeSpan.FromMinutes(1),
workerService)
{
_logger = logger;
_tradingService = tradingService;
_exchangeService = exchangeService;
_accountService = accountService;
}
protected override async Task Run(CancellationToken cancellationToken)
{
await ManageNewPositions();
await ManagePartillyFilledPositions();
await ManageFilledPositions();
}
private async Task ManagePartillyFilledPositions()
{
var positions = GetPositions(PositionStatus.PartiallyFilled);
_logger.LogInformation("Partilly filled positions count : {0} ", positions.Count());
foreach (var position in positions)
{
_logger.LogInformation("Managing Partilly filled position: {0} - Date: {1} - Direction: {2} - Ticker: {3}", position.Identifier, position.Date, position.OriginDirection, position.Ticker);
var account = await _accountService.GetAccount(position.AccountName, false, false);
try
{
if (position.StopLoss.Status == TradeStatus.PendingOpen)
{
var stopLoss = _exchangeService.OpenStopLoss(account, position.Ticker, position.OriginDirection, position.StopLoss.Price, position.StopLoss.Quantity, false, DateTime.UtcNow).Result;
if (stopLoss != null & (stopLoss.Status == TradeStatus.Requested))
{
position.StopLoss = stopLoss;
_logger.LogInformation("|_ SL is requested");
}
else
{
throw new Exception("Stop loss not requested");
}
}
else
{
_logger.LogInformation($"|_ SL is already handle. Current status = {position.StopLoss.Status}");
}
if (position.TakeProfit1.Status == TradeStatus.PendingOpen)
{
var takeProfit1 = _exchangeService.OpenTakeProfit(account, position.Ticker, position.OriginDirection, position.TakeProfit1.Price, position.TakeProfit1.Quantity, false, DateTime.UtcNow).Result;
if (takeProfit1 != null & (takeProfit1.Status == TradeStatus.Requested))
{
position.TakeProfit1 = takeProfit1;
_logger.LogInformation("|_ TP is requested");
}
else
{
throw new Exception("Take Profit 1 not requested");
}
}
else
{
_logger.LogInformation($"|_ TP is already handle. Current status = {position.TakeProfit1.Status}");
}
if (position.TakeProfit2 != null &&
position.TakeProfit2.Status == TradeStatus.PendingOpen)
{
var takeProfit2 = _exchangeService.OpenTakeProfit(account, position.Ticker, position.OriginDirection, position.TakeProfit2.Price, position.TakeProfit2.Quantity, false, DateTime.UtcNow).Result;
if (takeProfit2 != null & (takeProfit2.Status == TradeStatus.Requested))
{
position.TakeProfit2 = takeProfit2;
_logger.LogInformation("|_ TP2 is requested");
}
else
{
throw new Exception("Take Profit 2 not requested");
}
}
else
{
_logger.LogInformation("|_ TP2 is already handle or not required");
}
}
catch (Exception ex)
{
_logger.LogError($"|_ Cannot fully filled position because : {ex.Message}");
}
if (position.StopLoss.Status == TradeStatus.Requested
&& position.TakeProfit1.Status == TradeStatus.Requested
&& (position.TakeProfit2 == null || position.TakeProfit2.Status == TradeStatus.Requested))
{
position.Status = PositionStatus.Filled;
_logger.LogInformation($"|_ Position is now open and SL/TP are correctly requested");
}
_tradingService.UpdatePosition(position);
}
}
private async Task ManageFilledPositions()
{
var positions = GetPositions(PositionStatus.Filled);
_logger.LogInformation("Filled positions count : {0} ", positions.Count());
foreach (var position in positions)
{
_logger.LogInformation("Managing filled position: {0} - Date: {1} - Direction: {2} - Ticker: {3}", position.Identifier, position.Date, position.OriginDirection, position.Ticker);
var account = await _accountService.GetAccount(position.AccountName, false, false);
var updatedPosition = await _tradingService.ManagePosition(account, position);
_tradingService.UpdatePosition(updatedPosition);
}
}
private IEnumerable<Position> GetPositions(PositionStatus positionStatus)
{
return _tradingService.GetPositionsByStatus(positionStatus)
.Where(p => p.Initiator != PositionInitiator.PaperTrading);
}
private async Task ManageNewPositions()
{
var positions = GetPositions(PositionStatus.New);
_logger.LogInformation("New positions count : {0} ", positions.Count());
foreach (var position in positions)
{
_logger.LogInformation("Managing position: {0} - Date: {1} - Direction: {2} - Ticker: {3}", position.Identifier, position.Date, position.OriginDirection, position.Ticker);
position.Status = PositionStatus.Updating;
_tradingService.UpdatePosition(position);
// Update status if position is open since to long
if (position.Date < DateTime.UtcNow.AddDays(-2))
{
position.Status = PositionStatus.Canceled;
_tradingService.UpdatePosition(position);
_logger.LogInformation($"|_ Position is now Canceled");
continue;
}
var account = await _accountService.GetAccount(position.AccountName, false, false);
if (!(await _exchangeService.GetOpenOrders(account, position.Ticker)).Any())
{
position.Status = PositionStatus.Canceled;
_tradingService.UpdatePosition(position);
_logger.LogInformation($"|_ Position is now Canceled - Position close from exchange");
continue;
}
var quantityInPosition = await _exchangeService.GetQuantityInPosition(account, position.Ticker);
if (quantityInPosition <= 0)
{
position.Status = PositionStatus.New;
_logger.LogInformation("|_ Position is currently waiting for filling");
}
else
{
position.Open.SetStatus(TradeStatus.Filled);
position.Status = PositionStatus.PartiallyFilled;
_logger.LogInformation($"|_ Position is now PartiallyFilled");
}
_tradingService.UpdatePosition(position);
}
}
}