Update workers setup

src/Managing.Api.Workers/Program.cs

@@ -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();

src/Managing.Api.Workers/Workers/NoobiesboardWorker.cs

@@ -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();
-    }
-}

src/Managing.Api.Workers/Workers/PositionFetcher.cs

@@ -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);
-    }
-}

src/Managing.Api.Workers/Workers/PositionManagerWorker.cs

@@ -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;
-    }
-}

src/Managing.Api.Workers/Workers/TopVolumeTickerWorker.cs

@@ -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);
-    }
-}

src/Managing.Api.Workers/appsettings.Oda.json

@@ -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
 }

src/Managing.Application.Tests/BotsTests.cs

@@ -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,

src/Managing.Application.Workers/FeeWorker.cs

@@ -1,9 +1,9 @@
-using Managing.Application.Abstractions.Services;
+using Managing.Application.Abstractions.Services;
-using Managing.Application.Workers;
 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);
     }
-}
+} 

src/Managing.Application.Workers/FundingRatesWatcher.cs

@@ -1,9 +1,9 @@
-using Managing.Application.Abstractions.Services;
+using Managing.Application.Abstractions.Services;
-using Managing.Application.Workers;
 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();
     }
-}
+} 

src/Managing.Application.Workers/LeaderboardWorker.cs

@@ -1,17 +1,17 @@
-using Managing.Application.Abstractions.Services;
+using Managing.Application.Abstractions.Services;
-using Managing.Application.Workers;
 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();
     }
-}
+} 

src/Managing.Application.Workers/PricesBaseWorker.cs

@@ -1,9 +1,9 @@
-using Managing.Application.Abstractions.Services;
+using Managing.Application.Abstractions.Services;
-using Managing.Application.Workers;
 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);
         }
     }
-}
+} 

src/Managing.Application.Workers/PricesFifteenMinutesWorker.cs

@@ -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
     )
     {
     }
-}
+} 

src/Managing.Application.Workers/PricesFiveMinutesWorker.cs

@@ -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>
     )
     {
     }
-}
+} 

src/Managing.Application.Workers/PricesFourHoursWorker.cs

@@ -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>
     )
     {
     }
-}
+} 

src/Managing.Application.Workers/PricesOneDayWorker.cs

@@ -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>
     )
     {
     }
-}
+} 

src/Managing.Application.Workers/PricesOneHourWorker.cs

@@ -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)
     {
     }
-}
+} 

src/Managing.Application.Workers/SpotlightWorker.cs

@@ -1,9 +1,9 @@
-using Managing.Application.Abstractions.Services;
+using Managing.Application.Abstractions.Services;
-using Managing.Application.Workers;
 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;
         }
     }
-}
+} 

src/Managing.Application.Workers/TraderWatcher.cs

@@ -1,15 +1,15 @@
-using Managing.Application.Abstractions.Services;
+using Managing.Application.Abstractions.Services;
-using Managing.Application.Workers;
 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();
     }
-}
+} 

src/Managing.Bootstrap/WorkersBootstrap.cs

@@ -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;
     }