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

Rename strategy to indicators

Browse Source
This commit is contained in:
cryptooda
2025-06-16 22:09:23 +07:00
parent e4f4d078b2
commit 0f7df04813
45 changed files with 477 additions and 474 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
src/Managing.Domain/Backtests/Backtest.cs
View File

@@ -24,7 +24,7 @@ public class Backtest
Signals = signals;
Candles = candles;
WalletBalances = new List<KeyValuePair<DateTime, decimal>>();
StrategiesValues = new Dictionary<StrategyType, StrategiesResultBase>();
StrategiesValues = new Dictionary<IndicatorType, IndicatorsResultBase>();
// Initialize start and end dates if candles are provided
if (candles != null && candles.Count > 0)
@@ -55,7 +55,7 @@ public class Backtest
[Required] public List<KeyValuePair<DateTime, decimal>> WalletBalances { get; set; }
[Required] public MoneyManagement OptimizedMoneyManagement { get; set; }
[Required] public User User { get; set; }
[Required] public Dictionary<StrategyType, StrategiesResultBase> StrategiesValues { get; set; }
[Required] public Dictionary<IndicatorType, IndicatorsResultBase> StrategiesValues { get; set; }
[Required] public double Score { get; set; }
/// <summary>
@@ -130,12 +130,12 @@ public class Backtest
public string GetStringReport()
{
var timeBasedInfo = Config.MaxPositionTimeHours.HasValue
? $" | MaxTime: {Config.MaxPositionTimeHours}h"
var timeBasedInfo = Config.MaxPositionTimeHours.HasValue
? $" | MaxTime: {Config.MaxPositionTimeHours}h"
: " | MaxTime: Disabled";
var flipInfo = Config.FlipPosition
? $" | Flip: {(Config.FlipOnlyWhenInProfit ? "Profit-Only" : "Always")}"
var flipInfo = Config.FlipPosition
? $" | Flip: {(Config.FlipOnlyWhenInProfit ? "Profit-Only" : "Always")}"
: "";
return

8
src/Managing.Domain/Scenarios/Scenario.cs
View File

@@ -8,18 +8,18 @@ namespace Managing.Domain.Scenarios
public Scenario(string name, int? loopbackPeriod = 1)
{
Name = name;
Strategies = new List<Strategy>();
Indicators = new List<Indicator>();
LoopbackPeriod = loopbackPeriod;
}
public string Name { get; set; }
public List<Strategy> Strategies { get; set; }
public List<Indicator> Indicators { get; set; }
public int? LoopbackPeriod { get; set; }
public User User { get; set; }
public void AddStrategy(Strategy strategy)
public void AddIndicator(Indicator indicator)
{
Strategies.Add(strategy);
Indicators.Add(indicator);
}
}
}

174
src/Managing.Domain/Scenarios/ScenarioHelpers.cs
View File

