Loading backup

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;
-        private readonly ITaskCache _taskCache;
-        private readonly IMoneyManagementService _moneyManagementService;
-        private readonly IBotRepository _botRepository;
-        private readonly ILogger<LoadBackupBotCommandHandler> _logger;
+        _botFactory = botFactory;
+        _taskCache = taskCache;
+        _moneyManagementService = moneyManagementService;
+        _botRepository = botRepository;
+        _logger = logger;
+    }
 
-        public LoadBackupBotCommandHandler(
-            IBotFactory botFactory,
-            ITaskCache taskCache,
-            IMoneyManagementService moneyManagementService,
-            IBotRepository 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)
         {
-            _botFactory = botFactory;
-            _taskCache = taskCache;
-            _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
+            try
             {
-                // 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;
                 }
             }
-
-
-            return Task.FromResult(botStatus.ToString());
-        }
-
-        private void StartBot(BotBackup backupBot)
-        {
-            switch (backupBot.BotType)
+            catch (Exception ex)
             {
-                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);
-                    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;
-            };
+                _logger.LogError($"Error loading bot {backupBot.Name}", ex.Message);
+                result.Add(backupBot.Name, BotStatus.Down);
+            }
         }
+
+        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>
+{
+}