Loading backup

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

@@ -1,4 +1,5 @@
-using Managing.Application.Workers.Abstractions;
+using Managing.Application.Workers;
+using Managing.Application.Workers.Abstractions;
 using static Managing.Common.Enums;
 
 namespace Managing.Api.Workers.Workers;

src/Managing.Api/Workers/BotManagerWorker.cs

@@ -6,27 +6,18 @@ using static Managing.Common.Enums;
 
 namespace Managing.Api.Workers;
 
-public class BotManagerWorker : BaseWorker<BotManagerWorker>
+public class BotManagerWorker(
-{
+    ILogger<BotManagerWorker> logger,
-    private readonly IMediator _mediator;
+    IMediator mediadior,
-    private static readonly WorkerType _workerType = WorkerType.Fee;
+    IWorkerService workerService)
-
+    : BaseWorker<BotManagerWorker>(WorkerType.BotManager,
-    public BotManagerWorker(
-        ILogger<BotManagerWorker> logger,
-        IMediator tradingService,
-        IWorkerService workerService) : base(
-        _workerType,
         logger,
         TimeSpan.FromMinutes(1),
-        workerService
+        workerService)
-        )
+{
-    {
-        _mediator = tradingService;
-    }
-
     protected override async Task Run(CancellationToken cancellationToken)
     {
         var loadBackupBotCommand = new LoadBackupBotCommand();
-        await _mediator.Send(loadBackupBotCommand, cancellationToken);
+        await mediadior.Send(loadBackupBotCommand, cancellationToken);
     }
 }

src/Managing.Api/appsettings.Oda.json

@@ -5,8 +5,8 @@
   },
   "InfluxDb": {
     "Url": "http://localhost:8086/",
-    "Organization": "",
+    "Organization": "managing-org",
-    "Token": ""
+    "Token": "Fw2FPL2OwTzDHzSbR2Sd5xs0EKQYy00Q-hYKYAhr9cC1_q5YySONpxuf_Ck0PTjyUiF13xXmi__bu_pXH-H9zA=="
   },
   "Serilog": {
     "MinimumLevel": {

src/Managing.Application.Tests/BotsTests.cs

@@ -28,13 +28,15 @@ namespace Managing.Application.Tests
             var discordService = new Mock<IMessengerService>().Object;
             var tradingBotLogger = TradingBaseTests.CreateTradingBotLogger();
             var backtestLogger = TradingBaseTests.CreateBacktesterLogger();
+            var botService = new Mock<IBotService>().Object;
             _botFactory = new BotFactory(
                 _exchangeService,
                 tradingBotLogger,
                 _moneyManagementService.Object,
                 discordService,
                 _accountService.Object,
-                _tradingService.Object);
+                _tradingService.Object,
+                botService);
             _backtester = new Backtester(_exchangeService, _botFactory, backtestRepository, backtestLogger);
             _elapsedTimes = new List<double>();
         }

src/Managing.Application/Bots/FlippingBot.cs

@@ -38,7 +38,6 @@ namespace Managing.Application.Bots
                   flipPosition: true)
         {
             BotType = BotType.FlippingBot;
-            Start();
         }
 
         public sealed override void Start()

src/Managing.Application/Bots/ScalpingBot.cs

@@ -37,7 +37,6 @@ namespace Managing.Application.Bots
                   isForWatchingOnly)
         {
             BotType = BotType.ScalpingBot;
-            Start();
         }
 
         public sealed override void Start()

src/Managing.Application/Bots/SimpleBot.cs

@@ -18,7 +18,6 @@ namespace Managing.Application.Bots
             _botService = botService;
             _workflow = workflow;
             Interval = 100;
-            Start();
         }
 
         public override void Start()

src/Managing.Application/Bots/TradingBot.cs