@@ -10,48 +10,48 @@ namespace Managing.Domain.Scenarios;
public static class ScenarioHelpers
{
public static IEnumerable<IStrategy> GetStrategiesFromScenario(Scenario scenario)
public static IEnumerable<IIndicator> GetIndicatorsFromScenario(Scenario scenario)
{
var strategies = new List<IStrategy>();
foreach (var strategy in scenario.Strategies)
var strategies = new List<IIndicator>();
foreach (var strategy in scenario.Indicators)
{
var result = BuildStrategy(strategy);
var result = BuildIndicator(strategy);
strategies.Add(result);
}
return strategies;
}
public static IStrategy BuildStrategy(Strategy strategy, int size = 600)
public static IIndicator BuildIndicator(Indicator indicator, int size = 600)
{
IStrategy result = strategy.Type switch
IIndicator result = indicator.Type switch
{
StrategyType.StDev => new StDevContext(strategy.Name, strategy.Period.Value),
StrategyType.RsiDivergence => new RsiDivergenceStrategy(strategy.Name,
strategy.Period.Value),
StrategyType.RsiDivergenceConfirm => new RsiDivergenceConfirmStrategy(strategy.Name,
strategy.Period.Value),
StrategyType.MacdCross => new MacdCrossStrategy(strategy.Name,
strategy.FastPeriods.Value, strategy.SlowPeriods.Value, strategy.SignalPeriods.Value),
StrategyType.EmaCross => new EmaCrossStrategy(strategy.Name, strategy.Period.Value),
StrategyType.DualEmaCross => new DualEmaCrossStrategy(strategy.Name,
strategy.FastPeriods.Value, strategy.SlowPeriods.Value),
StrategyType.ThreeWhiteSoldiers => new ThreeWhiteSoldiersStrategy(strategy.Name,
strategy.Period.Value),
StrategyType.SuperTrend => new SuperTrendStrategy(strategy.Name,
strategy.Period.Value, strategy.Multiplier.Value),
StrategyType.ChandelierExit => new ChandelierExitStrategy(strategy.Name,
strategy.Period.Value, strategy.Multiplier.Value),
StrategyType.EmaTrend => new EmaTrendStrategy(strategy.Name, strategy.Period.Value),
StrategyType.StochRsiTrend => new StochRsiTrendStrategy(strategy.Name,
strategy.Period.Value, strategy.StochPeriods.Value, strategy.SignalPeriods.Value,
strategy.SmoothPeriods.Value),
StrategyType.Stc => new StcStrategy(strategy.Name, strategy.CyclePeriods.Value,
strategy.FastPeriods.Value, strategy.SlowPeriods.Value),
StrategyType.LaggingStc => new LaggingSTC(strategy.Name, strategy.CyclePeriods.Value,
strategy.FastPeriods.Value, strategy.SlowPeriods.Value),
StrategyType.SuperTrendCrossEma => new SuperTrendCrossEma(strategy.Name,
strategy.Period.Value, strategy.Multiplier.Value),
IndicatorType.StDev => new StDevContext(indicator.Name, indicator.Period.Value),
IndicatorType.RsiDivergence => new RsiDivergenceIndicator(indicator.Name,
indicator.Period.Value),
IndicatorType.RsiDivergenceConfirm => new RsiDivergenceConfirmIndicator(indicator.Name,
indicator.Period.Value),
IndicatorType.MacdCross => new MacdCrossIndicator(indicator.Name,
indicator.FastPeriods.Value, indicator.SlowPeriods.Value, indicator.SignalPeriods.Value),
IndicatorType.EmaCross => new EmaCrossIndicator(indicator.Name, indicator.Period.Value),
IndicatorType.DualEmaCross => new DualEmaCrossIndicator(indicator.Name,
indicator.FastPeriods.Value, indicator.SlowPeriods.Value),
IndicatorType.ThreeWhiteSoldiers => new ThreeWhiteSoldiersIndicator(indicator.Name,
indicator.Period.Value),
IndicatorType.SuperTrend => new SuperTrendIndicator(indicator.Name,
indicator.Period.Value, indicator.Multiplier.Value),
IndicatorType.ChandelierExit => new ChandelierExitIndicator(indicator.Name,
indicator.Period.Value, indicator.Multiplier.Value),
IndicatorType.EmaTrend => new EmaTrendIndicator(indicator.Name, indicator.Period.Value),
IndicatorType.StochRsiTrend => new StochRsiTrendIndicator(indicator.Name,
indicator.Period.Value, indicator.StochPeriods.Value, indicator.SignalPeriods.Value,
indicator.SmoothPeriods.Value),
IndicatorType.Stc => new StcIndicator(indicator.Name, indicator.CyclePeriods.Value,
indicator.FastPeriods.Value, indicator.SlowPeriods.Value),
IndicatorType.LaggingStc => new LaggingSTC(indicator.Name, indicator.CyclePeriods.Value,
indicator.FastPeriods.Value, indicator.SlowPeriods.Value),
IndicatorType.SuperTrendCrossEma => new SuperTrendCrossEma(indicator.Name,
indicator.Period.Value, indicator.Multiplier.Value),
_ => throw new NotImplementedException(),
};
@@ -59,8 +59,8 @@ public static class ScenarioHelpers
return result;
}
public static Strategy BuildStrategy(
StrategyType type,
public static Indicator BuildIndicator(
IndicatorType type,
string name,
int? period = null,
int? fastPeriods = null,
@@ -71,98 +71,98 @@ public static class ScenarioHelpers
int? smoothPeriods = null,
int? cyclePeriods = null)
{
var strategy = new Strategy(name, type);
var indicator = new Indicator(name, type);
switch (type)
{
case StrategyType.RsiDivergence:
case StrategyType.RsiDivergenceConfirm:
case StrategyType.EmaTrend:
case StrategyType.EmaCross:
case StrategyType.StDev:
case IndicatorType.RsiDivergence:
case IndicatorType.RsiDivergenceConfirm:
case IndicatorType.EmaTrend:
case IndicatorType.EmaCross:
case IndicatorType.StDev:
if (!period.HasValue)
{
throw new Exception($"Missing period for {strategy.Type} strategy type");
throw new Exception($"Missing period for {indicator.Type} strategy type");
}
else
{
strategy.Period = period.Value;
indicator.Period = period.Value;
}
break;
case StrategyType.MacdCross:
case IndicatorType.MacdCross:
if (!fastPeriods.HasValue || !slowPeriods.HasValue || !signalPeriods.HasValue)
{
throw new Exception(
$"Missing fastPeriods or slowPeriods or signalPeriods, for {strategy.Type} strategy type");
$"Missing fastPeriods or slowPeriods or signalPeriods, for {indicator.Type} strategy type");
}
else
{
strategy.FastPeriods = fastPeriods;
strategy.SlowPeriods = slowPeriods;
strategy.SignalPeriods = signalPeriods;
indicator.FastPeriods = fastPeriods;
indicator.SlowPeriods = slowPeriods;
indicator.SignalPeriods = signalPeriods;
}
break;
case StrategyType.DualEmaCross:
case IndicatorType.DualEmaCross:
if (!fastPeriods.HasValue || !slowPeriods.HasValue)
{
throw new Exception(
$"Missing fastPeriods or slowPeriods for {strategy.Type} strategy type");
$"Missing fastPeriods or slowPeriods for {indicator.Type} strategy type");
}
else
{
strategy.FastPeriods = fastPeriods;
strategy.SlowPeriods = slowPeriods;
indicator.FastPeriods = fastPeriods;
indicator.SlowPeriods = slowPeriods;
}
break;
case StrategyType.ThreeWhiteSoldiers:
case IndicatorType.ThreeWhiteSoldiers:
break;
case StrategyType.SuperTrend:
case StrategyType.SuperTrendCrossEma:
case StrategyType.ChandelierExit:
case IndicatorType.SuperTrend:
case IndicatorType.SuperTrendCrossEma:
case IndicatorType.ChandelierExit:
if (!period.HasValue || !multiplier.HasValue)
{
throw new Exception($"Missing period or multiplier, for {strategy.Type} strategy type");
throw new Exception($"Missing period or multiplier, for {indicator.Type} strategy type");
}
else
{
strategy.Period = period;
strategy.Multiplier = multiplier;
indicator.Period = period;
indicator.Multiplier = multiplier;
}
break;
case StrategyType.StochRsiTrend:
case IndicatorType.StochRsiTrend:
if (!period.HasValue
|| !stochPeriods.HasValue
|| !signalPeriods.HasValue
|| !smoothPeriods.HasValue)
{
throw new Exception(
$"Missing period, stochPeriods, signalPeriods, smoothPeriods for {strategy.Type} strategy type");
$"Missing period, stochPeriods, signalPeriods, smoothPeriods for {indicator.Type} strategy type");
}
else
{
strategy.Period = period;
strategy.StochPeriods = stochPeriods;
strategy.SignalPeriods = signalPeriods;
strategy.SmoothPeriods = smoothPeriods;
indicator.Period = period;
indicator.StochPeriods = stochPeriods;
indicator.SignalPeriods = signalPeriods;
indicator.SmoothPeriods = smoothPeriods;
}
break;
case StrategyType.Stc:
case StrategyType.LaggingStc:
case IndicatorType.Stc:
case IndicatorType.LaggingStc:
if (!fastPeriods.HasValue || !slowPeriods.HasValue || !cyclePeriods.HasValue)
{
throw new Exception(
$"Missing fastPeriods or slowPeriods or cyclePeriods, for {strategy.Type} strategy type");
$"Missing fastPeriods or slowPeriods or cyclePeriods, for {indicator.Type} strategy type");
}
else
{
strategy.FastPeriods = fastPeriods;
strategy.SlowPeriods = slowPeriods;
strategy.CyclePeriods = cyclePeriods;
indicator.FastPeriods = fastPeriods;
indicator.SlowPeriods = slowPeriods;
indicator.CyclePeriods = cyclePeriods;
}
break;
@@ -170,28 +170,28 @@ public static class ScenarioHelpers
break;
}
return strategy;
return indicator;
}
public static SignalType GetSignalType(StrategyType type)
public static SignalType GetSignalType(IndicatorType type)
{
return type switch
{
StrategyType.RsiDivergence => SignalType.Signal,
StrategyType.RsiDivergenceConfirm => SignalType.Signal,
StrategyType.MacdCross => SignalType.Signal,
StrategyType.EmaCross => SignalType.Signal,
StrategyType.DualEmaCross => SignalType.Signal,
StrategyType.ThreeWhiteSoldiers => SignalType.Signal,
StrategyType.SuperTrend => SignalType.Signal,
StrategyType.ChandelierExit => SignalType.Signal,
StrategyType.EmaTrend => SignalType.Trend,
StrategyType.Composite => SignalType.Signal,
StrategyType.StochRsiTrend => SignalType.Trend,
StrategyType.Stc => SignalType.Signal,
StrategyType.StDev => SignalType.Context,
StrategyType.LaggingStc => SignalType.Signal,
StrategyType.SuperTrendCrossEma => SignalType.Signal,
IndicatorType.RsiDivergence => SignalType.Signal,
IndicatorType.RsiDivergenceConfirm => SignalType.Signal,
IndicatorType.MacdCross => SignalType.Signal,
IndicatorType.EmaCross => SignalType.Signal,
IndicatorType.DualEmaCross => SignalType.Signal,
IndicatorType.ThreeWhiteSoldiers => SignalType.Signal,
IndicatorType.SuperTrend => SignalType.Signal,
IndicatorType.ChandelierExit => SignalType.Signal,
IndicatorType.EmaTrend => SignalType.Trend,
IndicatorType.Composite => SignalType.Signal,
IndicatorType.StochRsiTrend => SignalType.Trend,
IndicatorType.Stc => SignalType.Signal,
IndicatorType.StDev => SignalType.Context,
IndicatorType.LaggingStc => SignalType.Signal,
IndicatorType.SuperTrendCrossEma => SignalType.Signal,
_ => throw new NotImplementedException(),
};
}

