Oda/managing-apps
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update workers setup

Browse Source
This commit is contained in:
cryptooda
2025-07-10 16:47:13 +07:00
parent d07fc4b1e1
commit c2c181e417
19 changed files with 119 additions and 543 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
src/Managing.Api.Workers/Program.cs
View File

@@ -1,7 +1,6 @@
using System.Text.Json.Serialization;
using HealthChecks.UI.Client;
using Managing.Api.Workers.Filters;
using Managing.Api.Workers.Workers;
using Managing.Application.Hubs;
using Managing.Bootstrap;
using Managing.Common;
@@ -152,18 +151,6 @@ builder.Services.AddSwaggerGen(options =>
});
builder.WebHost.SetupDiscordBot();
// builder.Services.AddHostedService<FeeWorker>();
// builder.Services.AddHostedService<PositionManagerWorker>();
// builder.Services.AddHostedService<PositionFetcher>();
// builder.Services.AddHostedService<PricesFiveMinutesWorker>();
builder.Services.AddHostedService<PricesFifteenMinutesWorker>();
builder.Services.AddHostedService<PricesOneHourWorker>();
builder.Services.AddHostedService<PricesFourHoursWorker>();
builder.Services.AddHostedService<PricesOneDayWorker>();
// builder.Services.AddHostedService<SpotlightWorker>();
// builder.Services.AddHostedService<TraderWatcher>();
// builder.Services.AddHostedService<LeaderboardWorker>();
// builder.Services.AddHostedService<FundingRatesWatcher>();
// App
var app = builder.Build();

30
src/Managing.Api.Workers/Workers/NoobiesboardWorker.cs
View File

@@ -1,30 +0,0 @@
using Managing.Application.Abstractions.Services;
using Managing.Application.Workers;
using Managing.Application.Workers.Abstractions;
using static Managing.Common.Enums;
namespace Managing.Api.Workers.Workers;
public class NoobiesboardWorker : BaseWorker<FeeWorker>
{
private readonly IStatisticService _statisticService;
private static readonly WorkerType _workerType = WorkerType.Noobiesboard;
public NoobiesboardWorker(
ILogger<FeeWorker> logger,
IStatisticService statisticService,
IWorkerService workerService) : base(
_workerType,
logger,
TimeSpan.FromHours(24),
workerService
)
{
_statisticService = statisticService;
}
protected override async Task Run(CancellationToken cancellationToken)
{
await _statisticService.UpdateNoobiesboard();
}
}

38
src/Managing.Api.Workers/Workers/PositionFetcher.cs
View File

@@ -1,38 +0,0 @@
using Managing.Application.Abstractions.Services;
using Managing.Application.Hubs;
using Managing.Application.Workers;
using Managing.Application.Workers.Abstractions;
using Microsoft.AspNetCore.SignalR;
using static Managing.Common.Enums;
namespace Managing.Api.Workers.Workers;
public class PositionFetcher : BaseWorker<PositionFetcher>
{
private static readonly WorkerType _workerType = WorkerType.PositionFetcher;
private readonly ITradingService _tradingService;
private readonly IHubContext<PositionHub> _hubContext;
private readonly ILogger<PositionFetcher> _logger;
public PositionFetcher(
ILogger<PositionFetcher> logger,
IWorkerService workerService,
ITradingService tradingService,
IHubContext<PositionHub> hubContext) : base(
_workerType,
logger,
TimeSpan.FromSeconds(10),
workerService)
{
_logger = logger;
_tradingService = tradingService;
_hubContext = hubContext;
}
protected override async Task Run(CancellationToken cancellationToken)
{
var positions = _tradingService.GetPositions().Where(p => p.Initiator != PositionInitiator.PaperTrading);
await _hubContext.Clients.All.SendAsync("Positions", positions);
}
}

377
src/Managing.Api.Workers/Workers/PositionManagerWorker.cs
View File