@@ -670,7 +670,6 @@ public class TradingBot : Bot, ITradingBot
         {
             Name = Name,
             BotType = BotType,
-            Strategies = Strategies,
             Signals = Signals,
             Positions = Positions,
             Timeframe = Timeframe,
@@ -687,7 +686,6 @@ public class TradingBot : Bot, ITradingBot
     public override void LoadBackup(BotBackup backup)
     {
         var data = JsonConvert.DeserializeObject<TradingBotBackup>(backup.Data);
-        Strategies = data.Strategies;
         Signals = data.Signals;
         Positions = data.Positions;
         WalletBalances = data.WalletBalances;
@@ -698,7 +696,6 @@ public class TradingBotBackup
 {
     public string Name { get; set; }
     public BotType BotType { get; set; }
-    public HashSet<IStrategy> Strategies { get; set; }
     public HashSet<Signal> Signals { get; set; }
     public List<Position> Positions { get; set; }
     public Timeframe Timeframe { get; set; }

src/Managing.Application/ManageBot/BotService.cs

@@ -18,8 +18,22 @@ namespace Managing.Application.ManageBot
            await _botRepository.InsertBotAsync(botBackup);
         }
         
+        public BotBackup GetBotBackup(string name)
+        {
+            return _botRepository.GetBots().FirstOrDefault(b => b.Name == name);
+        }
+
         public void SaveBotBackup(string name, Enums.BotType botType, string data)
         {
+            var backup = GetBotBackup(name);
+            
+            if (backup != null)
+            {
+                backup.Data = data;
+                _botRepository.UpdateBackupBot(backup);
+                return;
+            }
+            
             var botBackup = new BotBackup
             {
                 Name = name,

src/Managing.Application/ManageBot/LoadBackupBotCommandHandler.cs

@@ -7,39 +7,43 @@ using Newtonsoft.Json;
 using Managing.Application.Bots;
 using Microsoft.Extensions.Logging;
 
-namespace Managing.Application.ManageBot
+namespace Managing.Application.ManageBot;
+
+public class LoadBackupBotCommandHandler : IRequestHandler<LoadBackupBotCommand, string>
 {
-    public class LoadBackupBotCommandHandler : IRequestHandler<LoadBackupBotCommand, string>
+    private readonly IBotFactory _botFactory;
+    private readonly ITaskCache _taskCache;
+    private readonly IMoneyManagementService _moneyManagementService;
+    private readonly IBotRepository _botRepository;
+    private readonly ILogger<LoadBackupBotCommandHandler> _logger;
+
+    public LoadBackupBotCommandHandler(
+        IBotFactory botFactory,
+        ITaskCache taskCache,
+        IMoneyManagementService moneyManagementService,
+        IBotRepository botRepository,
+        ILogger<LoadBackupBotCommandHandler> logger)
     {
-        private readonly IBotFactory _botFactory;
+        _botFactory = botFactory;
-        private readonly ITaskCache _taskCache;
+        _taskCache = taskCache;
-        private readonly IMoneyManagementService _moneyManagementService;
+        _moneyManagementService = moneyManagementService;
-        private readonly IBotRepository _botRepository;
+        _botRepository = botRepository;
-        private readonly ILogger<LoadBackupBotCommandHandler> _logger;
+        _logger = logger;
+    }
 
-        public LoadBackupBotCommandHandler(
+    public Task<string> Handle(LoadBackupBotCommand request, CancellationToken cancellationToken)
-            IBotFactory botFactory,
+    {
-            ITaskCache taskCache,
+        BotStatus botStatus = BotStatus.Down;
-            IMoneyManagementService moneyManagementService,
+        var backupBots = _botRepository.GetBots();
-            IBotRepository botRepository)
+        var result = new Dictionary<string, BotStatus>();
+
+        _logger.LogInformation($"Loading {backupBots.Count()}  backup bots");
+
+        foreach (var backupBot in backupBots)
         {
-            _botFactory = botFactory;
+            // Check if bot is existing in cache
-            _taskCache = taskCache;
+            try
-            _moneyManagementService = moneyManagementService;
-            _botRepository = botRepository;
-        }
-
-        public Task<string> Handle(LoadBackupBotCommand request, CancellationToken cancellationToken)
-        {
-            BotStatus botStatus = BotStatus.Down;
-            var backupBots = _botRepository.GetBots();
-            var result = new Dictionary<string, BotStatus>();
-
-            _logger.LogInformation($"Loading {backupBots.Count()} backup bots");
-
-            foreach (var backupBot in backupBots)
             {
-                // Check if bot is existing in cache
                 switch (backupBot.BotType)
                 {
                     case BotType.SimpleBot:
@@ -64,6 +68,7 @@ namespace Managing.Application.ManageBot
                         {
                             _logger.LogInformation($"Starting backup bot {backupBot.Name}");
                             StartBot(backupBot);
+                            scalpingBot = _taskCache.Get<ITradingBot>(backupBot.Name);
                             scalpingBot.LoadBackup(backupBot);
                             result.Add(scalpingBot.GetName(), BotStatus.Backup);
                         }
@@ -77,51 +82,58 @@ namespace Managing.Application.ManageBot
                         break;
                 }
             }
-
+            catch (Exception ex)
-
-            return Task.FromResult(botStatus.ToString());
-        }
-
-        private void StartBot(BotBackup backupBot)
-        {
-            switch (backupBot.BotType)
             {
-                case BotType.SimpleBot:
+                _logger.LogError($"Error loading bot {backupBot.Name}", ex.Message);
-                    Func<Task<IBot>> simpleBot = () => Task.FromResult(_botFactory.CreateSimpleBot(backupBot.Name, null));
+                result.Add(backupBot.Name, BotStatus.Down);
-                    var bot1 = _taskCache.AddOrGetExisting(backupBot.Name, simpleBot).Result;
+            }
-                    bot1.LoadBackup(backupBot);
-                    break;
-                case BotType.ScalpingBot:
-                    var data = JsonConvert.DeserializeObject<TradingBotBackup>(backupBot.Data);
-                    Func<Task<ITradingBot>> scalpingBot = () => Task.FromResult(_botFactory.CreateScalpingBot(
-                        data.AccountName,
-                        data.MoneyManagement,
-                        data.Name,
-                        data.Ticker,
-                        data.Scenario,
-                        data.Timeframe,
-                        data.IsForWatchingOnly));
-                    var bot2 = _taskCache.AddOrGetExisting(backupBot.Name, scalpingBot).Result;
-                    bot2.LoadBackup(backupBot);
-                    break;
-                case BotType.FlippingBot:
-                    var dataFlippingBot = JsonConvert.DeserializeObject<TradingBotBackup>(backupBot.Data);
-                    Func<Task<ITradingBot>> flippingBot = () => Task.FromResult(_botFactory.CreateFlippingBot(
-                        dataFlippingBot.AccountName,
-                        dataFlippingBot.MoneyManagement,
-                        dataFlippingBot.Name,
-                        dataFlippingBot.Ticker,
-                        dataFlippingBot.Scenario,
-                        dataFlippingBot.Timeframe,
-                        dataFlippingBot.IsForWatchingOnly));
-                    var bot3 = _taskCache.AddOrGetExisting(backupBot.Name, flippingBot).Result;
-                    bot3.LoadBackup(backupBot);
-                    break;
-            };
         }
+
+        return Task.FromResult(botStatus.ToString());
     }
 
-    public class LoadBackupBotCommand : IRequest<string>
+    private void StartBot(BotBackup backupBot)
     {
+        switch (backupBot.BotType)
+        {
+            case BotType.SimpleBot:
+                Func<Task<IBot>> simpleBot = () => Task.FromResult(_botFactory.CreateSimpleBot(backupBot.Name, null));
+                var bot1 = _taskCache.AddOrGetExisting(backupBot.Name, simpleBot).Result;
+                bot1.LoadBackup(backupBot);
+                bot1.Start();
+                break;
+            case BotType.ScalpingBot:
+                var data = JsonConvert.DeserializeObject<TradingBotBackup>(backupBot.Data);
+                Func<Task<ITradingBot>> scalpingBot = () => Task.FromResult(_botFactory.CreateScalpingBot(
+                    data.AccountName,
+                    data.MoneyManagement,
+                    data.Name,
+                    data.Ticker,
+                    data.Scenario,
+                    data.Timeframe,
+                    data.IsForWatchingOnly));
+                var bot2 = _taskCache.AddOrGetExisting(backupBot.Name, scalpingBot).Result;
+                bot2.LoadBackup(backupBot);
+                bot2.Start();
+                break;
+            case BotType.FlippingBot:
+                var dataFlippingBot = JsonConvert.DeserializeObject<TradingBotBackup>(backupBot.Data);
+                Func<Task<ITradingBot>> flippingBot = () => Task.FromResult(_botFactory.CreateFlippingBot(
+                    dataFlippingBot.AccountName,
+                    dataFlippingBot.MoneyManagement,
+                    dataFlippingBot.Name,
+                    dataFlippingBot.Ticker,
+                    dataFlippingBot.Scenario,
+                    dataFlippingBot.Timeframe,
+                    dataFlippingBot.IsForWatchingOnly));
+                var bot3 = _taskCache.AddOrGetExisting(backupBot.Name, flippingBot).Result;
+                bot3.LoadBackup(backupBot);
+                bot3.Start();
+                break;
+        };
     }
 }
+
+public class LoadBackupBotCommand : IRequest<string>
+{
+}

src/Managing.Application/ManageBot/StartBotCommandHandler.cs

@@ -26,13 +26,19 @@ namespace Managing.Application.ManageBot
             switch (request.BotType)
             {
                 case BotType.SimpleBot:
-                    Func<Task<IBot>> simpleBot = () => Task.FromResult(_botFactory.CreateSimpleBot(request.Name, null));
+                    var bot = _botFactory.CreateSimpleBot(request.Name, null);
+                    bot.Start();
+                    Func<Task<IBot>> simpleBot = () => Task.FromResult(bot);
                     return Task.FromResult(_taskCache.AddOrGetExisting(request.Name, simpleBot).Result.GetStatus());
                 case BotType.ScalpingBot:
-                    Func<Task<ITradingBot>> scalpingBot = () => Task.FromResult(_botFactory.CreateScalpingBot(request.AccountName, moneyManagement, request.Name, request.Ticker, request.Scenario, request.Timeframe, request.IsForWatchingOnly));
+                    var sBot = _botFactory.CreateScalpingBot(request.AccountName, moneyManagement, request.Name, request.Ticker, request.Scenario, request.Timeframe, request.IsForWatchingOnly);
+                    sBot.Start();
+                    Func<Task<ITradingBot>> scalpingBot = () => Task.FromResult(sBot);
                     return Task.FromResult(_taskCache.AddOrGetExisting(request.Name, scalpingBot).Result.GetStatus());
                 case BotType.FlippingBot:
-                    Func<Task<ITradingBot>> flippingBot = () => Task.FromResult(_botFactory.CreateFlippingBot(request.AccountName, moneyManagement, request.Name, request.Ticker, request.Scenario, request.Timeframe, request.IsForWatchingOnly));
+                    var fBot = _botFactory.CreateFlippingBot(request.AccountName, moneyManagement, request.Name, request.Ticker, request.Scenario, request.Timeframe, request.IsForWatchingOnly);
+                    fBot.Start();
+                    Func<Task<ITradingBot>> flippingBot = () => Task.FromResult(fBot);
                     return Task.FromResult(_taskCache.AddOrGetExisting(request.Name, flippingBot).Result.GetStatus());
             };
 

src/Managing.Bootstrap/ApiBootstrap.cs

@@ -112,7 +112,7 @@ public static class ApiBootstrap
         // Cache
         services.AddDistributedMemoryCache();
         services.AddTransient<ICacheService, CacheService>();
-        services.AddTransient<ITaskCache, TaskCache>();
+        services.AddSingleton<ITaskCache, TaskCache>();
 
         // Processors
         services.AddTransient<IExchangeProcessor, EvmProcessor>();

src/Managing.Bootstrap/WorkersBootstrap.cs

@@ -33,6 +33,7 @@ using Managing.Application.Trading.Commands;
 using Managing.Domain.Trades;
 using Managing.Infrastructure.Evm.Services;
 using Managing.Application.Bots.Base;
+using Managing.Application.ManageBot;
 
 namespace Managing.Bootstrap;
 
@@ -58,6 +59,7 @@ public static class WorkersBootstrap
         services.AddSingleton<ITradingService, TradingService>(); 
         services.AddSingleton<ISettingsService, SettingsService>();
         services.AddSingleton<IBacktester, Backtester>();
+        services.AddSingleton<IBotService, BotService>();
 
         services.AddTransient<ICommandHandler<OpenPositionRequest, Position>, OpenPositionCommandHandler>();
         services.AddTransient<ICommandHandler<ClosePositionCommand, Position>, ClosePositionCommandHandler>();
@@ -93,6 +95,7 @@ public static class WorkersBootstrap
         services.AddTransient<ISettingsRepository, SettingsRepository>();
         services.AddTransient<ITradingRepository, TradingRepository>();
         services.AddTransient<IBacktestRepository, BacktestRepository>();
+        services.AddTransient<IBotRepository, BotRepository>();
 
         // Cache
         services.AddDistributedMemoryCache();

src/Managing.Common/Enums.cs

@@ -317,7 +317,8 @@ public static class Enums
         PositionFetcher,
         TraderWatcher,
         LeaderboardWorker,
-        Noobiesboard
+        Noobiesboard,
+        BotManager
     }
 
     public enum WorkflowUsage

src/Managing.Infrastructure.Storage/TaskCache.cs

@@ -64,7 +64,8 @@ namespace Managing.Infrastructure.Storage
         public T Get<T>(string key)
         {
             var existingValue = (AsyncLazy<T>)_cache.Get(key);
-            return existingValue.Value.Result;
+            if (existingValue != null) return existingValue.Value.Result;
+            return default(T);
         }
 
         public virtual List<T> GetCache<T>()

src/Managing.WebApp/.env

@@ -1,4 +1,4 @@
-VITE_API_URL_LOCAL=https://localhost:443
+VITE_API_URL_LOCAL=http://localhost:5000
 VITE_API_URL_SERVER=https://dev-managing-api.apps.managing.live
 VITE_WORKER_URL_LOCAL=https://localhost:5002
 VITE_WORKER_URL_SERVER=https://dev-managing-worker.apps.managing.live