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

Filter everything with users (#16)

Browse Source 
* Filter everything with users

* Fix backtests and user management

* Add cursor rules

* Fix backtest and bots

* Update configs names

* Sign until unauth

* Setup delegate

* Setup delegate and sign

* refact

* Enhance Privy signature generation with improved cryptographic methods

* Add Fastify backend

* Add Fastify backend routes for privy

* fix privy signing

* fix privy client

* Fix tests

* add gmx core

* fix merging sdk

* Fix tests

* add gmx core

* add gmx core

* add privy to boilerplate

* clean

* fix

* add fastify

* Remove Managing.Fastify submodule

* Add Managing.Fastify as regular directory instead of submodule

* Update .gitignore to exclude Managing.Fastify dist and node_modules directories

* Add token approval functionality to Privy plugin

- Introduced a new endpoint `/approve-token` for approving ERC20 tokens.
- Added `approveToken` method to the Privy plugin for handling token approvals.
- Updated `signPrivyMessage` to differentiate between message signing and token approval requests.
- Enhanced the plugin with additional schemas for input validation.
- Included new utility functions for token data retrieval and message construction.
- Updated tests to verify the new functionality and ensure proper request decoration.

* Add PrivyApproveTokenResponse model for token approval response

- Created a new class `PrivyApproveTokenResponse` to encapsulate the response structure for token approval requests.
- The class includes properties for `Success` status and a transaction `Hash`.

* Refactor trading commands and enhance API routes

- Updated `OpenPositionCommandHandler` to use asynchronous methods for opening trades and canceling orders.
- Introduced new Fastify routes for opening positions and canceling orders with appropriate request validation.
- Modified `EvmManager` to handle both Privy and non-Privy wallet operations, utilizing the Fastify API for Privy wallets.
- Adjusted test configurations to reflect changes in account types and added helper methods for testing Web3 proxy services.

* Enhance GMX trading functionality and update dependencies

- Updated `dev:start` script in `package.json` to include the `-d` flag for Fastify.
- Upgraded `fastify-cli` dependency to version 7.3.0.
- Added `sourceMap` option to `tsconfig.json`.
- Refactored GMX plugin to improve position opening logic, including enhanced error handling and validation.
- Introduced a new method `getMarketInfoFromTicker` for better market data retrieval.
- Updated account type in `PrivateKeys.cs` to use `Privy`.
- Adjusted `EvmManager` to utilize the `direction` enum directly for trade direction handling.

* Refactor GMX plugin for improved trading logic and market data retrieval

- Enhanced the `openGmxPositionImpl` function to utilize the `TradeDirection` enum for trade direction handling.
- Introduced `getTokenDataFromTicker` and `getMarketByIndexToken` functions for better market and token data retrieval.
- Updated collateral calculation and logging for clarity.
- Adjusted `EvmManager` to ensure proper handling of price values in trade requests.

* Refactor GMX plugin and enhance testing for position opening

- Updated `test:single` script in `package.json` to include TypeScript compilation before running tests.
- Removed `this` context from `getClientForAddress` function and replaced logging with `console.error`.
- Improved collateral calculation in `openGmxPositionImpl` for better precision.
- Adjusted type casting for `direction` in the API route to utilize `TradeDirection` enum.
- Added a new test for opening a long position in GMX, ensuring functionality and correctness.

* Update sdk

* Update

* update fastify

* Refactor start script in package.json to simplify command execution

- Removed the build step from the start script, allowing for a more direct launch of the Fastify server.

* Update package.json for Web3Proxy

- Changed the name from "Web3Proxy" to "web3-proxy".
- Updated version from "0.0.0" to "1.0.0".
- Modified the description to "The official Managing Web3 Proxy".

* Update Dockerfile for Web3Proxy

- Upgraded Node.js base image from 18-alpine to 22.14.0-alpine.
- Added NODE_ENV environment variable set to production.

* Refactor Dockerfile and package.json for Web3Proxy

- Removed the build step from the Dockerfile to streamline the image creation process.
- Updated the start script in package.json to include the build step, ensuring the application is built before starting the server.

* Add fastify-tsconfig as a development dependency in Dockerfile-web3proxy

* Remove fastify-tsconfig extension from tsconfig.json for Web3Proxy

* Add PrivyInitAddressResponse model for handling initialization responses

- Introduced a new class `PrivyInitAddressResponse` to encapsulate the response structure for Privy initialization, including properties for success status, USDC hash, order vault hash, and error message.

* Update

* Update

* Remove fastify-tsconfig installation from Dockerfile-web3proxy

* Add build step to Dockerfile-web3proxy

- Included `npm run build` in the Dockerfile to ensure the application is built during the image creation process.

* Update

* approvals

* Open position from front embedded wallet

* Open position from front embedded wallet

* Open position from front embedded wallet

* Fix call contracts

* Fix limit price

* Close position

* Fix close position

* Fix close position

* add pinky

* Refactor position handling logic

* Update Dockerfile-pinky to copy package.json and source code from the correct directory

* Implement password protection modal and enhance UI with new styles; remove unused audio elements and update package dependencies.

* add cancel orders

* Update callContract function to explicitly cast account address as Address type

* Update callContract function to cast transaction parameters as any type for compatibility

* Cast transaction parameters as any type in approveTokenImpl for compatibility

* Cast wallet address and transaction parameters as Address type in approveTokenImpl for type safety

* Add .env configuration file for production setup including database and server settings

* Refactor home route to update welcome message and remove unused SDK configuration code

* add referral code

* fix referral

* Add sltp

* Fix typo

* Fix typo

* setup sltp on backtend

* get orders

* get positions with slp

* fixes

* fixes close position

* fixes

* Remove MongoDB project references from Dockerfiles for managing and worker APIs

* Comment out BotManagerWorker service registration and remove MongoDB project reference from Dockerfile

* fixes
This commit is contained in:
Oda
2025-04-20 22:18:27 +07:00
committed by GitHub
parent 0ae96a3278
commit 528c62a0a1
400 changed files with 94446 additions and 1635 deletions
Download Patch File Download Diff File Expand all files Collapse all files

85
src/Managing.Api/Controllers/BacktestController.cs
View File

@@ -19,7 +19,7 @@ namespace Managing.Api.Controllers;
[Authorize]
[Route("[controller]")]
[Produces("application/json")]
public class BacktestController : ControllerBase
public class BacktestController : BaseController
{
private readonly IHubContext<BotHub> _hubContext;
private readonly IBacktester _backtester;
@@ -40,7 +40,8 @@ public class BacktestController : ControllerBase
IBacktester backtester,
IScenarioService scenarioService,
IAccountService accountService,
IMoneyManagementService moneyManagementService)
IMoneyManagementService moneyManagementService,
IUserService userService) : base(userService)
{
_hubContext = hubContext;
_backtester = backtester;
@@ -50,24 +51,46 @@ public class BacktestController : ControllerBase
}
/// <summary>
/// Retrieves all backtests.
/// Retrieves all backtests for the authenticated user.
/// </summary>
/// <returns>A list of backtests.</returns>
[HttpGet]
public ActionResult<IEnumerable<Backtest>> Backtests()
public async Task<ActionResult<IEnumerable<Backtest>>> Backtests()
{
return Ok(_backtester.GetBacktests());
var user = await GetUser();
return Ok(await _backtester.GetBacktestsByUser(user));
}
/// <summary>
/// Deletes a specific backtest by ID.
/// Retrieves a specific backtest by ID for the authenticated user.
/// This endpoint will also populate the candles for visualization.
/// </summary>
/// <param name="id">The ID of the backtest to retrieve.</param>
/// <returns>The requested backtest with populated candle data.</returns>
[HttpGet("{id}")]
public async Task<ActionResult<Backtest>> Backtest(string id)
{
var user = await GetUser();
var backtest = _backtester.GetBacktestByIdForUser(user, id);
if (backtest == null)
{
return NotFound($"Backtest with ID {id} not found or doesn't belong to the current user.");
}
return Ok(backtest);
}
/// <summary>
/// Deletes a specific backtest by ID for the authenticated user.
/// </summary>
/// <param name="id">The ID of the backtest to delete.</param>
/// <returns>An ActionResult indicating the outcome of the operation.</returns>
[HttpDelete]
public ActionResult DeleteBacktest(string id)
public async Task<ActionResult> DeleteBacktest(string id)
{
return Ok(_backtester.DeleteBacktest(id));
var user = await GetUser();
return Ok(_backtester.DeleteBacktestByUser(user, id));
}
/// <summary>
@@ -90,7 +113,8 @@ public class BacktestController : ControllerBase
/// <param name="scenarioName">The name of the scenario to use for the backtest.</param>
/// <param name="timeframe">The timeframe for the backtest.</param>
/// <param name="watchOnly">Whether to only watch the backtest without executing trades.</param>
/// <param name="days">The number of days to backtest.</param>
/// <param name="startDate">The start date for the backtest.</param>
/// <param name="endDate">The end date for the backtest.</param>
/// <param name="balance">The starting balance for the backtest.</param>
/// <param name="moneyManagementName">The name of the money management strategy to use.</param>
/// <param name="moneyManagement">The money management strategy details, if not using a named strategy.</param>
@@ -104,9 +128,10 @@ public class BacktestController : ControllerBase
string scenarioName,
Timeframe timeframe,
bool watchOnly,
int days,
decimal balance,
string moneyManagementName,
DateTime startDate,
DateTime endDate,
MoneyManagement? moneyManagement = null,
bool save = false)
{
@@ -127,18 +152,14 @@ public class BacktestController : ControllerBase
nameof(moneyManagementName));
}
if (days > 0)
{
days = days * -1;
}
Backtest backtestResult = null;
var scenario = _scenarioService.GetScenario(scenarioName);
var account = await _accountService.GetAccount(accountName, true, false);
var user = await GetUser();
if (!string.IsNullOrEmpty(moneyManagementName) && moneyManagement is null)
{
moneyManagement = await _moneyManagementService.GetMoneyMangement(moneyManagementName);
moneyManagement = await _moneyManagementService.GetMoneyMangement(user, moneyManagementName);
}
else
{
@@ -148,21 +169,37 @@ public class BacktestController : ControllerBase
if (scenario == null)
return BadRequest("No scenario found");
// var localCandles = FileHelpers
// .ReadJson<List<Candle>>($"{ticker.ToString()}-{timeframe.ToString()}-candles.json")
// .TakeLast(500).ToList();
switch (botType)
{
case BotType.SimpleBot:
break;
case BotType.ScalpingBot:
backtestResult = _backtester.RunScalpingBotBacktest(account, moneyManagement, ticker, scenario,
timeframe, Convert.ToDouble(days), balance, watchOnly, save);
backtestResult = await _backtester.RunScalpingBotBacktest(
account,
moneyManagement,
ticker,
scenario,
timeframe,
balance,
startDate,
endDate,
user,
watchOnly,
save);
break;
case BotType.FlippingBot:
backtestResult = _backtester.RunFlippingBotBacktest(account, moneyManagement, ticker, scenario,
timeframe, Convert.ToDouble(days), balance, watchOnly, save);
backtestResult = await _backtester.RunFlippingBotBacktest(
account,
moneyManagement,
ticker,
scenario,
timeframe,
balance,
startDate,
endDate,
user,
watchOnly,
save);
break;
}

303
src/Managing.Api/Controllers/BotController.cs
View File

@@ -4,11 +4,22 @@ using Managing.Application.Abstractions;
using Managing.Application.Abstractions.Services;
using Managing.Application.Hubs;
using Managing.Application.ManageBot.Commands;
using Managing.Common;
using Managing.Domain.Bots;
using Managing.Domain.Users;
using MediatR;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.SignalR;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.Extensions.DependencyInjection;
using static Managing.Common.Enums;
using ApplicationTradingBot = Managing.Application.Bots.TradingBot;
using ApiTradingBot = Managing.Api.Models.Responses.TradingBot;
namespace Managing.Api.Controllers;
@@ -20,13 +31,15 @@ namespace Managing.Api.Controllers;
[Authorize]
[Route("[controller]")]
[Produces("application/json")]
public class BotController : ControllerBase
public class BotController : BaseController
{
private readonly IMediator _mediator;
private readonly ILogger<BotController> _logger;
private readonly IHubContext<BotHub> _hubContext;
private readonly IBacktester _backtester;
private readonly IBotService _botService;
private readonly IAccountService _accountService;
private readonly IMoneyManagementService _moneyManagementService;
/// <summary>
/// Initializes a new instance of the <see cref="BotController"/> class.
@@ -36,13 +49,57 @@ public class BotController : ControllerBase
/// <param name="hubContext">SignalR hub context for real-time communication.</param>
/// <param name="backtester">Backtester for running backtests on bots.</param>
public BotController(ILogger<BotController> logger, IMediator mediator, IHubContext<BotHub> hubContext,
IBacktester backtester, IBotService botService)
IBacktester backtester, IBotService botService, IUserService userService,
IAccountService accountService, IMoneyManagementService moneyManagementService) : base(userService)
{
_logger = logger;
_mediator = mediator;
_hubContext = hubContext;
_backtester = backtester;
_botService = botService;
_accountService = accountService;
_moneyManagementService = moneyManagementService;
}
/// <summary>
/// Checks if the current authenticated user owns the account associated with the specified bot or account name
/// </summary>
/// <param name="botName">The name of the bot to check</param>
/// <param name="accountName">Optional account name to check when creating a new bot</param>
/// <returns>True if the user owns the account, False otherwise</returns>
private async Task<bool> UserOwnsBotAccount(string botName, string accountName = null)
{
try
{
var user = await GetUser();
if (user == null)
return false;
// For new bot creation, check if the user owns the account provided in the request
if (!string.IsNullOrEmpty(accountName))
{
var accountService = HttpContext.RequestServices.GetRequiredService<IAccountService>();
var account = await accountService.GetAccount(accountName, true, false);
// Compare the user names
return account != null && account.User != null && account.User.Name == user.Name;
}
// For existing bots, check if the user owns the bot's account
var activeBots = _botService.GetActiveBots();
var bot = activeBots.FirstOrDefault(b => b.Name == botName);
if (bot == null)
return true; // Bot doesn't exist yet, so no ownership conflict
var botAccountService = HttpContext.RequestServices.GetRequiredService<IAccountService>();
var botAccount = await botAccountService.GetAccount(bot.AccountName, true, false);
// Compare the user names
return botAccount != null && botAccount.User != null && botAccount.User.Name == user.Name;
}
catch (Exception ex)
{
_logger.LogError(ex, "Error checking if user owns bot account");
return false;
}
}
/// <summary>
@@ -54,12 +111,39 @@ public class BotController : ControllerBase
[Route("Start")]
public async Task<ActionResult<string>> Start(StartBotRequest request)
{
var result = await _mediator.Send(new StartBotCommand(request.BotType, request.BotName, request.Ticker,
request.Scenario, request.Timeframe, request.AccountName, request.MoneyManagementName,
request.IsForWatchOnly));
try
{
// Check if user owns the account
if (!await UserOwnsBotAccount(request.BotName, request.AccountName))
{
return Forbid("You don't have permission to start this bot");
}
await NotifyBotSubscriberAsync();
return Ok(result);
// Trigger error if money management is not provided
if (string.IsNullOrEmpty(request.MoneyManagementName))
{
return BadRequest("Money management name is required");
}
var user = await GetUser();
var moneyManagement = await _moneyManagementService.GetMoneyMangement(user, request.MoneyManagementName);
if (moneyManagement == null)
{
return BadRequest("Money management not found");
}
var result = await _mediator.Send(new StartBotCommand(request.BotType, request.BotName, request.Ticker,
request.Scenario, request.Timeframe, request.AccountName, request.MoneyManagementName, user,
request.IsForWatchOnly));
await NotifyBotSubscriberAsync();
return Ok(result);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error starting bot");
return StatusCode(500, $"Error starting bot: {ex.Message}");
}
}
/// <summary>
@@ -72,12 +156,26 @@ public class BotController : ControllerBase
[Route("Stop")]
public async Task<ActionResult<string>> Stop(BotType botType, string botName)
{
var result = await _mediator.Send(new StopBotCommand(botType, botName));
_logger.LogInformation($"{botType} type called {botName} is now {result}");
try
{
// Check if user owns the account
if (!await UserOwnsBotAccount(botName))
{
return Forbid("You don't have permission to stop this bot");
}
await NotifyBotSubscriberAsync();
var result = await _mediator.Send(new StopBotCommand(botType, botName));
_logger.LogInformation($"{botType} type called {botName} is now {result}");
return Ok(result);
await NotifyBotSubscriberAsync();
return Ok(result);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error stopping bot");
return StatusCode(500, $"Error stopping bot: {ex.Message}");
}
}
/// <summary>
@@ -89,31 +187,68 @@ public class BotController : ControllerBase
[Route("Delete")]
public async Task<ActionResult<bool>> Delete(string botName)
{
var result = await _botService.DeleteBot(botName);
await NotifyBotSubscriberAsync();
return Ok(result);
try
{
// Check if user owns the account
if (!await UserOwnsBotAccount(botName))
{
return Forbid("You don't have permission to delete this bot");
}
var result = await _botService.DeleteBot(botName);
await NotifyBotSubscriberAsync();
return Ok(result);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error deleting bot");
return StatusCode(500, $"Error deleting bot: {ex.Message}");
}
}
/// <summary>
/// Stops all active bots.
/// </summary>
/// <returns>A string summarizing the results of the stop operations for all bots.</returns>
[HttpGet]
[Route("StopAll")]
[HttpPost("stop-all")]
public async Task<string> StopAll()
{
var bots = await GetBotList();
var result = "";
foreach (var bot in bots)
// This method should be restricted to only stop bots owned by the current user
var user = await GetUser();
if (user == null)
return "No authenticated user found";
try
{
result += $"{bot.Name} : ";
result += await _mediator.Send(new StopBotCommand(bot.BotType, bot.Name));
result += $" |";
var bots = await GetBotList();
// Filter to only include bots owned by the current user
var userBots = new List<ApiTradingBot>();
foreach (var bot in bots)
{
var account = await _accountService.GetAccount(bot.AccountName, true, false);
// Compare the user names
if (account != null && account.User != null && account.User.Name == user.Name)
{
userBots.Add(bot);
}
}
foreach (var bot in userBots)
{
await _mediator.Send(new StopBotCommand(bot.BotType, bot.Name));
await _hubContext.Clients.All.SendAsync("SendNotification",
$"Bot {bot.Name} paused by {user.Name}.", "Info");
}
await NotifyBotSubscriberAsync();
return "All your bots have been stopped successfully!";
}
catch (Exception ex)
{
_logger.LogError(ex, "Error stopping all bots");
return $"Error stopping bots: {ex.Message}";
}
await NotifyBotSubscriberAsync();
return result;
}
/// <summary>
@@ -126,34 +261,80 @@ public class BotController : ControllerBase
[Route("Restart")]
public async Task<ActionResult<string>> Restart(BotType botType, string botName)
{
var result = await _mediator.Send(new RestartBotCommand(botType, botName));
_logger.LogInformation($"{botType} type called {botName} is now {result}");
try
{
// Check if user owns the account
if (!await UserOwnsBotAccount(botName))
{
return Forbid("You don't have permission to restart this bot");
}
await NotifyBotSubscriberAsync();
var result = await _mediator.Send(new RestartBotCommand(botType, botName));
_logger.LogInformation($"{botType} type called {botName} is now {result}");
return Ok(result);
await NotifyBotSubscriberAsync();
return Ok(result);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error restarting bot");
return StatusCode(500, $"Error restarting bot: {ex.Message}");
}
}
/// <summary>
/// Restarts all active bots.
/// </summary>
/// <returns>A string summarizing the results of the restart operations for all bots.</returns>
[HttpGet]
[Route("RestartAll")]
[HttpPost("restart-all")]
public async Task<string> RestartAll()
{
var bots = await GetBotList();
var result = "";
foreach (var bot in bots)
var user = await GetUser();
if (user == null)
return "No authenticated user found";
try
{
result += $"{bot.Name} : ";
result += await _mediator.Send(new RestartBotCommand(bot.BotType, bot.Name));
result += $" |";
var bots = await GetBotList();
// Filter to only include bots owned by the current user
var userBots = new List<ApiTradingBot>();
var accountService = HttpContext.RequestServices.GetRequiredService<IAccountService>();
foreach (var bot in bots)
{
var account = await accountService.GetAccount(bot.AccountName, true, false);
// Compare the user names
if (account != null && account.User != null && account.User.Name == user.Name)
{
userBots.Add(bot);
}
}
foreach (var bot in userBots)
{
// We can't directly restart a bot with just BotType and Name
// Instead, stop the bot and then retrieve the backup to start it again
await _mediator.Send(new StopBotCommand(bot.BotType, bot.Name));
// Get the saved bot backup
var backup = _botService.GetBotBackup(bot.Name);
if (backup != null)
{
_botService.StartBotFromBackup(backup);
await _hubContext.Clients.All.SendAsync("SendNotification",
$"Bot {bot.Name} restarted by {user.Name}.", "Info");
}
}
await NotifyBotSubscriberAsync();
return "All your bots have been restarted successfully!";
}
catch (Exception e)
{
_logger.LogError(e, "Failed to restart all bots");
return $"Error restarting bots: {e.Message}";
}
await NotifyBotSubscriberAsync();
return result;
}
/// <summary>
@@ -165,12 +346,26 @@ public class BotController : ControllerBase
[Route("ToggleIsForWatching")]
public async Task<ActionResult<string>> ToggleIsForWatching(string botName)
{
var result = await _mediator.Send(new ToggleIsForWatchingCommand(botName));
_logger.LogInformation($"{botName} bot is now {result}");
try
{
// Check if user owns the account
if (!await UserOwnsBotAccount(botName))
{
return Forbid("You don't have permission to modify this bot");
}
await NotifyBotSubscriberAsync();
var result = await _mediator.Send(new ToggleIsForWatchingCommand(botName));
_logger.LogInformation($"{botName} bot is now {result}");
return Ok(result);
await NotifyBotSubscriberAsync();
return Ok(result);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error toggling bot watching status");
return StatusCode(500, $"Error toggling bot watching status: {ex.Message}");
}
}
/// <summary>
@@ -178,7 +373,7 @@ public class BotController : ControllerBase
/// </summary>
/// <returns>A list of active trading bots.</returns>
[HttpGet]
public async Task<List<TradingBot>> GetActiveBots()
public async Task<List<ApiTradingBot>> GetActiveBots()
{
return await GetBotList();
}
@@ -187,28 +382,28 @@ public class BotController : ControllerBase
/// Retrieves a list of active bots by sending a command to the mediator.
/// </summary>
/// <returns>A list of trading bots.</returns>
private async Task<List<TradingBot>> GetBotList()
private async Task<List<ApiTradingBot>> GetBotList()
{
var result = await _mediator.Send(new GetActiveBotsCommand());
var list = new List<TradingBot>();
var list = new List<ApiTradingBot>();
foreach (var item in result)
{
list.Add(new TradingBot
list.Add(new ApiTradingBot
{
Status = item.GetStatus(),
Name = item.GetName(),
Candles = item.OptimizedCandles.ToList(),
Positions = item.Positions,
Name = item.Name,
Signals = item.Signals.ToList(),
Positions = item.Positions,
Candles = item.Candles.ToList(),
WinRate = item.GetWinRate(),
ProfitAndLoss = item.GetProfitAndLoss(),
Timeframe = item.Timeframe,
Ticker = item.Ticker,
AccountName = item.AccountName,
Scenario = item.ScenarioName,
IsForWatchingOnly = item.IsForWatchingOnly,
BotType = item.BotType,
AccountName = item.AccountName,
MoneyManagement = item.MoneyManagement
});
}

2
src/Managing.Api/Controllers/DataController.cs
View File

@@ -59,7 +59,7 @@ public class DataController : ControllerBase
var cacheKey = string.Concat(timeframe.ToString());
var tickers = _cacheService.GetValue<List<Ticker>>(cacheKey);
if (tickers == null)
if (tickers == null || tickers.Count == 0)
{
tickers = await _exchangeService.GetTickers(timeframe);
_cacheService.SaveValue(cacheKey, tickers, TimeSpan.FromHours(2));

35
src/Managing.Api/Controllers/MoneyManagementController.cs
View File

@@ -1,4 +1,5 @@
using Managing.Application.Abstractions;
using Managing.Application.Abstractions.Services;
using Managing.Domain.MoneyManagements;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
@@ -14,7 +15,7 @@ namespace Managing.Api.Controllers;
[Authorize]
[Route("[controller]")]
[Produces("application/json")]
public class MoneyManagementController : ControllerBase
public class MoneyManagementController : BaseController
{
private readonly IMoneyManagementService _moneyManagementService;
@@ -22,52 +23,60 @@ public class MoneyManagementController : ControllerBase
/// Initializes a new instance of the <see cref="MoneyManagementController"/> class.
/// </summary>
/// <param name="moneyManagementService">The service for managing money management strategies.</param>
public MoneyManagementController(IMoneyManagementService moneyManagementService)
/// <param name="userService">The service for user-related operations.</param>
public MoneyManagementController(
IMoneyManagementService moneyManagementService,
IUserService userService)
: base(userService)
{
_moneyManagementService = moneyManagementService;
}
/// <summary>
/// Creates a new money management strategy or updates an existing one.
/// Creates a new money management strategy or updates an existing one for the authenticated user.
/// </summary>
/// <param name="moneyManagement">The money management strategy to create or update.</param>
/// <returns>The created or updated money management strategy.</returns>
[HttpPost]
public async Task<ActionResult<MoneyManagement>> PostMoneyManagement(MoneyManagement moneyManagement)
{
return Ok(await _moneyManagementService.CreateOrUpdateMoneyManagement(moneyManagement));
var user = await GetUser();
return Ok(await _moneyManagementService.CreateOrUpdateMoneyManagement(user, moneyManagement));
}
/// <summary>
/// Retrieves all money management strategies.
/// Retrieves all money management strategies for the authenticated user.
/// </summary>
/// <returns>A list of money management strategies.</returns>
[HttpGet]
[Route("moneymanagements")]
public ActionResult<IEnumerable<MoneyManagement>> GetMoneyManagements()
public async Task<ActionResult<IEnumerable<MoneyManagement>>> GetMoneyManagements()
{
return Ok(_moneyManagementService.GetMoneyMangements());
var user = await GetUser();
return Ok(_moneyManagementService.GetMoneyMangements(user));
}
/// <summary>
/// Retrieves a specific money management strategy by name.
/// Retrieves a specific money management strategy by name for the authenticated user.
/// </summary>
/// <param name="name">The name of the money management strategy to retrieve.</param>
/// <returns>The requested money management strategy if found.</returns>
[HttpGet]
public ActionResult<MoneyManagement> GetMoneyManagement(string name)
public async Task<ActionResult<MoneyManagement>> GetMoneyManagement(string name)
{
return Ok(_moneyManagementService.GetMoneyMangement(name));
var user = await GetUser();
return Ok(await _moneyManagementService.GetMoneyMangement(user, name));
}
/// <summary>
/// Deletes a specific money management strategy by name.
/// Deletes a specific money management strategy by name for the authenticated user.
/// </summary>
/// <param name="name">The name of the money management strategy to delete.</param>
/// <returns>An ActionResult indicating the outcome of the operation.</returns>
[HttpDelete]
public ActionResult DeleteMoneyManagement(string name)
public async Task<ActionResult> DeleteMoneyManagement(string name)
{
return Ok(_moneyManagementService.DeleteMoneyManagement(name));
var user = await GetUser();
return Ok(_moneyManagementService.DeleteMoneyManagement(user, name));
}
}

64
src/Managing.Api/Controllers/ScenarioController.cs
View File

@@ -1,4 +1,5 @@
using Managing.Application.Abstractions;
using Managing.Application.Abstractions.Services;
using Managing.Domain.Scenarios;
using Managing.Domain.Strategies;
using Microsoft.AspNetCore.Authorization;
@@ -16,7 +17,7 @@ namespace Managing.Api.Controllers;
[Authorize]
[Route("[controller]")]
[Produces("application/json")]
public class ScenarioController : ControllerBase
public class ScenarioController : BaseController
{
private readonly IScenarioService _scenarioService;
@@ -24,67 +25,75 @@ public class ScenarioController : ControllerBase
/// Initializes a new instance of the <see cref="ScenarioController"/> class.
/// </summary>
/// <param name="scenarioService">The service for managing scenarios.</param>
public ScenarioController(IScenarioService scenarioService)
/// <param name="userService">The service for user-related operations.</param>
public ScenarioController(
IScenarioService scenarioService,
IUserService userService)
: base(userService)
{
_scenarioService = scenarioService;
}
/// <summary>
/// Retrieves all scenarios.
/// Retrieves all scenarios for the authenticated user.
/// </summary>
/// <returns>A list of scenarios.</returns>
[HttpGet]
public ActionResult<IEnumerable<Scenario>> GetScenarios()
public async Task<ActionResult<IEnumerable<Scenario>>> GetScenarios()
{
return Ok(_scenarioService.GetScenarios());
var user = await GetUser();
return Ok(_scenarioService.GetScenariosByUser(user));
}
/// <summary>
/// Creates a new scenario with the specified name and strategies.
/// Creates a new scenario with the specified name and strategies for the authenticated user.
/// </summary>
/// <param name="name">The name of the scenario.</param>
/// <param name="strategies">A list of strategy names to include in the scenario.</param>
/// <returns>The created scenario.</returns>
[HttpPost]
public ActionResult<Scenario> CreateScenario(string name, List<string> strategies, int? loopbackPeriod = null)
public async Task<ActionResult<Scenario>> CreateScenario(string name, List<string> strategies, int? loopbackPeriod = null)
{
return Ok(_scenarioService.CreateScenario(name, strategies, loopbackPeriod));
var user = await GetUser();
return Ok(_scenarioService.CreateScenarioForUser(user, name, strategies, loopbackPeriod));
}
/// <summary>
/// Deletes a scenario by name.
/// Deletes a scenario by name for the authenticated user.
/// </summary>
/// <param name="name">The name of the scenario to delete.</param>
/// <returns>An ActionResult indicating the outcome of the operation.</returns>
[HttpDelete]
public ActionResult DeleteScenario(string name)
public async Task<ActionResult> DeleteScenario(string name)
{
return Ok(_scenarioService.DeleteScenario(name));
var user = await GetUser();
return Ok(_scenarioService.DeleteScenarioByUser(user, name));
}
// Update scenario
[HttpPut]
public ActionResult UpdateScenario(string name, List<string> strategies, int? loopbackPeriod = null)
public async Task<ActionResult> UpdateScenario(string name, List<string> strategies, int? loopbackPeriod = null)
{
return Ok(_scenarioService.UpdateScenario(name, strategies, loopbackPeriod));
var user = await GetUser();
return Ok(_scenarioService.UpdateScenarioByUser(user, name, strategies, loopbackPeriod));
}
/// <summary>
/// Retrieves all strategies.
/// Retrieves all strategies for the authenticated user.
/// </summary>
/// <returns>A list of strategies.</returns>
[HttpGet]
[Route("strategy")]
public ActionResult<IEnumerable<Strategy>> GetStrategies()
public async Task<ActionResult<IEnumerable<Strategy>>> GetStrategies()
{
return Ok(_scenarioService.GetStrategies());
var user = await GetUser();
return Ok(_scenarioService.GetStrategiesByUser(user));
}
/// <summary>
/// Creates a new strategy with specified parameters.
/// Creates a new strategy with specified parameters for the authenticated user.
/// </summary>
/// <param name="strategyType">The type of the strategy.</param>
/// <param name="timeframe">The timeframe for the strategy.</param>
/// <param name="name">The name of the strategy.</param>
/// <param name="period">The period for the strategy (optional).</param>
/// <param name="fastPeriods">The fast periods for the strategy (optional).</param>
@@ -97,7 +106,7 @@ public class ScenarioController : ControllerBase
/// <returns>The created strategy.</returns>
[HttpPost]
[Route("strategy")]
public ActionResult<Strategy> CreateStrategy(
public async Task<ActionResult<Strategy>> CreateStrategy(
StrategyType strategyType,
string name,
int? period = null,
@@ -109,7 +118,9 @@ public class ScenarioController : ControllerBase
int? smoothPeriods = null,
int? cyclePeriods = null)
{
return Ok(_scenarioService.CreateStrategy(
var user = await GetUser();
return Ok(_scenarioService.CreateStrategyForUser(
user,
strategyType,
name,
period,
@@ -123,21 +134,22 @@ public class ScenarioController : ControllerBase
}
/// <summary>
/// Deletes a strategy by name.
/// Deletes a strategy by name for the authenticated user.
/// </summary>
/// <param name="name">The name of the strategy to delete.</param>
/// <returns>An ActionResult indicating the outcome of the operation.</returns>
[HttpDelete]
[Route("strategy")]
public ActionResult DeleteStrategy(string name)
public async Task<ActionResult> DeleteStrategy(string name)
{
return Ok(_scenarioService.DeleteStrategy(name));
var user = await GetUser();
return Ok(_scenarioService.DeleteStrategyByUser(user, name));
}
// Update strategy
[HttpPut]
[Route("strategy")]
public ActionResult UpdateStrategy(
public async Task<ActionResult> UpdateStrategy(
StrategyType strategyType,
string name,
int? period = null,
@@ -149,7 +161,9 @@ public class ScenarioController : ControllerBase
int? smoothPeriods = null,
int? cyclePeriods = null)
{
return Ok(_scenarioService.UpdateStrategy(
var user = await GetUser();
return Ok(_scenarioService.UpdateStrategyByUser(
user,
strategyType,
name,
period,

42
src/Managing.Api/Controllers/SettingsController.cs
View File

@@ -1,6 +1,16 @@
using Managing.Application.Abstractions;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.DependencyInjection;
using System;
using System.Threading.Tasks;
using System.Collections.Generic;
using Managing.Application.Abstractions;
using Managing.Application.Abstractions.Services;
using Managing.Domain.MoneyManagements;
using Managing.Domain.Strategies;
using Managing.Domain.Scenarios;
using Managing.Domain.Users;
using static Managing.Common.Enums;
namespace Managing.Api.Controllers;
@@ -8,10 +18,12 @@ namespace Managing.Api.Controllers;
[Authorize]
[Route("[controller]")]
[Produces("application/json")]
public class SettingsController : ControllerBase
public class SettingsController : BaseController
{
private readonly ISettingsService _settingsService;
public SettingsController(ISettingsService settingsService)
public SettingsController(ISettingsService settingsService, IUserService userService)
: base(userService)
{
_settingsService = settingsService;
}
@@ -27,4 +39,26 @@ public class SettingsController : ControllerBase
{
return Ok(await _settingsService.ResetSettings());
}
/// <summary>
/// Creates default configuration for backtesting including Money Management, Strategy, and Scenario
/// </summary>
/// <returns>A result indicating if the default configuration was created successfully</returns>
[HttpPost]
[Route("create-default-config")]
public async Task<ActionResult<bool>> CreateDefaultConfiguration()
{
try
{
var user = await GetUser();
if (user == null)
return Unauthorized("User not found");
return Ok(await _settingsService.CreateDefaultConfiguration(user));
}
catch (Exception ex)
{
return StatusCode(500, $"Error creating default configuration: {ex.Message}");
}
}
}

8
src/Managing.Api/Controllers/TradingController.cs
View File

@@ -17,7 +17,7 @@ namespace Managing.Api.Controllers;
[ApiController]
[Authorize]
[Route("[controller]")]
public class TradingController : ControllerBase
public class TradingController : BaseController
{
private readonly ICommandHandler<OpenPositionRequest, Position> _openTradeCommandHandler;
private readonly ICommandHandler<ClosePositionCommand, Position> _closeTradeCommandHandler;
@@ -39,7 +39,8 @@ public class TradingController : ControllerBase
ICommandHandler<OpenPositionRequest, Position> openTradeCommandHandler,
ICommandHandler<ClosePositionCommand, Position> closeTradeCommandHandler,
ITradingService tradingService,
IMediator mediator, IMoneyManagementService moneyManagementService)
IMediator mediator, IMoneyManagementService moneyManagementService,
IUserService userService) : base(userService)
{
_logger = logger;
_openTradeCommandHandler = openTradeCommandHandler;
@@ -137,7 +138,8 @@ public class TradingController : ControllerBase
if (moneyManagement != null)
{
moneyManagement = await _moneyManagementService.GetMoneyMangement(moneyManagementName);
var user = await GetUser();
moneyManagement = await _moneyManagementService.GetMoneyMangement(user, moneyManagementName);
}
var command = new OpenPositionRequest(