Oda/managing-apps
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add backup management

Browse Source
This commit is contained in:
cryptooda
2024-06-20 22:38:26 +07:00
parent 897ff94a66
commit c25752c670
18 changed files with 413 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/Managing.Application/Abstractions/IBotService.cs Normal file
View File

@@ -0,0 +1,4 @@
public interface IBotService
{
void SaveBotBackup(BotBackup botBackup);
}

13
src/Managing.Application/Bots/SimpleBot.cs
View File

@@ -1,13 +1,14 @@
using Managing.Domain.Bots;
using Managing.Domain.Workflows;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
namespace Managing.Application.Bots
{
public class SimpleBot : Bot
{
public readonly ILogger<TradingBot> Logger;
private readonly Workflow _workflow;
private Workflow _workflow;
public SimpleBot(string name, ILogger<TradingBot> logger, Workflow workflow) : base(name)
{
@@ -35,5 +36,15 @@ namespace Managing.Application.Bots
Logger.LogInformation("__________________________________________________");
});
}
public override string GetBackup()
{
return JsonConvert.SerializeObject(_workflow);
}
public override void LoadBackup(BotBackup backup)
{
_workflow = JsonConvert.DeserializeObject<Workflow>(backup.Data);
}
}
}

46
src/Managing.Application/Bots/TradingBot.cs
View File

@@ -11,6 +11,7 @@ using Managing.Domain.Shared.Helpers;
using Managing.Domain.Strategies;
using Managing.Domain.Trades;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using static Managing.Common.Enums;
namespace Managing.Application.Bots;
@@ -64,6 +65,7 @@ public class TradingBot : Bot, ITradingBot
MessengerService = messengerService;
TradingService = tradingService;
IsForWatchingOnly = isForWatchingOnly;
FlipPosition = flipPosition;
AccountName = accountName;
@@ -648,4 +650,48 @@ public class TradingBot : Bot, ITradingBot
await MessengerService.SendTradeMessage(message, isBadBehavior);
}
}
public override string GetBackup()
{
return JsonConvert.SerializeObject(new TradingBotBackup
{
Name = Name,
BotType = BotType,
Strategies = Strategies,
Signals = Signals,
Positions = Positions,
Timeframe = Timeframe,
Ticker = Ticker,
Scenario = Scenario,
AccountName = AccountName,
IsForWatchingOnly = IsForWatchingOnly,
WalletBalances = WalletBalances,
MoneyManagement = MoneyManagement
});
}
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;
}
}
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; }
public Ticker Ticker { get; set; }
public string Scenario { get; set; }
public string AccountName { get; set; }
public bool IsForWatchingOnly { get; set; }
public Dictionary<DateTime, decimal> WalletBalances { get; set; }
public MoneyManagement MoneyManagement { get; internal set; }
}

68
src/Managing.Application/ManageBot/BackupBotCommandHandler.cs Normal file
View File

@@ -0,0 +1,68 @@
using Managing.Domain.Bots;
using MediatR;
using static Managing.Common.Enums;
using Managing.Application.Abstractions;
using Managing.Application.ManageBot.Commands;
using Managing.Domain.MoneyManagements;
namespace Managing.Application.ManageBot
{
public class BackupBotCommandHandler : IRequestHandler<BackupBotCommand, bool>
{
private readonly IBotFactory _botFactory;
private readonly ITaskCache _taskCache;
private readonly IMoneyManagementService _moneyManagementService;
private readonly IBotService _botService;
public BackupBotCommandHandler(IBotFactory botFactory, ITaskCache taskCache, IBotService botService)
{
_botFactory = botFactory;
_taskCache = taskCache;
_botService = botService;
}
public Task<bool> Handle(BackupBotCommand request, CancellationToken cancellationToken)
{
var botBackup = new BotBackup
{
Name = request.Name,
BotType = request.BotType,
Data = ""
};
switch (request.BotType)
{
case BotType.SimpleBot:
var simpleBot = _taskCache.Get<IBot>(request.Name);
botBackup.Data = simpleBot.GetBackup();
break;
case BotType.ScalpingBot:
var scalpingBot = _taskCache.Get<ITradingBot>(request.Name);
botBackup.Data = scalpingBot.GetBackup();
break;
case BotType.FlippingBot:
var flippingBot = _taskCache.Get<ITradingBot>(request.Name);
botBackup.Data = flippingBot.GetBackup();
break;
default:
return Task.FromResult(false);
}
_botService.SaveBotBackup(botBackup);
return Task.FromResult(true);
}
}
public class BackupBotCommand : IRequest<bool>
{
public string Name { get; }
public BotType BotType { get; }
public BackupBotCommand(BotType botType, string name)
{
BotType = botType;
Name = name;
}
}
}

37
src/Managing.Application/ManageBot/BotService.cs Normal file
View File

@@ -0,0 +1,37 @@
using Managing.Application.Abstractions;
using Newtonsoft.Json;
using System.IO;
namespace Managing.Application.ManageBot
{
public class BotService : IBotService
{
private readonly IBotFactory _botFactory;
private readonly IBotRepository _botRepository;
public BotService(IBotFactory botFactory, IBotRepository botRepository)
{
_botFactory = botFactory;
_botRepository = botRepository;
}
// public void CreateBot()
// {
// // Use the factory to create a new bot
// return _botFactory.CreateBot();
// }
// public void LoadBotBackup(BotBackup botBackup)
// {
// // Deserialize the JSON into a Bot object
// var bot = JsonConvert.DeserializeObject<Bot>(json);
// return bot;
// }
public async void SaveBotBackup(BotBackup botBackup)
{
await _botRepository.InsertBotAsync(botBackup);
}
}
}

127
src/Managing.Application/ManageBot/LoadBackupBotCommandHandler.cs Normal file
View File

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