@@ -1,377 +0,0 @@
using Managing.Application.Abstractions;
using Managing.Application.Abstractions.Services;
using Managing.Application.Workers;
using Managing.Application.Workers.Abstractions;
using Managing.Domain.Accounts;
using Managing.Domain.Shared.Helpers;
using Managing.Domain.Trades;
using Newtonsoft.Json;
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;
private readonly ICacheService _cacheService;
public PositionManagerWorker(
ILogger<PositionManagerWorker> logger,
IWorkerService workerService,
ITradingService tradingService,
IExchangeService exchangeService,
IAccountService accountService, ICacheService cacheService) : base(
_workerType,
logger,
TimeSpan.FromMinutes(1),
workerService)
{
_logger = logger;
_tradingService = tradingService;
_exchangeService = exchangeService;
_accountService = accountService;
_cacheService = cacheService;
}
protected override async Task Run(CancellationToken cancellationToken)
{
await ManageNewPositions();
await ManagePartiallyFilledPositions();
await ManageFilledPositions();
}
private async Task ManagePartiallyFilledPositions()
{
var positions = GetPositions(PositionStatus.PartiallyFilled);
_logger.LogInformation("Processing {PartiallyFilledCount} partially filled positions", positions.Count());
foreach (var position in positions)
{
using (_logger.BeginScope("Position {PositionId} ({Ticker})", position.Identifier, position.Ticker))
{
try
{
// Lock position for processing
position.Status = PositionStatus.Updating;
_tradingService.UpdatePosition(position);
_logger.LogDebug("Verifying position on exchange for {Direction} position opened at {OpenDate}",
position.OriginDirection, position.Date.ToString("o"));
var account = await _accountService.GetAccount(position.AccountName, false, false);
// Get positions directly from broker
var brokerPositions = await _exchangeService.GetBrokerPositions(account);
var exchangePosition = brokerPositions.FirstOrDefault(p =>
p.Ticker == position.Ticker &&
p.OriginDirection == position.OriginDirection);
if (exchangePosition == null)
{
_logger.LogWarning("Position not found on exchange - marking as canceled");
position.Status = PositionStatus.Canceled;
_tradingService.UpdatePosition(position);
continue;
}
// Update with exchange data if available
if (exchangePosition.StopLoss != null)
{
_logger.LogInformation("Stop Loss found on exchange - ID: {OrderId}", exchangePosition.StopLoss.ExchangeOrderId);
position.StopLoss = exchangePosition.StopLoss;
}
else
{
_logger.LogWarning("Stop Loss not found on exchange - creating new SL order");
var updatedSl = await _exchangeService.OpenStopLoss(account, position.Ticker, position.OriginDirection,
position.StopLoss.Price, position.StopLoss.Quantity, false, DateTime.UtcNow);
if (updatedSl != null)
{
position.StopLoss = updatedSl;
}
}
if (exchangePosition.TakeProfit1 != null)
{
_logger.LogInformation("Take Profit found on exchange - ID: {OrderId}", exchangePosition.TakeProfit1.ExchangeOrderId);
position.TakeProfit1 = exchangePosition.TakeProfit1;
}
else
{
_logger.LogWarning("Take Profit not found on exchange - creating new TP order");
var updatedTp1 = await _exchangeService.OpenTakeProfit(account, position.Ticker, position.OriginDirection,
position.TakeProfit1.Price, position.TakeProfit1.Quantity, false, DateTime.UtcNow);
if (updatedTp1 != null)
{
position.TakeProfit1 = updatedTp1;
}
}
// Handle TP2 if it exists
if (position.TakeProfit2 != null)
{
if (exchangePosition.TakeProfit2 != null)
{
_logger.LogInformation("Take Profit 2 found on exchange - ID: {OrderId}", exchangePosition.TakeProfit2.ExchangeOrderId);
position.TakeProfit2 = exchangePosition.TakeProfit2;
}
else
{
_logger.LogWarning("Take Profit 2 not found on exchange - creating new TP2 order");
var updatedTp2 = await _exchangeService.OpenTakeProfit(account, position.Ticker, position.OriginDirection,
position.TakeProfit2.Price, position.TakeProfit2.Quantity, false, DateTime.UtcNow);
if (updatedTp2 != null)
{
position.TakeProfit2 = updatedTp2;
}
}
}
// Update position status based on verification results
var success = AllTradesActive(position);
position.Status = success ? PositionStatus.Filled : PositionStatus.PartiallyFilled;
_logger.LogInformation("Final position status: {Status}", position.Status);
}
catch (Exception ex)
{
_logger.LogError(ex, "Position processing failed");
position.Status = PositionStatus.PartiallyFilled;
}
finally
{
_tradingService.UpdatePosition(position);
}
}
}
}
private bool AllTradesActive(Position position)
{
return position.StopLoss.Status.IsActive() &&
position.TakeProfit1.Status.IsActive() &&
(position.TakeProfit2?.Status.IsActive() ?? true);
}
private async Task ManageFilledPositions()
{
var positions = GetPositions(PositionStatus.Filled);
_logger.LogInformation("Monitoring {FilledPositionCount} filled positions", positions.Count());
foreach (var position in positions)
{
using (_logger.BeginScope("Position {PositionId} ({Ticker})", position.Identifier, position.Ticker))
{
try
{
// Acquire processing lock
_logger.LogDebug("Acquiring position lock");
position.Status = PositionStatus.Updating;
_tradingService.UpdatePosition(position);
_logger.LogInformation("Checking position state on exchange - Direction: {Direction}, Open Since: {OpenDate}",
position.OriginDirection, position.Date.ToString("yyyy-MM-dd HH:mm:ss"));
var account = await GetAccount(position.AccountName);
// Check if position still exists on broker
var brokerPositions = await _exchangeService.GetBrokerPositions(account);
var exchangePosition = brokerPositions.FirstOrDefault(p =>
p.Ticker == position.Ticker &&
p.OriginDirection == position.OriginDirection);
if (exchangePosition == null)
{
// Position no longer on exchange - it has been closed
_logger.LogInformation("Position no longer on exchange - marking as finished");
position.Status = PositionStatus.Finished;
// Determine if SL or TP was hit by checking which one is missing
if (exchangePosition?.StopLoss == null && position.StopLoss.Status != TradeStatus.Filled)
{
_logger.LogInformation("Stop loss appears to have been hit");
position.StopLoss.SetStatus(TradeStatus.Filled);
position.ProfitAndLoss = TradingBox.GetProfitAndLoss(
position,
position.StopLoss.Quantity,
position.StopLoss.Price,
position.Open.Leverage);
}
else if (exchangePosition?.TakeProfit1 == null && position.TakeProfit1.Status != TradeStatus.Filled)
{
_logger.LogInformation("Take profit 1 appears to have been hit");
position.TakeProfit1.SetStatus(TradeStatus.Filled);
position.ProfitAndLoss = TradingBox.GetProfitAndLoss(
position,
position.TakeProfit1.Quantity,
position.TakeProfit1.Price,
position.Open.Leverage);
}
else if (exchangePosition?.TakeProfit2 == null && position.TakeProfit2?.Status != TradeStatus.Filled)
{
_logger.LogInformation("Take profit 2 appears to have been hit");
position.TakeProfit2.SetStatus(TradeStatus.Filled);
position.ProfitAndLoss = TradingBox.GetProfitAndLoss(
position,
position.TakeProfit2.Quantity,
position.TakeProfit2.Price,
position.Open.Leverage);
}
// Cancel any remaining orders
await _exchangeService.CancelOrder(account, position.Ticker);
}
else
{
// Position still exists - update with exchange data
_logger.LogInformation("Position still active on exchange with quantity {Quantity}",
exchangePosition.Open?.Quantity ?? 0);
// Update our position with broker data
if (exchangePosition.Open != null)
position.Open = exchangePosition.Open;
if (exchangePosition.StopLoss != null)
position.StopLoss = exchangePosition.StopLoss;
if (exchangePosition.TakeProfit1 != null)
position.TakeProfit1 = exchangePosition.TakeProfit1;
if (exchangePosition.TakeProfit2 != null)
position.TakeProfit2 = exchangePosition.TakeProfit2;
if (exchangePosition.ProfitAndLoss != null)
position.ProfitAndLoss = exchangePosition.ProfitAndLoss;
else
{
// Calculate PNL if not provided
var lastPrice = _exchangeService.GetPrice(account, position.Ticker, DateTime.UtcNow);
position.ProfitAndLoss = TradingBox.GetProfitAndLoss(
position,
position.Open.Quantity,
lastPrice,
position.Open.Leverage);
}
_logger.LogInformation("Updated position from exchange - PNL: {PNL}",
position.ProfitAndLoss?.Net ?? 0);
// Keep status as Filled
position.Status = PositionStatus.Filled;
}
_tradingService.UpdatePosition(position);
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to manage position - {ErrorMessage}", ex.Message);
// Reset status for retry
position.Status = PositionStatus.Filled;
_tradingService.UpdatePosition(position);
}
finally
{
// Ensure lock is always released
if (position.Status == PositionStatus.Updating)
{
position.Status = PositionStatus.Filled;
_tradingService.UpdatePosition(position);
}
}
}
}
}
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("Processing {NewPositionCount} new positions", positions.Count());
foreach (var position in positions)
{
using (_logger.BeginScope("Position {Identifier}", position.Identifier))
{
try
{
// Immediate status update for concurrency protection
_logger.LogDebug("[{Identifier}] Acquiring position lock via status update", position.Identifier);
position.Status = PositionStatus.Updating;
_tradingService.UpdatePosition(position);
var account = await GetAccount(position.AccountName);
// Check if position exists on broker
var brokerPositions = await _exchangeService.GetBrokerPositions(account);
var exchangePosition = brokerPositions.FirstOrDefault(p =>
p.Ticker == position.Ticker &&
p.OriginDirection == position.OriginDirection);
if (exchangePosition != null)
{
// Position is confirmed on exchange
position.Status = PositionStatus.PartiallyFilled;
position.Open = exchangePosition.Open; // Use the exchange data
_tradingService.UpdatePosition(position);
_logger.LogInformation("[{Identifier}] Position found on exchange - moving to partially filled status",
position.Identifier);
continue;
}
// Position not found on exchange - check for staleness
if (position.Date < DateTime.UtcNow.AddDays(-1))
{
position.Status = PositionStatus.Canceled;
_tradingService.UpdatePosition(position);
_logger.LogWarning("[{Identifier}] Position canceled - stale since {PositionAge} days",
position.Identifier,
(DateTime.UtcNow - position.Date).TotalDays);
}
else
{
// Reset status to try again
position.Status = PositionStatus.New;
_tradingService.UpdatePosition(position);
_logger.LogInformation("[{Identifier}] Position not yet found on exchange - awaiting fill",
position.Identifier);
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Error processing position {Identifier}", position.Identifier);
// Reset to New status for retry
position.Status = PositionStatus.New;
_tradingService.UpdatePosition(position);
}
}
}
}
private async Task<Account> GetAccount(string accountName)
{
var account = _cacheService.GetValue<Account>(accountName);
if (account == null)
{
account = await _accountService.GetAccount(accountName, false, false);
_cacheService.SaveValue(accountName, JsonConvert.SerializeObject(account));
}
return account;
}
}

