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

Commit before refact factory into service

Browse Source
This commit is contained in:
cryptooda
2024-07-12 19:58:19 +07:00
parent 13e70cbf63
commit 0544749a69
11 changed files with 243 additions and 169 deletions
Download Patch File Download Diff File Expand all files Collapse all files

83
src/Managing.Application/ManageBot/BotService.cs
View File

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

23
src/Managing.Application/ManageBot/GetActiveBotsCommandHandler.cs
View File

@@ -1,30 +1,15 @@
using Managing.Application.Abstractions;
using Managing.Application.ManageBot.Commands;
using Managing.Core;
using MediatR;
namespace Managing.Application.ManageBot
{
public class GetActiveBotsCommandHandler : IRequestHandler<GetActiveBotsCommand, List<ITradingBot>>
public class GetActiveBotsCommandHandler(IBotService botService)
: IRequestHandler<GetActiveBotsCommand, List<ITradingBot>>
{
private readonly ITaskCache taskCache;
public GetActiveBotsCommandHandler(ITaskCache taskCache)
{
this.taskCache = taskCache;
}
public Task<List<ITradingBot>> Handle(GetActiveBotsCommand request, CancellationToken cancellationToken)
{
var cachedTask = taskCache.GetCache<AsyncLazy<ITradingBot>>();
var result = new List<ITradingBot>();
foreach (var item in cachedTask)
{
result.Add(item.Value.Result);
}
return Task.FromResult(result);
return Task.FromResult(botService.GetActiveBots());
}
}
}
}

76
src/Managing.Application/ManageBot/LoadBackupBotCommandHandler.cs
View File

@@ -11,30 +11,21 @@ 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 IBotService _botService;
private readonly ILogger<LoadBackupBotCommandHandler> _logger;
public LoadBackupBotCommandHandler(
IBotFactory botFactory,
ITaskCache taskCache,
IMoneyManagementService moneyManagementService,
IBotRepository botRepository,
ILogger<LoadBackupBotCommandHandler> logger)
ILogger<LoadBackupBotCommandHandler> logger, IBotService botService)
{
_botFactory = botFactory;
_taskCache = taskCache;
_moneyManagementService = moneyManagementService;
_botRepository = botRepository;
_logger = logger;
_botService = botService;
}
public Task<string> Handle(LoadBackupBotCommand request, CancellationToken cancellationToken)
{
BotStatus botStatus = BotStatus.Down;
var backupBots = _botRepository.GetBots();
var backupBots = _botService.GetSavedBots();
var activeBots = _botService.GetActiveBots();
var result = new Dictionary<string, BotStatus>();
_logger.LogInformation($"Loading {backupBots.Count()} backup bots");
@@ -47,12 +38,11 @@ public class LoadBackupBotCommandHandler : IRequestHandler<LoadBackupBotCommand,
switch (backupBot.BotType)
{
case BotType.SimpleBot:
var simpleBot = _taskCache.Get<IBot>(backupBot.Name);
var simpleBot = activeBots.FirstOrDefault(b => b.GetName() == backupBot.Name);
if (simpleBot == null)
{
_logger.LogInformation($"Starting backup bot {backupBot.Name}");
StartBot(backupBot);
simpleBot.LoadBackup(backupBot);
_botService.StartBot(backupBot);
result.Add(simpleBot.GetName(), BotStatus.Backup);
}
else
@@ -63,19 +53,18 @@ public class LoadBackupBotCommandHandler : IRequestHandler<LoadBackupBotCommand,
break;
case BotType.ScalpingBot:
case BotType.FlippingBot:
var scalpingBot = _taskCache.Get<ITradingBot>(backupBot.Name);
var scalpingBot = activeBots.FirstOrDefault(b => b.GetName() == backupBot.Name);
if (scalpingBot == null)
{
_logger.LogInformation($"Starting backup bot {backupBot.Name}");
StartBot(backupBot);
scalpingBot = _taskCache.Get<ITradingBot>(backupBot.Name);
scalpingBot.LoadBackup(backupBot);
result.Add(scalpingBot.GetName(), BotStatus.Backup);
_botService.StartBot(backupBot);
}
else
{
result.Add(scalpingBot.GetName(), MiscExtensions.ParseEnum<BotStatus>(scalpingBot.GetStatus()));
result.Add(scalpingBot.GetName(),
MiscExtensions.ParseEnum<BotStatus>(scalpingBot.GetStatus()));
}
break;
default:
result.Add(backupBot.Name, BotStatus.Down);
@@ -91,47 +80,6 @@ public class LoadBackupBotCommandHandler : IRequestHandler<LoadBackupBotCommand,
return Task.FromResult(botStatus.ToString());
}
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>

31
src/Managing.Application/ManageBot/StartBotCommandHandler.cs
View File

@@ -9,13 +9,14 @@ namespace Managing.Application.ManageBot
public class StartBotCommandHandler : IRequestHandler<StartBotCommand, string>
{
private readonly IBotFactory _botFactory;
private readonly ITaskCache _taskCache;
private readonly IBotService _botService;
private readonly IMoneyManagementService _moneyManagementService;
public StartBotCommandHandler(IBotFactory botFactory, ITaskCache taskCache, IMoneyManagementService moneyManagementService)
public StartBotCommandHandler(IBotFactory botFactory, IBotService botService,
IMoneyManagementService moneyManagementService)
{
_botFactory = botFactory;
_taskCache = taskCache;
_botService = botService;
_moneyManagementService = moneyManagementService;
}
@@ -28,21 +29,25 @@ namespace Managing.Application.ManageBot
case BotType.SimpleBot:
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());
_botService.AddSimpleBotToCache(bot);
return Task.FromResult(bot.GetStatus());
case BotType.ScalpingBot:
var sBot = _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());
_botService.AddTradingBotToCache(sBot);
return Task.FromResult(sBot.GetStatus());
case BotType.FlippingBot:
var fBot = _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());
};
_botService.AddTradingBotToCache(fBot);
return Task.FromResult(fBot.GetStatus());
}
;
return Task.FromResult(botStatus.ToString());
}
}
}
}