Task/centralize X-ray rule settings (part 2) (#7905)

* Use a single object parameter for the X-ray rule constructors

* Use a single object parameter for the Rule constructor

apps/api/src/app/portfolio/portfolio.service.ts

@@ -1338,12 +1338,12 @@ export class PortfolioService {
         }),
         rules: await this.rulesService.evaluate(
           [
-            new BuyingPower(
+            new BuyingPower({
-              this.exchangeRateDataService,
+              languageCode,
-              this.i18nService,
+              buyingPower: summary.cash,
-              summary.cash,
+              exchangeRateDataService: this.exchangeRateDataService,
-              languageCode
+              i18nService: this.i18nService
-            )
+            })
           ],
           userSettings
         )
@@ -1356,24 +1356,24 @@ export class PortfolioService {
         }),
         rules: await this.rulesService.evaluate(
           [
-            new EmergencyFundSetup(
+            new EmergencyFundSetup({
-              this.exchangeRateDataService,
-              this.i18nService,
               languageCode,
-              totalEmergencyFundInBaseCurrency
+              emergencyFundInBaseCurrency: totalEmergencyFundInBaseCurrency,
-            ),
+              exchangeRateDataService: this.exchangeRateDataService,
+              i18nService: this.i18nService
+            }),
             // The coverage is only meaningful once an emergency fund has been
             // set up, either by an amount or by the tagged holdings
             ...(totalEmergencyFundInBaseCurrency > 0
               ? [
-                  new EmergencyFundCoverage(
+                  new EmergencyFundCoverage({
-                    this.exchangeRateDataService,
+                    cashBalanceInBaseCurrency,
-                    this.i18nService,
-                    languageCode,
-                    emergencyFundInBaseCurrency,
                     emergencyFundHoldingsValueInBaseCurrency,
-                    cashBalanceInBaseCurrency
+                    emergencyFundInBaseCurrency,
-                  )
+                    languageCode,
+                    exchangeRateDataService: this.exchangeRateDataService,
+                    i18nService: this.i18nService
+                  })
                 ]
               : [])
           ],
@@ -1389,18 +1389,18 @@ export class PortfolioService {
         rules: hasOpenHoldings
           ? await this.rulesService.evaluate(
               [
-                new CurrencyClusterRiskBaseCurrencyCurrentInvestment(
+                new CurrencyClusterRiskBaseCurrencyCurrentInvestment({
-                  this.exchangeRateDataService,
-                  this.i18nService,
                   holdings,
-                  languageCode
+                  languageCode,
-                ),
+                  exchangeRateDataService: this.exchangeRateDataService,
-                new CurrencyClusterRiskCurrentInvestment(
+                  i18nService: this.i18nService
-                  this.exchangeRateDataService,
+                }),
-                  this.i18nService,
+                new CurrencyClusterRiskCurrentInvestment({
                   holdings,
-                  languageCode
+                  languageCode,
-                )
+                  exchangeRateDataService: this.exchangeRateDataService,
+                  i18nService: this.i18nService
+                })
               ],
               userSettings
             )
@@ -1415,18 +1415,18 @@ export class PortfolioService {
         rules: hasOpenHoldings
           ? await this.rulesService.evaluate(
               [
-                new AssetClassClusterRiskEquity(
+                new AssetClassClusterRiskEquity({
-                  this.exchangeRateDataService,
+                  holdings,
-                  this.i18nService,
                   languageCode,
-                  holdings
+                  exchangeRateDataService: this.exchangeRateDataService,
-                ),
+                  i18nService: this.i18nService
-                new AssetClassClusterRiskFixedIncome(
+                }),
-                  this.exchangeRateDataService,
+                new AssetClassClusterRiskFixedIncome({
-                  this.i18nService,
+                  holdings,
                   languageCode,
-                  holdings
+                  exchangeRateDataService: this.exchangeRateDataService,
-                )
+                  i18nService: this.i18nService
+                })
               ],
               userSettings
             )
@@ -1442,18 +1442,18 @@ export class PortfolioService {
           summary.activityCount > 0
             ? await this.rulesService.evaluate(
                 [
-                  new AccountClusterRiskCurrentInvestment(
+                  new AccountClusterRiskCurrentInvestment({
-                    this.exchangeRateDataService,
+                    accounts,
-                    this.i18nService,
                     languageCode,
-                    accounts
+                    exchangeRateDataService: this.exchangeRateDataService,
-                  ),
+                    i18nService: this.i18nService
-                  new AccountClusterRiskSingleAccount(
+                  }),
-                    this.exchangeRateDataService,
+                  new AccountClusterRiskSingleAccount({
-                    this.i18nService,
+                    accounts,
                     languageCode,
-                    accounts
+                    exchangeRateDataService: this.exchangeRateDataService,
-                  )
+                    i18nService: this.i18nService
+                  })
                 ],
                 userSettings
               )
@@ -1468,20 +1468,22 @@ export class PortfolioService {
         rules: hasOpenHoldings
           ? await this.rulesService.evaluate(
               [
-                new EconomicMarketClusterRiskDevelopedMarkets(
+                new EconomicMarketClusterRiskDevelopedMarkets({
-                  this.exchangeRateDataService,
+                  languageCode,
-                  this.i18nService,
+                  currentValueInBaseCurrency: marketsTotalInBaseCurrency,
-                  marketsTotalInBaseCurrency,
+                  developedMarketsValueInBaseCurrency:
                     markets.developedMarkets.valueInBaseCurrency,
-                  languageCode
+                  exchangeRateDataService: this.exchangeRateDataService,
-                ),
+                  i18nService: this.i18nService
-                new EconomicMarketClusterRiskEmergingMarkets(
+                }),
-                  this.exchangeRateDataService,
+                new EconomicMarketClusterRiskEmergingMarkets({
-                  this.i18nService,
+                  languageCode,
-                  marketsTotalInBaseCurrency,
+                  currentValueInBaseCurrency: marketsTotalInBaseCurrency,
+                  emergingMarketsValueInBaseCurrency:
                     markets.emergingMarkets.valueInBaseCurrency,
-                  languageCode
+                  exchangeRateDataService: this.exchangeRateDataService,
-                )
+                  i18nService: this.i18nService
+                })
               ],
               userSettings
             )
@@ -1496,41 +1498,51 @@ export class PortfolioService {
         rules: hasOpenHoldings
           ? await this.rulesService.evaluate(
               [
-                new RegionalMarketClusterRiskAsiaPacific(
+                new RegionalMarketClusterRiskAsiaPacific({
-                  this.exchangeRateDataService,
-                  this.i18nService,
                   languageCode,
+                  asiaPacificValueInBaseCurrency:
+                    marketsAdvanced.asiaPacific.valueInBaseCurrency,
+                  currentValueInBaseCurrency:
                     marketsAdvancedTotalInBaseCurrency,
-                  marketsAdvanced.asiaPacific.valueInBaseCurrency
+                  exchangeRateDataService: this.exchangeRateDataService,
-                ),
+                  i18nService: this.i18nService
-                new RegionalMarketClusterRiskEmergingMarkets(
+                }),
-                  this.exchangeRateDataService,
+                new RegionalMarketClusterRiskEmergingMarkets({
-                  this.i18nService,
                   languageCode,
+                  currentValueInBaseCurrency:
                     marketsAdvancedTotalInBaseCurrency,
-                  marketsAdvanced.emergingMarkets.valueInBaseCurrency
+                  emergingMarketsValueInBaseCurrency:
-                ),
+                    marketsAdvanced.emergingMarkets.valueInBaseCurrency,
-                new RegionalMarketClusterRiskEurope(
+                  exchangeRateDataService: this.exchangeRateDataService,
-                  this.exchangeRateDataService,
+                  i18nService: this.i18nService
-                  this.i18nService,
+                }),
+                new RegionalMarketClusterRiskEurope({
                   languageCode,
+                  currentValueInBaseCurrency:
                     marketsAdvancedTotalInBaseCurrency,
-                  marketsAdvanced.europe.valueInBaseCurrency
+                  europeValueInBaseCurrency:
-                ),
+                    marketsAdvanced.europe.valueInBaseCurrency,
-                new RegionalMarketClusterRiskJapan(
+                  exchangeRateDataService: this.exchangeRateDataService,
-                  this.exchangeRateDataService,
+                  i18nService: this.i18nService
-                  this.i18nService,
+                }),
+                new RegionalMarketClusterRiskJapan({
                   languageCode,
+                  currentValueInBaseCurrency:
                     marketsAdvancedTotalInBaseCurrency,
-                  marketsAdvanced.japan.valueInBaseCurrency
+                  japanValueInBaseCurrency:
-                ),
+                    marketsAdvanced.japan.valueInBaseCurrency,
-                new RegionalMarketClusterRiskNorthAmerica(
+                  exchangeRateDataService: this.exchangeRateDataService,
-                  this.exchangeRateDataService,
+                  i18nService: this.i18nService
-                  this.i18nService,
+                }),
+                new RegionalMarketClusterRiskNorthAmerica({
                   languageCode,
+                  currentValueInBaseCurrency:
                     marketsAdvancedTotalInBaseCurrency,
-                  marketsAdvanced.northAmerica.valueInBaseCurrency
+                  northAmericaValueInBaseCurrency:
-                )
+                    marketsAdvanced.northAmerica.valueInBaseCurrency,
+                  exchangeRateDataService: this.exchangeRateDataService,
+                  i18nService: this.i18nService
+                })
               ],
               userSettings
             )
@@ -1544,13 +1556,14 @@ export class PortfolioService {
         }),
         rules: await this.rulesService.evaluate(
           [
-            new FeeRatioTotalInvestmentVolume(
+            new FeeRatioTotalInvestmentVolume({
-              this.exchangeRateDataService,
-              this.i18nService,
               languageCode,
-              summary.totalBuy + summary.totalSell,
+              exchangeRateDataService: this.exchangeRateDataService,
-              summary.fees
+              fees: summary.fees,
-            )
+              i18nService: this.i18nService,
+              totalInvestmentVolumeInBaseCurrency:
+                summary.totalBuy + summary.totalSell
+            })
           ],
           userSettings
         )

apps/api/src/models/rule.ts

@@ -13,19 +13,21 @@ import { EvaluationResult } from './interfaces/evaluation-result.interface';
 import { RuleInterface } from './interfaces/rule.interface';
 
 export abstract class Rule<T extends RuleSettings> implements RuleInterface<T> {
+  protected exchangeRateDataService: ExchangeRateDataService;
+
   private key: XRayRuleKey;
   private languageCode: string;
 
-  public constructor(
+  public constructor({
-    protected exchangeRateDataService: ExchangeRateDataService,
+    exchangeRateDataService,
-    {
     key,
     languageCode
   }: {
+    exchangeRateDataService: ExchangeRateDataService;
     key: XRayRuleKey;
     languageCode: string;
-    }
+  }) {
-  ) {
+    this.exchangeRateDataService = exchangeRateDataService;
     this.key = key;
     this.languageCode = languageCode;
   }

apps/api/src/models/rules/account-cluster-risk/current-investment.ts

@@ -7,19 +7,27 @@ import { Account } from '@prisma/client';
 
 export class AccountClusterRiskCurrentInvestment extends Rule<Settings> {
   private accounts: PortfolioDetails['accounts'];
-
+  private i18nService: I18nService;
-  public constructor(
+
-    exchangeRateDataService: ExchangeRateDataService,
+  public constructor({
-    private i18nService: I18nService,
+    accounts,
-    languageCode: string,
+    exchangeRateDataService,
-    accounts: PortfolioDetails['accounts']
+    i18nService,
-  ) {
+    languageCode
-    super(exchangeRateDataService, {
+  }: {
+    accounts: PortfolioDetails['accounts'];
+    exchangeRateDataService: ExchangeRateDataService;
+    i18nService: I18nService;
+    languageCode: string;
+  }) {
+    super({
+      exchangeRateDataService,
       languageCode,
       key: 'AccountClusterRiskCurrentInvestment'
     });
 
     this.accounts = accounts;
+    this.i18nService = i18nService;
   }
 
   public evaluate(ruleSettings: Settings) {

apps/api/src/models/rules/account-cluster-risk/single-account.ts

@@ -5,19 +5,27 @@ import { PortfolioDetails, RuleSettings } from '@ghostfolio/common/interfaces';
 
 export class AccountClusterRiskSingleAccount extends Rule<RuleSettings> {
   private accounts: PortfolioDetails['accounts'];
+  private i18nService: I18nService;
 
-  public constructor(
+  public constructor({
-    exchangeRateDataService: ExchangeRateDataService,
+    accounts,
-    private i18nService: I18nService,
+    exchangeRateDataService,
-    languageCode: string,
+    i18nService,
-    accounts: PortfolioDetails['accounts']
+    languageCode
-  ) {
+  }: {
-    super(exchangeRateDataService, {
+    accounts: PortfolioDetails['accounts'];
+    exchangeRateDataService: ExchangeRateDataService;
+    i18nService: I18nService;
+    languageCode: string;
+  }) {
+    super({
+      exchangeRateDataService,
       languageCode,
       key: 'AccountClusterRiskSingleAccount'
     });
 
     this.accounts = accounts;
+    this.i18nService = i18nService;
   }
 
   public evaluate() {

apps/api/src/models/rules/asset-class-cluster-risk/equity.ts

@@ -5,19 +5,27 @@ import { PortfolioPosition, RuleSettings } from '@ghostfolio/common/interfaces';
 
 export class AssetClassClusterRiskEquity extends Rule<Settings> {
   private holdings: PortfolioPosition[];
+  private i18nService: I18nService;
 
-  public constructor(
+  public constructor({
-    exchangeRateDataService: ExchangeRateDataService,
+    exchangeRateDataService,
-    private i18nService: I18nService,
+    holdings,
-    languageCode: string,
+    i18nService,
-    holdings: PortfolioPosition[]
+    languageCode
-  ) {
+  }: {
-    super(exchangeRateDataService, {
+    exchangeRateDataService: ExchangeRateDataService;
+    holdings: PortfolioPosition[];
+    i18nService: I18nService;
+    languageCode: string;
+  }) {
+    super({
+      exchangeRateDataService,
       languageCode,
       key: 'AssetClassClusterRiskEquity'
     });
 
     this.holdings = holdings;
+    this.i18nService = i18nService;
   }
 
   public evaluate(ruleSettings: Settings) {

apps/api/src/models/rules/asset-class-cluster-risk/fixed-income.ts

@@ -5,19 +5,27 @@ import { PortfolioPosition, RuleSettings } from '@ghostfolio/common/interfaces';
 
 export class AssetClassClusterRiskFixedIncome extends Rule<Settings> {
   private holdings: PortfolioPosition[];
+  private i18nService: I18nService;
 
-  public constructor(
+  public constructor({
-    exchangeRateDataService: ExchangeRateDataService,
+    exchangeRateDataService,
-    private i18nService: I18nService,
+    holdings,
-    languageCode: string,
+    i18nService,
-    holdings: PortfolioPosition[]
+    languageCode
-  ) {
+  }: {
-    super(exchangeRateDataService, {
+    exchangeRateDataService: ExchangeRateDataService;
+    holdings: PortfolioPosition[];
+    i18nService: I18nService;
+    languageCode: string;
+  }) {
+    super({
+      exchangeRateDataService,
       languageCode,
       key: 'AssetClassClusterRiskFixedIncome'
     });
 
     this.holdings = holdings;
+    this.i18nService = i18nService;
   }
 
   public evaluate(ruleSettings: Settings) {

apps/api/src/models/rules/currency-cluster-risk/base-currency-current-investment.ts

@@ -5,19 +5,27 @@ import { PortfolioPosition, RuleSettings } from '@ghostfolio/common/interfaces';
 
 export class CurrencyClusterRiskBaseCurrencyCurrentInvestment extends Rule<Settings> {
   private holdings: PortfolioPosition[];
+  private i18nService: I18nService;
 
-  public constructor(
+  public constructor({
-    exchangeRateDataService: ExchangeRateDataService,
+    exchangeRateDataService,
-    private i18nService: I18nService,
+    holdings,
-    holdings: PortfolioPosition[],
+    i18nService,
-    languageCode: string
+    languageCode
-  ) {
+  }: {
-    super(exchangeRateDataService, {
+    exchangeRateDataService: ExchangeRateDataService;
+    holdings: PortfolioPosition[];
+    i18nService: I18nService;
+    languageCode: string;
+  }) {
+    super({
+      exchangeRateDataService,
       languageCode,
       key: 'CurrencyClusterRiskBaseCurrencyCurrentInvestment'
     });
 
     this.holdings = holdings;
+    this.i18nService = i18nService;
   }
 
   public evaluate(ruleSettings: Settings) {

apps/api/src/models/rules/currency-cluster-risk/current-investment.ts

@@ -5,19 +5,27 @@ import { PortfolioPosition, RuleSettings } from '@ghostfolio/common/interfaces';
 
 export class CurrencyClusterRiskCurrentInvestment extends Rule<Settings> {
   private holdings: PortfolioPosition[];
+  private i18nService: I18nService;
 
-  public constructor(
+  public constructor({
-    exchangeRateDataService: ExchangeRateDataService,
+    exchangeRateDataService,
-    private i18nService: I18nService,
+    holdings,
-    holdings: PortfolioPosition[],
+    i18nService,
-    languageCode: string
+    languageCode
-  ) {
+  }: {
-    super(exchangeRateDataService, {
+    exchangeRateDataService: ExchangeRateDataService;
+    holdings: PortfolioPosition[];
+    i18nService: I18nService;
+    languageCode: string;
+  }) {
+    super({
+      exchangeRateDataService,
       languageCode,
       key: 'CurrencyClusterRiskCurrentInvestment'
     });
 
     this.holdings = holdings;
+    this.i18nService = i18nService;
   }
 
   public evaluate(ruleSettings: Settings) {

apps/api/src/models/rules/economic-market-cluster-risk/developed-markets.ts

@@ -6,15 +6,23 @@ import { RuleSettings } from '@ghostfolio/common/interfaces';
 export class EconomicMarketClusterRiskDevelopedMarkets extends Rule<Settings> {
   private currentValueInBaseCurrency: number;
   private developedMarketsValueInBaseCurrency: number;
+  private i18nService: I18nService;
 
-  public constructor(
+  public constructor({
-    exchangeRateDataService: ExchangeRateDataService,
+    currentValueInBaseCurrency,
-    private i18nService: I18nService,
+    developedMarketsValueInBaseCurrency,
-    currentValueInBaseCurrency: number,
+    exchangeRateDataService,
-    developedMarketsValueInBaseCurrency: number,
+    i18nService,
-    languageCode: string
+    languageCode
-  ) {
+  }: {
-    super(exchangeRateDataService, {
+    currentValueInBaseCurrency: number;
+    developedMarketsValueInBaseCurrency: number;
+    exchangeRateDataService: ExchangeRateDataService;
+    i18nService: I18nService;
+    languageCode: string;
+  }) {
+    super({
+      exchangeRateDataService,
       languageCode,
       key: 'EconomicMarketClusterRiskDevelopedMarkets'
     });
@@ -22,6 +30,7 @@ export class EconomicMarketClusterRiskDevelopedMarkets extends Rule<Settings> {
     this.currentValueInBaseCurrency = currentValueInBaseCurrency;
     this.developedMarketsValueInBaseCurrency =
       developedMarketsValueInBaseCurrency;
+    this.i18nService = i18nService;
   }
 
   public evaluate(ruleSettings: Settings) {

apps/api/src/models/rules/economic-market-cluster-risk/emerging-markets.ts

@@ -6,15 +6,23 @@ import { RuleSettings } from '@ghostfolio/common/interfaces';
 export class EconomicMarketClusterRiskEmergingMarkets extends Rule<Settings> {
   private currentValueInBaseCurrency: number;
   private emergingMarketsValueInBaseCurrency: number;
+  private i18nService: I18nService;
 
-  public constructor(
+  public constructor({
-    exchangeRateDataService: ExchangeRateDataService,
+    currentValueInBaseCurrency,
-    private i18nService: I18nService,
+    emergingMarketsValueInBaseCurrency,
-    currentValueInBaseCurrency: number,
+    exchangeRateDataService,
-    emergingMarketsValueInBaseCurrency: number,
+    i18nService,
-    languageCode: string
+    languageCode
-  ) {
+  }: {
-    super(exchangeRateDataService, {
+    currentValueInBaseCurrency: number;
+    emergingMarketsValueInBaseCurrency: number;
+    exchangeRateDataService: ExchangeRateDataService;
+    i18nService: I18nService;
+    languageCode: string;
+  }) {
+    super({
+      exchangeRateDataService,
       languageCode,
       key: 'EconomicMarketClusterRiskEmergingMarkets'
     });
@@ -22,6 +30,7 @@ export class EconomicMarketClusterRiskEmergingMarkets extends Rule<Settings> {
     this.currentValueInBaseCurrency = currentValueInBaseCurrency;
     this.emergingMarketsValueInBaseCurrency =
       emergingMarketsValueInBaseCurrency;
+    this.i18nService = i18nService;
   }
 
   public evaluate(ruleSettings: Settings) {

apps/api/src/models/rules/emergency-fund/emergency-fund-coverage.ts

@@ -6,18 +6,37 @@ import { RuleSettings } from '@ghostfolio/common/interfaces';
 import { Big } from 'big.js';
 
 export class EmergencyFundCoverage extends Rule<Settings> {
-  public constructor(
+  private cashBalanceInBaseCurrency: number;
-    exchangeRateDataService: ExchangeRateDataService,
+  private emergencyFundHoldingsValueInBaseCurrency: number;
-    private i18nService: I18nService,
+  private emergencyFundInBaseCurrency: number;
-    languageCode: string,
+  private i18nService: I18nService;
-    private emergencyFundInBaseCurrency: number,
+
-    private emergencyFundHoldingsValueInBaseCurrency: number,
+  public constructor({
-    private cashBalanceInBaseCurrency: number
+    cashBalanceInBaseCurrency,
-  ) {
+    emergencyFundHoldingsValueInBaseCurrency,
-    super(exchangeRateDataService, {
+    emergencyFundInBaseCurrency,
+    exchangeRateDataService,
+    i18nService,
+    languageCode
+  }: {
+    cashBalanceInBaseCurrency: number;
+    emergencyFundHoldingsValueInBaseCurrency: number;
+    emergencyFundInBaseCurrency: number;
+    exchangeRateDataService: ExchangeRateDataService;
+    i18nService: I18nService;
+    languageCode: string;
+  }) {
+    super({
+      exchangeRateDataService,
       languageCode,
       key: 'EmergencyFundCoverage'
     });
+
+    this.cashBalanceInBaseCurrency = cashBalanceInBaseCurrency;
+    this.emergencyFundHoldingsValueInBaseCurrency =
+      emergencyFundHoldingsValueInBaseCurrency;
+    this.emergencyFundInBaseCurrency = emergencyFundInBaseCurrency;
+    this.i18nService = i18nService;
   }
 
   public evaluate(ruleSettings: Settings) {

apps/api/src/models/rules/emergency-fund/emergency-fund-setup.ts

@@ -4,24 +4,28 @@ import { I18nService } from '@ghostfolio/api/services/i18n/i18n.service';
 import { RuleSettings } from '@ghostfolio/common/interfaces';
 
 export class EmergencyFundSetup extends Rule<Settings> {
-  private emergencyFund: number;
+  private emergencyFundInBaseCurrency: number;
-
+  private i18nService: I18nService;
-  public constructor(
+
-    exchangeRateDataService: ExchangeRateDataService,
+  public constructor({
-    private i18nService: I18nService,
+    emergencyFundInBaseCurrency,
-    languageCode: string,
+    exchangeRateDataService,
-    emergencyFund: number
+    i18nService,
-  ) {
+    languageCode
-    super(exchangeRateDataService, {
+  }: {
-      languageCode,
+    emergencyFundInBaseCurrency: number;
-      key: 'EmergencyFundSetup'
+    exchangeRateDataService: ExchangeRateDataService;
-    });
+    i18nService: I18nService;
-
+    languageCode: string;
-    this.emergencyFund = emergencyFund;
+  }) {
+    super({ exchangeRateDataService, languageCode, key: 'EmergencyFundSetup' });
+
+    this.emergencyFundInBaseCurrency = emergencyFundInBaseCurrency;
+    this.i18nService = i18nService;
   }
 
   public evaluate() {
-    if (!this.emergencyFund) {
+    if (!this.emergencyFundInBaseCurrency) {
       return {
         evaluation: this.i18nService.getTranslation({
           id: 'rule.emergencyFundSetup.false',

apps/api/src/models/rules/fees/fee-ratio-total-investment-volume.ts

@@ -5,21 +5,30 @@ import { RuleSettings } from '@ghostfolio/common/interfaces';
 
 export class FeeRatioTotalInvestmentVolume extends Rule<Settings> {
   private fees: number;
+  private i18nService: I18nService;
   private totalInvestmentVolumeInBaseCurrency: number;
 
-  public constructor(
+  public constructor({
-    exchangeRateDataService: ExchangeRateDataService,
+    exchangeRateDataService,
-    private i18nService: I18nService,
+    fees,
-    languageCode: string,
+    i18nService,
-    totalInvestmentVolumeInBaseCurrency: number,
+    languageCode,
-    fees: number
+    totalInvestmentVolumeInBaseCurrency
-  ) {
+  }: {
-    super(exchangeRateDataService, {
+    exchangeRateDataService: ExchangeRateDataService;
+    fees: number;
+    i18nService: I18nService;
+    languageCode: string;
+    totalInvestmentVolumeInBaseCurrency: number;
+  }) {
+    super({
+      exchangeRateDataService,
       languageCode,
       key: 'FeeRatioTotalInvestmentVolume'
     });
 
     this.fees = fees;
+    this.i18nService = i18nService;
     this.totalInvestmentVolumeInBaseCurrency =
       totalInvestmentVolumeInBaseCurrency;
   }

apps/api/src/models/rules/liquidity/buying-power.ts

@@ -5,19 +5,23 @@ import { RuleSettings } from '@ghostfolio/common/interfaces';
 
 export class BuyingPower extends Rule<Settings> {
   private buyingPower: number;
+  private i18nService: I18nService;
 
-  public constructor(
+  public constructor({
-    exchangeRateDataService: ExchangeRateDataService,
+    buyingPower,
-    private i18nService: I18nService,
+    exchangeRateDataService,
-    buyingPower: number,
+    i18nService,
-    languageCode: string
+    languageCode
-  ) {
+  }: {
-    super(exchangeRateDataService, {
+    buyingPower: number;
-      languageCode,
+    exchangeRateDataService: ExchangeRateDataService;
-      key: 'BuyingPower'
+    i18nService: I18nService;
-    });
+    languageCode: string;
+  }) {
+    super({ exchangeRateDataService, languageCode, key: 'BuyingPower' });
 
     this.buyingPower = buyingPower;
+    this.i18nService = i18nService;
   }
 
   public evaluate(ruleSettings: Settings) {

apps/api/src/models/rules/regional-market-cluster-risk/asia-pacific.ts

@@ -7,21 +7,30 @@ import { Settings } from './interfaces/rule-settings.interface';
 export class RegionalMarketClusterRiskAsiaPacific extends Rule<Settings> {
   private asiaPacificValueInBaseCurrency: number;
   private currentValueInBaseCurrency: number;
+  private i18nService: I18nService;
 
-  public constructor(
+  public constructor({
-    exchangeRateDataService: ExchangeRateDataService,
+    asiaPacificValueInBaseCurrency,
-    private i18nService: I18nService,
+    currentValueInBaseCurrency,
-    languageCode: string,
+    exchangeRateDataService,
-    currentValueInBaseCurrency: number,
+    i18nService,
-    asiaPacificValueInBaseCurrency: number
+    languageCode
-  ) {
+  }: {
-    super(exchangeRateDataService, {
+    asiaPacificValueInBaseCurrency: number;
+    currentValueInBaseCurrency: number;
+    exchangeRateDataService: ExchangeRateDataService;
+    i18nService: I18nService;
+    languageCode: string;
+  }) {
+    super({
+      exchangeRateDataService,
       languageCode,
       key: 'RegionalMarketClusterRiskAsiaPacific'
     });
 
     this.asiaPacificValueInBaseCurrency = asiaPacificValueInBaseCurrency;
     this.currentValueInBaseCurrency = currentValueInBaseCurrency;
+    this.i18nService = i18nService;
   }
 
   public evaluate(ruleSettings: Settings) {

apps/api/src/models/rules/regional-market-cluster-risk/emerging-markets.ts

@@ -7,15 +7,23 @@ import { Settings } from './interfaces/rule-settings.interface';
 export class RegionalMarketClusterRiskEmergingMarkets extends Rule<Settings> {
   private currentValueInBaseCurrency: number;
   private emergingMarketsValueInBaseCurrency: number;
+  private i18nService: I18nService;
 
-  public constructor(
+  public constructor({
-    exchangeRateDataService: ExchangeRateDataService,
+    currentValueInBaseCurrency,
-    private i18nService: I18nService,
+    emergingMarketsValueInBaseCurrency,
-    languageCode: string,
+    exchangeRateDataService,
-    currentValueInBaseCurrency: number,
+    i18nService,
-    emergingMarketsValueInBaseCurrency: number
+    languageCode
-  ) {
+  }: {
-    super(exchangeRateDataService, {
+    currentValueInBaseCurrency: number;
+    emergingMarketsValueInBaseCurrency: number;
+    exchangeRateDataService: ExchangeRateDataService;
+    i18nService: I18nService;
+    languageCode: string;
+  }) {
+    super({
+      exchangeRateDataService,
       languageCode,
       key: 'RegionalMarketClusterRiskEmergingMarkets'
     });
@@ -23,6 +31,7 @@ export class RegionalMarketClusterRiskEmergingMarkets extends Rule<Settings> {
     this.currentValueInBaseCurrency = currentValueInBaseCurrency;
     this.emergingMarketsValueInBaseCurrency =
       emergingMarketsValueInBaseCurrency;
+    this.i18nService = i18nService;
   }
 
   public evaluate(ruleSettings: Settings) {

apps/api/src/models/rules/regional-market-cluster-risk/europe.ts

@@ -7,21 +7,30 @@ import { Settings } from './interfaces/rule-settings.interface';
 export class RegionalMarketClusterRiskEurope extends Rule<Settings> {
   private currentValueInBaseCurrency: number;
   private europeValueInBaseCurrency: number;
+  private i18nService: I18nService;
 
-  public constructor(
+  public constructor({
-    exchangeRateDataService: ExchangeRateDataService,
+    currentValueInBaseCurrency,
-    private i18nService: I18nService,
+    europeValueInBaseCurrency,
-    languageCode: string,
+    exchangeRateDataService,
-    currentValueInBaseCurrency: number,
+    i18nService,
-    europeValueInBaseCurrency: number
+    languageCode
-  ) {
+  }: {
-    super(exchangeRateDataService, {
+    currentValueInBaseCurrency: number;
+    europeValueInBaseCurrency: number;
+    exchangeRateDataService: ExchangeRateDataService;
+    i18nService: I18nService;
+    languageCode: string;
+  }) {
+    super({
+      exchangeRateDataService,
       languageCode,
       key: 'RegionalMarketClusterRiskEurope'
     });
 
     this.currentValueInBaseCurrency = currentValueInBaseCurrency;
     this.europeValueInBaseCurrency = europeValueInBaseCurrency;
+    this.i18nService = i18nService;
   }
 
   public evaluate(ruleSettings: Settings) {

apps/api/src/models/rules/regional-market-cluster-risk/japan.ts

@@ -6,21 +6,30 @@ import { Settings } from './interfaces/rule-settings.interface';
 
 export class RegionalMarketClusterRiskJapan extends Rule<Settings> {
   private currentValueInBaseCurrency: number;
+  private i18nService: I18nService;
   private japanValueInBaseCurrency: number;
 
-  public constructor(
+  public constructor({
-    exchangeRateDataService: ExchangeRateDataService,
+    currentValueInBaseCurrency,
-    private i18nService: I18nService,
+    exchangeRateDataService,
-    languageCode: string,
+    i18nService,
-    currentValueInBaseCurrency: number,
+    japanValueInBaseCurrency,
-    japanValueInBaseCurrency: number
+    languageCode
-  ) {
+  }: {
-    super(exchangeRateDataService, {
+    currentValueInBaseCurrency: number;
+    exchangeRateDataService: ExchangeRateDataService;
+    i18nService: I18nService;
+    japanValueInBaseCurrency: number;
+    languageCode: string;
+  }) {
+    super({
+      exchangeRateDataService,
       languageCode,
       key: 'RegionalMarketClusterRiskJapan'
     });
 
     this.currentValueInBaseCurrency = currentValueInBaseCurrency;
+    this.i18nService = i18nService;
     this.japanValueInBaseCurrency = japanValueInBaseCurrency;
   }
 

apps/api/src/models/rules/regional-market-cluster-risk/north-america.ts

@@ -6,21 +6,30 @@ import { Settings } from './interfaces/rule-settings.interface';
 
 export class RegionalMarketClusterRiskNorthAmerica extends Rule<Settings> {
   private currentValueInBaseCurrency: number;
+  private i18nService: I18nService;
   private northAmericaValueInBaseCurrency: number;
 
-  public constructor(
+  public constructor({
-    exchangeRateDataService: ExchangeRateDataService,
+    currentValueInBaseCurrency,
-    private i18nService: I18nService,
+    exchangeRateDataService,
-    languageCode: string,
+    i18nService,
-    currentValueInBaseCurrency: number,
+    languageCode,
-    northAmericaValueInBaseCurrency: number
+    northAmericaValueInBaseCurrency
-  ) {
+  }: {
-    super(exchangeRateDataService, {
+    currentValueInBaseCurrency: number;
+    exchangeRateDataService: ExchangeRateDataService;
+    i18nService: I18nService;
+    languageCode: string;
+    northAmericaValueInBaseCurrency: number;
+  }) {
+    super({
+      exchangeRateDataService,
       languageCode,
       key: 'RegionalMarketClusterRiskNorthAmerica'
     });
 
     this.currentValueInBaseCurrency = currentValueInBaseCurrency;
+    this.i18nService = i18nService;
     this.northAmericaValueInBaseCurrency = northAmericaValueInBaseCurrency;
   }