30
src/Managing.Api.Workers/Workers/TopVolumeTickerWorker.cs
View File

@@ -1,30 +0,0 @@
using Managing.Application.Abstractions.Services;
using Managing.Application.Workers;
using Managing.Application.Workers.Abstractions;
using static Managing.Common.Enums;
namespace Managing.Api.Workers.Workers;
public class TopVolumeTickerWorker : BaseWorker<TopVolumeTickerWorker>
{
private readonly IStatisticService _statisticService;
private static readonly WorkerType _workerType = WorkerType.TopVolumeTicker;
public TopVolumeTickerWorker(
ILogger<TopVolumeTickerWorker> logger,
IWorkerService workerService,
IStatisticService statisticService) : base(
_workerType,
logger,
TimeSpan.FromHours(12),
workerService
)
{
_statisticService = statisticService;
}
protected override async Task Run(CancellationToken cancellationToken)
{
await _statisticService.UpdateTopVolumeTicker(TradingExchanges.Evm, 10);
}
}

14
src/Managing.Api.Workers/appsettings.Oda.json
View File

@@ -24,5 +24,17 @@
"ElasticConfiguration": {
"Uri": "http://localhost:9200"
},
"AllowedHosts": "*"
"AllowedHosts": "*",
"WorkerPricesFifteenMinutes": true,
"WorkerPricesOneHour": true,
"WorkerPricesFourHours": true,
"WorkerPricesOneDay": true,
"WorkerPricesFiveMinutes": false,
"WorkerFee": false,
"WorkerPositionManager": false,
"WorkerPositionFetcher": false,
"WorkerSpotlight": false,
"WorkerTraderWatcher": false,
"WorkerLeaderboard": false,
"WorkerFundingRatesWatcher": false
}

