change rule service interface

apps/api/src/models/interfaces/rule.interface.ts

@@ -1,17 +1,9 @@
-import { PortfolioPosition } from '@ghostfolio/common/interfaces';
-
 import { UserSettings } from '@ghostfolio/api/models/interfaces/user-settings.interface';
 import { EvaluationResult } from './evaluation-result.interface';
 import { RuleSettings } from '@ghostfolio/api/models/interfaces/rule-settings.interface';
 
 export interface RuleInterface<T extends RuleSettings> {
-  evaluate(
+  evaluate(aRuleSettings: T): EvaluationResult;
-    aPortfolioPositionMap: {
-      [symbol: string]: PortfolioPosition;
-    },
-    aFees: number,
-    aRuleSettings: T
-  ): EvaluationResult;
 
   getSettings(aUserSettings: UserSettings): T;
 }

apps/api/src/models/portfolio.ts

@@ -450,42 +450,51 @@ export class Portfolio implements PortfolioInterface {
     return {
       rules: {
         accountClusterRisk: await this.rulesService.evaluate(
-          details,
-          fees,
           [
             new AccountClusterRiskInitialInvestment(
-              this.exchangeRateDataService
+              this.exchangeRateDataService,
+              details
             ),
             new AccountClusterRiskCurrentInvestment(
-              this.exchangeRateDataService
+              this.exchangeRateDataService,
+              details
             ),
-            new AccountClusterRiskSingleAccount(this.exchangeRateDataService)
+            new AccountClusterRiskSingleAccount(
+              this.exchangeRateDataService,
+              details
+            )
           ],
           { baseCurrency: this.user.Settings.currency }
         ),
         currencyClusterRisk: await this.rulesService.evaluate(
-          details,
-          fees,
           [
             new CurrencyClusterRiskBaseCurrencyInitialInvestment(
-              this.exchangeRateDataService
+              this.exchangeRateDataService,
+              details
             ),
             new CurrencyClusterRiskBaseCurrencyCurrentInvestment(
-              this.exchangeRateDataService
+              this.exchangeRateDataService,
+              details
             ),
             new CurrencyClusterRiskInitialInvestment(
-              this.exchangeRateDataService
+              this.exchangeRateDataService,
+              details
             ),
             new CurrencyClusterRiskCurrentInvestment(
-              this.exchangeRateDataService
+              this.exchangeRateDataService,
+              details
             )
           ],
           { baseCurrency: this.user.Settings.currency }
         ),
         fees: await this.rulesService.evaluate(
+          [
+            new FeeRatioInitialInvestment(
+              this.exchangeRateDataService,
               details,
-          fees,
+              fees
-          [new FeeRatioInitialInvestment(this.exchangeRateDataService)],
+            )
+          ],
           { baseCurrency: this.user.Settings.currency }
         )
       }

apps/api/src/models/rule.ts

@@ -12,7 +12,7 @@ export abstract class Rule<T extends RuleSettings> implements RuleInterface<T> {
   private name: string;
 
   public constructor(
-    public exchangeRateDataService: ExchangeRateDataService,
+    protected exchangeRateDataService: ExchangeRateDataService,
     {
       name
     }: {
@@ -22,13 +22,7 @@ export abstract class Rule<T extends RuleSettings> implements RuleInterface<T> {
     this.name = name;
   }
 
-  public abstract evaluate(
+  public abstract evaluate(aRuleSettings: T): EvaluationResult;
-    aPortfolioPositionMap: {
-      [symbol: string]: PortfolioPosition;
-    },
-    aFees: number,
-    aRuleSettings: T
-  ): EvaluationResult;
 
   public abstract getSettings(aUserSettings: UserSettings): T;
 

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

@@ -6,24 +6,23 @@ import { UserSettings } from '@ghostfolio/api/models/interfaces/user-settings.in
 import { RuleSettings } from '@ghostfolio/api/models/interfaces/rule-settings.interface';
 
 export class AccountClusterRiskCurrentInvestment extends Rule<Settings> {
-  public constructor(public exchangeRateDataService: ExchangeRateDataService) {
+  public constructor(
+    protected exchangeRateDataService: ExchangeRateDataService,
+    private positions: { [symbol: string]: PortfolioPosition }
+  ) {
     super(exchangeRateDataService, {
       name: 'Current Investment'
     });
   }
 
-  public evaluate(
+  public evaluate(ruleSettings: Settings) {
-    aPositions: { [symbol: string]: PortfolioPosition },
-    aFees: number,
-    ruleSettings?: Settings
-  ) {
     const accounts: {
       [symbol: string]: Pick<PortfolioPosition, 'name'> & {
         investment: number;
       };
     } = {};
 
-    Object.values(aPositions).forEach((position) => {
+    Object.values(this.positions).forEach((position) => {
       for (const [account, { current }] of Object.entries(position.accounts)) {
         if (accounts[account]?.investment) {
           accounts[account].investment += current;

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

@@ -6,24 +6,23 @@ import { UserSettings } from '@ghostfolio/api/models/interfaces/user-settings.in
 import { RuleSettings } from '@ghostfolio/api/models/interfaces/rule-settings.interface';
 
 export class AccountClusterRiskInitialInvestment extends Rule<Settings> {
-  public constructor(public exchangeRateDataService: ExchangeRateDataService) {
+  public constructor(
+    protected exchangeRateDataService: ExchangeRateDataService,
+    private positions: { [symbol: string]: PortfolioPosition }
+  ) {
     super(exchangeRateDataService, {
       name: 'Initial Investment'
     });
   }
 
-  public evaluate(
+  public evaluate(ruleSettings?: Settings) {
-    aPositions: { [symbol: string]: PortfolioPosition },
-    aFees: number,
-    ruleSettings?: Settings
-  ) {
     const platforms: {
       [symbol: string]: Pick<PortfolioPosition, 'name'> & {
         investment: number;
       };
     } = {};
 
-    Object.values(aPositions).forEach((position) => {
+    Object.values(this.positions).forEach((position) => {
       for (const [account, { original }] of Object.entries(position.accounts)) {
         if (platforms[account]?.investment) {
           platforms[account].investment += original;

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

@@ -6,16 +6,19 @@ import { UserSettings } from '@ghostfolio/api/models/interfaces/user-settings.in
 import { RuleSettings } from '@ghostfolio/api/models/interfaces/rule-settings.interface';
 
 export class AccountClusterRiskSingleAccount extends Rule<RuleSettings> {
-  public constructor(public exchangeRateDataService: ExchangeRateDataService) {
+  public constructor(
+    protected exchangeRateDataService: ExchangeRateDataService,
+    private positions: { [symbol: string]: PortfolioPosition }
+  ) {
     super(exchangeRateDataService, {
       name: 'Single Account'
     });
   }
 
-  public evaluate(positions: { [symbol: string]: PortfolioPosition }) {
+  public evaluate() {
     const accounts: string[] = [];
 
-    Object.values(positions).forEach((position) => {
+    Object.values(this.positions).forEach((position) => {
       for (const [account] of Object.entries(position.accounts)) {
         if (!accounts.includes(account)) {
           accounts.push(account);

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

@@ -7,19 +7,18 @@ import { UserSettings } from '@ghostfolio/api/models/interfaces/user-settings.in
 import { RuleSettings } from '@ghostfolio/api/models/interfaces/rule-settings.interface';
 
 export class CurrencyClusterRiskBaseCurrencyCurrentInvestment extends Rule<Settings> {
-  public constructor(public exchangeRateDataService: ExchangeRateDataService) {
+  public constructor(
+    protected exchangeRateDataService: ExchangeRateDataService,
+    private positions: { [symbol: string]: PortfolioPosition }
+  ) {
     super(exchangeRateDataService, {
       name: 'Current Investment: Base Currency'
     });
   }
 
-  public evaluate(
+  public evaluate(ruleSettings: Settings) {
-    aPositions: { [symbol: string]: PortfolioPosition },
-    aFees: number,
-    ruleSettings: Settings
-  ) {
     const positionsGroupedByCurrency = this.groupPositionsByAttribute(
-      aPositions,
+      this.positions,
       'currency',
       ruleSettings.baseCurrency
     );

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

@@ -7,19 +7,18 @@ import { UserSettings } from '@ghostfolio/api/models/interfaces/user-settings.in
 import { RuleSettings } from '@ghostfolio/api/models/interfaces/rule-settings.interface';
 
 export class CurrencyClusterRiskBaseCurrencyInitialInvestment extends Rule<Settings> {
-  public constructor(public exchangeRateDataService: ExchangeRateDataService) {
+  public constructor(
+    protected exchangeRateDataService: ExchangeRateDataService,
+    private positions: { [symbol: string]: PortfolioPosition }
+  ) {
     super(exchangeRateDataService, {
       name: 'Initial Investment: Base Currency'
     });
   }
 
-  public evaluate(
+  public evaluate(ruleSettings: Settings) {
-    aPositions: { [symbol: string]: PortfolioPosition },
-    aFees: number,
-    ruleSettings: Settings
-  ) {
     const positionsGroupedByCurrency = this.groupPositionsByAttribute(
-      aPositions,
+      this.positions,
       'currency',
       ruleSettings.baseCurrency
     );

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

@@ -7,19 +7,18 @@ import { Currency } from '@prisma/client';
 import { RuleSettings } from '@ghostfolio/api/models/interfaces/rule-settings.interface';
 
 export class CurrencyClusterRiskCurrentInvestment extends Rule<Settings> {
-  public constructor(public exchangeRateDataService: ExchangeRateDataService) {
+  public constructor(
+    public exchangeRateDataService: ExchangeRateDataService,
+    private positions: { [symbol: string]: PortfolioPosition }
+  ) {
     super(exchangeRateDataService, {
       name: 'Current Investment'
     });
   }
 
-  public evaluate(
+  public evaluate(ruleSettings: Settings) {
-    aPositions: { [symbol: string]: PortfolioPosition },
-    aFees: number,
-    ruleSettings: Settings
-  ) {
     const positionsGroupedByCurrency = this.groupPositionsByAttribute(
-      aPositions,
+      this.positions,
       'currency',
       ruleSettings.baseCurrency
     );

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

@@ -7,19 +7,18 @@ import { UserSettings } from '@ghostfolio/api/models/interfaces/user-settings.in
 import { RuleSettings } from '@ghostfolio/api/models/interfaces/rule-settings.interface';
 
 export class CurrencyClusterRiskInitialInvestment extends Rule<Settings> {
-  public constructor(public exchangeRateDataService: ExchangeRateDataService) {
+  public constructor(
+    protected exchangeRateDataService: ExchangeRateDataService,
+    private positions: { [symbol: string]: PortfolioPosition }
+  ) {
     super(exchangeRateDataService, {
       name: 'Initial Investment'
     });
   }
 
-  public evaluate(
+  public evaluate(ruleSettings: Settings) {
-    aPositions: { [symbol: string]: PortfolioPosition },
-    aFees: number,
-    ruleSettings: Settings
-  ) {
     const positionsGroupedByCurrency = this.groupPositionsByAttribute(
-      aPositions,
+      this.positions,
       'currency',
       ruleSettings.baseCurrency
     );

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

@@ -7,19 +7,19 @@ import { UserSettings } from '@ghostfolio/api/models/interfaces/user-settings.in
 import { RuleSettings } from '@ghostfolio/api/models/interfaces/rule-settings.interface';
 
 export class FeeRatioInitialInvestment extends Rule<Settings> {
-  public constructor(public exchangeRateDataService: ExchangeRateDataService) {
+  public constructor(
+    protected exchangeRateDataService: ExchangeRateDataService,
+    private positions: { [symbol: string]: PortfolioPosition },
+    private fees: number
+  ) {
     super(exchangeRateDataService, {
       name: 'Initial Investment'
     });
   }
 
-  public evaluate(
+  public evaluate(ruleSettings: Settings) {
-    aPositions: { [symbol: string]: PortfolioPosition },
-    aFees: number,
-    ruleSettings: Settings
-  ) {
     const positionsGroupedByCurrency = this.groupPositionsByAttribute(
-      aPositions,
+      this.positions,
       'currency',
       ruleSettings.baseCurrency
     );
@@ -31,7 +31,7 @@ export class FeeRatioInitialInvestment extends Rule<Settings> {
       totalInvestment += groupItem.investment;
     });
 
-    const feeRatio = aFees / totalInvestment;
+    const feeRatio = this.fees / totalInvestment;
 
     if (feeRatio > ruleSettings.threshold) {
       return {

apps/api/src/services/rules.service.ts

@@ -1,6 +1,5 @@
 import { Injectable } from '@nestjs/common';
 import { Rule } from '../models/rule';
-import { PortfolioPosition } from '@ghostfolio/common/interfaces';
 import { Currency } from '@prisma/client';
 import { RuleSettings } from '@ghostfolio/api/models/interfaces/rule-settings.interface';
 
@@ -9,8 +8,6 @@ export class RulesService {
   public constructor() {}
 
   public async evaluate<T extends RuleSettings>(
-    details: { [p: string]: PortfolioPosition },
-    fees: number,
     aRules: Rule<T>[],
     aUserSettings: { baseCurrency: Currency }
   ) {
@@ -19,11 +16,7 @@ export class RulesService {
         return rule.getSettings(aUserSettings)?.isActive;
       })
       .map((rule) => {
-        const evaluationResult = rule.evaluate(
+        const evaluationResult = rule.evaluate(rule.getSettings(aUserSettings));
-          details,
-          fees,
-          rule.getSettings(aUserSettings)
-        );
         return { ...evaluationResult, name: rule.getName() };
       });
   }