docker files fixes from liaqat

src/Managing.Api.Workers/Controllers/WorkerController.cs

@@ -0,0 +1,31 @@
+using Managing.Application.Workers.Abstractions;
+using Managing.Domain.Workers;
+using Microsoft.AspNetCore.Mvc;
+using static Managing.Common.Enums;
+
+namespace Managing.Api.Workers.Controllers;
+
+[ApiController]
+[Route("[controller]")]
+[Produces("application/json")]
+public class WorkerController : ControllerBase
+{
+    private readonly IWorkerService _workerService;
+
+    public WorkerController(IWorkerService workerService)
+    {
+        _workerService = workerService;
+    }
+
+    [HttpGet]
+    public ActionResult<List<Worker>> GetWorkers()
+    {
+        return Ok(_workerService.GetWorkers());
+    }
+
+    [HttpPatch]
+    public async Task<ActionResult> ToggleWorker(WorkerType workerType)
+    {
+        return Ok(await _workerService.ToggleWorker(workerType));
+    }
+}

src/Managing.Api.Workers/Dockerfile

@@ -0,0 +1,36 @@
+# Use the official Microsoft ASP.NET Core runtime as the base image.
+FROM mcr.microsoft.com/dotnet/aspnet:7.0 AS base
+WORKDIR /app
+EXPOSE 80
+EXPOSE 443
+
+# Use the official Microsoft .NET SDK image to build the code.
+FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build
+WORKDIR /src
+COPY ["Managing.Api.Workers/Managing.Api.Workers.csproj", "Managing.Api.Workers/"]
+COPY ["Managing.Bootstrap/Managing.Bootstrap.csproj", "Managing.Bootstrap/"]
+COPY ["Managing.Infrastructure.Storage/Managing.Infrastructure.Storage.csproj", "Managing.Infrastructure.Storage/"]
+COPY ["Managing.Application/Managing.Application.csproj", "Managing.Application/"]
+COPY ["Managing.Infrastructure.MongoDb/Managing.Infrastructure.MongoDb.csproj", "Managing.Infrastructure.MongoDb/"]
+COPY ["Managing.Common/Managing.Common.csproj", "Managing.Common/"]
+COPY ["Managing.Core/Managing.Core.csproj", "Managing.Core/"]
+COPY ["Managing.Application.Abstractions/Managing.Application.Abstractions.csproj", "Managing.Application.Abstractions/"]
+COPY ["Managing.Domain/Managing.Domain.csproj", "Managing.Domain/"]
+COPY ["Managing.Application.Workers/Managing.Application.Workers.csproj", "Managing.Application.Workers/"]
+COPY ["Managing.Infrastructure.Messengers/Managing.Infrastructure.Messengers.csproj", "Managing.Infrastructure.Messengers/"]
+COPY ["Managing.Infrastructure.Exchanges/Managing.Infrastructure.Exchanges.csproj", "Managing.Infrastructure.Exchanges/"]
+COPY ["Managing.Infrastructure.Database/Managing.Infrastructure.Databases.csproj", "Managing.Infrastructure.Database/"]
+RUN dotnet restore "Managing.Api.Workers/Managing.Api.Workers.csproj"
+COPY . .
+WORKDIR "/src/Managing.Api.Workers"
+RUN dotnet build "Managing.Api.Workers.csproj" -c Release -o /app/build
+
+FROM build AS publish
+RUN dotnet publish "Managing.Api.Workers.csproj" -c Release -o /app/publish
+
+FROM base AS final
+WORKDIR /app
+COPY --from=publish /app/publish .
+COPY Managing.Api.Workers/managing_cert.pfx .
+COPY Managing.Api.Workers/appsettings.Lowpro.json ./appsettings.json
+ENTRYPOINT ["dotnet", "Managing.Api.Workers.dll"]

src/Managing.Api.Workers/Filters/EnumSchemaFilter.cs