14
src/Managing.Application.Tests/BotsTests.cs
View File

@@ -33,6 +33,7 @@ namespace Managing.Application.Tests
var backtestRepository = new Mock<IBacktestRepository>().Object;
var discordService = new Mock<IMessengerService>().Object;
var scenarioService = new Mock<IScenarioService>().Object;
var messengerService = new Mock<IMessengerService>().Object;
var tradingBotLogger = TradingBaseTests.CreateTradingBotLogger();
var backtestLogger = TradingBaseTests.CreateBacktesterLogger();
var botService = new Mock<IBotService>().Object;
@@ -44,7 +45,7 @@ namespace Managing.Application.Tests
_tradingService.Object,
botService);
_backtester = new Backtester(_exchangeService, _botFactory, backtestRepository, backtestLogger,
scenarioService, _accountService.Object);
scenarioService, _accountService.Object, messengerService);
_elapsedTimes = new List<double>();
// Initialize cross-platform file paths
@@ -75,7 +76,6 @@ namespace Managing.Application.Tests
Timeframe = timeframe,
IsForWatchingOnly = false,
BotTradingBalance = 1000,
BotType = BotType.FlippingBot,
IsForBacktest = true,
CooldownPeriod = 1,
MaxLossStreak = 0,
@@ -87,7 +87,8 @@ namespace Managing.Application.Tests
};
// Act
var backtestResult = await _backtester.RunTradingBotBacktest(config, localCandles.TakeLast(500).ToList(), null, false);
var backtestResult =
await _backtester.RunTradingBotBacktest(config, localCandles.TakeLast(500).ToList(), null, false);
var json = JsonConvert.SerializeObject(backtestResult, Formatting.None);
File.WriteAllText($"{ticker.ToString()}-{timeframe.ToString()}-{Guid.NewGuid()}.json", json);
@@ -125,7 +126,6 @@ namespace Managing.Application.Tests
Timeframe = timeframe,
IsForWatchingOnly = false,
BotTradingBalance = 1000,
BotType = BotType.ScalpingBot,
IsForBacktest = true,
CooldownPeriod = 1,
MaxLossStreak = 0,
@@ -175,7 +175,6 @@ namespace Managing.Application.Tests
Timeframe = timeframe,
IsForWatchingOnly = false,
BotTradingBalance = 1000,
BotType = BotType.ScalpingBot,
IsForBacktest = true,
CooldownPeriod = 1,
MaxLossStreak = 0,
@@ -266,7 +265,6 @@ namespace Managing.Application.Tests
Timeframe = timeframe,
IsForWatchingOnly = false,
BotTradingBalance = 1000,
BotType = BotType.ScalpingBot,
IsForBacktest = true,
CooldownPeriod = 1,
MaxLossStreak = 0,
@@ -285,7 +283,6 @@ namespace Managing.Application.Tests
Timeframe = timeframe,
IsForWatchingOnly = false,
BotTradingBalance = 1000,
BotType = BotType.FlippingBot,
IsForBacktest = true,
CooldownPeriod = 1,
MaxLossStreak = 0,
@@ -408,7 +405,6 @@ namespace Managing.Application.Tests
Timeframe = timeframe,
IsForWatchingOnly = false,
BotTradingBalance = 1000,
BotType = BotType.ScalpingBot,
IsForBacktest = true,
CooldownPeriod = 1,
MaxLossStreak = 0,
@@ -427,7 +423,6 @@ namespace Managing.Application.Tests
Timeframe = timeframe,
IsForWatchingOnly = false,
BotTradingBalance = 1000,
BotType = BotType.FlippingBot,
IsForBacktest = true,
CooldownPeriod = 1,
MaxLossStreak = 0,
@@ -664,7 +659,6 @@ namespace Managing.Application.Tests
Timeframe = timeframe,
IsForWatchingOnly = false,
BotTradingBalance = 1000,
BotType = botType,
IsForBacktest = true,
CooldownPeriod = 1,
MaxLossStreak = 0,

