cryptooda
87bc2e9dce
- Updated the mapping logic in multiple methods to include PositionCount alongside existing fields such as NetPnl, Score, and InitialBalance.
1345 lines
54 KiB
C#
1345 lines
54 KiB
C#
using System.Diagnostics;
|
|
using Exilion.TradingAtomics;
|
|
using Managing.Application.Abstractions.Repositories;
|
|
using Managing.Application.Abstractions.Shared;
|
|
using Managing.Domain.Backtests;
|
|
using Managing.Domain.Bots;
|
|
using Managing.Domain.Users;
|
|
using Managing.Infrastructure.Databases.PostgreSql.Entities;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Newtonsoft.Json;
|
|
using static Managing.Common.Enums;
|
|
|
|
namespace Managing.Infrastructure.Databases.PostgreSql;
|
|
|
|
public class PostgreSqlBacktestRepository : IBacktestRepository
|
|
{
|
|
private readonly ManagingDbContext _context;
|
|
|
|
public PostgreSqlBacktestRepository(ManagingDbContext context)
|
|
{
|
|
_context = context;
|
|
}
|
|
|
|
// User-specific operations
|
|
public void InsertBacktestForUser(User user, Backtest result)
|
|
{
|
|
ValidateBacktestData(result);
|
|
result.User = user;
|
|
|
|
var entity = PostgreSqlMappers.Map(result);
|
|
_context.Backtests.Add(entity);
|
|
_context.SaveChanges();
|
|
}
|
|
|
|
public async Task InsertBacktestForUserAsync(User user, Backtest result)
|
|
{
|
|
ValidateBacktestData(result);
|
|
result.User = user;
|
|
|
|
var entity = PostgreSqlMappers.Map(result);
|
|
_context.Backtests.Add(entity);
|
|
await _context.SaveChangesAsync();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Validates that all numeric fields in the backtest are of the correct type
|
|
/// </summary>
|
|
private void ValidateBacktestData(Backtest backtest)
|
|
{
|
|
// Ensure FinalPnl is a valid decimal
|
|
if (backtest.FinalPnl.GetType() != typeof(decimal))
|
|
{
|
|
throw new InvalidOperationException(
|
|
$"FinalPnl must be of type decimal, but got {backtest.FinalPnl.GetType().Name}");
|
|
}
|
|
|
|
// Ensure other numeric fields are correct
|
|
if (backtest.GrowthPercentage.GetType() != typeof(decimal))
|
|
{
|
|
throw new InvalidOperationException(
|
|
$"GrowthPercentage must be of type decimal, but got {backtest.GrowthPercentage.GetType().Name}");
|
|
}
|
|
|
|
if (backtest.HodlPercentage.GetType() != typeof(decimal))
|
|
{
|
|
throw new InvalidOperationException(
|
|
$"HodlPercentage must be of type decimal, but got {backtest.HodlPercentage.GetType().Name}");
|
|
}
|
|
|
|
if (backtest.Score.GetType() != typeof(double))
|
|
{
|
|
throw new InvalidOperationException(
|
|
$"Score must be of type double, but got {backtest.Score.GetType().Name}");
|
|
}
|
|
|
|
if (backtest.WinRate.GetType() != typeof(int))
|
|
{
|
|
throw new InvalidOperationException(
|
|
$"WinRate must be of type int, but got {backtest.WinRate.GetType().Name}");
|
|
}
|
|
}
|
|
|
|
public IEnumerable<Backtest> GetBacktestsByUser(User user)
|
|
{
|
|
var entities = _context.Backtests
|
|
.AsNoTracking()
|
|
.Include(b => b.User)
|
|
.Where(b => b.UserId == user.Id)
|
|
.ToList();
|
|
|
|
return entities.Select(PostgreSqlMappers.Map);
|
|
}
|
|
|
|
public async Task<IEnumerable<Backtest>> GetBacktestsByUserAsync(User user)
|
|
{
|
|
var entities = await _context.Backtests
|
|
.AsNoTracking()
|
|
.Include(b => b.User)
|
|
.Where(b => b.UserId == user.Id)
|
|
.ToListAsync()
|
|
.ConfigureAwait(false);
|
|
|
|
return entities.Select(PostgreSqlMappers.Map);
|
|
}
|
|
|
|
public IEnumerable<Backtest> GetBacktestsByRequestId(Guid requestId)
|
|
{
|
|
var entities = _context.Backtests
|
|
.AsNoTracking()
|
|
.Where(b => b.RequestId == requestId)
|
|
.ToList();
|
|
|
|
return entities.Select(PostgreSqlMappers.Map);
|
|
}
|
|
|
|
public async Task<IEnumerable<Backtest>> GetBacktestsByRequestIdAsync(Guid requestId)
|
|
{
|
|
var entities = await _context.Backtests
|
|
.AsNoTracking()
|
|
.Where(b => b.RequestId == requestId)
|
|
.ToListAsync()
|
|
.ConfigureAwait(false);
|
|
|
|
return entities.Select(PostgreSqlMappers.Map);
|
|
}
|
|
|
|
public (IEnumerable<LightBacktest> Backtests, int TotalCount) GetBacktestsByRequestIdPaginated(Guid requestId,
|
|
int page, int pageSize, string sortBy = "score", string sortOrder = "desc")
|
|
{
|
|
var stopwatch = Stopwatch.StartNew();
|
|
|
|
var baseQuery = _context.Backtests
|
|
.AsNoTracking()
|
|
.Where(b => b.RequestId == requestId);
|
|
|
|
var afterQueryMs = stopwatch.ElapsedMilliseconds;
|
|
var totalCount = baseQuery.Count();
|
|
var afterCountMs = stopwatch.ElapsedMilliseconds;
|
|
|
|
// Apply sorting
|
|
IQueryable<BacktestEntity> sortedQuery = sortBy.ToLower() switch
|
|
{
|
|
"score" => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.Score)
|
|
: baseQuery.OrderBy(b => b.Score),
|
|
"finalpnl" => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.FinalPnl)
|
|
: baseQuery.OrderBy(b => b.FinalPnl),
|
|
"winrate" => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.WinRate)
|
|
: baseQuery.OrderBy(b => b.WinRate),
|
|
"growthpercentage" => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.GrowthPercentage)
|
|
: baseQuery.OrderBy(b => b.GrowthPercentage),
|
|
"hodlpercentage" => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.HodlPercentage)
|
|
: baseQuery.OrderBy(b => b.HodlPercentage),
|
|
_ => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.Score)
|
|
: baseQuery.OrderBy(b => b.Score)
|
|
};
|
|
|
|
var afterSortMs = stopwatch.ElapsedMilliseconds;
|
|
var entities = sortedQuery
|
|
.Skip((page - 1) * pageSize)
|
|
.Take(pageSize)
|
|
.ToList();
|
|
var afterToListMs = stopwatch.ElapsedMilliseconds;
|
|
|
|
Console.WriteLine(
|
|
$"[PostgreSqlBacktestRepo] Query: {afterQueryMs}ms, Count: {afterCountMs - afterQueryMs}ms, Sort: {afterSortMs - afterCountMs}ms, ToList: {afterToListMs - afterSortMs}ms, Total: {afterToListMs}ms");
|
|
|
|
var mappedBacktests = entities.Select(entity => new LightBacktest
|
|
{
|
|
Id = entity.Identifier,
|
|
Config = JsonConvert.DeserializeObject<TradingBotConfig>(entity.ConfigJson),
|
|
Ticker = entity.Ticker,
|
|
FinalPnl = entity.FinalPnl,
|
|
WinRate = entity.WinRate,
|
|
GrowthPercentage = entity.GrowthPercentage,
|
|
HodlPercentage = entity.HodlPercentage,
|
|
StartDate = entity.StartDate,
|
|
EndDate = entity.EndDate,
|
|
MaxDrawdown = !string.IsNullOrEmpty(entity.StatisticsJson)
|
|
? JsonConvert.DeserializeObject<PerformanceMetrics>(entity.StatisticsJson)?.MaxDrawdown
|
|
: null,
|
|
Fees = entity.Fees,
|
|
SharpeRatio = !string.IsNullOrEmpty(entity.StatisticsJson)
|
|
? JsonConvert.DeserializeObject<PerformanceMetrics>(entity.StatisticsJson)?.SharpeRatio != null
|
|
? (double?)JsonConvert.DeserializeObject<PerformanceMetrics>(entity.StatisticsJson).SharpeRatio
|
|
: null
|
|
: null,
|
|
Score = entity.Score,
|
|
ScoreMessage = entity.ScoreMessage ?? string.Empty,
|
|
InitialBalance = entity.InitialBalance,
|
|
NetPnl = entity.NetPnl,
|
|
PositionCount = entity.PositionCount
|
|
});
|
|
|
|
return (mappedBacktests, totalCount);
|
|
}
|
|
|
|
public async Task<(IEnumerable<LightBacktest> Backtests, int TotalCount)> GetBacktestsByRequestIdPaginatedAsync(
|
|
Guid requestId, int page, int pageSize, string sortBy = "score", string sortOrder = "desc")
|
|
{
|
|
var stopwatch = Stopwatch.StartNew();
|
|
|
|
var baseQuery = _context.Backtests
|
|
.AsNoTracking()
|
|
.Where(b => b.RequestId == requestId);
|
|
|
|
var afterQueryMs = stopwatch.ElapsedMilliseconds;
|
|
var totalCount = await baseQuery.CountAsync().ConfigureAwait(false);
|
|
var afterCountMs = stopwatch.ElapsedMilliseconds;
|
|
|
|
// Apply sorting
|
|
IQueryable<BacktestEntity> sortedQuery = sortBy.ToLower() switch
|
|
{
|
|
"score" => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.Score)
|
|
: baseQuery.OrderBy(b => b.Score),
|
|
"finalpnl" => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.FinalPnl)
|
|
: baseQuery.OrderBy(b => b.FinalPnl),
|
|
"winrate" => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.WinRate)
|
|
: baseQuery.OrderBy(b => b.WinRate),
|
|
"growthpercentage" => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.GrowthPercentage)
|
|
: baseQuery.OrderBy(b => b.GrowthPercentage),
|
|
"hodlpercentage" => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.HodlPercentage)
|
|
: baseQuery.OrderBy(b => b.HodlPercentage),
|
|
_ => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.Score)
|
|
: baseQuery.OrderBy(b => b.Score)
|
|
};
|
|
|
|
var afterSortMs = stopwatch.ElapsedMilliseconds;
|
|
var entities = await sortedQuery
|
|
.Skip((page - 1) * pageSize)
|
|
.Take(pageSize)
|
|
.ToListAsync()
|
|
.ConfigureAwait(false);
|
|
var afterToListMs = stopwatch.ElapsedMilliseconds;
|
|
|
|
Console.WriteLine(
|
|
$"[PostgreSqlBacktestRepo] Query: {afterQueryMs}ms, Count: {afterCountMs - afterQueryMs}ms, Sort: {afterSortMs - afterCountMs}ms, ToList: {afterToListMs - afterSortMs}ms, Total: {afterToListMs}ms");
|
|
|
|
var mappedBacktests = entities.Select(entity => new LightBacktest
|
|
{
|
|
Id = entity.Identifier,
|
|
Config = JsonConvert.DeserializeObject<TradingBotConfig>(entity.ConfigJson),
|
|
Ticker = entity.Ticker,
|
|
FinalPnl = entity.FinalPnl,
|
|
WinRate = entity.WinRate,
|
|
GrowthPercentage = entity.GrowthPercentage,
|
|
HodlPercentage = entity.HodlPercentage,
|
|
StartDate = entity.StartDate,
|
|
EndDate = entity.EndDate,
|
|
MaxDrawdown = !string.IsNullOrEmpty(entity.StatisticsJson)
|
|
? JsonConvert.DeserializeObject<PerformanceMetrics>(entity.StatisticsJson)?.MaxDrawdown
|
|
: null,
|
|
Fees = entity.Fees,
|
|
SharpeRatio = !string.IsNullOrEmpty(entity.StatisticsJson)
|
|
? JsonConvert.DeserializeObject<PerformanceMetrics>(entity.StatisticsJson)?.SharpeRatio != null
|
|
? (double?)JsonConvert.DeserializeObject<PerformanceMetrics>(entity.StatisticsJson).SharpeRatio
|
|
: null
|
|
: null,
|
|
Score = entity.Score,
|
|
ScoreMessage = entity.ScoreMessage ?? string.Empty,
|
|
InitialBalance = entity.InitialBalance,
|
|
NetPnl = entity.NetPnl,
|
|
PositionCount = entity.PositionCount
|
|
});
|
|
|
|
return (mappedBacktests, totalCount);
|
|
}
|
|
|
|
public Backtest GetBacktestByIdForUser(User user, string id)
|
|
{
|
|
var entity = _context.Backtests
|
|
.AsNoTracking()
|
|
.Include(b => b.User)
|
|
.FirstOrDefault(b => b.Identifier == id && b.UserId == user.Id);
|
|
|
|
return entity != null ? PostgreSqlMappers.Map(entity) : null;
|
|
}
|
|
|
|
public async Task<Backtest> GetBacktestByIdForUserAsync(User user, string id)
|
|
{
|
|
var entity = await _context.Backtests
|
|
.AsNoTracking()
|
|
.Include(b => b.User)
|
|
.FirstOrDefaultAsync(b => b.Identifier == id && b.UserId == user.Id)
|
|
.ConfigureAwait(false);
|
|
|
|
return entity != null ? PostgreSqlMappers.Map(entity) : null;
|
|
}
|
|
|
|
public void DeleteBacktestByIdForUser(User user, string id)
|
|
{
|
|
var entity = _context.Backtests
|
|
.AsTracking()
|
|
.FirstOrDefault(b => b.Identifier == id && b.UserId == user.Id);
|
|
|
|
if (entity != null)
|
|
{
|
|
_context.Backtests.Remove(entity);
|
|
_context.SaveChanges();
|
|
}
|
|
}
|
|
|
|
public async Task DeleteBacktestByIdForUserAsync(User user, string id)
|
|
{
|
|
var entity = await _context.Backtests
|
|
.AsTracking()
|
|
.FirstOrDefaultAsync(b => b.Identifier == id && b.UserId == user.Id)
|
|
.ConfigureAwait(false);
|
|
|
|
if (entity != null)
|
|
{
|
|
_context.Backtests.Remove(entity);
|
|
await _context.SaveChangesAsync().ConfigureAwait(false);
|
|
}
|
|
}
|
|
|
|
public void DeleteBacktestsByIdsForUser(User user, IEnumerable<string> ids)
|
|
{
|
|
var entities = _context.Backtests
|
|
.AsTracking()
|
|
.Where(b => b.UserId == user.Id && ids.Contains(b.Identifier))
|
|
.ToList();
|
|
|
|
if (entities.Any())
|
|
{
|
|
_context.Backtests.RemoveRange(entities);
|
|
_context.SaveChanges();
|
|
}
|
|
}
|
|
|
|
public async Task DeleteBacktestsByIdsForUserAsync(User user, IEnumerable<string> ids)
|
|
{
|
|
var entities = await _context.Backtests
|
|
.AsTracking()
|
|
.Where(b => b.UserId == user.Id && ids.Contains(b.Identifier))
|
|
.ToListAsync()
|
|
.ConfigureAwait(false);
|
|
|
|
if (entities.Any())
|
|
{
|
|
_context.Backtests.RemoveRange(entities);
|
|
await _context.SaveChangesAsync().ConfigureAwait(false);
|
|
}
|
|
}
|
|
|
|
public void DeleteAllBacktestsForUser(User user)
|
|
{
|
|
var entities = _context.Backtests
|
|
.AsTracking()
|
|
.Where(b => b.UserId == user.Id)
|
|
.ToList();
|
|
|
|
if (entities.Any())
|
|
{
|
|
_context.Backtests.RemoveRange(entities);
|
|
_context.SaveChanges();
|
|
}
|
|
}
|
|
|
|
public void DeleteBacktestsByRequestId(Guid requestId)
|
|
{
|
|
var entities = _context.Backtests
|
|
.AsTracking()
|
|
.Where(b => b.RequestId == requestId)
|
|
.ToList();
|
|
|
|
if (entities.Any())
|
|
{
|
|
_context.Backtests.RemoveRange(entities);
|
|
_context.SaveChanges();
|
|
}
|
|
}
|
|
|
|
public async Task DeleteBacktestsByRequestIdAsync(Guid requestId)
|
|
{
|
|
var entities = await _context.Backtests
|
|
.AsTracking()
|
|
.Where(b => b.RequestId == requestId)
|
|
.ToListAsync()
|
|
.ConfigureAwait(false);
|
|
|
|
if (entities.Any())
|
|
{
|
|
_context.Backtests.RemoveRange(entities);
|
|
await _context.SaveChangesAsync().ConfigureAwait(false);
|
|
}
|
|
}
|
|
|
|
public async Task<int> DeleteBacktestsByFiltersAsync(User user, BacktestsFilter filter)
|
|
{
|
|
var baseQuery = _context.Backtests
|
|
.AsTracking()
|
|
.Where(b => b.UserId == user.Id);
|
|
|
|
if (filter != null)
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(filter.NameContains))
|
|
{
|
|
var nameLike = $"%{filter.NameContains.Trim()}%";
|
|
baseQuery = baseQuery.Where(b => EF.Functions.ILike(b.Name, nameLike));
|
|
}
|
|
if (filter.ScoreMin.HasValue)
|
|
baseQuery = baseQuery.Where(b => b.Score >= filter.ScoreMin.Value);
|
|
if (filter.ScoreMax.HasValue)
|
|
baseQuery = baseQuery.Where(b => b.Score <= filter.ScoreMax.Value);
|
|
if (filter.WinrateMin.HasValue)
|
|
baseQuery = baseQuery.Where(b => b.WinRate >= filter.WinrateMin.Value);
|
|
if (filter.WinrateMax.HasValue)
|
|
baseQuery = baseQuery.Where(b => b.WinRate <= filter.WinrateMax.Value);
|
|
if (filter.MaxDrawdownMax.HasValue)
|
|
baseQuery = baseQuery.Where(b => b.MaxDrawdown <= filter.MaxDrawdownMax.Value);
|
|
|
|
if (filter.Tickers != null && filter.Tickers.Any())
|
|
{
|
|
var tickerArray = filter.Tickers.ToArray();
|
|
baseQuery = baseQuery.Where(b => tickerArray.Contains(b.Ticker));
|
|
}
|
|
|
|
if (filter.Indicators != null && filter.Indicators.Any())
|
|
{
|
|
foreach (var ind in filter.Indicators)
|
|
{
|
|
var token = "," + ind + ",";
|
|
baseQuery = baseQuery.Where(b => ("," + b.IndicatorsCsv + ",").Contains(token));
|
|
}
|
|
}
|
|
|
|
if (filter.DurationMin.HasValue)
|
|
baseQuery = baseQuery.Where(b => b.Duration >= filter.DurationMin.Value);
|
|
if (filter.DurationMax.HasValue)
|
|
baseQuery = baseQuery.Where(b => b.Duration <= filter.DurationMax.Value);
|
|
if (filter.TradingType.HasValue)
|
|
baseQuery = baseQuery.Where(b => b.TradingType == (int)filter.TradingType.Value);
|
|
}
|
|
|
|
var entities = await baseQuery.ToListAsync().ConfigureAwait(false);
|
|
var count = entities.Count;
|
|
|
|
if (count > 0)
|
|
{
|
|
_context.Backtests.RemoveRange(entities);
|
|
await _context.SaveChangesAsync().ConfigureAwait(false);
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
public (IEnumerable<LightBacktest> Backtests, int TotalCount) GetBacktestsByUserPaginated(
|
|
User user,
|
|
int page,
|
|
int pageSize,
|
|
BacktestSortableColumn sortBy = BacktestSortableColumn.Score,
|
|
string sortOrder = "desc",
|
|
BacktestsFilter? filter = null)
|
|
{
|
|
var stopwatch = Stopwatch.StartNew();
|
|
|
|
var baseQuery = _context.Backtests
|
|
.AsNoTracking()
|
|
.Where(b => b.UserId == user.Id);
|
|
|
|
if (filter != null)
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(filter.NameContains))
|
|
{
|
|
var nameLike = $"%{filter.NameContains.Trim()}%";
|
|
baseQuery = baseQuery.Where(b => EF.Functions.ILike(b.Name, nameLike));
|
|
}
|
|
if (filter.ScoreMin.HasValue)
|
|
baseQuery = baseQuery.Where(b => b.Score >= filter.ScoreMin.Value);
|
|
if (filter.ScoreMax.HasValue)
|
|
baseQuery = baseQuery.Where(b => b.Score <= filter.ScoreMax.Value);
|
|
if (filter.WinrateMin.HasValue)
|
|
baseQuery = baseQuery.Where(b => b.WinRate >= filter.WinrateMin.Value);
|
|
if (filter.WinrateMax.HasValue)
|
|
baseQuery = baseQuery.Where(b => b.WinRate <= filter.WinrateMax.Value);
|
|
if (filter.MaxDrawdownMax.HasValue)
|
|
baseQuery = baseQuery.Where(b => b.MaxDrawdown <= filter.MaxDrawdownMax.Value);
|
|
|
|
if (filter.Tickers != null && filter.Tickers.Any())
|
|
{
|
|
var tickerArray = filter.Tickers.ToArray();
|
|
baseQuery = baseQuery.Where(b => tickerArray.Contains(b.Ticker));
|
|
}
|
|
|
|
if (filter.Indicators != null && filter.Indicators.Any())
|
|
{
|
|
foreach (var ind in filter.Indicators)
|
|
{
|
|
var token = "," + ind + ",";
|
|
baseQuery = baseQuery.Where(b => ("," + b.IndicatorsCsv + ",").Contains(token));
|
|
}
|
|
}
|
|
|
|
if (filter.DurationMin.HasValue)
|
|
baseQuery = baseQuery.Where(b => b.Duration >= filter.DurationMin.Value);
|
|
if (filter.DurationMax.HasValue)
|
|
baseQuery = baseQuery.Where(b => b.Duration <= filter.DurationMax.Value);
|
|
if (filter.TradingType.HasValue)
|
|
baseQuery = baseQuery.Where(b => b.TradingType == (int)filter.TradingType.Value);
|
|
}
|
|
|
|
var afterQueryMs = stopwatch.ElapsedMilliseconds;
|
|
var totalCount = baseQuery.Count();
|
|
var afterCountMs = stopwatch.ElapsedMilliseconds;
|
|
|
|
// Apply sorting
|
|
IQueryable<BacktestEntity> sortedQuery = sortBy switch
|
|
{
|
|
BacktestSortableColumn.Score => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.Score)
|
|
: baseQuery.OrderBy(b => b.Score),
|
|
BacktestSortableColumn.FinalPnl => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.FinalPnl)
|
|
: baseQuery.OrderBy(b => b.FinalPnl),
|
|
BacktestSortableColumn.NetPnl => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.NetPnl)
|
|
: baseQuery.OrderBy(b => b.NetPnl),
|
|
BacktestSortableColumn.WinRate => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.WinRate)
|
|
: baseQuery.OrderBy(b => b.WinRate),
|
|
BacktestSortableColumn.GrowthPercentage => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.GrowthPercentage)
|
|
: baseQuery.OrderBy(b => b.GrowthPercentage),
|
|
BacktestSortableColumn.HodlPercentage => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.HodlPercentage)
|
|
: baseQuery.OrderBy(b => b.HodlPercentage),
|
|
BacktestSortableColumn.Duration => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.Duration)
|
|
: baseQuery.OrderBy(b => b.Duration),
|
|
BacktestSortableColumn.Timeframe => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.Timeframe)
|
|
: baseQuery.OrderBy(b => b.Timeframe),
|
|
BacktestSortableColumn.IndicatorsCount => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.IndicatorsCount)
|
|
: baseQuery.OrderBy(b => b.IndicatorsCount),
|
|
BacktestSortableColumn.MaxDrawdown => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.MaxDrawdown)
|
|
: baseQuery.OrderBy(b => b.MaxDrawdown),
|
|
BacktestSortableColumn.Fees => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.Fees)
|
|
: baseQuery.OrderBy(b => b.Fees),
|
|
BacktestSortableColumn.SharpeRatio => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.SharpeRatio)
|
|
: baseQuery.OrderBy(b => b.SharpeRatio),
|
|
BacktestSortableColumn.Ticker => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.Ticker)
|
|
: baseQuery.OrderBy(b => b.Ticker),
|
|
BacktestSortableColumn.Name => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.Name)
|
|
: baseQuery.OrderBy(b => b.Name),
|
|
_ => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.Score)
|
|
: baseQuery.OrderBy(b => b.Score)
|
|
};
|
|
|
|
var afterSortMs = stopwatch.ElapsedMilliseconds;
|
|
var entities = sortedQuery
|
|
.Skip((page - 1) * pageSize)
|
|
.Take(pageSize)
|
|
.ToList();
|
|
var afterToListMs = stopwatch.ElapsedMilliseconds;
|
|
|
|
Console.WriteLine(
|
|
$"[PostgreSqlBacktestRepo] User Query: {afterQueryMs}ms, Count: {afterCountMs - afterQueryMs}ms, Sort: {afterSortMs - afterCountMs}ms, ToList: {afterToListMs - afterSortMs}ms, Total: {afterToListMs}ms");
|
|
|
|
var mappedBacktests = entities.Select(entity => new LightBacktest
|
|
{
|
|
Id = entity.Identifier,
|
|
Config = JsonConvert.DeserializeObject<TradingBotConfig>(entity.ConfigJson),
|
|
Ticker = entity.Ticker,
|
|
FinalPnl = entity.FinalPnl,
|
|
WinRate = entity.WinRate,
|
|
GrowthPercentage = entity.GrowthPercentage,
|
|
HodlPercentage = entity.HodlPercentage,
|
|
StartDate = entity.StartDate,
|
|
EndDate = entity.EndDate,
|
|
MaxDrawdown = entity.MaxDrawdown,
|
|
Fees = entity.Fees,
|
|
SharpeRatio = (double?)entity.SharpeRatio,
|
|
Score = entity.Score,
|
|
ScoreMessage = entity.ScoreMessage ?? string.Empty,
|
|
InitialBalance = entity.InitialBalance,
|
|
NetPnl = entity.NetPnl,
|
|
PositionCount = entity.PositionCount
|
|
});
|
|
|
|
return (mappedBacktests, totalCount);
|
|
}
|
|
|
|
public async Task<(IEnumerable<LightBacktest> Backtests, int TotalCount)> GetBacktestsByUserPaginatedAsync(
|
|
User user,
|
|
int page,
|
|
int pageSize,
|
|
BacktestSortableColumn sortBy = BacktestSortableColumn.Score,
|
|
string sortOrder = "desc",
|
|
BacktestsFilter? filter = null)
|
|
{
|
|
var stopwatch = Stopwatch.StartNew();
|
|
|
|
var baseQuery = _context.Backtests
|
|
.AsNoTracking()
|
|
.Where(b => b.UserId == user.Id);
|
|
if (filter != null)
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(filter.NameContains))
|
|
{
|
|
var nameLike = $"%{filter.NameContains.Trim()}%";
|
|
baseQuery = baseQuery.Where(b => EF.Functions.ILike(b.Name, nameLike));
|
|
}
|
|
if (filter.ScoreMin.HasValue)
|
|
baseQuery = baseQuery.Where(b => b.Score >= filter.ScoreMin.Value);
|
|
if (filter.ScoreMax.HasValue)
|
|
baseQuery = baseQuery.Where(b => b.Score <= filter.ScoreMax.Value);
|
|
if (filter.WinrateMin.HasValue)
|
|
baseQuery = baseQuery.Where(b => b.WinRate >= filter.WinrateMin.Value);
|
|
if (filter.WinrateMax.HasValue)
|
|
baseQuery = baseQuery.Where(b => b.WinRate <= filter.WinrateMax.Value);
|
|
if (filter.MaxDrawdownMax.HasValue)
|
|
baseQuery = baseQuery.Where(b => b.MaxDrawdown <= filter.MaxDrawdownMax.Value);
|
|
|
|
if (filter.Tickers != null && filter.Tickers.Any())
|
|
{
|
|
var tickerArray = filter.Tickers.ToArray();
|
|
baseQuery = baseQuery.Where(b => tickerArray.Contains(b.Ticker));
|
|
}
|
|
|
|
if (filter.Indicators != null && filter.Indicators.Any())
|
|
{
|
|
foreach (var ind in filter.Indicators)
|
|
{
|
|
var token = "," + ind + ",";
|
|
baseQuery = baseQuery.Where(b => ("," + b.IndicatorsCsv + ",").Contains(token));
|
|
}
|
|
}
|
|
|
|
if (filter.DurationMin.HasValue)
|
|
baseQuery = baseQuery.Where(b => b.Duration >= filter.DurationMin.Value);
|
|
if (filter.DurationMax.HasValue)
|
|
baseQuery = baseQuery.Where(b => b.Duration <= filter.DurationMax.Value);
|
|
if (filter.TradingType.HasValue)
|
|
baseQuery = baseQuery.Where(b => b.TradingType == (int)filter.TradingType.Value);
|
|
}
|
|
|
|
var afterQueryMs = stopwatch.ElapsedMilliseconds;
|
|
var totalCount = await baseQuery.CountAsync().ConfigureAwait(false);
|
|
var afterCountMs = stopwatch.ElapsedMilliseconds;
|
|
|
|
// Apply sorting
|
|
IQueryable<BacktestEntity> sortedQuery = sortBy switch
|
|
{
|
|
BacktestSortableColumn.Score => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.Score)
|
|
: baseQuery.OrderBy(b => b.Score),
|
|
BacktestSortableColumn.FinalPnl => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.FinalPnl)
|
|
: baseQuery.OrderBy(b => b.FinalPnl),
|
|
BacktestSortableColumn.NetPnl => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.NetPnl)
|
|
: baseQuery.OrderBy(b => b.NetPnl),
|
|
BacktestSortableColumn.WinRate => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.WinRate)
|
|
: baseQuery.OrderBy(b => b.WinRate),
|
|
BacktestSortableColumn.GrowthPercentage => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.GrowthPercentage)
|
|
: baseQuery.OrderBy(b => b.GrowthPercentage),
|
|
BacktestSortableColumn.HodlPercentage => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.HodlPercentage)
|
|
: baseQuery.OrderBy(b => b.HodlPercentage),
|
|
BacktestSortableColumn.Duration => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.Duration)
|
|
: baseQuery.OrderBy(b => b.Duration),
|
|
BacktestSortableColumn.Timeframe => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.Timeframe)
|
|
: baseQuery.OrderBy(b => b.Timeframe),
|
|
BacktestSortableColumn.IndicatorsCount => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.IndicatorsCount)
|
|
: baseQuery.OrderBy(b => b.IndicatorsCount),
|
|
BacktestSortableColumn.MaxDrawdown => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.MaxDrawdown)
|
|
: baseQuery.OrderBy(b => b.MaxDrawdown),
|
|
BacktestSortableColumn.Fees => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.Fees)
|
|
: baseQuery.OrderBy(b => b.Fees),
|
|
BacktestSortableColumn.SharpeRatio => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.SharpeRatio)
|
|
: baseQuery.OrderBy(b => b.SharpeRatio),
|
|
BacktestSortableColumn.Ticker => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.Ticker)
|
|
: baseQuery.OrderBy(b => b.Ticker),
|
|
BacktestSortableColumn.Name => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.Name)
|
|
: baseQuery.OrderBy(b => b.Name),
|
|
_ => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.Score)
|
|
: baseQuery.OrderBy(b => b.Score)
|
|
};
|
|
|
|
var afterSortMs = stopwatch.ElapsedMilliseconds;
|
|
var entities = await sortedQuery
|
|
.Skip((page - 1) * pageSize)
|
|
.Take(pageSize)
|
|
.ToListAsync()
|
|
.ConfigureAwait(false);
|
|
var afterToListMs = stopwatch.ElapsedMilliseconds;
|
|
|
|
Console.WriteLine(
|
|
$"[PostgreSqlBacktestRepo] User Query: {afterQueryMs}ms, Count: {afterCountMs - afterQueryMs}ms, Sort: {afterSortMs - afterCountMs}ms, ToList: {afterToListMs - afterSortMs}ms, Total: {afterToListMs}ms");
|
|
|
|
var mappedBacktests = entities.Select(entity => new LightBacktest
|
|
{
|
|
Id = entity.Identifier,
|
|
Config = JsonConvert.DeserializeObject<TradingBotConfig>(entity.ConfigJson),
|
|
Ticker = entity.Ticker,
|
|
FinalPnl = entity.FinalPnl,
|
|
WinRate = entity.WinRate,
|
|
GrowthPercentage = entity.GrowthPercentage,
|
|
HodlPercentage = entity.HodlPercentage,
|
|
StartDate = entity.StartDate,
|
|
EndDate = entity.EndDate,
|
|
MaxDrawdown = entity.MaxDrawdown,
|
|
Fees = entity.Fees,
|
|
SharpeRatio = (double?)entity.SharpeRatio,
|
|
Score = entity.Score,
|
|
ScoreMessage = entity.ScoreMessage ?? string.Empty,
|
|
InitialBalance = entity.InitialBalance,
|
|
NetPnl = entity.NetPnl,
|
|
PositionCount = entity.PositionCount
|
|
});
|
|
|
|
return (mappedBacktests, totalCount);
|
|
}
|
|
|
|
// Bundle backtest methods
|
|
public void InsertBundleBacktestRequestForUser(User user, BundleBacktestRequest bundleRequest)
|
|
{
|
|
bundleRequest.User = user;
|
|
|
|
// Set the UserId by finding the user entity
|
|
var userEntity = _context.Users.FirstOrDefault(u => u.Name == user.Name);
|
|
if (userEntity != null)
|
|
{
|
|
// Check for existing bundle requests with the same name for this user
|
|
var maxVersion = _context.BundleBacktestRequests
|
|
.Where(b => b.UserId == userEntity.Id && b.Name == bundleRequest.Name)
|
|
.Max(b => (int?)b.Version);
|
|
|
|
// Increment version if a bundle with the same name exists
|
|
bundleRequest.Version = (maxVersion ?? 0) + 1;
|
|
}
|
|
|
|
var entity = PostgreSqlMappers.Map(bundleRequest);
|
|
if (userEntity != null)
|
|
{
|
|
entity.UserId = userEntity.Id;
|
|
}
|
|
|
|
_context.BundleBacktestRequests.Add(entity);
|
|
_context.SaveChanges();
|
|
}
|
|
|
|
public async Task InsertBundleBacktestRequestForUserAsync(User user, BundleBacktestRequest bundleRequest)
|
|
{
|
|
bundleRequest.User = user;
|
|
|
|
// Set the UserId by finding the user entity
|
|
var userEntity = await _context.Users.FirstOrDefaultAsync(u => u.Name == user.Name);
|
|
if (userEntity != null)
|
|
{
|
|
// Check for existing bundle requests with the same name for this user
|
|
var maxVersion = await _context.BundleBacktestRequests
|
|
.Where(b => b.UserId == userEntity.Id && b.Name == bundleRequest.Name)
|
|
.MaxAsync(b => (int?)b.Version);
|
|
|
|
// Increment version if a bundle with the same name exists
|
|
bundleRequest.Version = (maxVersion ?? 0) + 1;
|
|
}
|
|
|
|
var entity = PostgreSqlMappers.Map(bundleRequest);
|
|
if (userEntity != null)
|
|
{
|
|
entity.UserId = userEntity.Id;
|
|
}
|
|
|
|
await _context.BundleBacktestRequests.AddAsync(entity);
|
|
await _context.SaveChangesAsync();
|
|
}
|
|
|
|
public IEnumerable<BundleBacktestRequest> GetBundleBacktestRequestsByUser(User user)
|
|
{
|
|
var entities = _context.BundleBacktestRequests
|
|
.AsNoTracking()
|
|
.Include(b => b.User)
|
|
.Where(b => b.UserId == user.Id)
|
|
.OrderByDescending(b => b.CreatedAt)
|
|
.ToList();
|
|
|
|
return entities.Select(PostgreSqlMappers.Map);
|
|
}
|
|
|
|
public async Task<IEnumerable<BundleBacktestRequest>> GetBundleBacktestRequestsByUserAsync(User user)
|
|
{
|
|
var entities = await _context.BundleBacktestRequests
|
|
.AsNoTracking()
|
|
.Include(b => b.User)
|
|
.Where(b => b.UserId == user.Id)
|
|
.OrderByDescending(b => b.CreatedAt)
|
|
.ToListAsync()
|
|
.ConfigureAwait(false);
|
|
|
|
return entities.Select(PostgreSqlMappers.Map);
|
|
}
|
|
|
|
public BundleBacktestRequest? GetBundleBacktestRequestByIdForUser(User user, Guid id)
|
|
{
|
|
var entity = _context.BundleBacktestRequests
|
|
.AsNoTracking()
|
|
.Include(b => b.User)
|
|
.FirstOrDefault(b => b.RequestId == id && b.UserId == user.Id);
|
|
|
|
return entity != null ? PostgreSqlMappers.Map(entity) : null;
|
|
}
|
|
|
|
public async Task<BundleBacktestRequest?> GetBundleBacktestRequestByIdForUserAsync(User user, Guid id)
|
|
{
|
|
var entity = await _context.BundleBacktestRequests
|
|
.AsNoTracking()
|
|
.Include(b => b.User)
|
|
.FirstOrDefaultAsync(b => b.RequestId == id && b.UserId == user.Id)
|
|
.ConfigureAwait(false);
|
|
|
|
return entity != null ? PostgreSqlMappers.Map(entity) : null;
|
|
}
|
|
|
|
public void UpdateBundleBacktestRequest(BundleBacktestRequest bundleRequest)
|
|
{
|
|
var entity = _context.BundleBacktestRequests
|
|
.AsTracking()
|
|
.FirstOrDefault(b => b.RequestId == bundleRequest.RequestId);
|
|
|
|
if (entity != null)
|
|
{
|
|
// Update the entity properties
|
|
entity.Status = bundleRequest.Status;
|
|
entity.CompletedAt = bundleRequest.CompletedAt;
|
|
entity.CompletedBacktests = bundleRequest.CompletedBacktests;
|
|
entity.FailedBacktests = bundleRequest.FailedBacktests;
|
|
entity.ErrorMessage = bundleRequest.ErrorMessage;
|
|
entity.ProgressInfo = bundleRequest.ProgressInfo;
|
|
entity.CurrentBacktest = bundleRequest.CurrentBacktest;
|
|
entity.EstimatedTimeRemainingSeconds = bundleRequest.EstimatedTimeRemainingSeconds;
|
|
entity.Version = bundleRequest.Version; // Preserve the version
|
|
entity.UpdatedAt = DateTime.UtcNow;
|
|
|
|
// Serialize Results to JSON
|
|
if (bundleRequest.Results != null && bundleRequest.Results.Any())
|
|
{
|
|
try
|
|
{
|
|
entity.ResultsJson = JsonConvert.SerializeObject(bundleRequest.Results);
|
|
}
|
|
catch
|
|
{
|
|
entity.ResultsJson = "[]";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
entity.ResultsJson = "[]";
|
|
}
|
|
|
|
_context.SaveChanges();
|
|
}
|
|
}
|
|
|
|
public async Task UpdateBundleBacktestRequestAsync(BundleBacktestRequest bundleRequest)
|
|
{
|
|
var entity = await _context.BundleBacktestRequests
|
|
.AsTracking()
|
|
.FirstOrDefaultAsync(b => b.RequestId == bundleRequest.RequestId)
|
|
.ConfigureAwait(false);
|
|
|
|
if (entity != null)
|
|
{
|
|
// Update the entity properties
|
|
entity.Status = bundleRequest.Status;
|
|
entity.CompletedAt = bundleRequest.CompletedAt;
|
|
entity.CompletedBacktests = bundleRequest.CompletedBacktests;
|
|
entity.FailedBacktests = bundleRequest.FailedBacktests;
|
|
entity.ErrorMessage = bundleRequest.ErrorMessage;
|
|
entity.ProgressInfo = bundleRequest.ProgressInfo;
|
|
entity.CurrentBacktest = bundleRequest.CurrentBacktest;
|
|
entity.EstimatedTimeRemainingSeconds = bundleRequest.EstimatedTimeRemainingSeconds;
|
|
entity.Version = bundleRequest.Version; // Preserve the version
|
|
entity.UpdatedAt = DateTime.UtcNow;
|
|
|
|
// Serialize Results to JSON
|
|
if (bundleRequest.Results != null && bundleRequest.Results.Any())
|
|
{
|
|
try
|
|
{
|
|
entity.ResultsJson = JsonConvert.SerializeObject(bundleRequest.Results);
|
|
}
|
|
catch
|
|
{
|
|
entity.ResultsJson = "[]";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
entity.ResultsJson = "[]";
|
|
}
|
|
|
|
await _context.SaveChangesAsync().ConfigureAwait(false);
|
|
}
|
|
}
|
|
|
|
public void DeleteBundleBacktestRequestByIdForUser(User user, Guid id)
|
|
{
|
|
var entity = _context.BundleBacktestRequests
|
|
.AsTracking()
|
|
.FirstOrDefault(b => b.RequestId == id && b.UserId == user.Id);
|
|
|
|
if (entity != null)
|
|
{
|
|
_context.BundleBacktestRequests.Remove(entity);
|
|
_context.SaveChanges();
|
|
}
|
|
}
|
|
|
|
public async Task DeleteBundleBacktestRequestByIdForUserAsync(User user, Guid id)
|
|
{
|
|
var entity = await _context.BundleBacktestRequests
|
|
.AsTracking()
|
|
.FirstOrDefaultAsync(b => b.RequestId == id && b.UserId == user.Id)
|
|
.ConfigureAwait(false);
|
|
|
|
if (entity != null)
|
|
{
|
|
_context.BundleBacktestRequests.Remove(entity);
|
|
await _context.SaveChangesAsync().ConfigureAwait(false);
|
|
}
|
|
}
|
|
|
|
public async Task DeleteBundleBacktestRequestByIdAsync(Guid id)
|
|
{
|
|
var entity = await _context.BundleBacktestRequests
|
|
.AsTracking()
|
|
.FirstOrDefaultAsync(b => b.RequestId == id)
|
|
.ConfigureAwait(false);
|
|
|
|
if (entity != null)
|
|
{
|
|
_context.BundleBacktestRequests.Remove(entity);
|
|
await _context.SaveChangesAsync().ConfigureAwait(false);
|
|
}
|
|
}
|
|
|
|
public IEnumerable<BundleBacktestRequest> GetBundleBacktestRequestsByStatus(BundleBacktestRequestStatus status)
|
|
{
|
|
var entities = _context.BundleBacktestRequests
|
|
.AsNoTracking()
|
|
.Include(b => b.User)
|
|
.Where(b => b.Status == status)
|
|
.ToList();
|
|
|
|
return entities.Select(PostgreSqlMappers.Map);
|
|
}
|
|
|
|
public async Task<IEnumerable<BundleBacktestRequest>> GetBundleBacktestRequestsByStatusAsync(BundleBacktestRequestStatus status)
|
|
{
|
|
var entities = await _context.BundleBacktestRequests
|
|
.AsNoTracking()
|
|
.Include(b => b.User)
|
|
.Where(b => b.Status == status)
|
|
.ToListAsync()
|
|
.ConfigureAwait(false);
|
|
|
|
return entities.Select(PostgreSqlMappers.Map);
|
|
}
|
|
|
|
public (IEnumerable<BundleBacktestRequest> BundleRequests, int TotalCount) GetBundleBacktestRequestsPaginated(
|
|
int page,
|
|
int pageSize,
|
|
BundleBacktestRequestSortableColumn sortBy = BundleBacktestRequestSortableColumn.CreatedAt,
|
|
string sortOrder = "desc",
|
|
BundleBacktestRequestsFilter? filter = null)
|
|
{
|
|
var baseQuery = _context.BundleBacktestRequests
|
|
.AsNoTracking()
|
|
.Include(b => b.User)
|
|
.AsQueryable();
|
|
|
|
// Apply filters
|
|
if (filter != null)
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(filter.NameContains))
|
|
{
|
|
var nameLike = $"%{filter.NameContains.Trim()}%";
|
|
baseQuery = baseQuery.Where(b => EF.Functions.ILike(b.Name, nameLike));
|
|
}
|
|
|
|
if (filter.Status.HasValue)
|
|
{
|
|
baseQuery = baseQuery.Where(b => b.Status == filter.Status.Value);
|
|
}
|
|
|
|
if (filter.UserId.HasValue)
|
|
{
|
|
baseQuery = baseQuery.Where(b => b.UserId == filter.UserId.Value);
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(filter.UserNameContains))
|
|
{
|
|
var userNameLike = $"%{filter.UserNameContains.Trim()}%";
|
|
baseQuery = baseQuery.Where(b => b.User != null && EF.Functions.ILike(b.User.Name, userNameLike));
|
|
}
|
|
|
|
if (filter.TotalBacktestsMin.HasValue)
|
|
{
|
|
baseQuery = baseQuery.Where(b => b.TotalBacktests >= filter.TotalBacktestsMin.Value);
|
|
}
|
|
|
|
if (filter.TotalBacktestsMax.HasValue)
|
|
{
|
|
baseQuery = baseQuery.Where(b => b.TotalBacktests <= filter.TotalBacktestsMax.Value);
|
|
}
|
|
|
|
if (filter.CompletedBacktestsMin.HasValue)
|
|
{
|
|
baseQuery = baseQuery.Where(b => b.CompletedBacktests >= filter.CompletedBacktestsMin.Value);
|
|
}
|
|
|
|
if (filter.CompletedBacktestsMax.HasValue)
|
|
{
|
|
baseQuery = baseQuery.Where(b => b.CompletedBacktests <= filter.CompletedBacktestsMax.Value);
|
|
}
|
|
|
|
if (filter.ProgressPercentageMin.HasValue)
|
|
{
|
|
var minProgress = filter.ProgressPercentageMin.Value;
|
|
baseQuery = baseQuery.Where(b => b.TotalBacktests > 0 &&
|
|
(double)b.CompletedBacktests / b.TotalBacktests * 100 >= minProgress);
|
|
}
|
|
|
|
if (filter.ProgressPercentageMax.HasValue)
|
|
{
|
|
var maxProgress = filter.ProgressPercentageMax.Value;
|
|
baseQuery = baseQuery.Where(b => b.TotalBacktests > 0 &&
|
|
(double)b.CompletedBacktests / b.TotalBacktests * 100 <= maxProgress);
|
|
}
|
|
|
|
if (filter.CreatedAtFrom.HasValue)
|
|
{
|
|
baseQuery = baseQuery.Where(b => b.CreatedAt >= filter.CreatedAtFrom.Value);
|
|
}
|
|
|
|
if (filter.CreatedAtTo.HasValue)
|
|
{
|
|
baseQuery = baseQuery.Where(b => b.CreatedAt <= filter.CreatedAtTo.Value);
|
|
}
|
|
}
|
|
|
|
var totalCount = baseQuery.Count();
|
|
|
|
// Apply sorting
|
|
IQueryable<BundleBacktestRequestEntity> sortedQuery = sortBy switch
|
|
{
|
|
BundleBacktestRequestSortableColumn.RequestId => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.RequestId)
|
|
: baseQuery.OrderBy(b => b.RequestId),
|
|
BundleBacktestRequestSortableColumn.Name => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.Name)
|
|
: baseQuery.OrderBy(b => b.Name),
|
|
BundleBacktestRequestSortableColumn.Status => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.Status)
|
|
: baseQuery.OrderBy(b => b.Status),
|
|
BundleBacktestRequestSortableColumn.CreatedAt => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.CreatedAt)
|
|
: baseQuery.OrderBy(b => b.CreatedAt),
|
|
BundleBacktestRequestSortableColumn.CompletedAt => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.CompletedAt ?? DateTime.MinValue)
|
|
: baseQuery.OrderBy(b => b.CompletedAt ?? DateTime.MaxValue),
|
|
BundleBacktestRequestSortableColumn.TotalBacktests => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.TotalBacktests)
|
|
: baseQuery.OrderBy(b => b.TotalBacktests),
|
|
BundleBacktestRequestSortableColumn.CompletedBacktests => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.CompletedBacktests)
|
|
: baseQuery.OrderBy(b => b.CompletedBacktests),
|
|
BundleBacktestRequestSortableColumn.FailedBacktests => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.FailedBacktests)
|
|
: baseQuery.OrderBy(b => b.FailedBacktests),
|
|
BundleBacktestRequestSortableColumn.ProgressPercentage => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.TotalBacktests > 0 ? (double)b.CompletedBacktests / b.TotalBacktests : 0)
|
|
: baseQuery.OrderBy(b => b.TotalBacktests > 0 ? (double)b.CompletedBacktests / b.TotalBacktests : 0),
|
|
BundleBacktestRequestSortableColumn.UserId => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.UserId ?? int.MaxValue)
|
|
: baseQuery.OrderBy(b => b.UserId ?? int.MinValue),
|
|
BundleBacktestRequestSortableColumn.UserName => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.User != null ? b.User.Name : string.Empty)
|
|
: baseQuery.OrderBy(b => b.User != null ? b.User.Name : string.Empty),
|
|
BundleBacktestRequestSortableColumn.UpdatedAt => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.UpdatedAt)
|
|
: baseQuery.OrderBy(b => b.UpdatedAt),
|
|
_ => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.CreatedAt)
|
|
: baseQuery.OrderBy(b => b.CreatedAt)
|
|
};
|
|
|
|
var entities = sortedQuery
|
|
.Skip((page - 1) * pageSize)
|
|
.Take(pageSize)
|
|
.ToList();
|
|
|
|
var mappedRequests = entities.Select(PostgreSqlMappers.Map);
|
|
|
|
return (mappedRequests, totalCount);
|
|
}
|
|
|
|
public async Task<(IEnumerable<BundleBacktestRequest> BundleRequests, int TotalCount)> GetBundleBacktestRequestsPaginatedAsync(
|
|
int page,
|
|
int pageSize,
|
|
BundleBacktestRequestSortableColumn sortBy = BundleBacktestRequestSortableColumn.CreatedAt,
|
|
string sortOrder = "desc",
|
|
BundleBacktestRequestsFilter? filter = null)
|
|
{
|
|
var baseQuery = _context.BundleBacktestRequests
|
|
.AsNoTracking()
|
|
.Include(b => b.User)
|
|
.AsQueryable();
|
|
|
|
// Apply filters
|
|
if (filter != null)
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(filter.NameContains))
|
|
{
|
|
var nameLike = $"%{filter.NameContains.Trim()}%";
|
|
baseQuery = baseQuery.Where(b => EF.Functions.ILike(b.Name, nameLike));
|
|
}
|
|
|
|
if (filter.Status.HasValue)
|
|
{
|
|
baseQuery = baseQuery.Where(b => b.Status == filter.Status.Value);
|
|
}
|
|
|
|
if (filter.UserId.HasValue)
|
|
{
|
|
baseQuery = baseQuery.Where(b => b.UserId == filter.UserId.Value);
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(filter.UserNameContains))
|
|
{
|
|
var userNameLike = $"%{filter.UserNameContains.Trim()}%";
|
|
baseQuery = baseQuery.Where(b => b.User != null && EF.Functions.ILike(b.User.Name, userNameLike));
|
|
}
|
|
|
|
if (filter.TotalBacktestsMin.HasValue)
|
|
{
|
|
baseQuery = baseQuery.Where(b => b.TotalBacktests >= filter.TotalBacktestsMin.Value);
|
|
}
|
|
|
|
if (filter.TotalBacktestsMax.HasValue)
|
|
{
|
|
baseQuery = baseQuery.Where(b => b.TotalBacktests <= filter.TotalBacktestsMax.Value);
|
|
}
|
|
|
|
if (filter.CompletedBacktestsMin.HasValue)
|
|
{
|
|
baseQuery = baseQuery.Where(b => b.CompletedBacktests >= filter.CompletedBacktestsMin.Value);
|
|
}
|
|
|
|
if (filter.CompletedBacktestsMax.HasValue)
|
|
{
|
|
baseQuery = baseQuery.Where(b => b.CompletedBacktests <= filter.CompletedBacktestsMax.Value);
|
|
}
|
|
|
|
if (filter.ProgressPercentageMin.HasValue)
|
|
{
|
|
var minProgress = filter.ProgressPercentageMin.Value;
|
|
baseQuery = baseQuery.Where(b => b.TotalBacktests > 0 &&
|
|
(double)b.CompletedBacktests / b.TotalBacktests * 100 >= minProgress);
|
|
}
|
|
|
|
if (filter.ProgressPercentageMax.HasValue)
|
|
{
|
|
var maxProgress = filter.ProgressPercentageMax.Value;
|
|
baseQuery = baseQuery.Where(b => b.TotalBacktests > 0 &&
|
|
(double)b.CompletedBacktests / b.TotalBacktests * 100 <= maxProgress);
|
|
}
|
|
|
|
if (filter.CreatedAtFrom.HasValue)
|
|
{
|
|
baseQuery = baseQuery.Where(b => b.CreatedAt >= filter.CreatedAtFrom.Value);
|
|
}
|
|
|
|
if (filter.CreatedAtTo.HasValue)
|
|
{
|
|
baseQuery = baseQuery.Where(b => b.CreatedAt <= filter.CreatedAtTo.Value);
|
|
}
|
|
}
|
|
|
|
var totalCount = await baseQuery.CountAsync().ConfigureAwait(false);
|
|
|
|
// Apply sorting
|
|
IQueryable<BundleBacktestRequestEntity> sortedQuery = sortBy switch
|
|
{
|
|
BundleBacktestRequestSortableColumn.RequestId => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.RequestId)
|
|
: baseQuery.OrderBy(b => b.RequestId),
|
|
BundleBacktestRequestSortableColumn.Name => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.Name)
|
|
: baseQuery.OrderBy(b => b.Name),
|
|
BundleBacktestRequestSortableColumn.Status => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.Status)
|
|
: baseQuery.OrderBy(b => b.Status),
|
|
BundleBacktestRequestSortableColumn.CreatedAt => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.CreatedAt)
|
|
: baseQuery.OrderBy(b => b.CreatedAt),
|
|
BundleBacktestRequestSortableColumn.CompletedAt => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.CompletedAt ?? DateTime.MinValue)
|
|
: baseQuery.OrderBy(b => b.CompletedAt ?? DateTime.MaxValue),
|
|
BundleBacktestRequestSortableColumn.TotalBacktests => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.TotalBacktests)
|
|
: baseQuery.OrderBy(b => b.TotalBacktests),
|
|
BundleBacktestRequestSortableColumn.CompletedBacktests => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.CompletedBacktests)
|
|
: baseQuery.OrderBy(b => b.CompletedBacktests),
|
|
BundleBacktestRequestSortableColumn.FailedBacktests => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.FailedBacktests)
|
|
: baseQuery.OrderBy(b => b.FailedBacktests),
|
|
BundleBacktestRequestSortableColumn.ProgressPercentage => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.TotalBacktests > 0 ? (double)b.CompletedBacktests / b.TotalBacktests : 0)
|
|
: baseQuery.OrderBy(b => b.TotalBacktests > 0 ? (double)b.CompletedBacktests / b.TotalBacktests : 0),
|
|
BundleBacktestRequestSortableColumn.UserId => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.UserId ?? int.MaxValue)
|
|
: baseQuery.OrderBy(b => b.UserId ?? int.MinValue),
|
|
BundleBacktestRequestSortableColumn.UserName => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.User != null ? b.User.Name : string.Empty)
|
|
: baseQuery.OrderBy(b => b.User != null ? b.User.Name : string.Empty),
|
|
BundleBacktestRequestSortableColumn.UpdatedAt => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.UpdatedAt)
|
|
: baseQuery.OrderBy(b => b.UpdatedAt),
|
|
_ => sortOrder == "desc"
|
|
? baseQuery.OrderByDescending(b => b.CreatedAt)
|
|
: baseQuery.OrderBy(b => b.CreatedAt)
|
|
};
|
|
|
|
var entities = await sortedQuery
|
|
.Skip((page - 1) * pageSize)
|
|
.Take(pageSize)
|
|
.ToListAsync()
|
|
.ConfigureAwait(false);
|
|
|
|
var mappedRequests = entities.Select(PostgreSqlMappers.Map);
|
|
|
|
return (mappedRequests, totalCount);
|
|
}
|
|
|
|
public async Task<BundleBacktestRequestSummary> GetBundleBacktestRequestsSummaryAsync()
|
|
{
|
|
// Use ADO.NET directly for aggregation queries to avoid EF Core mapping issues
|
|
var connection = _context.Database.GetDbConnection();
|
|
await connection.OpenAsync();
|
|
|
|
try
|
|
{
|
|
var statusCounts = new List<BundleBacktestRequestStatusCountResult>();
|
|
var totalRequests = 0;
|
|
|
|
// Query 1: Status summary
|
|
// Note: Status is stored as text in PostgreSQL, not as integer
|
|
var statusSummarySql = @"
|
|
SELECT ""Status"", COUNT(*) as Count
|
|
FROM ""BundleBacktestRequests""
|
|
GROUP BY ""Status""
|
|
ORDER BY ""Status""";
|
|
|
|
using (var command = connection.CreateCommand())
|
|
{
|
|
command.CommandText = statusSummarySql;
|
|
using (var reader = await command.ExecuteReaderAsync())
|
|
{
|
|
while (await reader.ReadAsync())
|
|
{
|
|
var statusString = reader.GetString(0);
|
|
var count = reader.GetInt32(1);
|
|
|
|
// Parse the string status to enum
|
|
if (Enum.TryParse<BundleBacktestRequestStatus>(statusString, ignoreCase: true, out var status))
|
|
{
|
|
statusCounts.Add(new BundleBacktestRequestStatusCountResult
|
|
{
|
|
Status = status,
|
|
Count = count
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Query 2: Total count
|
|
var totalCountSql = @"
|
|
SELECT COUNT(*) as Count
|
|
FROM ""BundleBacktestRequests""";
|
|
|
|
using (var command = connection.CreateCommand())
|
|
{
|
|
command.CommandText = totalCountSql;
|
|
var result = await command.ExecuteScalarAsync();
|
|
totalRequests = result != null ? Convert.ToInt32(result) : 0;
|
|
}
|
|
|
|
return new BundleBacktestRequestSummary
|
|
{
|
|
StatusCounts = statusCounts.Select(s => new BundleBacktestRequestStatusCount
|
|
{
|
|
Status = s.Status,
|
|
Count = s.Count
|
|
}).ToList(),
|
|
TotalRequests = totalRequests
|
|
};
|
|
}
|
|
finally
|
|
{
|
|
await connection.CloseAsync();
|
|
}
|
|
}
|
|
|
|
private class BundleBacktestRequestStatusCountResult
|
|
{
|
|
public BundleBacktestRequestStatus Status { get; set; }
|
|
public int Count { get; set; }
|
|
}
|
|
} |