@@ -0,0 +1,20 @@
+using Microsoft.OpenApi.Any;
+using Microsoft.OpenApi.Models;
+using Swashbuckle.AspNetCore.SwaggerGen;
+
+namespace Managing.Api.Workers.Filters
+{
+    public class EnumSchemaFilter : ISchemaFilter
+    {
+        public void Apply(OpenApiSchema model, SchemaFilterContext context)
+        {
+            if (context.Type.IsEnum)
+            {
+                model.Enum.Clear();
+                Enum.GetNames(context.Type)
+                    .ToList()
+                    .ForEach(n => model.Enum.Add(new OpenApiString(n)));
+            }
+        }
+    }
+}

src/Managing.Api.Workers/Managing.Api.Workers.csproj

@@ -0,0 +1,45 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+	<TargetFramework>net7.0</TargetFramework>
+	<ImplicitUsings>enable</ImplicitUsings>
+    <Platforms>AnyCPU;x64</Platforms>
+    <UserSecretsId>3900ce93-de15-49e5-9a61-7dc2209939ca</UserSecretsId>
+    <DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
+    <DockerfileContext>..\..</DockerfileContext>
+    <DockerComposeProjectPath>..\..\docker-compose.dcproj</DockerComposeProjectPath>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Essential.LoggerProvider.Elasticsearch" Version="1.3.2" />
+    <PackageReference Include="Microsoft.VisualStudio.Azure.Containers.Tools.Targets" Version="1.19.5" />
+    <PackageReference Include="NSwag.AspNetCore" Version="13.20.0" />
+    <PackageReference Include="Serilog.AspNetCore" Version="7.0.0" />
+    <PackageReference Include="Serilog.Enrichers.Environment" Version="2.2.0" />
+    <PackageReference Include="Serilog.Exceptions" Version="8.4.0" />
+    <PackageReference Include="Serilog.Sinks.Console" Version="4.1.0" />
+    <PackageReference Include="Serilog.Sinks.Debug" Version="2.0.0" />
+    <PackageReference Include="Serilog.Sinks.Elasticsearch" Version="9.0.3" />
+    <PackageReference Include="Swashbuckle.AspNetCore.Newtonsoft" Version="6.5.0" />
+    <PackageReference Include="Swashbuckle.AspNetCore.Swagger" Version="6.5.0" />
+    <PackageReference Include="Swashbuckle.AspNetCore.SwaggerGen" Version="6.5.0" />
+    <PackageReference Include="Swashbuckle.AspNetCore.SwaggerUI" Version="6.5.0" />
+    <PackageReference Include="xunit" Version="2.5.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Managing.Bootstrap\Managing.Bootstrap.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Content Update="appsettings.Lowpro.json">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Content>
+    <Content Update="appsettings.json">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Content>
+    <Content Update="appsettings.Oda-docker.json">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+</Project>

src/Managing.Api.Workers/Program.cs