8
src/Managing.Api.Workers/Workers/FeeWorker.cs → src/Managing.Application.Workers/FeeWorker.cs
View File

@@ -1,9 +1,9 @@
using Managing.Application.Abstractions.Services;
using Managing.Application.Workers;
using Managing.Application.Abstractions.Services;
using Managing.Application.Workers.Abstractions;
using Microsoft.Extensions.Logging;
using static Managing.Common.Enums;
namespace Managing.Api.Workers.Workers;
namespace Managing.Application.Workers;
public class FeeWorker : BaseWorker<FeeWorker>
{
@@ -27,4 +27,4 @@ public class FeeWorker : BaseWorker<FeeWorker>
{
_tradingService.UpdateFee(TradingExchanges.Evm);
}
}
}

8
src/Managing.Api.Workers/Workers/FundingRatesWatcher.cs → src/Managing.Application.Workers/FundingRatesWatcher.cs
View File

@@ -1,9 +1,9 @@
using Managing.Application.Abstractions.Services;
using Managing.Application.Workers;
using Managing.Application.Abstractions.Services;
using Managing.Application.Workers.Abstractions;
using Managing.Common;
using Microsoft.Extensions.Logging;
namespace Managing.Api.Workers.Workers;
namespace Managing.Application.Workers;
public class FundingRatesWatcher : BaseWorker<FundingRatesWatcher>
{
@@ -26,4 +26,4 @@ public class FundingRatesWatcher : BaseWorker<FundingRatesWatcher>
{
await _statisticService.UpdateFundingRates();
}
}
}

