Rename strategy to indicators

src/Managing.Infrastructure.Database/MongoDb/MongoMappers.cs

@@ -370,7 +370,7 @@ public static class MongoMappers
             Ticker = signal.Ticker,
             Status = signal.Status,
             Timeframe = signal.Timeframe,
-            Type = signal.StrategyType,
+            Type = signal.IndicatorType,
             User = signal.User != null ? Map(signal.User) : null
         };
     }
@@ -412,7 +412,7 @@ public static class MongoMappers
         return new ScenarioDto
         {
             Name = scenario.Name,
-            Strategies = Map(scenario.Strategies),
+            Indicators = Map(scenario.Indicators),
             LoopbackPeriod = scenario.LoopbackPeriod ?? 1,
             User = scenario.User != null ? Map(scenario.User) : null
         };
@@ -430,64 +430,64 @@ public static class MongoMappers
 
         var scenario = new Scenario(d.Name, d.LoopbackPeriod)
         {
-            Strategies = d.Strategies.Select(s => Map(s)).ToList(),
+            Indicators = d.Indicators.Select(s => Map(s)).ToList(),
             User = d.User != null ? Map(d.User) : null
         };
         return scenario;
     }
 
-    private static List<StrategyDto> Map(List<Strategy> strategies)
+    private static List<IndicatorDto> Map(List<Indicator> indicators)
     {
-        return strategies.ConvertAll(strategy => Map(strategy));
+        return indicators.ConvertAll(strategy => Map(strategy));
     }
 
-    internal static Strategy Map(StrategyDto strategyDto)
+    internal static Indicator Map(IndicatorDto indicatorDto)
     {
-        if (strategyDto == null)
+        if (indicatorDto == null)
             return null;
 
-        return new Strategy(strategyDto.Name, strategyDto.Type)
+        return new Indicator(indicatorDto.Name, indicatorDto.Type)
         {
-            SignalType = strategyDto.SignalType,
-            MinimumHistory = strategyDto.MinimumHistory,
-            Period = strategyDto.Period,
-            FastPeriods = strategyDto.FastPeriods,
-            SlowPeriods = strategyDto.SlowPeriods,
-            SignalPeriods = strategyDto.SignalPeriods,
-            Multiplier = strategyDto.Multiplier,
-            SmoothPeriods = strategyDto.SmoothPeriods,
-            StochPeriods = strategyDto.StochPeriods,
-            CyclePeriods = strategyDto.CyclePeriods,
-            User = strategyDto.User != null ? Map(strategyDto.User) : null
+            SignalType = indicatorDto.SignalType,
+            MinimumHistory = indicatorDto.MinimumHistory,
+            Period = indicatorDto.Period,
+            FastPeriods = indicatorDto.FastPeriods,
+            SlowPeriods = indicatorDto.SlowPeriods,
+            SignalPeriods = indicatorDto.SignalPeriods,
+            Multiplier = indicatorDto.Multiplier,
+            SmoothPeriods = indicatorDto.SmoothPeriods,
+            StochPeriods = indicatorDto.StochPeriods,
+            CyclePeriods = indicatorDto.CyclePeriods,
+            User = indicatorDto.User != null ? Map(indicatorDto.User) : null
         };
     }
 
-    internal static StrategyDto Map(Strategy strategy)
+    internal static IndicatorDto Map(Indicator indicator)
     {
-        if (strategy == null)
+        if (indicator == null)
             return null;
 
-        return new StrategyDto
+        return new IndicatorDto
         {
-            Name = strategy.Name,
-            Type = strategy.Type,
-            SignalType = strategy.SignalType,
-            MinimumHistory = strategy.MinimumHistory,
-            Period = strategy.Period,
-            FastPeriods = strategy.FastPeriods,
-            SlowPeriods = strategy.SlowPeriods,
-            SignalPeriods = strategy.SignalPeriods,
-            Multiplier = strategy.Multiplier,
-            SmoothPeriods = strategy.SmoothPeriods,
-            StochPeriods = strategy.StochPeriods,
-            CyclePeriods = strategy.CyclePeriods,
-            User = strategy.User != null ? Map(strategy.User) : null
+            Name = indicator.Name,
+            Type = indicator.Type,
+            SignalType = indicator.SignalType,
+            MinimumHistory = indicator.MinimumHistory,
+            Period = indicator.Period,
+            FastPeriods = indicator.FastPeriods,
+            SlowPeriods = indicator.SlowPeriods,
+            SignalPeriods = indicator.SignalPeriods,
+            Multiplier = indicator.Multiplier,
+            SmoothPeriods = indicator.SmoothPeriods,
+            StochPeriods = indicator.StochPeriods,
+            CyclePeriods = indicator.CyclePeriods,
+            User = indicator.User != null ? Map(indicator.User) : null
         };
     }
 
-    internal static IEnumerable<Strategy> Map(IEnumerable<StrategyDto> strategies)
+    internal static IEnumerable<Indicator> Map(IEnumerable<IndicatorDto> indicators)
     {
-        return strategies.Select(strategy => Map(strategy));
+        return indicators.Select(indicator => Map(indicator));
     }
 
     #endregion
@@ -567,8 +567,8 @@ public static class MongoMappers
             Scenario = new ScenarioDto
             {
                 Name = spotlight.Scenario.Name,
-                Strategies =
-                    spotlight.Scenario.Strategies.ConvertAll(
+                Indicators =
+                    spotlight.Scenario.Indicators.ConvertAll(
                         spotlightScenarioStrategy => Map(spotlightScenarioStrategy))
             },
             TickerSignals = spotlight.TickerSignals.ConvertAll(spotlightTickerSignal => new TickerSignalDto
@@ -607,8 +607,8 @@ public static class MongoMappers
         {
             Scenario = new Scenario(name: spotlight.Scenario.Name)
             {
-                Strategies =
-                    spotlight.Scenario.Strategies.ConvertAll(
+                Indicators =
+                    spotlight.Scenario.Indicators.ConvertAll(
                         spotlightScenarioStrategy => Map(spotlightScenarioStrategy))
             },
             TickerSignals = spotlight.TickerSignals.ConvertAll(spotlightTickerSignal => new TickerSignal