Commit before refact factory into service

src/Managing.Application/ManageBot/BotService.cs

@@ -1,23 +1,31 @@
 using Managing.Application.Abstractions;
 using Managing.Application.Bots;
 using Managing.Common;
+using Managing.Core;
+using Managing.Domain.Bots;
+using Newtonsoft.Json;
 
 namespace Managing.Application.ManageBot
 {
     public class BotService : IBotService
     {
         private readonly IBotRepository _botRepository;
+        private readonly ITaskCache _taskCache;
+        private readonly IBotFactory _botFactory;
+        
 
-        public BotService(IBotRepository botRepository)
+        public BotService(IBotRepository botRepository, ITaskCache taskCache, IBotFactory botFactory)
         {
             _botRepository = botRepository;
+            _taskCache = taskCache;
+            _botFactory = botFactory;
         }
 
         public async void SaveBotBackup(BotBackup botBackup)
         {
-           await _botRepository.InsertBotAsync(botBackup);
+            await _botRepository.InsertBotAsync(botBackup);
         }
-        
+
         public BotBackup GetBotBackup(string name)
         {
             return _botRepository.GetBots().FirstOrDefault(b => b.Name == name);
@@ -26,14 +34,14 @@ namespace Managing.Application.ManageBot
         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,
@@ -43,5 +51,70 @@ namespace Managing.Application.ManageBot
 
             _botRepository.InsertBotAsync(botBackup);
         }
+
+        public void AddSimpleBotToCache(IBot bot)
+        {
+            _taskCache.AddOrGetExisting(bot.GetName(), () => Task.FromResult(bot));
+        }
+
+        public void AddTradingBotToCache(ITradingBot bot)
+        {
+            _taskCache.AddOrGetExisting(bot.GetName(), () => Task.FromResult(bot));
+        }
+
+        public List<ITradingBot> GetActiveBots()
+        {
+            var cachedTask = _taskCache.GetCache<AsyncLazy<ITradingBot>>();
+            return cachedTask.Select(item => item.Value.Result).ToList();
+        }
+
+        public IEnumerable<BotBackup> GetSavedBots()
+        {
+            return _botRepository.GetBots();
+        }
+
+        public void StartBot(BotBackup backupBot)
+        {
+            switch (backupBot.BotType)
+            {
+                case Enums.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 Enums.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 Enums.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;
+            }
+
+            ;
+        }
     }
 }