12
src/Managing.Api.Workers/Workers/LeaderboardWorker.cs → src/Managing.Application.Workers/LeaderboardWorker.cs
View File

@@ -1,17 +1,17 @@
using Managing.Application.Abstractions.Services;
using Managing.Application.Workers;
using Managing.Application.Abstractions.Services;
using Managing.Application.Workers.Abstractions;
using Microsoft.Extensions.Logging;
using static Managing.Common.Enums;
namespace Managing.Api.Workers.Workers;
namespace Managing.Application.Workers;
public class LeaderboardWorker : BaseWorker<FeeWorker>
public class LeaderboardWorker : BaseWorker<LeaderboardWorker>
{
private readonly IStatisticService _statisticService;
private static readonly WorkerType _workerType = WorkerType.LeaderboardWorker;
public LeaderboardWorker(
ILogger<FeeWorker> logger,
ILogger<LeaderboardWorker> logger,
IStatisticService statisticService,
IWorkerService workerService) : base(
_workerType,
@@ -27,4 +27,4 @@ public class LeaderboardWorker : BaseWorker<FeeWorker>
{
await _statisticService.UpdateLeaderboard();
}
}
}

8
src/Managing.Api.Workers/Workers/PricesBaseWorker.cs → src/Managing.Application.Workers/PricesBaseWorker.cs
View File

@@ -1,9 +1,9 @@
using Managing.Application.Abstractions.Services;
using Managing.Application.Workers;
using Managing.Application.Abstractions.Services;
using Managing.Application.Workers.Abstractions;
using Microsoft.Extensions.Logging;
using static Managing.Common.Enums;
namespace Managing.Api.Workers.Workers;
namespace Managing.Application.Workers;
public abstract class PricesBaseWorker<T> : BaseWorker<T> where T : class
{
@@ -64,4 +64,4 @@ public abstract class PricesBaseWorker<T> : BaseWorker<T> where T : class
await _pricesService.UpdatePrice(TradingExchanges.Evm, ticker, _timeframe);
}
}
}
}