28
src/Managing.Domain/Shared/Helpers/TradingBox.cs
View File

@@ -10,7 +10,7 @@ namespace Managing.Domain.Shared.Helpers;
/// <summary>
/// Configuration for strategy combination logic
/// </summary>
public class StrategyComboConfig
public class IndicatorComboConfig
{
/// <summary>
/// Minimum percentage of trend strategies that must agree for strong trend (default: 66%)
@@ -47,16 +47,16 @@ public class StrategyComboConfig
public static class TradingBox
{
private static readonly StrategyComboConfig _defaultConfig = new();
private static readonly IndicatorComboConfig _defaultConfig = new();
public static Signal GetSignal(HashSet<Candle> newCandles, HashSet<IStrategy> strategies,
public static Signal GetSignal(HashSet<Candle> newCandles, HashSet<IIndicator> strategies,
HashSet<Signal> previousSignal, int? loopbackPeriod = 1)
{
return GetSignal(newCandles, strategies, previousSignal, _defaultConfig, loopbackPeriod);
}
public static Signal GetSignal(HashSet<Candle> newCandles, HashSet<IStrategy> strategies,
HashSet<Signal> previousSignal, StrategyComboConfig config, int? loopbackPeriod = 1)
public static Signal GetSignal(HashSet<Candle> newCandles, HashSet<IIndicator> strategies,
HashSet<Signal> previousSignal, IndicatorComboConfig config, int? loopbackPeriod = 1)
{
var signalOnCandles = new HashSet<Signal>();
var limitedCandles = newCandles.ToList().TakeLast(600).ToList();
@@ -120,14 +120,14 @@ public static class TradingBox
data.Timeframe, config);
}
public static Signal ComputeSignals(HashSet<IStrategy> strategies, HashSet<Signal> signalOnCandles, Ticker ticker,
public static Signal ComputeSignals(HashSet<IIndicator> strategies, HashSet<Signal> signalOnCandles, Ticker ticker,
Timeframe timeframe)
{
return ComputeSignals(strategies, signalOnCandles, ticker, timeframe, _defaultConfig);
}
public static Signal ComputeSignals(HashSet<IStrategy> strategies, HashSet<Signal> signalOnCandles, Ticker ticker,
Timeframe timeframe, StrategyComboConfig config)
public static Signal ComputeSignals(HashSet<IIndicator> strategies, HashSet<Signal> signalOnCandles, Ticker ticker,
Timeframe timeframe, IndicatorComboConfig config)
{
if (strategies.Count == 1)
{
@@ -179,15 +179,15 @@ public static class TradingBox
lastSignal?.Candle,
lastSignal?.Date ?? DateTime.UtcNow,
lastSignal?.Exchange ?? config.DefaultExchange,
StrategyType.Composite,
IndicatorType.Composite,
SignalType.Signal);
}
/// <summary>
/// Validates context strategies based on confidence levels indicating market condition quality
/// </summary>
private static bool ValidateContextStrategies(HashSet<IStrategy> allStrategies, List<Signal> contextSignals,
StrategyComboConfig config)
private static bool ValidateContextStrategies(HashSet<IIndicator> allStrategies, List<Signal> contextSignals,
IndicatorComboConfig config)
{
var contextStrategiesCount = allStrategies.Count(s => s.SignalType == SignalType.Context);
@@ -210,7 +210,7 @@ public static class TradingBox
/// <summary>
/// Evaluates trend direction using majority voting with neutral handling
/// </summary>
private static TradeDirection EvaluateTrendDirection(List<Signal> trendSignals, StrategyComboConfig config)
private static TradeDirection EvaluateTrendDirection(List<Signal> trendSignals, IndicatorComboConfig config)
{
if (!trendSignals.Any())
{
@@ -241,7 +241,7 @@ public static class TradingBox
/// <summary>
/// Evaluates signal direction using weighted majority voting
/// </summary>
private static TradeDirection EvaluateSignalDirection(List<Signal> signalStrategies, StrategyComboConfig config)
private static TradeDirection EvaluateSignalDirection(List<Signal> signalStrategies, IndicatorComboConfig config)
{
if (!signalStrategies.Any())
{
@@ -270,7 +270,7 @@ public static class TradingBox
TradeDirection trendDirection,
List<Signal> signalStrategies,
List<Signal> trendStrategies,
StrategyComboConfig config)
IndicatorComboConfig config)
{
// Priority 1: If we have signal strategies, they take precedence
if (signalDirection != TradeDirection.None)

4
src/Managing.Domain/Strategies/Base/EmaBaseStrategy.cs → src/Managing.Domain/Strategies/Base/EmaBaseIndicator.cs
View File

@@ -4,9 +4,9 @@ using Skender.Stock.Indicators;
namespace Managing.Domain.Strategies.Base;
public abstract class EmaBaseStrategy : Strategy
public abstract class EmaBaseIndicator : Indicator
{
protected EmaBaseStrategy(string name, Enums.StrategyType type) : base(name, type)
protected EmaBaseIndicator(string name, Enums.IndicatorType type) : base(name, type)
{
}

2
src/Managing.Domain/Strategies/Base/StrategiesResultBase.cs → src/Managing.Domain/Strategies/Base/IndicatorsResultBase.cs
View File

@@ -2,7 +2,7 @@ using Skender.Stock.Indicators;
namespace Managing.Domain.Strategies.Base;
public class StrategiesResultBase
public class IndicatorsResultBase
{
public List<EmaResult> Ema { get; set; }
public List<EmaResult> FastEma { get; set; }

8
src/Managing.Domain/Strategies/Context/StDevContext.cs
View File

@@ -7,11 +7,11 @@ using static Managing.Common.Enums;
namespace Managing.Domain.Strategies.Context;
public class StDevContext : Strategy
public class StDevContext : Indicator
{
public List<Signal> Signals { get; set; }
public StDevContext(string name, int period) : base(name, StrategyType.StDev)
public StDevContext(string name, int period) : base(name, IndicatorType.StDev)
{
Signals = new List<Signal>();
Period = period;
@@ -73,9 +73,9 @@ public class StDevContext : Strategy
}
}
public override StrategiesResultBase GetStrategyValues()
public override IndicatorsResultBase GetStrategyValues()
{
var test = new StrategiesResultBase()
var test = new IndicatorsResultBase()
{
StdDev = Candles.GetStdDev(Period.Value).ToList()
};

6
src/Managing.Domain/Strategies/IStrategy.cs → src/Managing.Domain/Strategies/IIndicator.cs
View File

@@ -5,10 +5,10 @@ using static Managing.Common.Enums;
namespace Managing.Domain.Strategies
{
public interface IStrategy
public interface IIndicator
{
string Name { get; set; }
StrategyType Type { get; set; }
IndicatorType Type { get; set; }
SignalType SignalType { get; set; }
int? Period { get; set; }
int? FastPeriods { get; set; }
@@ -17,7 +17,7 @@ namespace Managing.Domain.Strategies
FixedSizeQueue<Candle> Candles { get; set; }
List<Signal> Run();
StrategiesResultBase GetStrategyValues();
IndicatorsResultBase GetStrategyValues();
void UpdateCandles(HashSet<Candle> newCandles);
string GetName();
}

10
src/Managing.Domain/Strategies/Strategy.cs → src/Managing.Domain/Strategies/Indicator.cs
View File

@@ -8,9 +8,9 @@ using static Managing.Common.Enums;
namespace Managing.Domain.Strategies
{
public class Strategy : IStrategy
public class Indicator : IIndicator
{
public Strategy(string name, StrategyType type)
public Indicator(string name, IndicatorType type)
{
Name = name;
Type = type;
@@ -20,7 +20,7 @@ namespace Managing.Domain.Strategies
public string Name { get; set; }
[JsonIgnore] public FixedSizeQueue<Candle> Candles { get; set; }
public StrategyType Type { get; set; }
public IndicatorType Type { get; set; }
public SignalType SignalType { get; set; }
public int MinimumHistory { get; set; }
public int? Period { get; set; }
@@ -38,9 +38,9 @@ namespace Managing.Domain.Strategies
return new List<Signal>();
}
public virtual StrategiesResultBase GetStrategyValues()
public virtual IndicatorsResultBase GetStrategyValues()
{
return new StrategiesResultBase();
return new IndicatorsResultBase();
}
public void UpdateCandles(HashSet<Candle> newCandles)

9
src/Managing.Domain/Strategies/Signal.cs
View File

@@ -18,12 +18,12 @@ namespace Managing.Domain.Strategies
[Required] public string Identifier { get; }
[Required] public Ticker Ticker { get; }
[Required] public TradingExchanges Exchange { get; set; }
[Required] public StrategyType StrategyType { get; set; }
[Required] public IndicatorType IndicatorType { get; set; }
[Required] public SignalType SignalType { get; set; }
public User User { get; set; }
public Signal(Ticker ticker, TradeDirection direction, Confidence confidence, Candle candle, DateTime date,
TradingExchanges exchange, StrategyType strategyType, SignalType signalType, User user = null)
TradingExchanges exchange, IndicatorType indicatorType, SignalType signalType, User user = null)
{
Direction = direction;
Confidence = confidence;
@@ -32,10 +32,11 @@ namespace Managing.Domain.Strategies
Ticker = ticker;
Exchange = exchange;
Status = SignalStatus.WaitingForPosition;
StrategyType = strategyType;
IndicatorType = indicatorType;
User = user;
Identifier = $"{StrategyType}-{direction}-{ticker}-{candle?.Close.ToString(CultureInfo.InvariantCulture)}-{date:yyyyMMdd-HHmmss}";
Identifier =
$"{IndicatorType}-{direction}-{ticker}-{candle?.Close.ToString(CultureInfo.InvariantCulture)}-{date:yyyyMMdd-HHmmss}";
SignalType = signalType;
}

9
src/Managing.Domain/Strategies/Signals/ChandelierExitStrategy.cs → src/Managing.Domain/Strategies/Signals/ChandelierExitIndicator.cs
View File

@@ -7,11 +7,12 @@ using static Managing.Common.Enums;
namespace Managing.Domain.Strategies.Signals;
public class ChandelierExitStrategy : Strategy
public class ChandelierExitIndicator : Indicator
{
public List<Signal> Signals { get; set; }
public ChandelierExitStrategy(string name, int period, double multiplier) : base(name, StrategyType.ChandelierExit)
public ChandelierExitIndicator(string name, int period, double multiplier) : base(name,
IndicatorType.ChandelierExit)
{
Signals = new List<Signal>();
Period = period;
@@ -39,9 +40,9 @@ public class ChandelierExitStrategy : Strategy
}
}
public override StrategiesResultBase GetStrategyValues()
public override IndicatorsResultBase GetStrategyValues()
{
return new StrategiesResultBase()
return new IndicatorsResultBase()
{
ChandelierLong = Candles.GetChandelier(Period.Value, Multiplier.Value, ChandelierType.Long).ToList(),
ChandelierShort = Candles.GetChandelier(Period.Value, Multiplier.Value, ChandelierType.Short).ToList()

8
src/Managing.Domain/Strategies/Signals/DualEmaCrossStrategy.cs → src/Managing.Domain/Strategies/Signals/DualEmaCrossIndicator.cs
View File

@@ -7,11 +7,11 @@ using static Managing.Common.Enums;
namespace Managing.Domain.Strategies.Signals;
public class DualEmaCrossStrategy : EmaBaseStrategy
public class DualEmaCrossIndicator : EmaBaseIndicator
{
public List<Signal> Signals { get; set; }
public DualEmaCrossStrategy(string name, int fastPeriod, int slowPeriod) : base(name, StrategyType.DualEmaCross)
public DualEmaCrossIndicator(string name, int fastPeriod, int slowPeriod) : base(name, IndicatorType.DualEmaCross)
{
Signals = new List<Signal>();
FastPeriods = fastPeriod;
@@ -19,9 +19,9 @@ public class DualEmaCrossStrategy : EmaBaseStrategy
MinimumHistory = Math.Max(fastPeriod, slowPeriod) * 2;
}
public override StrategiesResultBase GetStrategyValues()
public override IndicatorsResultBase GetStrategyValues()
{
return new StrategiesResultBase()
return new IndicatorsResultBase()
{
FastEma = Candles.GetEma(FastPeriods.Value).ToList(),
SlowEma = Candles.GetEma(SlowPeriods.Value).ToList()

8
src/Managing.Domain/Strategies/Signals/EmaCrossStrategy.cs → src/Managing.Domain/Strategies/Signals/EmaCrossIndicator.cs
View File

@@ -6,19 +6,19 @@ using static Managing.Common.Enums;
namespace Managing.Domain.Strategies.Signals;
public class EmaCrossStrategy : EmaBaseStrategy
public class EmaCrossIndicator : EmaBaseIndicator
{
public List<Signal> Signals { get; set; }
public EmaCrossStrategy(string name, int period) : base(name, StrategyType.EmaCross)
public EmaCrossIndicator(string name, int period) : base(name, IndicatorType.EmaCross)
{
Signals = new List<Signal>();
Period = period;
}
public override StrategiesResultBase GetStrategyValues()
public override IndicatorsResultBase GetStrategyValues()
{
return new StrategiesResultBase()
return new IndicatorsResultBase()
{
Ema = Candles.GetEma(Period.Value).ToList()
};

8
src/Managing.Domain/Strategies/Signals/LaggingSTC.cs
View File

@@ -14,12 +14,12 @@ namespace Managing.Domain.Strategies.Signals;
/// 2. Long signals on STC rebound from oversold (25- → ≥25) with recent compressed volatility (max <11)
/// 3. Avoids look-ahead bias through proper rolling window implementation
/// </summary>
public class LaggingSTC : Strategy
public class LaggingSTC : Indicator
{
public List<Signal> Signals { get; set; }
public LaggingSTC(string name, int cyclePeriods, int fastPeriods, int slowPeriods) : base(name,
StrategyType.LaggingStc)
IndicatorType.LaggingStc)
{
Signals = new List<Signal>();
FastPeriods = fastPeriods;
@@ -89,10 +89,10 @@ public class LaggingSTC : Strategy
}
}
public override StrategiesResultBase GetStrategyValues()
public override IndicatorsResultBase GetStrategyValues()
{
var stc = Candles.GetStc(FastPeriods.Value, FastPeriods.Value, SlowPeriods.Value).ToList();
return new StrategiesResultBase
return new IndicatorsResultBase
{
Stc = stc
};

10
src/Managing.Domain/Strategies/Signals/MACDCrossStrategy.cs → src/Managing.Domain/Strategies/Signals/MacdCrossIndicator.cs
View File

@@ -7,12 +7,12 @@ using static Managing.Common.Enums;
namespace Managing.Domain.Strategies.Signals;
public class MacdCrossStrategy : Strategy
public class MacdCrossIndicator : Indicator
{
public List<Signal> Signals { get; set; }
public MacdCrossStrategy(string name, int fastPeriods, int slowPeriods, int signalPeriods) :
base(name, StrategyType.MacdCross)
public MacdCrossIndicator(string name, int fastPeriods, int slowPeriods, int signalPeriods) :
base(name, IndicatorType.MacdCross)
{
Signals = new List<Signal>();
FastPeriods = fastPeriods;
@@ -59,9 +59,9 @@ public class MacdCrossStrategy : Strategy
}
}
public override StrategiesResultBase GetStrategyValues()
public override IndicatorsResultBase GetStrategyValues()
{
return new StrategiesResultBase()
return new IndicatorsResultBase()
{
Macd = Candles.GetMacd(FastPeriods.Value, SlowPeriods.Value, SignalPeriods.Value).ToList()
};

8
src/Managing.Domain/Strategies/Signals/RSIDivergenceConfirmStrategy.cs → src/Managing.Domain/Strategies/Signals/RsiDivergenceConfirmIndicator.cs
View File

@@ -7,11 +7,11 @@ using Candle = Managing.Domain.Candles.Candle;
namespace Managing.Domain.Strategies.Signals;
public class RsiDivergenceConfirmStrategy : Strategy
public class RsiDivergenceConfirmIndicator : Indicator
{
public List<Signal> Signals { get; set; }
public RsiDivergenceConfirmStrategy(string name, int period) : base(name, StrategyType.RsiDivergenceConfirm)
public RsiDivergenceConfirmIndicator(string name, int period) : base(name, IndicatorType.RsiDivergenceConfirm)
{
Period = period;
Signals = new List<Signal>();
@@ -49,9 +49,9 @@ public class RsiDivergenceConfirmStrategy : Strategy
}
}
public override StrategiesResultBase GetStrategyValues()
public override IndicatorsResultBase GetStrategyValues()
{
return new StrategiesResultBase()
return new IndicatorsResultBase()
{
Rsi = Candles.GetRsi(Period.Value).ToList()
};

8
src/Managing.Domain/Strategies/Signals/RSIDivergenceStrategy.cs → src/Managing.Domain/Strategies/Signals/RsiDivergenceIndicator.cs
View File

@@ -7,14 +7,14 @@ using Candle = Managing.Domain.Candles.Candle;
namespace Managing.Domain.Strategies.Signals;
public class RsiDivergenceStrategy : Strategy
public class RsiDivergenceIndicator : Indicator
{
public List<Signal> Signals { get; set; }
public TradeDirection Direction { get; set; }
private const int UpperBand = 70;
private const int LowerBand = 30;
public RsiDivergenceStrategy(string name, int period) : base(name, StrategyType.RsiDivergence)
public RsiDivergenceIndicator(string name, int period) : base(name, IndicatorType.RsiDivergence)
{
Period = period;
Signals = new List<Signal>();
@@ -52,9 +52,9 @@ public class RsiDivergenceStrategy : Strategy
}
}
public override StrategiesResultBase GetStrategyValues()
public override IndicatorsResultBase GetStrategyValues()
{
return new StrategiesResultBase()
return new IndicatorsResultBase()
{
Rsi = Candles.GetRsi(Period.Value).ToList()
};

8
src/Managing.Domain/Strategies/Signals/STCStrategy.cs → src/Managing.Domain/Strategies/Signals/StcIndicator.cs
View File

@@ -7,11 +7,11 @@ using static Managing.Common.Enums;
namespace Managing.Domain.Strategies.Signals;
public class StcStrategy : Strategy
public class StcIndicator : Indicator
{
public List<Signal> Signals { get; set; }
public StcStrategy(string name, int cyclePeriods, int fastPeriods, int slowPeriods) : base(name, StrategyType.Stc)
public StcIndicator(string name, int cyclePeriods, int fastPeriods, int slowPeriods) : base(name, IndicatorType.Stc)
{
Signals = new List<Signal>();
FastPeriods = fastPeriods;
@@ -64,12 +64,12 @@ public class StcStrategy : Strategy
}
}
public override StrategiesResultBase GetStrategyValues()
public override IndicatorsResultBase GetStrategyValues()
{
if (FastPeriods != null && SlowPeriods != null)
{
var stc = Candles.GetStc(FastPeriods.Value, FastPeriods.Value, SlowPeriods.Value).ToList();
return new StrategiesResultBase
return new IndicatorsResultBase
{
Stc = stc
};

8
src/Managing.Domain/Strategies/Signals/SuperTrendCrossEma.cs
View File

@@ -7,11 +7,11 @@ using static Managing.Common.Enums;
namespace Managing.Domain.Strategies.Signals;
public class SuperTrendCrossEma : Strategy
public class SuperTrendCrossEma : Indicator
{
public List<Signal> Signals { get; set; }
public SuperTrendCrossEma(string name, int period, double multiplier) : base(name, StrategyType.SuperTrendCrossEma)
public SuperTrendCrossEma(string name, int period, double multiplier) : base(name, IndicatorType.SuperTrendCrossEma)
{
Signals = new List<Signal>();
Period = period;
@@ -157,9 +157,9 @@ public class SuperTrendCrossEma : Strategy
return superTrends;
}
public override StrategiesResultBase GetStrategyValues()
public override IndicatorsResultBase GetStrategyValues()
{
return new StrategiesResultBase()
return new IndicatorsResultBase()
{
SuperTrend = Candles.GetSuperTrend(Period.Value, Multiplier.Value).Where(s => s.SuperTrend.HasValue)
.ToList()

8
src/Managing.Domain/Strategies/Signals/SuperTrendStrategy.cs → src/Managing.Domain/Strategies/Signals/SuperTrendIndicator.cs
View File

@@ -7,11 +7,11 @@ using static Managing.Common.Enums;
namespace Managing.Domain.Strategies.Signals;
public class SuperTrendStrategy : Strategy
public class SuperTrendIndicator : Indicator
{
public List<Signal> Signals { get; set; }
public SuperTrendStrategy(string name, int period, double multiplier) : base(name, StrategyType.SuperTrend)
public SuperTrendIndicator(string name, int period, double multiplier) : base(name, IndicatorType.SuperTrend)
{
Signals = new List<Signal>();
Period = period;
@@ -61,9 +61,9 @@ public class SuperTrendStrategy : Strategy
}
}
public override StrategiesResultBase GetStrategyValues()
public override IndicatorsResultBase GetStrategyValues()
{
return new StrategiesResultBase()
return new IndicatorsResultBase()
{
SuperTrend = Candles.GetSuperTrend(Period.Value, Multiplier.Value).Where(s => s.SuperTrend.HasValue)
.ToList()

8
src/Managing.Domain/Strategies/Signals/ThreeWhiteSoldiersStrategy.cs → src/Managing.Domain/Strategies/Signals/ThreeWhiteSoldiersIndicator.cs
View File

@@ -6,10 +6,10 @@ using static Managing.Common.Enums;
namespace Managing.Domain.Strategies.Signals
{
public class ThreeWhiteSoldiersStrategy : Strategy
public class ThreeWhiteSoldiersIndicator : Indicator
{
public ThreeWhiteSoldiersStrategy(string name, int period)
: base(name, StrategyType.ThreeWhiteSoldiers)
public ThreeWhiteSoldiersIndicator(string name, int period)
: base(name, IndicatorType.ThreeWhiteSoldiers)
{
Period = period;
}
@@ -52,7 +52,7 @@ namespace Managing.Domain.Strategies.Signals
}
}
public override StrategiesResultBase GetStrategyValues()
public override IndicatorsResultBase GetStrategyValues()
{
throw new NotImplementedException();
}

8
src/Managing.Domain/Strategies/Trends/EmaTrendStrategy.cs → src/Managing.Domain/Strategies/Trends/EmaTrendIndicator.cs
View File

@@ -6,11 +6,11 @@ using static Managing.Common.Enums;
namespace Managing.Domain.Strategies.Trends;
public class EmaTrendStrategy : EmaBaseStrategy
public class EmaTrendIndicator : EmaBaseIndicator
{
public List<Signal> Signals { get; set; }
public EmaTrendStrategy(string name, int period) : base(name, StrategyType.EmaTrend)
public EmaTrendIndicator(string name, int period) : base(name, IndicatorType.EmaTrend)
{
Signals = new List<Signal>();
Period = period;
@@ -54,9 +54,9 @@ public class EmaTrendStrategy : EmaBaseStrategy
}
}
public override StrategiesResultBase GetStrategyValues()
public override IndicatorsResultBase GetStrategyValues()
{
return new StrategiesResultBase()
return new IndicatorsResultBase()
{
Ema = Candles.GetEma(Period.Value).ToList()
};

10
src/Managing.Domain/Strategies/Trends/StochRsiTrendStrategy.cs → src/Managing.Domain/Strategies/Trends/StochRsiTrendIndicator.cs
View File

@@ -7,16 +7,16 @@ using static Managing.Common.Enums;
namespace Managing.Domain.Strategies.Trends;
public class StochRsiTrendStrategy : Strategy
public class StochRsiTrendIndicator : Indicator
{
public List<Signal> Signals { get; set; }
public StochRsiTrendStrategy(
public StochRsiTrendIndicator(
string name,
int period,
int stochPeriod,
int signalPeriod,
int smoothPeriods) : base(name, StrategyType.StochRsiTrend)
int smoothPeriods) : base(name, IndicatorType.StochRsiTrend)
{
Signals = new List<Signal>();
StochPeriods = stochPeriod;
@@ -65,9 +65,9 @@ public class StochRsiTrendStrategy : Strategy
}
}
public override StrategiesResultBase GetStrategyValues()
public override IndicatorsResultBase GetStrategyValues()
{
return new StrategiesResultBase()
return new IndicatorsResultBase()
{
StochRsi = Candles.GetStochRsi(Period.Value, StochPeriods.Value, SignalPeriods.Value, SmoothPeriods.Value)
.ToList()