Move percentage formulas of portfolio calculator to method class

apps/api/src/app/portfolio/calculator/mwr/portfolio-calculator.ts

@@ -1,12 +1,28 @@
 import { PortfolioCalculator } from '@ghostfolio/api/app/portfolio/calculator/portfolio-calculator';
+import { AccumulatedValues } from '@ghostfolio/api/app/portfolio/interfaces/accumulated-values.interface';
 import { HoldingPerformance } from '@ghostfolio/api/app/portfolio/interfaces/holding-performance.interface';
-import { PortfolioCalculatorHolding } from '@ghostfolio/api/app/portfolio/interfaces/portfolio-calculator-holding.interface';
+import { NetPerformancePercentages } from '@ghostfolio/api/app/portfolio/interfaces/net-performance-percentages.interface';
-import { AssetProfileIdentifier } from '@ghostfolio/common/interfaces';
+import {
+  AssetProfileIdentifier,
+  HistoricalDataItem
+} from '@ghostfolio/common/interfaces';
 import { PortfolioSnapshot } from '@ghostfolio/common/models';
 import { PerformanceCalculationType } from '@ghostfolio/common/types/performance-calculation-type.type';
 
 export class MwrPortfolioCalculator extends PortfolioCalculator {
-  protected calculateOverallPerformance([]: PortfolioCalculatorHolding[]): PortfolioSnapshot {
+  protected calculateNetPerformancePercentages({}: {
+    accumulatedValuesByDate: { [date: string]: AccumulatedValues };
+  }): { [date: string]: NetPerformancePercentages } {
+    throw new Error('Method not implemented.');
+  }
+
+  protected calculateNetPerformancePercentagesForDateRange({}: {
+    historicalDataItems: HistoricalDataItem[];
+  }): { [date: string]: NetPerformancePercentages } {
+    throw new Error('Method not implemented.');
+  }
+
+  protected calculateOverallPerformance(): PortfolioSnapshot {
     throw new Error('Method not implemented.');
   }
 

apps/api/src/app/portfolio/calculator/portfolio-calculator.ts

@@ -1,8 +1,10 @@
 import { CurrentRateService } from '@ghostfolio/api/app/portfolio/current-rate.service';
 import { PortfolioSnapshotComputationError } from '@ghostfolio/api/app/portfolio/errors/portfolio-snapshot-computation.error';
+import { AccumulatedValues } from '@ghostfolio/api/app/portfolio/interfaces/accumulated-values.interface';
 import { HoldingPerformance } from '@ghostfolio/api/app/portfolio/interfaces/holding-performance.interface';
 import { HoldingValuationItem } from '@ghostfolio/api/app/portfolio/interfaces/holding-valuation-item.interface';
 import { HoldingValuation } from '@ghostfolio/api/app/portfolio/interfaces/holding-valuation.interface';
+import { NetPerformancePercentages } from '@ghostfolio/api/app/portfolio/interfaces/net-performance-percentages.interface';
 import { PortfolioCalculatorActivityItem } from '@ghostfolio/api/app/portfolio/interfaces/portfolio-calculator-activity-item.interface';
 import { PortfolioCalculatorActivity } from '@ghostfolio/api/app/portfolio/interfaces/portfolio-calculator-activity.interface';
 import { PortfolioCalculatorHolding } from '@ghostfolio/api/app/portfolio/interfaces/portfolio-calculator-holding.interface';
@@ -67,7 +69,7 @@ import {
   startOfYear,
   subDays
 } from 'date-fns';
-import { groupBy, isNumber, sortBy, sum, uniqBy } from 'lodash';
+import { groupBy, isNumber, sortBy, uniqBy } from 'lodash';
 
 export abstract class PortfolioCalculator {
   protected static readonly ENABLE_LOGGING = false;
@@ -213,6 +215,18 @@ export abstract class PortfolioCalculator {
     this.snapshotPromise.catch(() => undefined);
   }
 
+  protected abstract calculateNetPerformancePercentages({
+    accumulatedValuesByDate
+  }: {
+    accumulatedValuesByDate: { [date: string]: AccumulatedValues };
+  }): { [date: string]: NetPerformancePercentages };
+
+  protected abstract calculateNetPerformancePercentagesForDateRange({
+    historicalDataItems
+  }: {
+    historicalDataItems: HistoricalDataItem[];
+  }): { [date: string]: NetPerformancePercentages };
+
   protected abstract calculateOverallPerformance(
     positions: PortfolioCalculatorHolding[]
   ): PortfolioSnapshot;
@@ -230,6 +244,8 @@ export abstract class PortfolioCalculator {
         activitiesCount: 0,
         createdAt: new Date(),
         currentValueInBaseCurrency: new Big(0),
+        dividendYieldPercent: new Big(0),
+        dividendYieldPercentWithCurrencyEffect: new Big(0),
         errors: [],
         hasErrors: false,
         historicalData: [],
@@ -353,19 +369,7 @@ export abstract class PortfolioCalculator {
     const positions: PortfolioCalculatorHolding[] = [];
 
     const accumulatedValuesByDate: {
-      [date: string]: {
+      [date: string]: AccumulatedValues;
-        investmentValueWithCurrencyEffect: Big;
-        totalAverageInvestmentValue: Big;
-        totalAverageInvestmentValueWithCurrencyEffect: Big;
-        totalCashValueWithCurrencyEffect: Big;
-        totalCurrentValue: Big;
-        totalCurrentValueWithCurrencyEffect: Big;
-        totalInvestmentValue: Big;
-        totalInvestmentValueWithCurrencyEffect: Big;
-        totalNetPerformanceValue: Big;
-        totalNetPerformanceValueWithCurrencyEffect: Big;
-        totalNetWorthValueWithCurrencyEffect: Big;
-      };
     } = {};
 
     const valuesByAssetProfileIdentifier: {
@@ -409,6 +413,8 @@ export abstract class PortfolioCalculator {
         averageInvestmentWithCurrencyEffect,
         currentValues,
         currentValuesWithCurrencyEffect,
+        dividendYieldPercent,
+        dividendYieldPercentWithCurrencyEffect,
         grossPerformance,
         grossPerformancePercentage,
         grossPerformancePercentageWithCurrencyEffect,
@@ -477,6 +483,8 @@ export abstract class PortfolioCalculator {
       positions.push({
         averageInvestment,
         averageInvestmentWithCurrencyEffect,
+        dividendYieldPercent,
+        dividendYieldPercentWithCurrencyEffect,
         activitiesCount: item.activitiesCount,
         averagePrice: item.averagePrice,
         currency: item.currency,
@@ -647,13 +655,14 @@ export abstract class PortfolioCalculator {
       }
     }
 
+    const netPerformancePercentagesByDate =
+      this.calculateNetPerformancePercentages({ accumulatedValuesByDate });
+
     const historicalData: HistoricalDataItem[] = Object.entries(
       accumulatedValuesByDate
     ).map(([date, values]) => {
       const {
         investmentValueWithCurrencyEffect,
-        totalAverageInvestmentValue,
-        totalAverageInvestmentValueWithCurrencyEffect,
         totalCashValueWithCurrencyEffect,
         totalCurrentValue,
         totalCurrentValueWithCurrencyEffect,
@@ -664,21 +673,9 @@ export abstract class PortfolioCalculator {
         totalNetWorthValueWithCurrencyEffect
       } = values;
 
-      const netPerformanceInPercentage = totalAverageInvestmentValue.eq(0)
-        ? 0
-        : totalNetPerformanceValue.div(totalAverageInvestmentValue).toNumber();
-
-      const netPerformanceInPercentageWithCurrencyEffect =
-        totalAverageInvestmentValueWithCurrencyEffect.eq(0)
-          ? 0
-          : totalNetPerformanceValueWithCurrencyEffect
-              .div(totalAverageInvestmentValueWithCurrencyEffect)
-              .toNumber();
-
       return {
+        ...netPerformancePercentagesByDate[date],
         date,
-        netPerformanceInPercentage,
-        netPerformanceInPercentageWithCurrencyEffect,
         investmentValueWithCurrencyEffect:
           investmentValueWithCurrencyEffect.toNumber(),
         netPerformance: totalNetPerformanceValue.toNumber(),
@@ -872,6 +869,8 @@ export abstract class PortfolioCalculator {
       averageInvestmentWithCurrencyEffect: new Big(0),
       currentValues: {},
       currentValuesWithCurrencyEffect: {},
+      dividendYieldPercent: new Big(0),
+      dividendYieldPercentWithCurrencyEffect: new Big(0),
       grossPerformance: new Big(0),
       grossPerformancePercentage: new Big(0),
       grossPerformancePercentageWithCurrencyEffect: new Big(0),
@@ -1342,12 +1341,8 @@ export abstract class PortfolioCalculator {
 
     const { historicalData } = this.snapshot;
 
-    const chart: HistoricalDataItem[] = [];
+    const historicalDataItemsOfDateRange: HistoricalDataItem[] = [];
 
-    const averageInvestmentValues: number[] = [];
-    const averageInvestmentValuesWithCurrencyEffect: number[] = [];
-    let grossPerformanceAtStartDate: number;
-    let grossPerformanceWithCurrencyEffectAtStartDate: number;
     let netPerformanceAtStartDate: number;
     let netPerformanceWithCurrencyEffectAtStartDate: number;
 
@@ -1356,71 +1351,35 @@ export abstract class PortfolioCalculator {
 
       if (!isBefore(date, start) && !isAfter(date, end)) {
         if (!isNumber(netPerformanceAtStartDate)) {
-          grossPerformanceAtStartDate =
-            historicalDataItem.value - historicalDataItem.totalInvestment;
-
-          grossPerformanceWithCurrencyEffectAtStartDate =
-            historicalDataItem.valueWithCurrencyEffect -
-            historicalDataItem.totalInvestmentValueWithCurrencyEffect;
-
           netPerformanceAtStartDate = historicalDataItem.netPerformance;
 
           netPerformanceWithCurrencyEffectAtStartDate =
             historicalDataItem.netPerformanceWithCurrencyEffect;
         }
 
-        const netPerformanceSinceStartDate =
+        historicalDataItemsOfDateRange.push({
-          historicalDataItem.netPerformance - netPerformanceAtStartDate;
-
-        const netPerformanceWithCurrencyEffectSinceStartDate =
-          historicalDataItem.netPerformanceWithCurrencyEffect -
-          netPerformanceWithCurrencyEffectAtStartDate;
-
-        // Add the gross performance at the start date of the range to the
-        // investment of each day. Thus the range starts with the value of its
-        // first day, and subsequent buy and sell activities stay included.
-        if (historicalDataItem.totalInvestment > 0) {
-          averageInvestmentValues.push(
-            historicalDataItem.totalInvestment + grossPerformanceAtStartDate
-          );
-        }
-
-        if (historicalDataItem.totalInvestmentValueWithCurrencyEffect > 0) {
-          averageInvestmentValuesWithCurrencyEffect.push(
-            historicalDataItem.totalInvestmentValueWithCurrencyEffect +
-              grossPerformanceWithCurrencyEffectAtStartDate
-          );
-        }
-
-        const averageInvestmentValue =
-          averageInvestmentValues.length > 0
-            ? sum(averageInvestmentValues) / averageInvestmentValues.length
-            : 0;
-
-        const averageInvestmentValueWithCurrencyEffect =
-          averageInvestmentValuesWithCurrencyEffect.length > 0
-            ? sum(averageInvestmentValuesWithCurrencyEffect) /
-              averageInvestmentValuesWithCurrencyEffect.length
-            : 0;
-
-        chart.push({
           ...historicalDataItem,
-          netPerformance: netPerformanceSinceStartDate,
+          netPerformance:
+            historicalDataItem.netPerformance - netPerformanceAtStartDate,
           netPerformanceWithCurrencyEffect:
-            netPerformanceWithCurrencyEffectSinceStartDate,
+            historicalDataItem.netPerformanceWithCurrencyEffect -
-          netPerformanceInPercentage:
+            netPerformanceWithCurrencyEffectAtStartDate
-            averageInvestmentValue > 0
-              ? netPerformanceSinceStartDate / averageInvestmentValue
-              : 0,
-          netPerformanceInPercentageWithCurrencyEffect:
-            averageInvestmentValueWithCurrencyEffect > 0
-              ? netPerformanceWithCurrencyEffectSinceStartDate /
-                averageInvestmentValueWithCurrencyEffect
-              : 0
         });
       }
     }
 
+    const netPerformancePercentagesByDate =
+      this.calculateNetPerformancePercentagesForDateRange({
+        historicalDataItems: historicalDataItemsOfDateRange
+      });
+
+    const chart = historicalDataItemsOfDateRange.map((historicalDataItem) => {
+      return {
+        ...historicalDataItem,
+        ...netPerformancePercentagesByDate[historicalDataItem.date]
+      };
+    });
+
     return { chart };
   }
 

apps/api/src/app/portfolio/calculator/roai/portfolio-calculator-cash.spec.ts

@@ -262,6 +262,8 @@ describe('PortfolioCalculator', () => {
         dateOfFirstActivity: '2023-12-31',
         dividend: new Big(0),
         dividendInBaseCurrency: new Big(0),
+        dividendYieldPercent: new Big(0),
+        dividendYieldPercentWithCurrencyEffect: new Big(0),
         fee: new Big(0),
         feeInBaseCurrency: new Big(0),
         grossPerformance: new Big(0),

apps/api/src/app/portfolio/calculator/roai/portfolio-calculator-msft-buy-with-dividend.spec.ts

@@ -137,6 +137,8 @@ describe('PortfolioCalculator', () => {
       });
 
       expect(portfolioSnapshot).toMatchObject({
+        dividendYieldPercent: new Big('0.001144362748184'),
+        dividendYieldPercentWithCurrencyEffect: new Big('0.001144362748184'),
         errors: [],
         hasErrors: false,
         positions: [
@@ -148,6 +150,10 @@ describe('PortfolioCalculator', () => {
             dateOfFirstActivity: '2021-09-16',
             dividend: new Big('0.62'),
             dividendInBaseCurrency: new Big('0.62'),
+            dividendYieldPercent: new Big('0.001144362748184'),
+            dividendYieldPercentWithCurrencyEffect: new Big(
+              '0.001144362748184'
+            ),
             fee: new Big('19'),
             grossPerformance: new Big('33.25'),
             grossPerformancePercentage: new Big('0.11136043941322258691'),

apps/api/src/app/portfolio/calculator/roai/portfolio-calculator.ts

@@ -1,14 +1,22 @@
 import { PortfolioCalculator } from '@ghostfolio/api/app/portfolio/calculator/portfolio-calculator';
+import { AccumulatedValues } from '@ghostfolio/api/app/portfolio/interfaces/accumulated-values.interface';
 import { HoldingPerformance } from '@ghostfolio/api/app/portfolio/interfaces/holding-performance.interface';
+import { NetPerformancePercentages } from '@ghostfolio/api/app/portfolio/interfaces/net-performance-percentages.interface';
 import { PortfolioCalculatorActivityItem } from '@ghostfolio/api/app/portfolio/interfaces/portfolio-calculator-activity-item.interface';
 import { PortfolioCalculatorHolding } from '@ghostfolio/api/app/portfolio/interfaces/portfolio-calculator-holding.interface';
-import { getIntervalFromDateRange } from '@ghostfolio/common/calculation-helper';
+import {
+  getAnnualizedPerformancePercent,
+  getIntervalFromDateRange
+} from '@ghostfolio/common/calculation-helper';
 import {
   DATE_FORMAT,
   getAssetProfileIdentifier,
   parseDate
 } from '@ghostfolio/common/helper';
-import { AssetProfileIdentifier } from '@ghostfolio/common/interfaces';
+import {
+  AssetProfileIdentifier,
+  HistoricalDataItem
+} from '@ghostfolio/common/interfaces';
 import { PortfolioSnapshot } from '@ghostfolio/common/models';
 import { DateRange } from '@ghostfolio/common/types';
 import { PerformanceCalculationType } from '@ghostfolio/common/types/performance-calculation-type.type';
@@ -21,18 +29,120 @@ import {
   isBefore,
   isThisYear
 } from 'date-fns';
+import { isNumber, sum } from 'lodash';
 
 export class RoaiPortfolioCalculator extends PortfolioCalculator {
+  protected calculateNetPerformancePercentages({
+    accumulatedValuesByDate
+  }: {
+    accumulatedValuesByDate: { [date: string]: AccumulatedValues };
+  }): { [date: string]: NetPerformancePercentages } {
+    const netPerformancePercentagesByDate: {
+      [date: string]: NetPerformancePercentages;
+    } = {};
+
+    for (const [
+      date,
+      {
+        totalAverageInvestmentValue,
+        totalAverageInvestmentValueWithCurrencyEffect,
+        totalNetPerformanceValue,
+        totalNetPerformanceValueWithCurrencyEffect
+      }
+    ] of Object.entries(accumulatedValuesByDate)) {
+      netPerformancePercentagesByDate[date] = {
+        netPerformanceInPercentage: totalAverageInvestmentValue.eq(0)
+          ? 0
+          : totalNetPerformanceValue
+              .div(totalAverageInvestmentValue)
+              .toNumber(),
+        netPerformanceInPercentageWithCurrencyEffect:
+          totalAverageInvestmentValueWithCurrencyEffect.eq(0)
+            ? 0
+            : totalNetPerformanceValueWithCurrencyEffect
+                .div(totalAverageInvestmentValueWithCurrencyEffect)
+                .toNumber()
+      };
+    }
+
+    return netPerformancePercentagesByDate;
+  }
+
+  protected calculateNetPerformancePercentagesForDateRange({
+    historicalDataItems
+  }: {
+    historicalDataItems: HistoricalDataItem[];
+  }): { [date: string]: NetPerformancePercentages } {
+    const averageInvestmentValues: number[] = [];
+    const averageInvestmentValuesWithCurrencyEffect: number[] = [];
+    let grossPerformanceAtStartDate: number;
+    let grossPerformanceWithCurrencyEffectAtStartDate: number;
+
+    const netPerformancePercentagesByDate: {
+      [date: string]: NetPerformancePercentages;
+    } = {};
+
+    for (const historicalDataItem of historicalDataItems) {
+      if (!isNumber(grossPerformanceAtStartDate)) {
+        grossPerformanceAtStartDate =
+          historicalDataItem.value - historicalDataItem.totalInvestment;
+
+        grossPerformanceWithCurrencyEffectAtStartDate =
+          historicalDataItem.valueWithCurrencyEffect -
+          historicalDataItem.totalInvestmentValueWithCurrencyEffect;
+      }
+
+      // Add the gross performance at the start date of the range to the
+      // investment of each day. Thus the range starts with the value of its
+      // first day, and subsequent buy and sell activities stay included.
+      if (historicalDataItem.totalInvestment > 0) {
+        averageInvestmentValues.push(
+          historicalDataItem.totalInvestment + grossPerformanceAtStartDate
+        );
+      }
+
+      if (historicalDataItem.totalInvestmentValueWithCurrencyEffect > 0) {
+        averageInvestmentValuesWithCurrencyEffect.push(
+          historicalDataItem.totalInvestmentValueWithCurrencyEffect +
+            grossPerformanceWithCurrencyEffectAtStartDate
+        );
+      }
+
+      const averageInvestmentValue =
+        averageInvestmentValues.length > 0
+          ? sum(averageInvestmentValues) / averageInvestmentValues.length
+          : 0;
+
+      const averageInvestmentValueWithCurrencyEffect =
+        averageInvestmentValuesWithCurrencyEffect.length > 0
+          ? sum(averageInvestmentValuesWithCurrencyEffect) /
+            averageInvestmentValuesWithCurrencyEffect.length
+          : 0;
+
+      netPerformancePercentagesByDate[historicalDataItem.date] = {
+        netPerformanceInPercentage:
+          averageInvestmentValue > 0
+            ? historicalDataItem.netPerformance / averageInvestmentValue
+            : 0,
+        netPerformanceInPercentageWithCurrencyEffect:
+          averageInvestmentValueWithCurrencyEffect > 0
+            ? historicalDataItem.netPerformanceWithCurrencyEffect /
+              averageInvestmentValueWithCurrencyEffect
+            : 0
+      };
+    }
+
+    return netPerformancePercentagesByDate;
+  }
+
   protected calculateOverallPerformance(
     positions: PortfolioCalculatorHolding[]
   ): PortfolioSnapshot {
     let currentValueInBaseCurrency = new Big(0);
-    let grossPerformance = new Big(0);
-    let grossPerformanceWithCurrencyEffect = new Big(0);
     let hasErrors = false;
-    let netPerformance = new Big(0);
     let totalAverageInvestment = new Big(0);
     let totalAverageInvestmentWithCurrencyEffect = new Big(0);
+    let totalDividendInBaseCurrency = new Big(0);
     let totalFeesWithCurrencyEffect = new Big(0);
     const totalInterestWithCurrencyEffect = new Big(0);
     let totalInvestment = new Big(0);
@@ -51,6 +161,12 @@ export class RoaiPortfolioCalculator extends PortfolioCalculator {
         continue;
       }
 
+      if (currentPosition.dividendInBaseCurrency) {
+        totalDividendInBaseCurrency = totalDividendInBaseCurrency.plus(
+          currentPosition.dividendInBaseCurrency
+        );
+      }
+
       if (currentPosition.feeInBaseCurrency) {
         totalFeesWithCurrencyEffect = totalFeesWithCurrencyEffect.plus(
           currentPosition.feeInBaseCurrency
@@ -68,18 +184,10 @@ export class RoaiPortfolioCalculator extends PortfolioCalculator {
         hasErrors = true;
       }
 
-      if (currentPosition.grossPerformance) {
+      if (
-        grossPerformance = grossPerformance.plus(
+        !currentPosition.grossPerformance &&
-          currentPosition.grossPerformance
+        !currentPosition.quantity.eq(0)
-        );
+      ) {
-
-        grossPerformanceWithCurrencyEffect =
-          grossPerformanceWithCurrencyEffect.plus(
-            currentPosition.grossPerformanceWithCurrencyEffect
-          );
-
-        netPerformance = netPerformance.plus(currentPosition.netPerformance);
-      } else if (!currentPosition.quantity.eq(0)) {
         hasErrors = true;
       }
 
@@ -101,8 +209,33 @@ export class RoaiPortfolioCalculator extends PortfolioCalculator {
       }
     }
 
+    const dateOfFirstActivity = this.getStartDate();
+
+    const daysInMarket = dateOfFirstActivity
+      ? differenceInDays(new Date(), dateOfFirstActivity)
+      : 0;
+
+    const dividendYieldPercent = getAnnualizedPerformancePercent({
+      daysInMarket,
+      netPerformancePercentage: totalAverageInvestment.eq(0)
+        ? new Big(0)
+        : totalDividendInBaseCurrency.div(totalAverageInvestment)
+    });
+
+    const dividendYieldPercentWithCurrencyEffect =
+      getAnnualizedPerformancePercent({
+        daysInMarket,
+        netPerformancePercentage: totalAverageInvestmentWithCurrencyEffect.eq(0)
+          ? new Big(0)
+          : totalDividendInBaseCurrency.div(
+              totalAverageInvestmentWithCurrencyEffect
+            )
+      });
+
     return {
       currentValueInBaseCurrency,
+      dividendYieldPercent,
+      dividendYieldPercentWithCurrencyEffect,
       hasErrors,
       positions,
       totalFeesWithCurrencyEffect,
@@ -401,6 +534,28 @@ export class RoaiPortfolioCalculator extends PortfolioCalculator {
       ? totalNetPerformance.div(averageInvestmentBetweenStartAndEndDate)
       : new Big(0);
 
+    const daysInMarket = differenceInDays(new Date(), dateOfFirstActivity);
+
+    const dividendYieldPercent = getAnnualizedPerformancePercent({
+      daysInMarket,
+      netPerformancePercentage: averageInvestmentBetweenStartAndEndDate.eq(0)
+        ? new Big(0)
+        : totalDividendInBaseCurrency.div(
+            averageInvestmentBetweenStartAndEndDate
+          )
+    });
+
+    const dividendYieldPercentWithCurrencyEffect =
+      getAnnualizedPerformancePercent({
+        daysInMarket,
+        netPerformancePercentage:
+          averageInvestmentBetweenStartAndEndDateWithCurrencyEffect.eq(0)
+            ? new Big(0)
+            : totalDividendInBaseCurrency.div(
+                averageInvestmentBetweenStartAndEndDateWithCurrencyEffect
+              )
+      });
+
     const netPerformancePercentageWithCurrencyEffectMap: {
       [key: DateRange]: Big;
     } = {};
@@ -538,6 +693,8 @@ export class RoaiPortfolioCalculator extends PortfolioCalculator {
       averageInvestmentValuesWithCurrencyEffect,
       currentValues,
       currentValuesWithCurrencyEffect,
+      dividendYieldPercent,
+      dividendYieldPercentWithCurrencyEffect,
       grossPerformancePercentage,
       grossPerformancePercentageWithCurrencyEffect,
       investmentValuesAccumulated,

apps/api/src/app/portfolio/calculator/roi/portfolio-calculator.ts

@@ -1,12 +1,28 @@
 import { PortfolioCalculator } from '@ghostfolio/api/app/portfolio/calculator/portfolio-calculator';
+import { AccumulatedValues } from '@ghostfolio/api/app/portfolio/interfaces/accumulated-values.interface';
 import { HoldingPerformance } from '@ghostfolio/api/app/portfolio/interfaces/holding-performance.interface';
-import { PortfolioCalculatorHolding } from '@ghostfolio/api/app/portfolio/interfaces/portfolio-calculator-holding.interface';
+import { NetPerformancePercentages } from '@ghostfolio/api/app/portfolio/interfaces/net-performance-percentages.interface';
-import { AssetProfileIdentifier } from '@ghostfolio/common/interfaces';
+import {
+  AssetProfileIdentifier,
+  HistoricalDataItem
+} from '@ghostfolio/common/interfaces';
 import { PortfolioSnapshot } from '@ghostfolio/common/models';
 import { PerformanceCalculationType } from '@ghostfolio/common/types/performance-calculation-type.type';
 
 export class RoiPortfolioCalculator extends PortfolioCalculator {
-  protected calculateOverallPerformance([]: PortfolioCalculatorHolding[]): PortfolioSnapshot {
+  protected calculateNetPerformancePercentages({}: {
+    accumulatedValuesByDate: { [date: string]: AccumulatedValues };
+  }): { [date: string]: NetPerformancePercentages } {
+    throw new Error('Method not implemented.');
+  }
+
+  protected calculateNetPerformancePercentagesForDateRange({}: {
+    historicalDataItems: HistoricalDataItem[];
+  }): { [date: string]: NetPerformancePercentages } {
+    throw new Error('Method not implemented.');
+  }
+
+  protected calculateOverallPerformance(): PortfolioSnapshot {
     throw new Error('Method not implemented.');
   }
 

apps/api/src/app/portfolio/calculator/twr/portfolio-calculator.ts

@@ -1,12 +1,28 @@
 import { PortfolioCalculator } from '@ghostfolio/api/app/portfolio/calculator/portfolio-calculator';
+import { AccumulatedValues } from '@ghostfolio/api/app/portfolio/interfaces/accumulated-values.interface';
 import { HoldingPerformance } from '@ghostfolio/api/app/portfolio/interfaces/holding-performance.interface';
-import { PortfolioCalculatorHolding } from '@ghostfolio/api/app/portfolio/interfaces/portfolio-calculator-holding.interface';
+import { NetPerformancePercentages } from '@ghostfolio/api/app/portfolio/interfaces/net-performance-percentages.interface';
-import { AssetProfileIdentifier } from '@ghostfolio/common/interfaces';
+import {
+  AssetProfileIdentifier,
+  HistoricalDataItem
+} from '@ghostfolio/common/interfaces';
 import { PortfolioSnapshot } from '@ghostfolio/common/models';
 import { PerformanceCalculationType } from '@ghostfolio/common/types/performance-calculation-type.type';
 
 export class TwrPortfolioCalculator extends PortfolioCalculator {
-  protected calculateOverallPerformance([]: PortfolioCalculatorHolding[]): PortfolioSnapshot {
+  protected calculateNetPerformancePercentages({}: {
+    accumulatedValuesByDate: { [date: string]: AccumulatedValues };
+  }): { [date: string]: NetPerformancePercentages } {
+    throw new Error('Method not implemented.');
+  }
+
+  protected calculateNetPerformancePercentagesForDateRange({}: {
+    historicalDataItems: HistoricalDataItem[];
+  }): { [date: string]: NetPerformancePercentages } {
+    throw new Error('Method not implemented.');
+  }
+
+  protected calculateOverallPerformance(): PortfolioSnapshot {
     throw new Error('Method not implemented.');
   }
 

apps/api/src/app/portfolio/interfaces/accumulated-values.interface.ts

@@ -0,0 +1,15 @@
+import { Big } from 'big.js';
+
+export interface AccumulatedValues {
+  investmentValueWithCurrencyEffect: Big;
+  totalAverageInvestmentValue: Big;
+  totalAverageInvestmentValueWithCurrencyEffect: Big;
+  totalCashValueWithCurrencyEffect: Big;
+  totalCurrentValue: Big;
+  totalCurrentValueWithCurrencyEffect: Big;
+  totalInvestmentValue: Big;
+  totalInvestmentValueWithCurrencyEffect: Big;
+  totalNetPerformanceValue: Big;
+  totalNetPerformanceValueWithCurrencyEffect: Big;
+  totalNetWorthValueWithCurrencyEffect: Big;
+}

apps/api/src/app/portfolio/interfaces/holding-performance.interface.ts

@@ -17,6 +17,8 @@ export interface HoldingPerformance {
   currentValuesWithCurrencyEffect: {
     [date: string]: Big;
   };
+  dividendYieldPercent: Big;
+  dividendYieldPercentWithCurrencyEffect: Big;
   grossPerformance: Big;
   grossPerformancePercentage: Big;
   grossPerformancePercentageWithCurrencyEffect: Big;

apps/api/src/app/portfolio/interfaces/net-performance-percentages.interface.ts

@@ -0,0 +1,6 @@
+import { HistoricalDataItem } from '@ghostfolio/common/interfaces';
+
+export interface NetPerformancePercentages extends Pick<
+  HistoricalDataItem,
+  'netPerformanceInPercentage' | 'netPerformanceInPercentageWithCurrencyEffect'
+> {}

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

@@ -984,12 +984,12 @@ export class PortfolioService {
 
     const {
       activitiesCount,
-      averageInvestment,
-      averageInvestmentWithCurrencyEffect,
       averagePrice,
       currency,
       dateOfFirstActivity,
       dividendInBaseCurrency,
+      dividendYieldPercent,
+      dividendYieldPercentWithCurrencyEffect,
       feeInBaseCurrency,
       grossPerformance,
       grossPerformancePercentage,
@@ -1012,27 +1012,6 @@ export class PortfolioService {
       );
     });
 
-    const dividendYieldPercent = getAnnualizedPerformancePercent({
-      daysInMarket: differenceInDays(
-        new Date(),
-        parseDate(dateOfFirstActivity)
-      ),
-      netPerformancePercentage: averageInvestment.eq(0)
-        ? new Big(0)
-        : dividendInBaseCurrency.div(averageInvestment)
-    });
-
-    const dividendYieldPercentWithCurrencyEffect =
-      getAnnualizedPerformancePercent({
-        daysInMarket: differenceInDays(
-          new Date(),
-          parseDate(dateOfFirstActivity)
-        ),
-        netPerformancePercentage: averageInvestmentWithCurrencyEffect.eq(0)
-          ? new Big(0)
-          : dividendInBaseCurrency.div(averageInvestmentWithCurrencyEffect)
-      });
-
     const historicalData = await this.dataProviderService.getHistorical(
       [{ dataSource, symbol }],
       'day',
@@ -1138,9 +1117,11 @@ export class PortfolioService {
         .getDataProvider(dataSource)
         .getDataProviderInfo(),
       dividendInBaseCurrency: dividendInBaseCurrency.toNumber(),
-      dividendYieldPercent: dividendYieldPercent.toNumber(),
+      // TODO: Remove the fallback with the next release, when the cached
+      // portfolio snapshots have been recalculated
+      dividendYieldPercent: dividendYieldPercent?.toNumber() ?? 0,
       dividendYieldPercentWithCurrencyEffect:
-        dividendYieldPercentWithCurrencyEffect.toNumber(),
+        dividendYieldPercentWithCurrencyEffect?.toNumber() ?? 0,
       feeInBaseCurrency: feeInBaseCurrency.toNumber(),
       grossPerformance: grossPerformance?.toNumber(),
       grossPerformancePercent: grossPerformancePercentage?.toNumber(),
@@ -2097,6 +2078,8 @@ export class PortfolioService {
     }
 
     const {
+      dividendYieldPercent,
+      dividendYieldPercentWithCurrencyEffect,
       totalCashInBaseCurrency,
       totalInvestment,
       totalInvestmentWithCurrencyEffect,
@@ -2219,6 +2202,11 @@ export class PortfolioService {
         return ['BUY', 'SELL'].includes(type);
       }).length,
       dividendInBaseCurrency: dividendInBaseCurrency.toNumber(),
+      // TODO: Remove the fallback with the next release, when the cached
+      // portfolio snapshots have been recalculated
+      dividendYieldPercent: dividendYieldPercent?.toNumber() ?? 0,
+      dividendYieldPercentWithCurrencyEffect:
+        dividendYieldPercentWithCurrencyEffect?.toNumber() ?? 0,
       emergencyFund: {
         assets: emergencyFundHoldingsValueInBaseCurrency,
         cash: totalEmergencyFund

libs/common/src/lib/interfaces/portfolio-summary.interface.ts

@@ -8,6 +8,8 @@ export interface PortfolioSummary extends PortfolioPerformance {
   cash: number;
   dateOfFirstActivity?: Date;
   dividendInBaseCurrency: number;
+  dividendYieldPercent: number;
+  dividendYieldPercentWithCurrencyEffect: number;
   emergencyFund: {
     assets: number;
     cash: number;

libs/common/src/lib/models/portfolio-snapshot-holding.ts

@@ -60,6 +60,14 @@ export class PortfolioSnapshotHolding {
   @Type(() => Big)
   dividendInBaseCurrency: Big;
 
+  @Transform(transformToBig, { toClassOnly: true })
+  @Type(() => Big)
+  dividendYieldPercent: Big;
+
+  @Transform(transformToBig, { toClassOnly: true })
+  @Type(() => Big)
+  dividendYieldPercentWithCurrencyEffect: Big;
+
   @Transform(transformToBig, { toClassOnly: true })
   @Type(() => Big)
   fee: Big;

libs/common/src/lib/models/portfolio-snapshot.ts

@@ -17,6 +17,14 @@ export class PortfolioSnapshot {
   @Type(() => Big)
   currentValueInBaseCurrency: Big;
 
+  @Transform(transformToBig, { toClassOnly: true })
+  @Type(() => Big)
+  dividendYieldPercent: Big;
+
+  @Transform(transformToBig, { toClassOnly: true })
+  @Type(() => Big)
+  dividendYieldPercentWithCurrencyEffect: Big;
+
   errors: AssetProfileIdentifier[];
 
   hasErrors: boolean;