7
src/Managing.Api.Workers/Workers/PricesFifteenMinutesWorker.cs → src/Managing.Application.Workers/PricesFifteenMinutesWorker.cs
View File

@@ -1,8 +1,9 @@
using Managing.Application.Abstractions.Services;
using Managing.Application.Abstractions.Services;
using Managing.Application.Workers.Abstractions;
using Microsoft.Extensions.Logging;
using static Managing.Common.Enums;
namespace Managing.Api.Workers.Workers;
namespace Managing.Application.Workers;
public class PricesFifteenMinutesWorker : PricesBaseWorker<PricesFifteenMinutesWorker>
{
@@ -21,4 +22,4 @@ public class PricesFifteenMinutesWorker : PricesBaseWorker<PricesFifteenMinutesW
)
{
}
}
}

7
src/Managing.Api.Workers/Workers/PricesFiveMinutesWorker.cs → src/Managing.Application.Workers/PricesFiveMinutesWorker.cs
View File

@@ -1,8 +1,9 @@
using Managing.Application.Abstractions.Services;
using Managing.Application.Abstractions.Services;
using Managing.Application.Workers.Abstractions;
using Microsoft.Extensions.Logging;
using static Managing.Common.Enums;
namespace Managing.Api.Workers.Workers;
namespace Managing.Application.Workers;
public class PricesFiveMinutesWorker : PricesBaseWorker<PricesFiveMinutesWorker>
{
@@ -21,4 +22,4 @@ public class PricesFiveMinutesWorker : PricesBaseWorker<PricesFiveMinutesWorker>
)
{
}
}
}

7
src/Managing.Api.Workers/Workers/PricesFourHoursWorker.cs → src/Managing.Application.Workers/PricesFourHoursWorker.cs
View File

@@ -1,8 +1,9 @@
using Managing.Application.Abstractions.Services;
using Managing.Application.Abstractions.Services;
using Managing.Application.Workers.Abstractions;
using Microsoft.Extensions.Logging;
using static Managing.Common.Enums;
namespace Managing.Api.Workers.Workers;
namespace Managing.Application.Workers;
public class PricesFourHoursWorker : PricesBaseWorker<PricesFourHoursWorker>
{
@@ -21,4 +22,4 @@ public class PricesFourHoursWorker : PricesBaseWorker<PricesFourHoursWorker>
)
{
}
}
}

7
src/Managing.Api.Workers/Workers/PricesOneDayWorker.cs → src/Managing.Application.Workers/PricesOneDayWorker.cs
View File

@@ -1,8 +1,9 @@
using Managing.Application.Abstractions.Services;
using Managing.Application.Abstractions.Services;
using Managing.Application.Workers.Abstractions;
using Microsoft.Extensions.Logging;
using static Managing.Common.Enums;
namespace Managing.Api.Workers.Workers;
namespace Managing.Application.Workers;
public class PricesOneDayWorker : PricesBaseWorker<PricesOneDayWorker>
{
@@ -21,4 +22,4 @@ public class PricesOneDayWorker : PricesBaseWorker<PricesOneDayWorker>
)
{
}
}
}

7
src/Managing.Api.Workers/Workers/PricesOneHourWorker.cs → src/Managing.Application.Workers/PricesOneHourWorker.cs
View File

@@ -1,8 +1,9 @@
using Managing.Application.Abstractions.Services;
using Managing.Application.Abstractions.Services;
using Managing.Application.Workers.Abstractions;
using Microsoft.Extensions.Logging;
using static Managing.Common.Enums;
namespace Managing.Api.Workers.Workers;
namespace Managing.Application.Workers;
public class PricesOneHourWorker : PricesBaseWorker<PricesOneHourWorker>
{
@@ -20,4 +21,4 @@ public class PricesOneHourWorker : PricesBaseWorker<PricesOneHourWorker>
Timeframe.OneHour)
{
}
}
}

8
src/Managing.Api.Workers/Workers/SpotlightWorker.cs → src/Managing.Application.Workers/SpotlightWorker.cs
View File