@@ -0,0 +1,150 @@
+using System.Text.Json.Serialization;
+using Managing.Api.Workers.Filters;
+using Managing.Api.Workers.Workers;
+using Managing.Api.WorkersExceptions;
+using Managing.Application.Hubs;
+using Managing.Bootstrap;
+using Managing.Common;
+using Managing.Infrastructure.Databases.InfluxDb.Models;
+using Managing.Infrastructure.Databases.MongoDb;
+using NSwag;
+using NSwag.Generation.Processors.Security;
+using Serilog;
+using Serilog.Sinks.Elasticsearch;
+
+// Builder
+var builder = WebApplication.CreateBuilder(args);
+builder.Configuration
+    .AddEnvironmentVariables();
+
+builder.Host.UseSerilog((hostBuilder, loggerConfiguration) =>
+{
+    var envName = builder.Environment.EnvironmentName.ToLower().Replace(".", "-");
+    var indexFormat = $"managing-worker-{envName}-" + "{0:yyyy.MM.dd}";
+    var yourTemplateName = "dotnetlogs";
+    var es = new ElasticsearchSinkOptions(new Uri(hostBuilder.Configuration["ElasticConfiguration:Uri"]))
+    {
+        IndexFormat = indexFormat.ToLower(),
+        AutoRegisterTemplate = true,
+        OverwriteTemplate = true,
+        TemplateName = yourTemplateName,
+        AutoRegisterTemplateVersion = AutoRegisterTemplateVersion.ESv7,
+        TypeName = null,
+        BatchAction = ElasticOpType.Create,
+        MinimumLogEventLevel = Serilog.Events.LogEventLevel.Information,
+        FailureCallback = e => Console.WriteLine($"Unable to submit event {e.RenderMessage()} to ElasticSearch. " +
+        $"Full message : " + e.Exception.Message),
+        DetectElasticsearchVersion = true,
+        RegisterTemplateFailure = RegisterTemplateRecovery.IndexAnyway,
+    };
+
+    loggerConfiguration
+        .WriteTo.Console()
+        .WriteTo.Elasticsearch(es);
+});
+builder.Services.AddOptions();
+builder.Services.Configure<ManagingDatabaseSettings>(builder.Configuration.GetSection(Constants.Databases.MongoDb));
+builder.Services.Configure<InfluxDbSettings>(builder.Configuration.GetSection(Constants.Databases.InfluxDb));
+builder.Services.AddControllers().AddJsonOptions(options =>
+    options.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter()));
+builder.Services.AddCors(o => o.AddPolicy("CorsPolicy", builder =>
+{
+    builder
+           .SetIsOriginAllowed((host) => true)
+           .AllowAnyOrigin()
+           .WithOrigins("http://localhost:3000/")
+           .AllowAnyMethod()
+           .AllowAnyHeader()
+           .AllowCredentials();
+}));
+builder.Services.AddSignalR().AddJsonProtocol();
+
+builder.Services.RegisterWorkersDependencies(builder.Configuration);
+builder.Services.AddEndpointsApiExplorer();
+builder.Services.AddOpenApiDocument(document =>
+{
+    document.AddSecurity("JWT", Enumerable.Empty<string>(), new OpenApiSecurityScheme
+    {
+        Type = OpenApiSecuritySchemeType.ApiKey,
+        Name = "Authorization",
+        In = OpenApiSecurityApiKeyLocation.Header,
+        Description = "Type into the textbox: Bearer {your JWT token}."
+    });
+
+    document.OperationProcessors.Add(
+        new AspNetCoreOperationSecurityScopeProcessor("JWT"));
+});
+builder.Services.AddSwaggerGen(options =>
+{
+    options.SchemaFilter<EnumSchemaFilter>();
+    options.AddSecurityDefinition("Bearer,", new Microsoft.OpenApi.Models.OpenApiSecurityScheme
+    {
+        Description = "Please insert your JWT Token into field : Bearer {your_token}",
+        Name = "Authorization",
+        Type = Microsoft.OpenApi.Models.SecuritySchemeType.Http,
+        In = Microsoft.OpenApi.Models.ParameterLocation.Header,
+        Scheme = "Bearer",
+        BearerFormat = "JWT"
+    });
+    options.AddSecurityRequirement(new Microsoft.OpenApi.Models.OpenApiSecurityRequirement{
+        {
+            new Microsoft.OpenApi.Models.OpenApiSecurityScheme{
+                Reference = new Microsoft.OpenApi.Models.OpenApiReference{
+                    Type = Microsoft.OpenApi.Models.ReferenceType.SecurityScheme,
+                    Id = "Bearer"
+                }
+            },
+            new string[]{}
+        }
+    });
+});
+
+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<PositionManagerWorker>();
+builder.Services.AddHostedService<SpotlightWorker>();
+builder.Services.AddHostedService<TraderWatcher>();
+builder.Services.AddHostedService<LeaderboardWorker>();
+builder.Services.AddHostedService<NoobiesboardWorker>();
+
+// App
+var app = builder.Build();
+app.UseSerilogRequestLogging();
+
+if (app.Environment.IsDevelopment())
+{
+    app.UseDeveloperExceptionPage();
+}
+
+app.UseOpenApi();
+app.UseSwaggerUi3();
+app.UseSwaggerUI(c =>
+{
+    c.SwaggerEndpoint("/swagger/v1/swagger.json", "Managing Workers v1");
+    c.RoutePrefix = string.Empty;
+});
+
+app.UseCors("CorsPolicy");
+
+app.UseMiddleware(typeof(GlobalErrorHandlingMiddleware));
+
+app.UseHttpsRedirection();
+
+app.UseRouting();
+
+app.UseAuthorization();
+
+app.UseEndpoints(endpoints =>
+{
+    endpoints.MapControllers();
+    endpoints.MapHub<PositionHub>("/positionhub");
+});
+
+app.Run();

