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
1 week ago · c008c338ee
19 changed files with 411 additions and 249 deletions
--- a/apps/api/src/app/portfolio/portfolio.service.ts
+++ b/apps/api/src/app/portfolio/portfolio.service.ts
@ -1338,12 +1338,12 @@ export class PortfolioService {
        }),
        rules: await this.rulesService.evaluate(
          [
-            new BuyingPower(
-              this.exchangeRateDataService,
-              this.i18nService,
-              summary.cash,
-              languageCode
-            )
+            new BuyingPower({
+              languageCode,
+              buyingPower: summary.cash,
+              exchangeRateDataService: this.exchangeRateDataService,
+              i18nService: this.i18nService
+            })
          ],
          userSettings
        )
@ -1356,24 +1356,24 @@ export class PortfolioService {
        }),
        rules: await this.rulesService.evaluate(
          [
-            new EmergencyFundSetup(
-              this.exchangeRateDataService,
-              this.i18nService,
+            new EmergencyFundSetup({
              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(
-                    this.exchangeRateDataService,
-                    this.i18nService,
-                    languageCode,
-                    emergencyFundInBaseCurrency,
+                  new EmergencyFundCoverage({
+                    cashBalanceInBaseCurrency,
                    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(
-                  this.exchangeRateDataService,
-                  this.i18nService,
+                new CurrencyClusterRiskBaseCurrencyCurrentInvestment({
                  holdings,
-                  languageCode
-                ),
-                new CurrencyClusterRiskCurrentInvestment(
-                  this.exchangeRateDataService,
-                  this.i18nService,
+                  languageCode,
+                  exchangeRateDataService: this.exchangeRateDataService,
+                  i18nService: 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(
-                  this.exchangeRateDataService,
-                  this.i18nService,
+                new AssetClassClusterRiskEquity({
+                  holdings,
                  languageCode,
-                  holdings
-                ),
-                new AssetClassClusterRiskFixedIncome(
-                  this.exchangeRateDataService,
-                  this.i18nService,
+                  exchangeRateDataService: this.exchangeRateDataService,
+                  i18nService: this.i18nService
+                }),
+                new AssetClassClusterRiskFixedIncome({
+                  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(
-                    this.exchangeRateDataService,
-                    this.i18nService,
+                  new AccountClusterRiskCurrentInvestment({
+                    accounts,
                    languageCode,
-                    accounts
-                  ),
-                  new AccountClusterRiskSingleAccount(
-                    this.exchangeRateDataService,
-                    this.i18nService,
+                    exchangeRateDataService: this.exchangeRateDataService,
+                    i18nService: this.i18nService
+                  }),
+                  new AccountClusterRiskSingleAccount({
+                    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(
-                  this.exchangeRateDataService,
-                  this.i18nService,
-                  marketsTotalInBaseCurrency,
+                new EconomicMarketClusterRiskDevelopedMarkets({
+                  languageCode,
+                  currentValueInBaseCurrency: marketsTotalInBaseCurrency,
+                  developedMarketsValueInBaseCurrency:
                    markets.developedMarkets.valueInBaseCurrency,
-                  languageCode
-                ),
-                new EconomicMarketClusterRiskEmergingMarkets(
-                  this.exchangeRateDataService,
-                  this.i18nService,
-                  marketsTotalInBaseCurrency,
+                  exchangeRateDataService: this.exchangeRateDataService,
+                  i18nService: this.i18nService
+                }),
+                new EconomicMarketClusterRiskEmergingMarkets({
+                  languageCode,
+                  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(
-                  this.exchangeRateDataService,
-                  this.i18nService,
+                new RegionalMarketClusterRiskAsiaPacific({
                  languageCode,
+                  asiaPacificValueInBaseCurrency:
+                    marketsAdvanced.asiaPacific.valueInBaseCurrency,
+                  currentValueInBaseCurrency:
                    marketsAdvancedTotalInBaseCurrency,
-                  marketsAdvanced.asiaPacific.valueInBaseCurrency
-                ),
-                new RegionalMarketClusterRiskEmergingMarkets(
-                  this.exchangeRateDataService,
-                  this.i18nService,
+                  exchangeRateDataService: this.exchangeRateDataService,
+                  i18nService: this.i18nService
+                }),
+                new RegionalMarketClusterRiskEmergingMarkets({
                  languageCode,
+                  currentValueInBaseCurrency:
                    marketsAdvancedTotalInBaseCurrency,
-                  marketsAdvanced.emergingMarkets.valueInBaseCurrency
-                ),
-                new RegionalMarketClusterRiskEurope(
-                  this.exchangeRateDataService,
-                  this.i18nService,
+                  emergingMarketsValueInBaseCurrency:
+                    marketsAdvanced.emergingMarkets.valueInBaseCurrency,
+                  exchangeRateDataService: this.exchangeRateDataService,
+                  i18nService: this.i18nService
+                }),
+                new RegionalMarketClusterRiskEurope({
                  languageCode,
+                  currentValueInBaseCurrency:
                    marketsAdvancedTotalInBaseCurrency,
-                  marketsAdvanced.europe.valueInBaseCurrency
-                ),
-                new RegionalMarketClusterRiskJapan(
-                  this.exchangeRateDataService,
-                  this.i18nService,
+                  europeValueInBaseCurrency:
+                    marketsAdvanced.europe.valueInBaseCurrency,
+                  exchangeRateDataService: this.exchangeRateDataService,
+                  i18nService: this.i18nService
+                }),
+                new RegionalMarketClusterRiskJapan({
                  languageCode,
+                  currentValueInBaseCurrency:
                    marketsAdvancedTotalInBaseCurrency,
-                  marketsAdvanced.japan.valueInBaseCurrency
-                ),
-                new RegionalMarketClusterRiskNorthAmerica(
-                  this.exchangeRateDataService,
-                  this.i18nService,
+                  japanValueInBaseCurrency:
+                    marketsAdvanced.japan.valueInBaseCurrency,
+                  exchangeRateDataService: this.exchangeRateDataService,
+                  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(
-              this.exchangeRateDataService,
-              this.i18nService,
+            new FeeRatioTotalInvestmentVolume({
              languageCode,
-              summary.totalBuy + summary.totalSell,
-              summary.fees
-            )
+              exchangeRateDataService: this.exchangeRateDataService,
+              fees: summary.fees,
+              i18nService: this.i18nService,
+              totalInvestmentVolumeInBaseCurrency:
+                summary.totalBuy + summary.totalSell
+            })
          ],
          userSettings
        )
--- a/apps/api/src/models/rule.ts
+++ b/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(
-    protected exchangeRateDataService: ExchangeRateDataService,
-    {
+  public constructor({
+    exchangeRateDataService,
    key,
    languageCode
  }: {
+    exchangeRateDataService: ExchangeRateDataService;
    key: XRayRuleKey;
    languageCode: string;
-    }
-  ) {
+  }) {
+    this.exchangeRateDataService = exchangeRateDataService;
    this.key = key;
    this.languageCode = languageCode;
  }
--- a/apps/api/src/models/rules/account-cluster-risk/current-investment.ts
+++ b/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'];
-
-  public constructor(
-    exchangeRateDataService: ExchangeRateDataService,
-    private i18nService: I18nService,
-    languageCode: string,
-    accounts: PortfolioDetails['accounts']
-  ) {
-    super(exchangeRateDataService, {
+  private i18nService: I18nService;
+
+  public constructor({
+    accounts,
+    exchangeRateDataService,
+    i18nService,
+    languageCode
+  }: {
+    accounts: PortfolioDetails['accounts'];
+    exchangeRateDataService: ExchangeRateDataService;
+    i18nService: I18nService;
+    languageCode: string;
+  }) {
+    super({
+      exchangeRateDataService,
      languageCode,
      key: 'AccountClusterRiskCurrentInvestment'
    });

    this.accounts = accounts;
+    this.i18nService = i18nService;
  }

  public evaluate(ruleSettings: Settings) {
--- a/apps/api/src/models/rules/account-cluster-risk/single-account.ts
+++ b/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(
-    exchangeRateDataService: ExchangeRateDataService,
-    private i18nService: I18nService,
-    languageCode: string,
-    accounts: PortfolioDetails['accounts']
-  ) {
-    super(exchangeRateDataService, {
+  public constructor({
+    accounts,
+    exchangeRateDataService,
+    i18nService,
+    languageCode
+  }: {
+    accounts: PortfolioDetails['accounts'];
+    exchangeRateDataService: ExchangeRateDataService;
+    i18nService: I18nService;
+    languageCode: string;
+  }) {
+    super({
+      exchangeRateDataService,
      languageCode,
      key: 'AccountClusterRiskSingleAccount'
    });

    this.accounts = accounts;
+    this.i18nService = i18nService;
  }

  public evaluate() {
--- a/apps/api/src/models/rules/asset-class-cluster-risk/equity.ts
+++ b/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(
-    exchangeRateDataService: ExchangeRateDataService,
-    private i18nService: I18nService,
-    languageCode: string,
-    holdings: PortfolioPosition[]
-  ) {
-    super(exchangeRateDataService, {
+  public constructor({
+    exchangeRateDataService,
+    holdings,
+    i18nService,
+    languageCode
+  }: {
+    exchangeRateDataService: ExchangeRateDataService;
+    holdings: PortfolioPosition[];
+    i18nService: I18nService;
+    languageCode: string;
+  }) {
+    super({
+      exchangeRateDataService,
      languageCode,
      key: 'AssetClassClusterRiskEquity'
    });

    this.holdings = holdings;
+    this.i18nService = i18nService;
  }

  public evaluate(ruleSettings: Settings) {
--- a/apps/api/src/models/rules/asset-class-cluster-risk/fixed-income.ts
+++ b/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(
-    exchangeRateDataService: ExchangeRateDataService,
-    private i18nService: I18nService,
-    languageCode: string,
-    holdings: PortfolioPosition[]
-  ) {
-    super(exchangeRateDataService, {
+  public constructor({
+    exchangeRateDataService,
+    holdings,
+    i18nService,
+    languageCode
+  }: {
+    exchangeRateDataService: ExchangeRateDataService;
+    holdings: PortfolioPosition[];
+    i18nService: I18nService;
+    languageCode: string;
+  }) {
+    super({
+      exchangeRateDataService,
      languageCode,
      key: 'AssetClassClusterRiskFixedIncome'
    });

    this.holdings = holdings;
+    this.i18nService = i18nService;
  }

  public evaluate(ruleSettings: Settings) {
--- a/apps/api/src/models/rules/currency-cluster-risk/base-currency-current-investment.ts
+++ b/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(
-    exchangeRateDataService: ExchangeRateDataService,
-    private i18nService: I18nService,
-    holdings: PortfolioPosition[],
-    languageCode: string
-  ) {
-    super(exchangeRateDataService, {
+  public constructor({
+    exchangeRateDataService,
+    holdings,
+    i18nService,
+    languageCode
+  }: {
+    exchangeRateDataService: ExchangeRateDataService;
+    holdings: PortfolioPosition[];
+    i18nService: I18nService;
+    languageCode: string;
+  }) {
+    super({
+      exchangeRateDataService,
      languageCode,
      key: 'CurrencyClusterRiskBaseCurrencyCurrentInvestment'
    });

    this.holdings = holdings;
+    this.i18nService = i18nService;
  }

  public evaluate(ruleSettings: Settings) {
--- a/apps/api/src/models/rules/currency-cluster-risk/current-investment.ts
+++ b/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(
-    exchangeRateDataService: ExchangeRateDataService,
-    private i18nService: I18nService,
-    holdings: PortfolioPosition[],
-    languageCode: string
-  ) {
-    super(exchangeRateDataService, {
+  public constructor({
+    exchangeRateDataService,
+    holdings,
+    i18nService,
+    languageCode
+  }: {
+    exchangeRateDataService: ExchangeRateDataService;
+    holdings: PortfolioPosition[];
+    i18nService: I18nService;
+    languageCode: string;
+  }) {
+    super({
+      exchangeRateDataService,
      languageCode,
      key: 'CurrencyClusterRiskCurrentInvestment'
    });

    this.holdings = holdings;
+    this.i18nService = i18nService;
  }

  public evaluate(ruleSettings: Settings) {
--- a/apps/api/src/models/rules/economic-market-cluster-risk/developed-markets.ts
+++ b/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(
-    exchangeRateDataService: ExchangeRateDataService,
-    private i18nService: I18nService,
-    currentValueInBaseCurrency: number,
-    developedMarketsValueInBaseCurrency: number,
-    languageCode: string
-  ) {
-    super(exchangeRateDataService, {
+  public constructor({
+    currentValueInBaseCurrency,
+    developedMarketsValueInBaseCurrency,
+    exchangeRateDataService,
+    i18nService,
+    languageCode
+  }: {
+    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) {
--- a/apps/api/src/models/rules/economic-market-cluster-risk/emerging-markets.ts
+++ b/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(
-    exchangeRateDataService: ExchangeRateDataService,
-    private i18nService: I18nService,
-    currentValueInBaseCurrency: number,
-    emergingMarketsValueInBaseCurrency: number,
-    languageCode: string
-  ) {
-    super(exchangeRateDataService, {
+  public constructor({
+    currentValueInBaseCurrency,
+    emergingMarketsValueInBaseCurrency,
+    exchangeRateDataService,
+    i18nService,
+    languageCode
+  }: {
+    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) {
--- a/apps/api/src/models/rules/emergency-fund/emergency-fund-coverage.ts
+++ b/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(
-    exchangeRateDataService: ExchangeRateDataService,
-    private i18nService: I18nService,
-    languageCode: string,
-    private emergencyFundInBaseCurrency: number,
-    private emergencyFundHoldingsValueInBaseCurrency: number,
-    private cashBalanceInBaseCurrency: number
-  ) {
-    super(exchangeRateDataService, {
+  private cashBalanceInBaseCurrency: number;
+  private emergencyFundHoldingsValueInBaseCurrency: number;
+  private emergencyFundInBaseCurrency: number;
+  private i18nService: I18nService;
+
+  public constructor({
+    cashBalanceInBaseCurrency,
+    emergencyFundHoldingsValueInBaseCurrency,
+    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) {
--- a/apps/api/src/models/rules/emergency-fund/emergency-fund-setup.ts
+++ b/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;
-
-  public constructor(
-    exchangeRateDataService: ExchangeRateDataService,
-    private i18nService: I18nService,
-    languageCode: string,
-    emergencyFund: number
-  ) {
-    super(exchangeRateDataService, {
-      languageCode,
-      key: 'EmergencyFundSetup'
-    });
-
-    this.emergencyFund = emergencyFund;
+  private emergencyFundInBaseCurrency: number;
+  private i18nService: I18nService;
+
+  public constructor({
+    emergencyFundInBaseCurrency,
+    exchangeRateDataService,
+    i18nService,
+    languageCode
+  }: {
+    emergencyFundInBaseCurrency: number;
+    exchangeRateDataService: ExchangeRateDataService;
+    i18nService: I18nService;
+    languageCode: string;
+  }) {
+    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',
--- a/apps/api/src/models/rules/fees/fee-ratio-total-investment-volume.ts
+++ b/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(
-    exchangeRateDataService: ExchangeRateDataService,
-    private i18nService: I18nService,
-    languageCode: string,
-    totalInvestmentVolumeInBaseCurrency: number,
-    fees: number
-  ) {
-    super(exchangeRateDataService, {
+  public constructor({
+    exchangeRateDataService,
+    fees,
+    i18nService,
+    languageCode,
+    totalInvestmentVolumeInBaseCurrency
+  }: {
+    exchangeRateDataService: ExchangeRateDataService;
+    fees: number;
+    i18nService: I18nService;
+    languageCode: string;
+    totalInvestmentVolumeInBaseCurrency: number;
+  }) {
+    super({
+      exchangeRateDataService,
      languageCode,
      key: 'FeeRatioTotalInvestmentVolume'
    });

    this.fees = fees;
+    this.i18nService = i18nService;
    this.totalInvestmentVolumeInBaseCurrency =
      totalInvestmentVolumeInBaseCurrency;
  }
--- a/apps/api/src/models/rules/liquidity/buying-power.ts
+++ b/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(
-    exchangeRateDataService: ExchangeRateDataService,
-    private i18nService: I18nService,
-    buyingPower: number,
-    languageCode: string
-  ) {
-    super(exchangeRateDataService, {
-      languageCode,
-      key: 'BuyingPower'
-    });
+  public constructor({
+    buyingPower,
+    exchangeRateDataService,
+    i18nService,
+    languageCode
+  }: {
+    buyingPower: number;
+    exchangeRateDataService: ExchangeRateDataService;
+    i18nService: I18nService;
+    languageCode: string;
+  }) {
+    super({ exchangeRateDataService, languageCode, key: 'BuyingPower' });

    this.buyingPower = buyingPower;
+    this.i18nService = i18nService;
  }

  public evaluate(ruleSettings: Settings) {
--- a/apps/api/src/models/rules/regional-market-cluster-risk/asia-pacific.ts
+++ b/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(
-    exchangeRateDataService: ExchangeRateDataService,
-    private i18nService: I18nService,
-    languageCode: string,
-    currentValueInBaseCurrency: number,
-    asiaPacificValueInBaseCurrency: number
-  ) {
-    super(exchangeRateDataService, {
+  public constructor({
+    asiaPacificValueInBaseCurrency,
+    currentValueInBaseCurrency,
+    exchangeRateDataService,
+    i18nService,
+    languageCode
+  }: {
+    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) {
--- a/apps/api/src/models/rules/regional-market-cluster-risk/emerging-markets.ts
+++ b/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(
-    exchangeRateDataService: ExchangeRateDataService,
-    private i18nService: I18nService,
-    languageCode: string,
-    currentValueInBaseCurrency: number,
-    emergingMarketsValueInBaseCurrency: number
-  ) {
-    super(exchangeRateDataService, {
+  public constructor({
+    currentValueInBaseCurrency,
+    emergingMarketsValueInBaseCurrency,
+    exchangeRateDataService,
+    i18nService,
+    languageCode
+  }: {
+    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) {
--- a/apps/api/src/models/rules/regional-market-cluster-risk/europe.ts
+++ b/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(
-    exchangeRateDataService: ExchangeRateDataService,
-    private i18nService: I18nService,
-    languageCode: string,
-    currentValueInBaseCurrency: number,
-    europeValueInBaseCurrency: number
-  ) {
-    super(exchangeRateDataService, {
+  public constructor({
+    currentValueInBaseCurrency,
+    europeValueInBaseCurrency,
+    exchangeRateDataService,
+    i18nService,
+    languageCode
+  }: {
+    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) {
--- a/apps/api/src/models/rules/regional-market-cluster-risk/japan.ts
+++ b/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(
-    exchangeRateDataService: ExchangeRateDataService,
-    private i18nService: I18nService,
-    languageCode: string,
-    currentValueInBaseCurrency: number,
-    japanValueInBaseCurrency: number
-  ) {
-    super(exchangeRateDataService, {
+  public constructor({
+    currentValueInBaseCurrency,
+    exchangeRateDataService,
+    i18nService,
+    japanValueInBaseCurrency,
+    languageCode
+  }: {
+    currentValueInBaseCurrency: number;
+    exchangeRateDataService: ExchangeRateDataService;
+    i18nService: I18nService;
+    japanValueInBaseCurrency: number;
+    languageCode: string;
+  }) {
+    super({
+      exchangeRateDataService,
      languageCode,
      key: 'RegionalMarketClusterRiskJapan'
    });

    this.currentValueInBaseCurrency = currentValueInBaseCurrency;
+    this.i18nService = i18nService;
    this.japanValueInBaseCurrency = japanValueInBaseCurrency;
  }

--- a/apps/api/src/models/rules/regional-market-cluster-risk/north-america.ts
+++ b/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(
-    exchangeRateDataService: ExchangeRateDataService,
-    private i18nService: I18nService,
-    languageCode: string,
-    currentValueInBaseCurrency: number,
-    northAmericaValueInBaseCurrency: number
-  ) {
-    super(exchangeRateDataService, {
+  public constructor({
+    currentValueInBaseCurrency,
+    exchangeRateDataService,
+    i18nService,
+    languageCode,
+    northAmericaValueInBaseCurrency
+  }: {
+    currentValueInBaseCurrency: number;
+    exchangeRateDataService: ExchangeRateDataService;
+    i18nService: I18nService;
+    languageCode: string;
+    northAmericaValueInBaseCurrency: number;
+  }) {
+    super({
+      exchangeRateDataService,
      languageCode,
      key: 'RegionalMarketClusterRiskNorthAmerica'
    });

    this.currentValueInBaseCurrency = currentValueInBaseCurrency;
+    this.i18nService = i18nService;
    this.northAmericaValueInBaseCurrency = northAmericaValueInBaseCurrency;
  }