Add backup management

2024-06-20 22:38:26 +07:00
parent 897ff94a66
commit c25752c670
18 changed files with 413 additions and 5 deletions
--- a/src/Managing.Application/ManageBot/LoadBackupBotCommandHandler.cs
+++ b/src/Managing.Application/ManageBot/LoadBackupBotCommandHandler.cs
@@ -0,0 +1,127 @@
+using Managing.Domain.Bots;
+using MediatR;
+using static Managing.Common.Enums;
+using Managing.Application.Abstractions;
+using Managing.Core;
+using Managing.Domain.MoneyManagements;
+using Newtonsoft.Json;
+using Managing.Application.Bots;
+
+namespace Managing.Application.ManageBot
+{
+    public class LoadBackupBotCommandHandler : IRequestHandler<LoadBackupBotCommand, string>
+    {
+        private readonly IBotFactory _botFactory;
+        private readonly ITaskCache _taskCache;
+        private readonly IMoneyManagementService _moneyManagementService;
+        private readonly IBotRepository _botRepository;
+        private readonly IMediator _mediator;
+
+        public LoadBackupBotCommandHandler(
+            IBotFactory botFactory,
+            ITaskCache taskCache,
+            IMoneyManagementService moneyManagementService,
+            IBotRepository botRepository,
+            IMediator mediator)
+        {
+            _botFactory = botFactory;
+            _taskCache = taskCache;
+            _moneyManagementService = moneyManagementService;
+            _botRepository = botRepository;
+            _mediator = mediator;
+        }
+
+        public Task<string> Handle(LoadBackupBotCommand request, CancellationToken cancellationToken)
+        {
+            BotStatus botStatus = BotStatus.Down;
+            var backupBots = _botRepository.GetBots();
+            var result = new Dictionary<string, BotStatus>();
+
+            foreach (var backupBot in backupBots)
+            {
+                // Check if bot is existing in cache
+                switch (backupBot.BotType)
+                {
+                    case BotType.SimpleBot:
+                        var simpleBot = _taskCache.Get<IBot>(backupBot.Name);
+                        if (simpleBot == null)
+                        {
+                            StartBot(request, backupBot);
+                            simpleBot.LoadBackup(backupBot);
+                            result.Add(simpleBot.GetName(), BotStatus.Backup);
+                        }
+                        else
+                        {
+                            result.Add(simpleBot.GetName(), MiscExtensions.ParseEnum<BotStatus>(simpleBot.GetStatus()));
+                        }
+
+                        break;
+                    case BotType.ScalpingBot:
+                    case BotType.FlippingBot:
+                        var scalpingBot = _taskCache.Get<ITradingBot>(backupBot.Name);
+                        if (scalpingBot == null)
+                        {
+                            StartBot(request, backupBot);
+                            scalpingBot.LoadBackup(backupBot);
+                            result.Add(scalpingBot.GetName(), BotStatus.Backup);
+                        }
+                        else
+                        {
+                            result.Add(scalpingBot.GetName(), MiscExtensions.ParseEnum<BotStatus>(scalpingBot.GetStatus()));
+                        }
+                        break;
+                    default:
+                        result.Add(backupBot.Name, BotStatus.Down);
+                        break;
+                }
+            }
+
+
+            return Task.FromResult(botStatus.ToString());
+        }
+
+        private void StartBot(LoadBackupBotCommand request, BotBackup backupBot)
+        {
+            switch (backupBot.BotType)
+            {
+                case BotType.SimpleBot:
+                    Func<Task<IBot>> simpleBot = () => Task.FromResult(_botFactory.CreateSimpleBot(request.Name, null));
+                    var bot1 = _taskCache.AddOrGetExisting(request.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(request.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(request.Name, flippingBot).Result;
+                    bot3.LoadBackup(backupBot);
+                    break;
+            };
+        }
+    }
+
+    public class LoadBackupBotCommand : IRequest<string>
+    {
+        public string Name { get; internal set; }
+        public string AccountName { get; internal set; }
+    }
+}