src/Managing.Api.Workers/Workers/BaseWorker.cs

@@ -0,0 +1,75 @@
+
+using Managing.Application.Workers.Abstractions;
+using static Managing.Common.Enums;
+
+namespace Managing.Api.Workers;
+
+public abstract class BaseWorker<T> : BackgroundService where T : class
+{
+    private readonly WorkerType _workerType;
+    protected readonly ILogger<T> _logger;
+    protected readonly TimeSpan _delay;
+    private readonly IWorkerService _workerService;
+    private int _executionCount;
+
+    protected BaseWorker(
+        WorkerType workerType,
+        ILogger<T> logger,
+        TimeSpan timeSpan,
+        IWorkerService workerService)
+    {
+        _workerType = workerType;
+        _logger = logger;
+        _delay = timeSpan == TimeSpan.Zero ? TimeSpan.FromMinutes(1) : timeSpan;
+        _workerService = workerService;
+        _executionCount = 0;
+    }
+
+    protected override async Task ExecuteAsync(CancellationToken cancellationToken)
+    {
+        try
+        {
+            _logger.LogInformation($"[{_workerType}] Starting");
+            var worker = await _workerService.GetWorker(_workerType);
+
+            if (worker == null)
+            {
+                await _workerService.InsertWorker(_workerType, _delay);
+            }
+            else
+            {
+                _logger.LogInformation($"[{_workerType}] Last run : {worker.LastRunTime} - Execution Count : {worker.ExecutionCount}");
+                _executionCount = worker.ExecutionCount;
+            }
+
+            cancellationToken.Register(() => _logger.LogInformation($"[{_workerType}] Stopping"));
+
+            while (!cancellationToken.IsCancellationRequested)
+            {
+                worker = await _workerService.GetWorker(_workerType);
+
+                //if (true)
+                if (worker.IsActive)
+                {
+                    await Run(cancellationToken);
+                    _executionCount++;
+                    await _workerService.UpdateWorker(_workerType, _executionCount);
+                    _logger.LogInformation($"[{_workerType}] Run ok. Next run at : {DateTime.UtcNow.Add(_delay)}");
+                }
+                else
+                {
+                    _logger.LogInformation($"[{_workerType}] Worker not active. Next run at : {DateTime.UtcNow.Add(_delay)}");
+                }
+
+                await Task.Delay(_delay);
+            }
+            _logger.LogInformation($"[{_workerType}] Stopped");
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError($"Error : {ex.Message}");
+        }
+    }
+
+    protected abstract Task Run(CancellationToken cancellationToken);
+}

src/Managing.Api.Workers/Workers/FeeWorker.cs

@@ -0,0 +1,29 @@
+using Managing.Application.Abstractions.Services;
+using Managing.Application.Workers.Abstractions;
+using static Managing.Common.Enums;
+
+namespace Managing.Api.Workers.Workers;
+
+public class FeeWorker : BaseWorker<FeeWorker>
+{
+    private readonly ITradingService _tradingService;
+    private static readonly WorkerType _workerType = WorkerType.Fee;
+
+    public FeeWorker(
+        ILogger<FeeWorker> logger,
+        ITradingService tradingService,
+        IWorkerService workerService) : base(
+        _workerType,
+        logger,
+        TimeSpan.FromHours(12),
+        workerService
+        )
+    {
+        _tradingService = tradingService;
+    }
+
+    protected override async Task Run(CancellationToken cancellationToken)
+    {
+        _tradingService.UpdateFee(TradingExchanges.Evm);
+    }
+}

src/Managing.Api.Workers/Workers/LeaderboardWorker.cs