@@ -1,9 +1,9 @@
using Managing.Application.Abstractions.Services;
using Managing.Application.Workers;
using Managing.Application.Abstractions.Services;
using Managing.Application.Workers.Abstractions;
using Managing.Common;
using Microsoft.Extensions.Logging;
namespace Managing.Api.Workers.Workers;
namespace Managing.Application.Workers;
public class SpotlightWorker : BaseWorker<SpotlightWorker>
{
@@ -33,4 +33,4 @@ public class SpotlightWorker : BaseWorker<SpotlightWorker>
throw;
}
}
}
}

14
src/Managing.Api.Workers/Workers/TraderWatcher.cs → src/Managing.Application.Workers/TraderWatcher.cs
View File

@@ -1,15 +1,15 @@
using Managing.Application.Abstractions.Services;
using Managing.Application.Workers;
using Managing.Application.Abstractions.Services;
using Managing.Application.Workers.Abstractions;
using Microsoft.Extensions.Logging;
using static Managing.Common.Enums;
namespace Managing.Api.Workers.Workers;
namespace Managing.Application.Workers;
/// <summary>
/// Represents a worker that watches traders and performs actions based on trading activities.
/// Inherits from <see cref="BaseWorker{TWorker}"/> where TWorker is <see cref="FeeWorker"/>.
/// Inherits from <see cref="BaseWorker{TWorker}"/> where TWorker is <see cref="TraderWatcher"/>.
/// </summary>
public class TraderWatcher : BaseWorker<FeeWorker>
public class TraderWatcher : BaseWorker<TraderWatcher>
{
private readonly ITradingService _tradingService;
private static readonly WorkerType _workerType = WorkerType.TraderWatcher;
@@ -21,7 +21,7 @@ public class TraderWatcher : BaseWorker<FeeWorker>
/// <param name="tradingService">The trading service to monitor trading activities.</param>
/// <param name="workerService">The worker service to manage worker lifecycle.</param>
public TraderWatcher(
ILogger<FeeWorker> logger,
ILogger<TraderWatcher> logger,
ITradingService tradingService,
IWorkerService workerService) : base(
_workerType,
@@ -41,4 +41,4 @@ public class TraderWatcher : BaseWorker<FeeWorker>
{
await _tradingService.WatchTrader();
}
}
}

53
src/Managing.Bootstrap/WorkersBootstrap.cs
View File

@@ -49,6 +49,7 @@ public static class WorkersBootstrap
{
return services
.AddApplication()
.AddWorkers(configuration)
.AddInfrastructure(configuration);
}
@@ -76,6 +77,58 @@ public static class WorkersBootstrap
private static IServiceCollection AddWorkers(this IServiceCollection services, IConfiguration configuration)
{
// Price Workers
if (configuration.GetValue<bool>("WorkerPricesFifteenMinutes", false))
{
services.AddHostedService<PricesFifteenMinutesWorker>();
}
if (configuration.GetValue<bool>("WorkerPricesOneHour", false))
{
services.AddHostedService<PricesOneHourWorker>();
}
if (configuration.GetValue<bool>("WorkerPricesFourHours", false))
{
services.AddHostedService<PricesFourHoursWorker>();
}
if (configuration.GetValue<bool>("WorkerPricesOneDay", false))
{
services.AddHostedService<PricesOneDayWorker>();
}
if (configuration.GetValue<bool>("WorkerPricesFiveMinutes", false))
{
services.AddHostedService<PricesFiveMinutesWorker>();
}
// Other Workers
if (configuration.GetValue<bool>("WorkerFee", false))
{
services.AddHostedService<FeeWorker>();
}
if (configuration.GetValue<bool>("WorkerSpotlight", false))
{
services.AddHostedService<SpotlightWorker>();
}
if (configuration.GetValue<bool>("WorkerTraderWatcher", false))
{
services.AddHostedService<TraderWatcher>();
}
if (configuration.GetValue<bool>("WorkerLeaderboard", false))
{
services.AddHostedService<LeaderboardWorker>();
}
if (configuration.GetValue<bool>("WorkerFundingRatesWatcher", false))
{
services.AddHostedService<FundingRatesWatcher>();
}
return services;
}