@@ -0,0 +1,28 @@
+using Managing.Application.Workers.Abstractions;
+using static Managing.Common.Enums;
+
+namespace Managing.Api.Workers.Workers;
+
+public class LeaderboardWorker : BaseWorker<FeeWorker>
+{
+    private readonly IStatisticService _statisticService;
+    private static readonly WorkerType _workerType = WorkerType.LeaderboardWorker;
+
+    public LeaderboardWorker(
+        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.UpdateLeaderboard();
+    }
+}

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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,37 @@
+using Managing.Application.Abstractions.Services;
+using Managing.Application.Hubs;
+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

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

src/Managing.Api.Workers/Workers/PricesBaseWorker.cs

@@ -0,0 +1,40 @@
+using Managing.Application.Workers.Abstractions;
+using static Managing.Common.Enums;
+
+namespace Managing.Api.Workers.Workers;
+
+public abstract class PricesBaseWorker<T> : BaseWorker<T> where T : class
+{
+    private readonly IPricesService _pricesService;
+    private readonly IStatisticService _statisticService;
+    private readonly Timeframe _timeframe;
+
+    public PricesBaseWorker(
+        ILogger<T> logger,
+        IPricesService pricesService,
+        IWorkerService workerService,
+        IStatisticService statisticService,
+        TimeSpan delay,
+        WorkerType workerType,
+        Timeframe timeframe) : base(
+        workerType,
+        logger,
+        delay,
+        workerService
+        )
+    {
+        _pricesService = pricesService;
+        _statisticService = statisticService;
+        _timeframe = timeframe;
+    }
+
+    protected override async Task Run(CancellationToken cancellationToken)
+    {
+        var tickers = _statisticService.GetTickers();
+
+        foreach (var ticker in tickers)
+        {
+            await _pricesService.UpdatePrice(TradingExchanges.Evm, ticker, _timeframe);
+        }
+    }
+}

src/Managing.Api.Workers/Workers/PricesFifteenMinutesWorker.cs

@@ -0,0 +1,23 @@
+using Managing.Application.Workers.Abstractions;
+using static Managing.Common.Enums;
+
+namespace Managing.Api.Workers.Workers;
+
+public class PricesFifteenMinutesWorker : PricesBaseWorker<PricesFifteenMinutesWorker>
+{
+    public PricesFifteenMinutesWorker(
+        ILogger<PricesFifteenMinutesWorker> logger,
+        IPricesService pricesService,
+        IStatisticService statisticService,
+        IWorkerService workerService) : base(
+        logger,
+        pricesService,
+        workerService,
+        statisticService,
+        TimeSpan.FromMinutes(1),
+        WorkerType.PriceFifteenMinutes,
+        Timeframe.FifteenMinutes
+        )
+    {
+    }
+}

src/Managing.Api.Workers/Workers/PricesFiveMinutesWorker.cs

@@ -0,0 +1,23 @@
+using Managing.Application.Workers.Abstractions;
+using static Managing.Common.Enums;
+
+namespace Managing.Api.Workers.Workers;
+
+public class PricesFiveMinutesWorker : PricesBaseWorker<PricesFiveMinutesWorker>
+{
+    public PricesFiveMinutesWorker(
+    ILogger<PricesFiveMinutesWorker> logger,
+    IPricesService pricesService,
+    IStatisticService statisticService,
+    IWorkerService workerService) : base(
+    logger,
+    pricesService,
+    workerService,
+    statisticService,
+    TimeSpan.FromMinutes(2.5),
+    WorkerType.PriceFiveMinutes,
+    Timeframe.FiveMinutes
+    )
+    {
+    }
+}

src/Managing.Api.Workers/Workers/PricesFourHoursWorker.cs

@@ -0,0 +1,23 @@
+using Managing.Application.Workers.Abstractions;
+using static Managing.Common.Enums;
+
+namespace Managing.Api.Workers.Workers;
+
+public class PricesFourHoursWorker : PricesBaseWorker<PricesFourHoursWorker>
+{
+    public PricesFourHoursWorker(
+        ILogger<PricesFourHoursWorker> logger,
+        IPricesService pricesService,
+        IStatisticService statisticService,
+        IWorkerService workerService) : base(
+        logger,
+        pricesService,
+        workerService,
+        statisticService,
+        TimeSpan.FromHours(2),
+        WorkerType.PriceFourHour,
+        Timeframe.FourHour
+        )
+    {
+    }
+}

src/Managing.Api.Workers/Workers/PricesOneDayWorker.cs

@@ -0,0 +1,23 @@
+using Managing.Application.Workers.Abstractions;
+using static Managing.Common.Enums;
+
+namespace Managing.Api.Workers.Workers;
+
+public class PricesOneDayWorker : PricesBaseWorker<PricesOneDayWorker>
+{
+    public PricesOneDayWorker(
+        ILogger<PricesOneDayWorker> logger,
+        IPricesService pricesService,
+        IStatisticService statisticService,
+        IWorkerService workerService) : base(
+        logger,
+        pricesService,
+        workerService,
+        statisticService,
+        TimeSpan.FromHours(12),
+        WorkerType.PriceOneDay,
+        Timeframe.OneDay
+        )
+    {
+    }
+}

src/Managing.Api.Workers/Workers/PricesOneHourWorker.cs

@@ -0,0 +1,22 @@
+using Managing.Application.Workers.Abstractions;
+using static Managing.Common.Enums;
+
+namespace Managing.Api.Workers.Workers;
+
+public class PricesOneHourWorker : PricesBaseWorker<PricesOneHourWorker>
+{
+    public PricesOneHourWorker(
+        ILogger<PricesOneHourWorker> logger,
+        IPricesService pricesService,
+        IStatisticService statisticService,
+        IWorkerService workerService) : base(
+        logger,
+        pricesService,
+        workerService,
+        statisticService,
+        TimeSpan.FromMinutes(30),
+        WorkerType.PriceOneHour,
+        Timeframe.OneHour)
+    {
+    }
+}

src/Managing.Api.Workers/Workers/SpotlightWorker.cs

@@ -0,0 +1,34 @@
+using Managing.Application.Workers.Abstractions;
+using Managing.Common;
+
+namespace Managing.Api.Workers.Workers;
+
+public class SpotlightWorker : BaseWorker<SpotlightWorker>
+{
+    private readonly IStatisticService _statisticService;
+
+    public SpotlightWorker(
+        ILogger<SpotlightWorker> logger,
+        IWorkerService workerService,
+        IStatisticService statisticService) : base(
+            Enums.WorkerType.Spotlight,
+            logger,
+            TimeSpan.FromMinutes(5),
+            workerService)
+    {
+        _statisticService = statisticService;
+    }
+
+    protected async override Task Run(CancellationToken cancellationToken)
+    {
+        try
+        {
+            await _statisticService.UpdateSpotlight();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError("Enable to update spotlight", ex);
+            throw;
+        }
+    }
+}

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

@@ -0,0 +1,28 @@
+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/Workers/TraderWatcher.cs

@@ -0,0 +1,29 @@
+using Managing.Application.Abstractions.Services;
+using Managing.Application.Workers.Abstractions;
+using static Managing.Common.Enums;
+
+namespace Managing.Api.Workers.Workers;
+
+public class TraderWatcher : BaseWorker<FeeWorker>
+{
+    private readonly ITradingService _tradingService;
+    private static readonly WorkerType _workerType = WorkerType.TraderWatcher;
+
+    public TraderWatcher(
+        ILogger<FeeWorker> logger,
+        ITradingService tradingService,
+        IWorkerService workerService) : base(
+        _workerType,
+        logger,
+        TimeSpan.FromSeconds(120),
+        workerService
+        )
+    {
+        _tradingService = tradingService;
+    }
+
+    protected override async Task Run(CancellationToken cancellationToken)
+    {
+        await _tradingService.WatchTrader();
+    }
+}

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

@@ -0,0 +1,23 @@
+{
+  "ManagingDatabase": {
+    "ConnectionString": "mongodb://localhost:27017",
+    "DatabaseName": "ManagingDb"
+  },
+  "InfluxDb": {
+    "Url": "http://localhost:8086/",
+    "Token": ""
+  },
+  "Serilog": {
+    "MinimumLevel": {
+      "Default": "Information",
+      "Override": {
+        "Microsoft": "Information",
+        "System": "Warning"
+      }
+    }
+  },
+  "ElasticConfiguration": {
+    "Uri": "http://localhost:9200"
+  },
+  "AllowedHosts": "*"
+}

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

@@ -0,0 +1,24 @@
+{
+  "ManagingDatabase": {
+    "ConnectionString": "mongodb://localhost:27017",
+    "DatabaseName": "ManagingDb",
+  },
+  "InfluxDb": {
+    "Url": "http://localhost:8086/",
+    "Organization": "",
+    "Token": ""
+  },
+  "Serilog": {
+    "MinimumLevel": {
+      "Default": "Information",
+      "Override": {
+        "Microsoft": "Information",
+        "System": "Warning"
+      }
+    }
+  },
+  "ElasticConfiguration": {
+    "Uri": "http://localhost:9200"
+  },
+  "AllowedHosts": "*"
+}

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

@@ -0,0 +1,39 @@
+{
+  "ManagingDatabase": {
+    "ConnectionString": "mongodb://managingdb:27017",
+    "DatabaseName": "ManagingDb"
+  },
+  "InfluxDb": {
+    "Url": "http://influxdb:8086",
+    "Token": "OPjdwQBmKr0zQecJ10IDQ4bt32oOJzmFp687QWWzbGeyH0R-gCA6HnXI_B0oQ_InPmSUXKFje8DSAUPbY0hn-w==",
+    "Organization": "managing-org"
+  },
+  "Serilog": {
+    "MinimumLevel": {
+      "Default": "Information",
+      "Override": {
+        "Microsoft": "Information",
+        "System": "Warning"
+      }
+    }
+  },
+  "ElasticConfiguration": {
+    "Uri": "http://elasticsearch:9200"
+  },
+  "Discord": {
+    "ApplicationId": "966075382002516031",
+    "PublicKey": "63028f6bb740cd5d26ae0340b582dee2075624011b28757436255fc002ca8a7c",
+    "TokenId": "OTY2MDc1MzgyMDAyNTE2MDMx.Yl8dzw.xpeIAaMwGrwTNY4r9JYv0ebzb-U",
+
+    "SignalChannelId": 1134858150667898910,
+    "TradesChannelId": 1134858092530634864,
+    "TroublesChannelId": 1134858233031446671,
+    "CopyTradingChannelId": 1134857874896588881,
+    "RequestsChannelId": 1018589494968078356,
+    "LeaderboardChannelId": 1133169725237633095,
+    "NoobiesboardChannelId": 1133504653485690940,
+    "ButtonExpirationMinutes": 10
+
+  },
+  "AllowedHosts": "*"
+}

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

@@ -0,0 +1,24 @@
+{
+  "ManagingDatabase": {
+    "ConnectionString": "mongodb://managingdb:27017",
+    "DatabaseName": "ManagingDb"
+  },
+  "InfluxDb": {
+    "Url": "http://influxdb:8086/",
+    "Organization": "",
+    "Token": ""
+  },
+  "Serilog": {
+    "MinimumLevel": {
+      "Default": "Information",
+      "Override": {
+        "Microsoft": "Information",
+        "System": "Warning"
+      }
+    }
+  },
+  "ElasticConfiguration": {
+    "Uri": "http://elasticsearch:9200"
+  },
+  "AllowedHosts": "*"
+}

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

@@ -0,0 +1,24 @@
+{
+  "ManagingDatabase": {
+    "ConnectionString": "mongodb://localhost:27017",
+    "DatabaseName": "ManagingDb",
+  },
+  "InfluxDb": {
+    "Url": "http://localhost:8086/",
+    "Organization": "",
+    "Token": ""
+  },
+  "Serilog": {
+    "MinimumLevel": {
+      "Default": "Information",
+      "Override": {
+        "Microsoft": "Information",
+        "System": "Warning"
+      }
+    }
+  },
+  "ElasticConfiguration": {
+    "Uri": "http://localhost:9200"
+  },
+  "AllowedHosts": "*"
+}