Merge branch 'main' into feature/add-storybook-to-sitemap.xml

CHANGELOG.md

@@ -9,11 +9,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- Added support for filtering in the _Copy AI prompt to clipboard_ actions on the analysis page (experimental)
 - Added the _Storybook_ path to the `sitemap.xml` file
 
 ### Changed
 
 - Improved the symbol validation in the _Yahoo Finance_ service (get asset profiles)
+- Refreshed the cryptocurrencies list
+
+### Fixed
+
+- Fixed an issue in the activities import functionality related to the account balances
+- Changed client-side dates to be sent in UTC format to ensure date consistency
+  - Benchmark endpoint
+  - Exchange rate endpoint
 
 ## 2.146.0 - 2025-03-15
 

apps/api/src/app/endpoints/ai/ai.controller.ts

@@ -1,5 +1,6 @@
 import { HasPermission } from '@ghostfolio/api/decorators/has-permission.decorator';
 import { HasPermissionGuard } from '@ghostfolio/api/guards/has-permission.guard';
+import { ApiService } from '@ghostfolio/api/services/api/api.service';
 import {
   DEFAULT_CURRENCY,
   DEFAULT_LANGUAGE_CODE
@@ -8,7 +9,14 @@ import { AiPromptResponse } from '@ghostfolio/common/interfaces';
 import { permissions } from '@ghostfolio/common/permissions';
 import type { AiPromptMode, RequestWithUser } from '@ghostfolio/common/types';
 
-import { Controller, Get, Inject, Param, UseGuards } from '@nestjs/common';
+import {
+  Controller,
+  Get,
+  Inject,
+  Param,
+  Query,
+  UseGuards
+} from '@nestjs/common';
 import { REQUEST } from '@nestjs/core';
 import { AuthGuard } from '@nestjs/passport';
 
@@ -18,6 +26,7 @@ import { AiService } from './ai.service';
 export class AiController {
   public constructor(
     private readonly aiService: AiService,
+    private readonly apiService: ApiService,
     @Inject(REQUEST) private readonly request: RequestWithUser
   ) {}
 
@@ -25,9 +34,23 @@ export class AiController {
   @HasPermission(permissions.readAiPrompt)
   @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
   public async getPrompt(
-    @Param('mode') mode: AiPromptMode
+    @Param('mode') mode: AiPromptMode,
+    @Query('accounts') filterByAccounts?: string,
+    @Query('assetClasses') filterByAssetClasses?: string,
+    @Query('dataSource') filterByDataSource?: string,
+    @Query('symbol') filterBySymbol?: string,
+    @Query('tags') filterByTags?: string
   ): Promise<AiPromptResponse> {
+    const filters = this.apiService.buildFiltersFromQueryParams({
+      filterByAccounts,
+      filterByAssetClasses,
+      filterByDataSource,
+      filterBySymbol,
+      filterByTags
+    });
+
     const prompt = await this.aiService.getPrompt({
+      filters,
       mode,
       impersonationId: undefined,
       languageCode:

apps/api/src/app/endpoints/ai/ai.module.ts

@@ -7,6 +7,7 @@ import { PortfolioService } from '@ghostfolio/api/app/portfolio/portfolio.servic
 import { RulesService } from '@ghostfolio/api/app/portfolio/rules.service';
 import { RedisCacheModule } from '@ghostfolio/api/app/redis-cache/redis-cache.module';
 import { UserModule } from '@ghostfolio/api/app/user/user.module';
+import { ApiModule } from '@ghostfolio/api/services/api/api.module';
 import { ConfigurationModule } from '@ghostfolio/api/services/configuration/configuration.module';
 import { DataProviderModule } from '@ghostfolio/api/services/data-provider/data-provider.module';
 import { ExchangeRateDataModule } from '@ghostfolio/api/services/exchange-rate-data/exchange-rate-data.module';
@@ -25,6 +26,7 @@ import { AiService } from './ai.service';
 @Module({
   controllers: [AiController],
   imports: [
+    ApiModule,
     ConfigurationModule,
     DataProviderModule,
     ExchangeRateDataModule,

apps/api/src/app/endpoints/ai/ai.service.ts

@@ -1,4 +1,5 @@
 import { PortfolioService } from '@ghostfolio/api/app/portfolio/portfolio.service';
+import { Filter } from '@ghostfolio/common/interfaces';
 import type { AiPromptMode } from '@ghostfolio/common/types';
 
 import { Injectable } from '@nestjs/common';
@@ -8,12 +9,14 @@ export class AiService {
   public constructor(private readonly portfolioService: PortfolioService) {}
 
   public async getPrompt({
+    filters,
     impersonationId,
     languageCode,
     mode,
     userCurrency,
     userId
   }: {
+    filters?: Filter[];
     impersonationId: string;
     languageCode: string;
     mode: AiPromptMode;
@@ -21,6 +24,7 @@ export class AiService {
     userId: string;
   }) {
     const { holdings } = await this.portfolioService.getDetails({
+      filters,
       impersonationId,
       userId
     });

apps/api/src/app/import/create-account-with-balances.dto.ts

@@ -0,0 +1,10 @@
+import { CreateAccountDto } from '@ghostfolio/api/app/account/create-account.dto';
+import { AccountBalance } from '@ghostfolio/common/interfaces';
+
+import { IsArray, IsOptional } from 'class-validator';
+
+export class CreateAccountWithBalancesDto extends CreateAccountDto {
+  @IsArray()
+  @IsOptional()
+  balances?: AccountBalance;
+}

apps/api/src/app/import/import-data.dto.ts

@@ -1,15 +1,16 @@
-import { CreateAccountDto } from '@ghostfolio/api/app/account/create-account.dto';
 import { CreateOrderDto } from '@ghostfolio/api/app/order/create-order.dto';
 
 import { Type } from 'class-transformer';
 import { IsArray, IsOptional, ValidateNested } from 'class-validator';
 
+import { CreateAccountWithBalancesDto } from './create-account-with-balances.dto';
+
 export class ImportDataDto {
   @IsOptional()
   @IsArray()
-  @Type(() => CreateAccountDto)
+  @Type(() => CreateAccountWithBalancesDto)
   @ValidateNested({ each: true })
-  accounts: CreateAccountDto[];
+  accounts: CreateAccountWithBalancesDto[];
 
   @IsArray()
   @Type(() => CreateOrderDto)

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

@@ -5,7 +5,7 @@ import {
 } from '@ghostfolio/common/interfaces';
 import { PortfolioSnapshot } from '@ghostfolio/common/models';
 
-export class MWRPortfolioCalculator extends PortfolioCalculator {
+export class MwrPortfolioCalculator extends PortfolioCalculator {
   protected calculateOverallPerformance(): PortfolioSnapshot {
     throw new Error('Method not implemented.');
   }

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

@@ -8,12 +8,14 @@ import { Filter, HistoricalDataItem } from '@ghostfolio/common/interfaces';
 
 import { Injectable } from '@nestjs/common';
 
-import { MWRPortfolioCalculator } from './mwr/portfolio-calculator';
+import { MwrPortfolioCalculator } from './mwr/portfolio-calculator';
 import { PortfolioCalculator } from './portfolio-calculator';
-import { TWRPortfolioCalculator } from './twr/portfolio-calculator';
+import { RoaiPortfolioCalculator } from './roai/portfolio-calculator';
+import { TwrPortfolioCalculator } from './twr/portfolio-calculator';
 
 export enum PerformanceCalculationType {
   MWR = 'MWR', // Money-Weighted Rate of Return
+  ROAI = 'ROAI', // Return on Average Investment
   TWR = 'TWR' // Time-Weighted Rate of Return
 }
 
@@ -44,7 +46,7 @@ export class PortfolioCalculatorFactory {
   }): PortfolioCalculator {
     switch (calculationType) {
       case PerformanceCalculationType.MWR:
-        return new MWRPortfolioCalculator({
+        return new MwrPortfolioCalculator({
           accountBalanceItems,
           activities,
           currency,
@@ -56,15 +58,28 @@ export class PortfolioCalculatorFactory {
           portfolioSnapshotService: this.portfolioSnapshotService,
           redisCacheService: this.redisCacheService
         });
-      case PerformanceCalculationType.TWR:
+      case PerformanceCalculationType.ROAI:
-        return new TWRPortfolioCalculator({
+        return new RoaiPortfolioCalculator({
           accountBalanceItems,
           activities,
           currency,
+          filters,
+          userId,
+          configurationService: this.configurationService,
           currentRateService: this.currentRateService,
+          exchangeRateDataService: this.exchangeRateDataService,
+          portfolioSnapshotService: this.portfolioSnapshotService,
+          redisCacheService: this.redisCacheService
+        });
+      case PerformanceCalculationType.TWR:
+        return new TwrPortfolioCalculator({
+          accountBalanceItems,
+          activities,
+          currency,
           filters,
           userId,
           configurationService: this.configurationService,
+          currentRateService: this.currentRateService,
           exchangeRateDataService: this.exchangeRateDataService,
           portfolioSnapshotService: this.portfolioSnapshotService,
           redisCacheService: this.redisCacheService

apps/api/src/app/portfolio/calculator/twr/portfolio-calculator-baln-buy-and-sell-in-two-activities.spec.ts → apps/api/src/app/portfolio/calculator/roai/portfolio-calculator-baln-buy-and-sell-in-two-activities.spec.ts

@@ -137,7 +137,7 @@ describe('PortfolioCalculator', () => {
 
       const portfolioCalculator = portfolioCalculatorFactory.createCalculator({
         activities,
-        calculationType: PerformanceCalculationType.TWR,
+        calculationType: PerformanceCalculationType.ROAI,
         currency: 'CHF',
         userId: userDummyData.id
       });

apps/api/src/app/portfolio/calculator/twr/portfolio-calculator-baln-buy-and-sell.spec.ts → apps/api/src/app/portfolio/calculator/roai/portfolio-calculator-baln-buy-and-sell.spec.ts

@@ -122,7 +122,7 @@ describe('PortfolioCalculator', () => {
 
       const portfolioCalculator = portfolioCalculatorFactory.createCalculator({
         activities,
-        calculationType: PerformanceCalculationType.TWR,
+        calculationType: PerformanceCalculationType.ROAI,
         currency: 'CHF',
         userId: userDummyData.id
       });

apps/api/src/app/portfolio/calculator/twr/portfolio-calculator-baln-buy.spec.ts → apps/api/src/app/portfolio/calculator/roai/portfolio-calculator-baln-buy.spec.ts

@@ -107,7 +107,7 @@ describe('PortfolioCalculator', () => {
 
       const portfolioCalculator = portfolioCalculatorFactory.createCalculator({
         activities,
-        calculationType: PerformanceCalculationType.TWR,
+        calculationType: PerformanceCalculationType.ROAI,
         currency: 'CHF',
         userId: userDummyData.id
       });

apps/api/src/app/portfolio/calculator/twr/portfolio-calculator-btcusd-buy-and-sell-partially.spec.ts → apps/api/src/app/portfolio/calculator/roai/portfolio-calculator-btcusd-buy-and-sell-partially.spec.ts

@@ -136,7 +136,7 @@ describe('PortfolioCalculator', () => {
 
       const portfolioCalculator = portfolioCalculatorFactory.createCalculator({
         activities,
-        calculationType: PerformanceCalculationType.TWR,
+        calculationType: PerformanceCalculationType.ROAI,
         currency: 'CHF',
         userId: userDummyData.id
       });

apps/api/src/app/portfolio/calculator/twr/portfolio-calculator-fee.spec.ts → apps/api/src/app/portfolio/calculator/roai/portfolio-calculator-fee.spec.ts

@@ -107,7 +107,7 @@ describe('PortfolioCalculator', () => {
 
       const portfolioCalculator = portfolioCalculatorFactory.createCalculator({
         activities,
-        calculationType: PerformanceCalculationType.TWR,
+        calculationType: PerformanceCalculationType.ROAI,
         currency: 'USD',
         userId: userDummyData.id
       });

apps/api/src/app/portfolio/calculator/twr/portfolio-calculator-googl-buy.spec.ts → apps/api/src/app/portfolio/calculator/roai/portfolio-calculator-googl-buy.spec.ts

@@ -120,7 +120,7 @@ describe('PortfolioCalculator', () => {
 
       const portfolioCalculator = portfolioCalculatorFactory.createCalculator({
         activities,
-        calculationType: PerformanceCalculationType.TWR,
+        calculationType: PerformanceCalculationType.ROAI,
         currency: 'CHF',
         userId: userDummyData.id
       });

apps/api/src/app/portfolio/calculator/twr/portfolio-calculator-item.spec.ts → apps/api/src/app/portfolio/calculator/roai/portfolio-calculator-item.spec.ts

@@ -107,7 +107,7 @@ describe('PortfolioCalculator', () => {
 
       const portfolioCalculator = portfolioCalculatorFactory.createCalculator({
         activities,
-        calculationType: PerformanceCalculationType.TWR,
+        calculationType: PerformanceCalculationType.ROAI,
         currency: 'USD',
         userId: userDummyData.id
       });

apps/api/src/app/portfolio/calculator/twr/portfolio-calculator-liability.spec.ts → apps/api/src/app/portfolio/calculator/roai/portfolio-calculator-liability.spec.ts

@@ -107,7 +107,7 @@ describe('PortfolioCalculator', () => {
 
       const portfolioCalculator = portfolioCalculatorFactory.createCalculator({
         activities,
-        calculationType: PerformanceCalculationType.TWR,
+        calculationType: PerformanceCalculationType.ROAI,
         currency: 'USD',
         userId: userDummyData.id
       });

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

@@ -135,7 +135,7 @@ describe('PortfolioCalculator', () => {
 
       const portfolioCalculator = portfolioCalculatorFactory.createCalculator({
         activities,
-        calculationType: PerformanceCalculationType.TWR,
+        calculationType: PerformanceCalculationType.ROAI,
         currency: 'USD',
         userId: userDummyData.id
       });

apps/api/src/app/portfolio/calculator/twr/portfolio-calculator-no-orders.spec.ts → apps/api/src/app/portfolio/calculator/roai/portfolio-calculator-no-orders.spec.ts

@@ -84,7 +84,7 @@ describe('PortfolioCalculator', () => {
 
       const portfolioCalculator = portfolioCalculatorFactory.createCalculator({
         activities: [],
-        calculationType: PerformanceCalculationType.TWR,
+        calculationType: PerformanceCalculationType.ROAI,
         currency: 'CHF',
         userId: userDummyData.id
       });

apps/api/src/app/portfolio/calculator/twr/portfolio-calculator-novn-buy-and-sell-partially.spec.ts → apps/api/src/app/portfolio/calculator/roai/portfolio-calculator-novn-buy-and-sell-partially.spec.ts

@@ -116,7 +116,7 @@ describe('PortfolioCalculator', () => {
 
       const portfolioCalculator = portfolioCalculatorFactory.createCalculator({
         activities,
-        calculationType: PerformanceCalculationType.TWR,
+        calculationType: PerformanceCalculationType.ROAI,
         currency: 'CHF',
         userId: userDummyData.id
       });

apps/api/src/app/portfolio/calculator/twr/portfolio-calculator-novn-buy-and-sell.spec.ts → apps/api/src/app/portfolio/calculator/roai/portfolio-calculator-novn-buy-and-sell.spec.ts

@@ -116,7 +116,7 @@ describe('PortfolioCalculator', () => {
 
       const portfolioCalculator = portfolioCalculatorFactory.createCalculator({
         activities,
-        calculationType: PerformanceCalculationType.TWR,
+        calculationType: PerformanceCalculationType.ROAI,
         currency: 'CHF',
         userId: userDummyData.id
       });

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

@@ -0,0 +1,969 @@
+import { PortfolioCalculator } from '@ghostfolio/api/app/portfolio/calculator/portfolio-calculator';
+import { PortfolioOrderItem } from '@ghostfolio/api/app/portfolio/interfaces/portfolio-order-item.interface';
+import { getFactor } from '@ghostfolio/api/helper/portfolio.helper';
+import { getIntervalFromDateRange } from '@ghostfolio/common/calculation-helper';
+import { DATE_FORMAT } from '@ghostfolio/common/helper';
+import {
+  AssetProfileIdentifier,
+  SymbolMetrics
+} from '@ghostfolio/common/interfaces';
+import { PortfolioSnapshot, TimelinePosition } from '@ghostfolio/common/models';
+import { DateRange } from '@ghostfolio/common/types';
+
+import { Logger } from '@nestjs/common';
+import { Big } from 'big.js';
+import { addMilliseconds, differenceInDays, format, isBefore } from 'date-fns';
+import { cloneDeep, sortBy } from 'lodash';
+
+export class RoaiPortfolioCalculator extends PortfolioCalculator {
+  private chartDates: string[];
+
+  protected calculateOverallPerformance(
+    positions: TimelinePosition[]
+  ): 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 totalFeesWithCurrencyEffect = new Big(0);
+    const totalInterestWithCurrencyEffect = new Big(0);
+    let totalInvestment = new Big(0);
+    let totalInvestmentWithCurrencyEffect = new Big(0);
+    let totalTimeWeightedInvestment = new Big(0);
+    let totalTimeWeightedInvestmentWithCurrencyEffect = new Big(0);
+
+    for (const currentPosition of positions) {
+      if (currentPosition.feeInBaseCurrency) {
+        totalFeesWithCurrencyEffect = totalFeesWithCurrencyEffect.plus(
+          currentPosition.feeInBaseCurrency
+        );
+      }
+
+      if (currentPosition.valueInBaseCurrency) {
+        currentValueInBaseCurrency = currentValueInBaseCurrency.plus(
+          currentPosition.valueInBaseCurrency
+        );
+      } else {
+        hasErrors = true;
+      }
+
+      if (currentPosition.investment) {
+        totalInvestment = totalInvestment.plus(currentPosition.investment);
+
+        totalInvestmentWithCurrencyEffect =
+          totalInvestmentWithCurrencyEffect.plus(
+            currentPosition.investmentWithCurrencyEffect
+          );
+      } else {
+        hasErrors = true;
+      }
+
+      if (currentPosition.grossPerformance) {
+        grossPerformance = grossPerformance.plus(
+          currentPosition.grossPerformance
+        );
+
+        grossPerformanceWithCurrencyEffect =
+          grossPerformanceWithCurrencyEffect.plus(
+            currentPosition.grossPerformanceWithCurrencyEffect
+          );
+
+        netPerformance = netPerformance.plus(currentPosition.netPerformance);
+      } else if (!currentPosition.quantity.eq(0)) {
+        hasErrors = true;
+      }
+
+      if (currentPosition.timeWeightedInvestment) {
+        totalTimeWeightedInvestment = totalTimeWeightedInvestment.plus(
+          currentPosition.timeWeightedInvestment
+        );
+
+        totalTimeWeightedInvestmentWithCurrencyEffect =
+          totalTimeWeightedInvestmentWithCurrencyEffect.plus(
+            currentPosition.timeWeightedInvestmentWithCurrencyEffect
+          );
+      } else if (!currentPosition.quantity.eq(0)) {
+        Logger.warn(
+          `Missing historical market data for ${currentPosition.symbol} (${currentPosition.dataSource})`,
+          'PortfolioCalculator'
+        );
+
+        hasErrors = true;
+      }
+    }
+
+    return {
+      currentValueInBaseCurrency,
+      hasErrors,
+      positions,
+      totalFeesWithCurrencyEffect,
+      totalInterestWithCurrencyEffect,
+      totalInvestment,
+      totalInvestmentWithCurrencyEffect,
+      activitiesCount: this.activities.filter(({ type }) => {
+        return ['BUY', 'SELL'].includes(type);
+      }).length,
+      createdAt: new Date(),
+      errors: [],
+      historicalData: [],
+      totalLiabilitiesWithCurrencyEffect: new Big(0),
+      totalValuablesWithCurrencyEffect: new Big(0)
+    };
+  }
+
+  protected getSymbolMetrics({
+    chartDateMap,
+    dataSource,
+    end,
+    exchangeRates,
+    marketSymbolMap,
+    start,
+    symbol
+  }: {
+    chartDateMap?: { [date: string]: boolean };
+    end: Date;
+    exchangeRates: { [dateString: string]: number };
+    marketSymbolMap: {
+      [date: string]: { [symbol: string]: Big };
+    };
+    start: Date;
+  } & AssetProfileIdentifier): SymbolMetrics {
+    const currentExchangeRate = exchangeRates[format(new Date(), DATE_FORMAT)];
+    const currentValues: { [date: string]: Big } = {};
+    const currentValuesWithCurrencyEffect: { [date: string]: Big } = {};
+    let fees = new Big(0);
+    let feesAtStartDate = new Big(0);
+    let feesAtStartDateWithCurrencyEffect = new Big(0);
+    let feesWithCurrencyEffect = new Big(0);
+    let grossPerformance = new Big(0);
+    let grossPerformanceWithCurrencyEffect = new Big(0);
+    let grossPerformanceAtStartDate = new Big(0);
+    let grossPerformanceAtStartDateWithCurrencyEffect = new Big(0);
+    let grossPerformanceFromSells = new Big(0);
+    let grossPerformanceFromSellsWithCurrencyEffect = new Big(0);
+    let initialValue: Big;
+    let initialValueWithCurrencyEffect: Big;
+    let investmentAtStartDate: Big;
+    let investmentAtStartDateWithCurrencyEffect: Big;
+    const investmentValuesAccumulated: { [date: string]: Big } = {};
+    const investmentValuesAccumulatedWithCurrencyEffect: {
+      [date: string]: Big;
+    } = {};
+    const investmentValuesWithCurrencyEffect: { [date: string]: Big } = {};
+    let lastAveragePrice = new Big(0);
+    let lastAveragePriceWithCurrencyEffect = new Big(0);
+    const netPerformanceValues: { [date: string]: Big } = {};
+    const netPerformanceValuesWithCurrencyEffect: { [date: string]: Big } = {};
+    const timeWeightedInvestmentValues: { [date: string]: Big } = {};
+
+    const timeWeightedInvestmentValuesWithCurrencyEffect: {
+      [date: string]: Big;
+    } = {};
+
+    const totalAccountBalanceInBaseCurrency = new Big(0);
+    let totalDividend = new Big(0);
+    let totalDividendInBaseCurrency = new Big(0);
+    let totalInterest = new Big(0);
+    let totalInterestInBaseCurrency = new Big(0);
+    let totalInvestment = new Big(0);
+    let totalInvestmentFromBuyTransactions = new Big(0);
+    let totalInvestmentFromBuyTransactionsWithCurrencyEffect = new Big(0);
+    let totalInvestmentWithCurrencyEffect = new Big(0);
+    let totalLiabilities = new Big(0);
+    let totalLiabilitiesInBaseCurrency = new Big(0);
+    let totalQuantityFromBuyTransactions = new Big(0);
+    let totalUnits = new Big(0);
+    let totalValuables = new Big(0);
+    let totalValuablesInBaseCurrency = new Big(0);
+    let valueAtStartDate: Big;
+    let valueAtStartDateWithCurrencyEffect: Big;
+
+    // Clone orders to keep the original values in this.orders
+    let orders: PortfolioOrderItem[] = cloneDeep(
+      this.activities.filter(({ SymbolProfile }) => {
+        return SymbolProfile.symbol === symbol;
+      })
+    );
+
+    if (orders.length <= 0) {
+      return {
+        currentValues: {},
+        currentValuesWithCurrencyEffect: {},
+        feesWithCurrencyEffect: new Big(0),
+        grossPerformance: new Big(0),
+        grossPerformancePercentage: new Big(0),
+        grossPerformancePercentageWithCurrencyEffect: new Big(0),
+        grossPerformanceWithCurrencyEffect: new Big(0),
+        hasErrors: false,
+        initialValue: new Big(0),
+        initialValueWithCurrencyEffect: new Big(0),
+        investmentValuesAccumulated: {},
+        investmentValuesAccumulatedWithCurrencyEffect: {},
+        investmentValuesWithCurrencyEffect: {},
+        netPerformance: new Big(0),
+        netPerformancePercentage: new Big(0),
+        netPerformancePercentageWithCurrencyEffectMap: {},
+        netPerformanceValues: {},
+        netPerformanceValuesWithCurrencyEffect: {},
+        netPerformanceWithCurrencyEffectMap: {},
+        timeWeightedInvestment: new Big(0),
+        timeWeightedInvestmentValues: {},
+        timeWeightedInvestmentValuesWithCurrencyEffect: {},
+        timeWeightedInvestmentWithCurrencyEffect: new Big(0),
+        totalAccountBalanceInBaseCurrency: new Big(0),
+        totalDividend: new Big(0),
+        totalDividendInBaseCurrency: new Big(0),
+        totalInterest: new Big(0),
+        totalInterestInBaseCurrency: new Big(0),
+        totalInvestment: new Big(0),
+        totalInvestmentWithCurrencyEffect: new Big(0),
+        totalLiabilities: new Big(0),
+        totalLiabilitiesInBaseCurrency: new Big(0),
+        totalValuables: new Big(0),
+        totalValuablesInBaseCurrency: new Big(0)
+      };
+    }
+
+    const dateOfFirstTransaction = new Date(orders[0].date);
+
+    const endDateString = format(end, DATE_FORMAT);
+    const startDateString = format(start, DATE_FORMAT);
+
+    const unitPriceAtStartDate = marketSymbolMap[startDateString]?.[symbol];
+    const unitPriceAtEndDate = marketSymbolMap[endDateString]?.[symbol];
+
+    if (
+      !unitPriceAtEndDate ||
+      (!unitPriceAtStartDate && isBefore(dateOfFirstTransaction, start))
+    ) {
+      return {
+        currentValues: {},
+        currentValuesWithCurrencyEffect: {},
+        feesWithCurrencyEffect: new Big(0),
+        grossPerformance: new Big(0),
+        grossPerformancePercentage: new Big(0),
+        grossPerformancePercentageWithCurrencyEffect: new Big(0),
+        grossPerformanceWithCurrencyEffect: new Big(0),
+        hasErrors: true,
+        initialValue: new Big(0),
+        initialValueWithCurrencyEffect: new Big(0),
+        investmentValuesAccumulated: {},
+        investmentValuesAccumulatedWithCurrencyEffect: {},
+        investmentValuesWithCurrencyEffect: {},
+        netPerformance: new Big(0),
+        netPerformancePercentage: new Big(0),
+        netPerformancePercentageWithCurrencyEffectMap: {},
+        netPerformanceWithCurrencyEffectMap: {},
+        netPerformanceValues: {},
+        netPerformanceValuesWithCurrencyEffect: {},
+        timeWeightedInvestment: new Big(0),
+        timeWeightedInvestmentValues: {},
+        timeWeightedInvestmentValuesWithCurrencyEffect: {},
+        timeWeightedInvestmentWithCurrencyEffect: new Big(0),
+        totalAccountBalanceInBaseCurrency: new Big(0),
+        totalDividend: new Big(0),
+        totalDividendInBaseCurrency: new Big(0),
+        totalInterest: new Big(0),
+        totalInterestInBaseCurrency: new Big(0),
+        totalInvestment: new Big(0),
+        totalInvestmentWithCurrencyEffect: new Big(0),
+        totalLiabilities: new Big(0),
+        totalLiabilitiesInBaseCurrency: new Big(0),
+        totalValuables: new Big(0),
+        totalValuablesInBaseCurrency: new Big(0)
+      };
+    }
+
+    // Add a synthetic order at the start and the end date
+    orders.push({
+      date: startDateString,
+      fee: new Big(0),
+      feeInBaseCurrency: new Big(0),
+      itemType: 'start',
+      quantity: new Big(0),
+      SymbolProfile: {
+        dataSource,
+        symbol
+      },
+      type: 'BUY',
+      unitPrice: unitPriceAtStartDate
+    });
+
+    orders.push({
+      date: endDateString,
+      fee: new Big(0),
+      feeInBaseCurrency: new Big(0),
+      itemType: 'end',
+      SymbolProfile: {
+        dataSource,
+        symbol
+      },
+      quantity: new Big(0),
+      type: 'BUY',
+      unitPrice: unitPriceAtEndDate
+    });
+
+    let lastUnitPrice: Big;
+
+    const ordersByDate: { [date: string]: PortfolioOrderItem[] } = {};
+
+    for (const order of orders) {
+      ordersByDate[order.date] = ordersByDate[order.date] ?? [];
+      ordersByDate[order.date].push(order);
+    }
+
+    if (!this.chartDates) {
+      this.chartDates = Object.keys(chartDateMap).sort();
+    }
+
+    for (const dateString of this.chartDates) {
+      if (dateString < startDateString) {
+        continue;
+      } else if (dateString > endDateString) {
+        break;
+      }
+
+      if (ordersByDate[dateString]?.length > 0) {
+        for (const order of ordersByDate[dateString]) {
+          order.unitPriceFromMarketData =
+            marketSymbolMap[dateString]?.[symbol] ?? lastUnitPrice;
+        }
+      } else {
+        orders.push({
+          date: dateString,
+          fee: new Big(0),
+          feeInBaseCurrency: new Big(0),
+          quantity: new Big(0),
+          SymbolProfile: {
+            dataSource,
+            symbol
+          },
+          type: 'BUY',
+          unitPrice: marketSymbolMap[dateString]?.[symbol] ?? lastUnitPrice,
+          unitPriceFromMarketData:
+            marketSymbolMap[dateString]?.[symbol] ?? lastUnitPrice
+        });
+      }
+
+      const lastOrder = orders.at(-1);
+
+      lastUnitPrice = lastOrder.unitPriceFromMarketData ?? lastOrder.unitPrice;
+    }
+
+    // Sort orders so that the start and end placeholder order are at the correct
+    // position
+    orders = sortBy(orders, ({ date, itemType }) => {
+      let sortIndex = new Date(date);
+
+      if (itemType === 'end') {
+        sortIndex = addMilliseconds(sortIndex, 1);
+      } else if (itemType === 'start') {
+        sortIndex = addMilliseconds(sortIndex, -1);
+      }
+
+      return sortIndex.getTime();
+    });
+
+    const indexOfStartOrder = orders.findIndex(({ itemType }) => {
+      return itemType === 'start';
+    });
+
+    const indexOfEndOrder = orders.findIndex(({ itemType }) => {
+      return itemType === 'end';
+    });
+
+    let totalInvestmentDays = 0;
+    let sumOfTimeWeightedInvestments = new Big(0);
+    let sumOfTimeWeightedInvestmentsWithCurrencyEffect = new Big(0);
+
+    for (let i = 0; i < orders.length; i += 1) {
+      const order = orders[i];
+
+      if (PortfolioCalculator.ENABLE_LOGGING) {
+        console.log();
+        console.log();
+        console.log(
+          i + 1,
+          order.date,
+          order.type,
+          order.itemType ? `(${order.itemType})` : ''
+        );
+      }
+
+      const exchangeRateAtOrderDate = exchangeRates[order.date];
+
+      if (order.type === 'DIVIDEND') {
+        const dividend = order.quantity.mul(order.unitPrice);
+
+        totalDividend = totalDividend.plus(dividend);
+        totalDividendInBaseCurrency = totalDividendInBaseCurrency.plus(
+          dividend.mul(exchangeRateAtOrderDate ?? 1)
+        );
+      } else if (order.type === 'INTEREST') {
+        const interest = order.quantity.mul(order.unitPrice);
+
+        totalInterest = totalInterest.plus(interest);
+        totalInterestInBaseCurrency = totalInterestInBaseCurrency.plus(
+          interest.mul(exchangeRateAtOrderDate ?? 1)
+        );
+      } else if (order.type === 'ITEM') {
+        const valuables = order.quantity.mul(order.unitPrice);
+
+        totalValuables = totalValuables.plus(valuables);
+        totalValuablesInBaseCurrency = totalValuablesInBaseCurrency.plus(
+          valuables.mul(exchangeRateAtOrderDate ?? 1)
+        );
+      } else if (order.type === 'LIABILITY') {
+        const liabilities = order.quantity.mul(order.unitPrice);
+
+        totalLiabilities = totalLiabilities.plus(liabilities);
+        totalLiabilitiesInBaseCurrency = totalLiabilitiesInBaseCurrency.plus(
+          liabilities.mul(exchangeRateAtOrderDate ?? 1)
+        );
+      }
+
+      if (order.itemType === 'start') {
+        // Take the unit price of the order as the market price if there are no
+        // orders of this symbol before the start date
+        order.unitPrice =
+          indexOfStartOrder === 0
+            ? orders[i + 1]?.unitPrice
+            : unitPriceAtStartDate;
+      }
+
+      if (order.fee) {
+        order.feeInBaseCurrency = order.fee.mul(currentExchangeRate ?? 1);
+        order.feeInBaseCurrencyWithCurrencyEffect = order.fee.mul(
+          exchangeRateAtOrderDate ?? 1
+        );
+      }
+
+      const unitPrice = ['BUY', 'SELL'].includes(order.type)
+        ? order.unitPrice
+        : order.unitPriceFromMarketData;
+
+      if (unitPrice) {
+        order.unitPriceInBaseCurrency = unitPrice.mul(currentExchangeRate ?? 1);
+
+        order.unitPriceInBaseCurrencyWithCurrencyEffect = unitPrice.mul(
+          exchangeRateAtOrderDate ?? 1
+        );
+      }
+
+      const valueOfInvestmentBeforeTransaction = totalUnits.mul(
+        order.unitPriceInBaseCurrency
+      );
+
+      const valueOfInvestmentBeforeTransactionWithCurrencyEffect =
+        totalUnits.mul(order.unitPriceInBaseCurrencyWithCurrencyEffect);
+
+      if (!investmentAtStartDate && i >= indexOfStartOrder) {
+        investmentAtStartDate = totalInvestment ?? new Big(0);
+
+        investmentAtStartDateWithCurrencyEffect =
+          totalInvestmentWithCurrencyEffect ?? new Big(0);
+
+        valueAtStartDate = valueOfInvestmentBeforeTransaction;
+
+        valueAtStartDateWithCurrencyEffect =
+          valueOfInvestmentBeforeTransactionWithCurrencyEffect;
+      }
+
+      let transactionInvestment = new Big(0);
+      let transactionInvestmentWithCurrencyEffect = new Big(0);
+
+      if (order.type === 'BUY') {
+        transactionInvestment = order.quantity
+          .mul(order.unitPriceInBaseCurrency)
+          .mul(getFactor(order.type));
+
+        transactionInvestmentWithCurrencyEffect = order.quantity
+          .mul(order.unitPriceInBaseCurrencyWithCurrencyEffect)
+          .mul(getFactor(order.type));
+
+        totalQuantityFromBuyTransactions =
+          totalQuantityFromBuyTransactions.plus(order.quantity);
+
+        totalInvestmentFromBuyTransactions =
+          totalInvestmentFromBuyTransactions.plus(transactionInvestment);
+
+        totalInvestmentFromBuyTransactionsWithCurrencyEffect =
+          totalInvestmentFromBuyTransactionsWithCurrencyEffect.plus(
+            transactionInvestmentWithCurrencyEffect
+          );
+      } else if (order.type === 'SELL') {
+        if (totalUnits.gt(0)) {
+          transactionInvestment = totalInvestment
+            .div(totalUnits)
+            .mul(order.quantity)
+            .mul(getFactor(order.type));
+          transactionInvestmentWithCurrencyEffect =
+            totalInvestmentWithCurrencyEffect
+              .div(totalUnits)
+              .mul(order.quantity)
+              .mul(getFactor(order.type));
+        }
+      }
+
+      if (PortfolioCalculator.ENABLE_LOGGING) {
+        console.log('order.quantity', order.quantity.toNumber());
+        console.log('transactionInvestment', transactionInvestment.toNumber());
+
+        console.log(
+          'transactionInvestmentWithCurrencyEffect',
+          transactionInvestmentWithCurrencyEffect.toNumber()
+        );
+      }
+
+      const totalInvestmentBeforeTransaction = totalInvestment;
+
+      const totalInvestmentBeforeTransactionWithCurrencyEffect =
+        totalInvestmentWithCurrencyEffect;
+
+      totalInvestment = totalInvestment.plus(transactionInvestment);
+
+      totalInvestmentWithCurrencyEffect =
+        totalInvestmentWithCurrencyEffect.plus(
+          transactionInvestmentWithCurrencyEffect
+        );
+
+      if (i >= indexOfStartOrder && !initialValue) {
+        if (
+          i === indexOfStartOrder &&
+          !valueOfInvestmentBeforeTransaction.eq(0)
+        ) {
+          initialValue = valueOfInvestmentBeforeTransaction;
+
+          initialValueWithCurrencyEffect =
+            valueOfInvestmentBeforeTransactionWithCurrencyEffect;
+        } else if (transactionInvestment.gt(0)) {
+          initialValue = transactionInvestment;
+
+          initialValueWithCurrencyEffect =
+            transactionInvestmentWithCurrencyEffect;
+        }
+      }
+
+      fees = fees.plus(order.feeInBaseCurrency ?? 0);
+
+      feesWithCurrencyEffect = feesWithCurrencyEffect.plus(
+        order.feeInBaseCurrencyWithCurrencyEffect ?? 0
+      );
+
+      totalUnits = totalUnits.plus(order.quantity.mul(getFactor(order.type)));
+
+      const valueOfInvestment = totalUnits.mul(order.unitPriceInBaseCurrency);
+
+      const valueOfInvestmentWithCurrencyEffect = totalUnits.mul(
+        order.unitPriceInBaseCurrencyWithCurrencyEffect
+      );
+
+      const grossPerformanceFromSell =
+        order.type === 'SELL'
+          ? order.unitPriceInBaseCurrency
+              .minus(lastAveragePrice)
+              .mul(order.quantity)
+          : new Big(0);
+
+      const grossPerformanceFromSellWithCurrencyEffect =
+        order.type === 'SELL'
+          ? order.unitPriceInBaseCurrencyWithCurrencyEffect
+              .minus(lastAveragePriceWithCurrencyEffect)
+              .mul(order.quantity)
+          : new Big(0);
+
+      grossPerformanceFromSells = grossPerformanceFromSells.plus(
+        grossPerformanceFromSell
+      );
+
+      grossPerformanceFromSellsWithCurrencyEffect =
+        grossPerformanceFromSellsWithCurrencyEffect.plus(
+          grossPerformanceFromSellWithCurrencyEffect
+        );
+
+      lastAveragePrice = totalQuantityFromBuyTransactions.eq(0)
+        ? new Big(0)
+        : totalInvestmentFromBuyTransactions.div(
+            totalQuantityFromBuyTransactions
+          );
+
+      lastAveragePriceWithCurrencyEffect = totalQuantityFromBuyTransactions.eq(
+        0
+      )
+        ? new Big(0)
+        : totalInvestmentFromBuyTransactionsWithCurrencyEffect.div(
+            totalQuantityFromBuyTransactions
+          );
+
+      if (PortfolioCalculator.ENABLE_LOGGING) {
+        console.log(
+          'grossPerformanceFromSells',
+          grossPerformanceFromSells.toNumber()
+        );
+        console.log(
+          'grossPerformanceFromSellWithCurrencyEffect',
+          grossPerformanceFromSellWithCurrencyEffect.toNumber()
+        );
+      }
+
+      const newGrossPerformance = valueOfInvestment
+        .minus(totalInvestment)
+        .plus(grossPerformanceFromSells);
+
+      const newGrossPerformanceWithCurrencyEffect =
+        valueOfInvestmentWithCurrencyEffect
+          .minus(totalInvestmentWithCurrencyEffect)
+          .plus(grossPerformanceFromSellsWithCurrencyEffect);
+
+      grossPerformance = newGrossPerformance;
+
+      grossPerformanceWithCurrencyEffect =
+        newGrossPerformanceWithCurrencyEffect;
+
+      if (order.itemType === 'start') {
+        feesAtStartDate = fees;
+        feesAtStartDateWithCurrencyEffect = feesWithCurrencyEffect;
+        grossPerformanceAtStartDate = grossPerformance;
+
+        grossPerformanceAtStartDateWithCurrencyEffect =
+          grossPerformanceWithCurrencyEffect;
+      }
+
+      if (i > indexOfStartOrder) {
+        // Only consider periods with an investment for the calculation of
+        // the time weighted investment
+        if (
+          valueOfInvestmentBeforeTransaction.gt(0) &&
+          ['BUY', 'SELL'].includes(order.type)
+        ) {
+          // Calculate the number of days since the previous order
+          const orderDate = new Date(order.date);
+          const previousOrderDate = new Date(orders[i - 1].date);
+
+          let daysSinceLastOrder = differenceInDays(
+            orderDate,
+            previousOrderDate
+          );
+          if (daysSinceLastOrder <= 0) {
+            // The time between two activities on the same day is unknown
+            // -> Set it to the smallest floating point number greater than 0
+            daysSinceLastOrder = Number.EPSILON;
+          }
+
+          // Sum up the total investment days since the start date to calculate
+          // the time weighted investment
+          totalInvestmentDays += daysSinceLastOrder;
+
+          sumOfTimeWeightedInvestments = sumOfTimeWeightedInvestments.add(
+            valueAtStartDate
+              .minus(investmentAtStartDate)
+              .plus(totalInvestmentBeforeTransaction)
+              .mul(daysSinceLastOrder)
+          );
+
+          sumOfTimeWeightedInvestmentsWithCurrencyEffect =
+            sumOfTimeWeightedInvestmentsWithCurrencyEffect.add(
+              valueAtStartDateWithCurrencyEffect
+                .minus(investmentAtStartDateWithCurrencyEffect)
+                .plus(totalInvestmentBeforeTransactionWithCurrencyEffect)
+                .mul(daysSinceLastOrder)
+            );
+        }
+
+        currentValues[order.date] = valueOfInvestment;
+
+        currentValuesWithCurrencyEffect[order.date] =
+          valueOfInvestmentWithCurrencyEffect;
+
+        netPerformanceValues[order.date] = grossPerformance
+          .minus(grossPerformanceAtStartDate)
+          .minus(fees.minus(feesAtStartDate));
+
+        netPerformanceValuesWithCurrencyEffect[order.date] =
+          grossPerformanceWithCurrencyEffect
+            .minus(grossPerformanceAtStartDateWithCurrencyEffect)
+            .minus(
+              feesWithCurrencyEffect.minus(feesAtStartDateWithCurrencyEffect)
+            );
+
+        investmentValuesAccumulated[order.date] = totalInvestment;
+
+        investmentValuesAccumulatedWithCurrencyEffect[order.date] =
+          totalInvestmentWithCurrencyEffect;
+
+        investmentValuesWithCurrencyEffect[order.date] = (
+          investmentValuesWithCurrencyEffect[order.date] ?? new Big(0)
+        ).add(transactionInvestmentWithCurrencyEffect);
+
+        timeWeightedInvestmentValues[order.date] =
+          totalInvestmentDays > 0
+            ? sumOfTimeWeightedInvestments.div(totalInvestmentDays)
+            : new Big(0);
+
+        timeWeightedInvestmentValuesWithCurrencyEffect[order.date] =
+          totalInvestmentDays > 0
+            ? sumOfTimeWeightedInvestmentsWithCurrencyEffect.div(
+                totalInvestmentDays
+              )
+            : new Big(0);
+      }
+
+      if (PortfolioCalculator.ENABLE_LOGGING) {
+        console.log('totalInvestment', totalInvestment.toNumber());
+
+        console.log(
+          'totalInvestmentWithCurrencyEffect',
+          totalInvestmentWithCurrencyEffect.toNumber()
+        );
+
+        console.log(
+          'totalGrossPerformance',
+          grossPerformance.minus(grossPerformanceAtStartDate).toNumber()
+        );
+
+        console.log(
+          'totalGrossPerformanceWithCurrencyEffect',
+          grossPerformanceWithCurrencyEffect
+            .minus(grossPerformanceAtStartDateWithCurrencyEffect)
+            .toNumber()
+        );
+      }
+
+      if (i === indexOfEndOrder) {
+        break;
+      }
+    }
+
+    const totalGrossPerformance = grossPerformance.minus(
+      grossPerformanceAtStartDate
+    );
+
+    const totalGrossPerformanceWithCurrencyEffect =
+      grossPerformanceWithCurrencyEffect.minus(
+        grossPerformanceAtStartDateWithCurrencyEffect
+      );
+
+    const totalNetPerformance = grossPerformance
+      .minus(grossPerformanceAtStartDate)
+      .minus(fees.minus(feesAtStartDate));
+
+    const timeWeightedAverageInvestmentBetweenStartAndEndDate =
+      totalInvestmentDays > 0
+        ? sumOfTimeWeightedInvestments.div(totalInvestmentDays)
+        : new Big(0);
+
+    const timeWeightedAverageInvestmentBetweenStartAndEndDateWithCurrencyEffect =
+      totalInvestmentDays > 0
+        ? sumOfTimeWeightedInvestmentsWithCurrencyEffect.div(
+            totalInvestmentDays
+          )
+        : new Big(0);
+
+    const grossPerformancePercentage =
+      timeWeightedAverageInvestmentBetweenStartAndEndDate.gt(0)
+        ? totalGrossPerformance.div(
+            timeWeightedAverageInvestmentBetweenStartAndEndDate
+          )
+        : new Big(0);
+
+    const grossPerformancePercentageWithCurrencyEffect =
+      timeWeightedAverageInvestmentBetweenStartAndEndDateWithCurrencyEffect.gt(
+        0
+      )
+        ? totalGrossPerformanceWithCurrencyEffect.div(
+            timeWeightedAverageInvestmentBetweenStartAndEndDateWithCurrencyEffect
+          )
+        : new Big(0);
+
+    const feesPerUnit = totalUnits.gt(0)
+      ? fees.minus(feesAtStartDate).div(totalUnits)
+      : new Big(0);
+
+    const feesPerUnitWithCurrencyEffect = totalUnits.gt(0)
+      ? feesWithCurrencyEffect
+          .minus(feesAtStartDateWithCurrencyEffect)
+          .div(totalUnits)
+      : new Big(0);
+
+    const netPerformancePercentage =
+      timeWeightedAverageInvestmentBetweenStartAndEndDate.gt(0)
+        ? totalNetPerformance.div(
+            timeWeightedAverageInvestmentBetweenStartAndEndDate
+          )
+        : new Big(0);
+
+    const netPerformancePercentageWithCurrencyEffectMap: {
+      [key: DateRange]: Big;
+    } = {};
+
+    const netPerformanceWithCurrencyEffectMap: {
+      [key: DateRange]: Big;
+    } = {};
+
+    for (const dateRange of [
+      '1d',
+      '1y',
+      '5y',
+      'max',
+      'mtd',
+      'wtd',
+      'ytd'
+      // TODO:
+      // ...eachYearOfInterval({ end, start })
+      //   .filter((date) => {
+      //     return !isThisYear(date);
+      //   })
+      //   .map((date) => {
+      //     return format(date, 'yyyy');
+      //   })
+    ] as DateRange[]) {
+      const dateInterval = getIntervalFromDateRange(dateRange);
+      const endDate = dateInterval.endDate;
+      let startDate = dateInterval.startDate;
+
+      if (isBefore(startDate, start)) {
+        startDate = start;
+      }
+
+      const rangeEndDateString = format(endDate, DATE_FORMAT);
+      const rangeStartDateString = format(startDate, DATE_FORMAT);
+
+      const currentValuesAtDateRangeStartWithCurrencyEffect =
+        currentValuesWithCurrencyEffect[rangeStartDateString] ?? new Big(0);
+
+      const investmentValuesAccumulatedAtStartDateWithCurrencyEffect =
+        investmentValuesAccumulatedWithCurrencyEffect[rangeStartDateString] ??
+        new Big(0);
+
+      const grossPerformanceAtDateRangeStartWithCurrencyEffect =
+        currentValuesAtDateRangeStartWithCurrencyEffect.minus(
+          investmentValuesAccumulatedAtStartDateWithCurrencyEffect
+        );
+
+      let average = new Big(0);
+      let dayCount = 0;
+
+      for (let i = this.chartDates.length - 1; i >= 0; i -= 1) {
+        const date = this.chartDates[i];
+
+        if (date > rangeEndDateString) {
+          continue;
+        } else if (date < rangeStartDateString) {
+          break;
+        }
+
+        if (
+          investmentValuesAccumulatedWithCurrencyEffect[date] instanceof Big &&
+          investmentValuesAccumulatedWithCurrencyEffect[date].gt(0)
+        ) {
+          average = average.add(
+            investmentValuesAccumulatedWithCurrencyEffect[date].add(
+              grossPerformanceAtDateRangeStartWithCurrencyEffect
+            )
+          );
+
+          dayCount++;
+        }
+      }
+
+      if (dayCount > 0) {
+        average = average.div(dayCount);
+      }
+
+      netPerformanceWithCurrencyEffectMap[dateRange] =
+        netPerformanceValuesWithCurrencyEffect[rangeEndDateString]?.minus(
+          // If the date range is 'max', take 0 as a start value. Otherwise,
+          // the value of the end of the day of the start date is taken which
+          // differs from the buying price.
+          dateRange === 'max'
+            ? new Big(0)
+            : (netPerformanceValuesWithCurrencyEffect[rangeStartDateString] ??
+                new Big(0))
+        ) ?? new Big(0);
+
+      netPerformancePercentageWithCurrencyEffectMap[dateRange] = average.gt(0)
+        ? netPerformanceWithCurrencyEffectMap[dateRange].div(average)
+        : new Big(0);
+    }
+
+    if (PortfolioCalculator.ENABLE_LOGGING) {
+      console.log(
+        `
+        ${symbol}
+        Unit price: ${orders[indexOfStartOrder].unitPrice.toFixed(
+          2
+        )} -> ${unitPriceAtEndDate.toFixed(2)}
+        Total investment: ${totalInvestment.toFixed(2)}
+        Total investment with currency effect: ${totalInvestmentWithCurrencyEffect.toFixed(
+          2
+        )}
+        Time weighted investment: ${timeWeightedAverageInvestmentBetweenStartAndEndDate.toFixed(
+          2
+        )}
+        Time weighted investment with currency effect: ${timeWeightedAverageInvestmentBetweenStartAndEndDateWithCurrencyEffect.toFixed(
+          2
+        )}
+        Total dividend: ${totalDividend.toFixed(2)}
+        Gross performance: ${totalGrossPerformance.toFixed(
+          2
+        )} / ${grossPerformancePercentage.mul(100).toFixed(2)}%
+        Gross performance with currency effect: ${totalGrossPerformanceWithCurrencyEffect.toFixed(
+          2
+        )} / ${grossPerformancePercentageWithCurrencyEffect
+          .mul(100)
+          .toFixed(2)}%
+        Fees per unit: ${feesPerUnit.toFixed(2)}
+        Fees per unit with currency effect: ${feesPerUnitWithCurrencyEffect.toFixed(
+          2
+        )}
+        Net performance: ${totalNetPerformance.toFixed(
+          2
+        )} / ${netPerformancePercentage.mul(100).toFixed(2)}%
+        Net performance with currency effect: ${netPerformancePercentageWithCurrencyEffectMap[
+          'max'
+        ].toFixed(2)}%`
+      );
+    }
+
+    return {
+      currentValues,
+      currentValuesWithCurrencyEffect,
+      feesWithCurrencyEffect,
+      grossPerformancePercentage,
+      grossPerformancePercentageWithCurrencyEffect,
+      initialValue,
+      initialValueWithCurrencyEffect,
+      investmentValuesAccumulated,
+      investmentValuesAccumulatedWithCurrencyEffect,
+      investmentValuesWithCurrencyEffect,
+      netPerformancePercentage,
+      netPerformancePercentageWithCurrencyEffectMap,
+      netPerformanceValues,
+      netPerformanceValuesWithCurrencyEffect,
+      netPerformanceWithCurrencyEffectMap,
+      timeWeightedInvestmentValues,
+      timeWeightedInvestmentValuesWithCurrencyEffect,
+      totalAccountBalanceInBaseCurrency,
+      totalDividend,
+      totalDividendInBaseCurrency,
+      totalInterest,
+      totalInterestInBaseCurrency,
+      totalInvestment,
+      totalInvestmentWithCurrencyEffect,
+      totalLiabilities,
+      totalLiabilitiesInBaseCurrency,
+      totalValuables,
+      totalValuablesInBaseCurrency,
+      grossPerformance: totalGrossPerformance,
+      grossPerformanceWithCurrencyEffect:
+        totalGrossPerformanceWithCurrencyEffect,
+      hasErrors: totalUnits.gt(0) && (!initialValue || !unitPriceAtEndDate),
+      netPerformance: totalNetPerformance,
+      timeWeightedInvestment:
+        timeWeightedAverageInvestmentBetweenStartAndEndDate,
+      timeWeightedInvestmentWithCurrencyEffect:
+        timeWeightedAverageInvestmentBetweenStartAndEndDateWithCurrencyEffect
+    };
+  }
+}

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

@@ -1,969 +1,24 @@
 import { PortfolioCalculator } from '@ghostfolio/api/app/portfolio/calculator/portfolio-calculator';
-import { PortfolioOrderItem } from '@ghostfolio/api/app/portfolio/interfaces/portfolio-order-item.interface';
-import { getFactor } from '@ghostfolio/api/helper/portfolio.helper';
-import { getIntervalFromDateRange } from '@ghostfolio/common/calculation-helper';
-import { DATE_FORMAT } from '@ghostfolio/common/helper';
 import {
   AssetProfileIdentifier,
   SymbolMetrics
 } from '@ghostfolio/common/interfaces';
-import { PortfolioSnapshot, TimelinePosition } from '@ghostfolio/common/models';
+import { PortfolioSnapshot } from '@ghostfolio/common/models';
-import { DateRange } from '@ghostfolio/common/types';
 
-import { Logger } from '@nestjs/common';
+export class TwrPortfolioCalculator extends PortfolioCalculator {
-import { Big } from 'big.js';
+  protected calculateOverallPerformance(): PortfolioSnapshot {
-import { addMilliseconds, differenceInDays, format, isBefore } from 'date-fns';
+    throw new Error('Method not implemented.');
-import { cloneDeep, sortBy } from 'lodash';
-
-export class TWRPortfolioCalculator extends PortfolioCalculator {
-  private chartDates: string[];
-
-  protected calculateOverallPerformance(
-    positions: TimelinePosition[]
-  ): 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 totalFeesWithCurrencyEffect = new Big(0);
-    const totalInterestWithCurrencyEffect = new Big(0);
-    let totalInvestment = new Big(0);
-    let totalInvestmentWithCurrencyEffect = new Big(0);
-    let totalTimeWeightedInvestment = new Big(0);
-    let totalTimeWeightedInvestmentWithCurrencyEffect = new Big(0);
-
-    for (const currentPosition of positions) {
-      if (currentPosition.feeInBaseCurrency) {
-        totalFeesWithCurrencyEffect = totalFeesWithCurrencyEffect.plus(
-          currentPosition.feeInBaseCurrency
-        );
-      }
-
-      if (currentPosition.valueInBaseCurrency) {
-        currentValueInBaseCurrency = currentValueInBaseCurrency.plus(
-          currentPosition.valueInBaseCurrency
-        );
-      } else {
-        hasErrors = true;
-      }
-
-      if (currentPosition.investment) {
-        totalInvestment = totalInvestment.plus(currentPosition.investment);
-
-        totalInvestmentWithCurrencyEffect =
-          totalInvestmentWithCurrencyEffect.plus(
-            currentPosition.investmentWithCurrencyEffect
-          );
-      } else {
-        hasErrors = true;
-      }
-
-      if (currentPosition.grossPerformance) {
-        grossPerformance = grossPerformance.plus(
-          currentPosition.grossPerformance
-        );
-
-        grossPerformanceWithCurrencyEffect =
-          grossPerformanceWithCurrencyEffect.plus(
-            currentPosition.grossPerformanceWithCurrencyEffect
-          );
-
-        netPerformance = netPerformance.plus(currentPosition.netPerformance);
-      } else if (!currentPosition.quantity.eq(0)) {
-        hasErrors = true;
   }
 
-      if (currentPosition.timeWeightedInvestment) {
+  protected getSymbolMetrics({}: {
-        totalTimeWeightedInvestment = totalTimeWeightedInvestment.plus(
-          currentPosition.timeWeightedInvestment
-        );
-
-        totalTimeWeightedInvestmentWithCurrencyEffect =
-          totalTimeWeightedInvestmentWithCurrencyEffect.plus(
-            currentPosition.timeWeightedInvestmentWithCurrencyEffect
-          );
-      } else if (!currentPosition.quantity.eq(0)) {
-        Logger.warn(
-          `Missing historical market data for ${currentPosition.symbol} (${currentPosition.dataSource})`,
-          'PortfolioCalculator'
-        );
-
-        hasErrors = true;
-      }
-    }
-
-    return {
-      currentValueInBaseCurrency,
-      hasErrors,
-      positions,
-      totalFeesWithCurrencyEffect,
-      totalInterestWithCurrencyEffect,
-      totalInvestment,
-      totalInvestmentWithCurrencyEffect,
-      activitiesCount: this.activities.filter(({ type }) => {
-        return ['BUY', 'SELL'].includes(type);
-      }).length,
-      createdAt: new Date(),
-      errors: [],
-      historicalData: [],
-      totalLiabilitiesWithCurrencyEffect: new Big(0),
-      totalValuablesWithCurrencyEffect: new Big(0)
-    };
-  }
-
-  protected getSymbolMetrics({
-    chartDateMap,
-    dataSource,
-    end,
-    exchangeRates,
-    marketSymbolMap,
-    start,
-    symbol
-  }: {
-    chartDateMap?: { [date: string]: boolean };
     end: Date;
     exchangeRates: { [dateString: string]: number };
     marketSymbolMap: {
       [date: string]: { [symbol: string]: Big };
     };
     start: Date;
+    step?: number;
   } & AssetProfileIdentifier): SymbolMetrics {
-    const currentExchangeRate = exchangeRates[format(new Date(), DATE_FORMAT)];
+    throw new Error('Method not implemented.');
-    const currentValues: { [date: string]: Big } = {};
-    const currentValuesWithCurrencyEffect: { [date: string]: Big } = {};
-    let fees = new Big(0);
-    let feesAtStartDate = new Big(0);
-    let feesAtStartDateWithCurrencyEffect = new Big(0);
-    let feesWithCurrencyEffect = new Big(0);
-    let grossPerformance = new Big(0);
-    let grossPerformanceWithCurrencyEffect = new Big(0);
-    let grossPerformanceAtStartDate = new Big(0);
-    let grossPerformanceAtStartDateWithCurrencyEffect = new Big(0);
-    let grossPerformanceFromSells = new Big(0);
-    let grossPerformanceFromSellsWithCurrencyEffect = new Big(0);
-    let initialValue: Big;
-    let initialValueWithCurrencyEffect: Big;
-    let investmentAtStartDate: Big;
-    let investmentAtStartDateWithCurrencyEffect: Big;
-    const investmentValuesAccumulated: { [date: string]: Big } = {};
-    const investmentValuesAccumulatedWithCurrencyEffect: {
-      [date: string]: Big;
-    } = {};
-    const investmentValuesWithCurrencyEffect: { [date: string]: Big } = {};
-    let lastAveragePrice = new Big(0);
-    let lastAveragePriceWithCurrencyEffect = new Big(0);
-    const netPerformanceValues: { [date: string]: Big } = {};
-    const netPerformanceValuesWithCurrencyEffect: { [date: string]: Big } = {};
-    const timeWeightedInvestmentValues: { [date: string]: Big } = {};
-
-    const timeWeightedInvestmentValuesWithCurrencyEffect: {
-      [date: string]: Big;
-    } = {};
-
-    const totalAccountBalanceInBaseCurrency = new Big(0);
-    let totalDividend = new Big(0);
-    let totalDividendInBaseCurrency = new Big(0);
-    let totalInterest = new Big(0);
-    let totalInterestInBaseCurrency = new Big(0);
-    let totalInvestment = new Big(0);
-    let totalInvestmentFromBuyTransactions = new Big(0);
-    let totalInvestmentFromBuyTransactionsWithCurrencyEffect = new Big(0);
-    let totalInvestmentWithCurrencyEffect = new Big(0);
-    let totalLiabilities = new Big(0);
-    let totalLiabilitiesInBaseCurrency = new Big(0);
-    let totalQuantityFromBuyTransactions = new Big(0);
-    let totalUnits = new Big(0);
-    let totalValuables = new Big(0);
-    let totalValuablesInBaseCurrency = new Big(0);
-    let valueAtStartDate: Big;
-    let valueAtStartDateWithCurrencyEffect: Big;
-
-    // Clone orders to keep the original values in this.orders
-    let orders: PortfolioOrderItem[] = cloneDeep(
-      this.activities.filter(({ SymbolProfile }) => {
-        return SymbolProfile.symbol === symbol;
-      })
-    );
-
-    if (orders.length <= 0) {
-      return {
-        currentValues: {},
-        currentValuesWithCurrencyEffect: {},
-        feesWithCurrencyEffect: new Big(0),
-        grossPerformance: new Big(0),
-        grossPerformancePercentage: new Big(0),
-        grossPerformancePercentageWithCurrencyEffect: new Big(0),
-        grossPerformanceWithCurrencyEffect: new Big(0),
-        hasErrors: false,
-        initialValue: new Big(0),
-        initialValueWithCurrencyEffect: new Big(0),
-        investmentValuesAccumulated: {},
-        investmentValuesAccumulatedWithCurrencyEffect: {},
-        investmentValuesWithCurrencyEffect: {},
-        netPerformance: new Big(0),
-        netPerformancePercentage: new Big(0),
-        netPerformancePercentageWithCurrencyEffectMap: {},
-        netPerformanceValues: {},
-        netPerformanceValuesWithCurrencyEffect: {},
-        netPerformanceWithCurrencyEffectMap: {},
-        timeWeightedInvestment: new Big(0),
-        timeWeightedInvestmentValues: {},
-        timeWeightedInvestmentValuesWithCurrencyEffect: {},
-        timeWeightedInvestmentWithCurrencyEffect: new Big(0),
-        totalAccountBalanceInBaseCurrency: new Big(0),
-        totalDividend: new Big(0),
-        totalDividendInBaseCurrency: new Big(0),
-        totalInterest: new Big(0),
-        totalInterestInBaseCurrency: new Big(0),
-        totalInvestment: new Big(0),
-        totalInvestmentWithCurrencyEffect: new Big(0),
-        totalLiabilities: new Big(0),
-        totalLiabilitiesInBaseCurrency: new Big(0),
-        totalValuables: new Big(0),
-        totalValuablesInBaseCurrency: new Big(0)
-      };
-    }
-
-    const dateOfFirstTransaction = new Date(orders[0].date);
-
-    const endDateString = format(end, DATE_FORMAT);
-    const startDateString = format(start, DATE_FORMAT);
-
-    const unitPriceAtStartDate = marketSymbolMap[startDateString]?.[symbol];
-    const unitPriceAtEndDate = marketSymbolMap[endDateString]?.[symbol];
-
-    if (
-      !unitPriceAtEndDate ||
-      (!unitPriceAtStartDate && isBefore(dateOfFirstTransaction, start))
-    ) {
-      return {
-        currentValues: {},
-        currentValuesWithCurrencyEffect: {},
-        feesWithCurrencyEffect: new Big(0),
-        grossPerformance: new Big(0),
-        grossPerformancePercentage: new Big(0),
-        grossPerformancePercentageWithCurrencyEffect: new Big(0),
-        grossPerformanceWithCurrencyEffect: new Big(0),
-        hasErrors: true,
-        initialValue: new Big(0),
-        initialValueWithCurrencyEffect: new Big(0),
-        investmentValuesAccumulated: {},
-        investmentValuesAccumulatedWithCurrencyEffect: {},
-        investmentValuesWithCurrencyEffect: {},
-        netPerformance: new Big(0),
-        netPerformancePercentage: new Big(0),
-        netPerformancePercentageWithCurrencyEffectMap: {},
-        netPerformanceWithCurrencyEffectMap: {},
-        netPerformanceValues: {},
-        netPerformanceValuesWithCurrencyEffect: {},
-        timeWeightedInvestment: new Big(0),
-        timeWeightedInvestmentValues: {},
-        timeWeightedInvestmentValuesWithCurrencyEffect: {},
-        timeWeightedInvestmentWithCurrencyEffect: new Big(0),
-        totalAccountBalanceInBaseCurrency: new Big(0),
-        totalDividend: new Big(0),
-        totalDividendInBaseCurrency: new Big(0),
-        totalInterest: new Big(0),
-        totalInterestInBaseCurrency: new Big(0),
-        totalInvestment: new Big(0),
-        totalInvestmentWithCurrencyEffect: new Big(0),
-        totalLiabilities: new Big(0),
-        totalLiabilitiesInBaseCurrency: new Big(0),
-        totalValuables: new Big(0),
-        totalValuablesInBaseCurrency: new Big(0)
-      };
-    }
-
-    // Add a synthetic order at the start and the end date
-    orders.push({
-      date: startDateString,
-      fee: new Big(0),
-      feeInBaseCurrency: new Big(0),
-      itemType: 'start',
-      quantity: new Big(0),
-      SymbolProfile: {
-        dataSource,
-        symbol
-      },
-      type: 'BUY',
-      unitPrice: unitPriceAtStartDate
-    });
-
-    orders.push({
-      date: endDateString,
-      fee: new Big(0),
-      feeInBaseCurrency: new Big(0),
-      itemType: 'end',
-      SymbolProfile: {
-        dataSource,
-        symbol
-      },
-      quantity: new Big(0),
-      type: 'BUY',
-      unitPrice: unitPriceAtEndDate
-    });
-
-    let lastUnitPrice: Big;
-
-    const ordersByDate: { [date: string]: PortfolioOrderItem[] } = {};
-
-    for (const order of orders) {
-      ordersByDate[order.date] = ordersByDate[order.date] ?? [];
-      ordersByDate[order.date].push(order);
-    }
-
-    if (!this.chartDates) {
-      this.chartDates = Object.keys(chartDateMap).sort();
-    }
-
-    for (const dateString of this.chartDates) {
-      if (dateString < startDateString) {
-        continue;
-      } else if (dateString > endDateString) {
-        break;
-      }
-
-      if (ordersByDate[dateString]?.length > 0) {
-        for (const order of ordersByDate[dateString]) {
-          order.unitPriceFromMarketData =
-            marketSymbolMap[dateString]?.[symbol] ?? lastUnitPrice;
-        }
-      } else {
-        orders.push({
-          date: dateString,
-          fee: new Big(0),
-          feeInBaseCurrency: new Big(0),
-          quantity: new Big(0),
-          SymbolProfile: {
-            dataSource,
-            symbol
-          },
-          type: 'BUY',
-          unitPrice: marketSymbolMap[dateString]?.[symbol] ?? lastUnitPrice,
-          unitPriceFromMarketData:
-            marketSymbolMap[dateString]?.[symbol] ?? lastUnitPrice
-        });
-      }
-
-      const lastOrder = orders.at(-1);
-
-      lastUnitPrice = lastOrder.unitPriceFromMarketData ?? lastOrder.unitPrice;
-    }
-
-    // Sort orders so that the start and end placeholder order are at the correct
-    // position
-    orders = sortBy(orders, ({ date, itemType }) => {
-      let sortIndex = new Date(date);
-
-      if (itemType === 'end') {
-        sortIndex = addMilliseconds(sortIndex, 1);
-      } else if (itemType === 'start') {
-        sortIndex = addMilliseconds(sortIndex, -1);
-      }
-
-      return sortIndex.getTime();
-    });
-
-    const indexOfStartOrder = orders.findIndex(({ itemType }) => {
-      return itemType === 'start';
-    });
-
-    const indexOfEndOrder = orders.findIndex(({ itemType }) => {
-      return itemType === 'end';
-    });
-
-    let totalInvestmentDays = 0;
-    let sumOfTimeWeightedInvestments = new Big(0);
-    let sumOfTimeWeightedInvestmentsWithCurrencyEffect = new Big(0);
-
-    for (let i = 0; i < orders.length; i += 1) {
-      const order = orders[i];
-
-      if (PortfolioCalculator.ENABLE_LOGGING) {
-        console.log();
-        console.log();
-        console.log(
-          i + 1,
-          order.date,
-          order.type,
-          order.itemType ? `(${order.itemType})` : ''
-        );
-      }
-
-      const exchangeRateAtOrderDate = exchangeRates[order.date];
-
-      if (order.type === 'DIVIDEND') {
-        const dividend = order.quantity.mul(order.unitPrice);
-
-        totalDividend = totalDividend.plus(dividend);
-        totalDividendInBaseCurrency = totalDividendInBaseCurrency.plus(
-          dividend.mul(exchangeRateAtOrderDate ?? 1)
-        );
-      } else if (order.type === 'INTEREST') {
-        const interest = order.quantity.mul(order.unitPrice);
-
-        totalInterest = totalInterest.plus(interest);
-        totalInterestInBaseCurrency = totalInterestInBaseCurrency.plus(
-          interest.mul(exchangeRateAtOrderDate ?? 1)
-        );
-      } else if (order.type === 'ITEM') {
-        const valuables = order.quantity.mul(order.unitPrice);
-
-        totalValuables = totalValuables.plus(valuables);
-        totalValuablesInBaseCurrency = totalValuablesInBaseCurrency.plus(
-          valuables.mul(exchangeRateAtOrderDate ?? 1)
-        );
-      } else if (order.type === 'LIABILITY') {
-        const liabilities = order.quantity.mul(order.unitPrice);
-
-        totalLiabilities = totalLiabilities.plus(liabilities);
-        totalLiabilitiesInBaseCurrency = totalLiabilitiesInBaseCurrency.plus(
-          liabilities.mul(exchangeRateAtOrderDate ?? 1)
-        );
-      }
-
-      if (order.itemType === 'start') {
-        // Take the unit price of the order as the market price if there are no
-        // orders of this symbol before the start date
-        order.unitPrice =
-          indexOfStartOrder === 0
-            ? orders[i + 1]?.unitPrice
-            : unitPriceAtStartDate;
-      }
-
-      if (order.fee) {
-        order.feeInBaseCurrency = order.fee.mul(currentExchangeRate ?? 1);
-        order.feeInBaseCurrencyWithCurrencyEffect = order.fee.mul(
-          exchangeRateAtOrderDate ?? 1
-        );
-      }
-
-      const unitPrice = ['BUY', 'SELL'].includes(order.type)
-        ? order.unitPrice
-        : order.unitPriceFromMarketData;
-
-      if (unitPrice) {
-        order.unitPriceInBaseCurrency = unitPrice.mul(currentExchangeRate ?? 1);
-
-        order.unitPriceInBaseCurrencyWithCurrencyEffect = unitPrice.mul(
-          exchangeRateAtOrderDate ?? 1
-        );
-      }
-
-      const valueOfInvestmentBeforeTransaction = totalUnits.mul(
-        order.unitPriceInBaseCurrency
-      );
-
-      const valueOfInvestmentBeforeTransactionWithCurrencyEffect =
-        totalUnits.mul(order.unitPriceInBaseCurrencyWithCurrencyEffect);
-
-      if (!investmentAtStartDate && i >= indexOfStartOrder) {
-        investmentAtStartDate = totalInvestment ?? new Big(0);
-
-        investmentAtStartDateWithCurrencyEffect =
-          totalInvestmentWithCurrencyEffect ?? new Big(0);
-
-        valueAtStartDate = valueOfInvestmentBeforeTransaction;
-
-        valueAtStartDateWithCurrencyEffect =
-          valueOfInvestmentBeforeTransactionWithCurrencyEffect;
-      }
-
-      let transactionInvestment = new Big(0);
-      let transactionInvestmentWithCurrencyEffect = new Big(0);
-
-      if (order.type === 'BUY') {
-        transactionInvestment = order.quantity
-          .mul(order.unitPriceInBaseCurrency)
-          .mul(getFactor(order.type));
-
-        transactionInvestmentWithCurrencyEffect = order.quantity
-          .mul(order.unitPriceInBaseCurrencyWithCurrencyEffect)
-          .mul(getFactor(order.type));
-
-        totalQuantityFromBuyTransactions =
-          totalQuantityFromBuyTransactions.plus(order.quantity);
-
-        totalInvestmentFromBuyTransactions =
-          totalInvestmentFromBuyTransactions.plus(transactionInvestment);
-
-        totalInvestmentFromBuyTransactionsWithCurrencyEffect =
-          totalInvestmentFromBuyTransactionsWithCurrencyEffect.plus(
-            transactionInvestmentWithCurrencyEffect
-          );
-      } else if (order.type === 'SELL') {
-        if (totalUnits.gt(0)) {
-          transactionInvestment = totalInvestment
-            .div(totalUnits)
-            .mul(order.quantity)
-            .mul(getFactor(order.type));
-          transactionInvestmentWithCurrencyEffect =
-            totalInvestmentWithCurrencyEffect
-              .div(totalUnits)
-              .mul(order.quantity)
-              .mul(getFactor(order.type));
-        }
-      }
-
-      if (PortfolioCalculator.ENABLE_LOGGING) {
-        console.log('order.quantity', order.quantity.toNumber());
-        console.log('transactionInvestment', transactionInvestment.toNumber());
-
-        console.log(
-          'transactionInvestmentWithCurrencyEffect',
-          transactionInvestmentWithCurrencyEffect.toNumber()
-        );
-      }
-
-      const totalInvestmentBeforeTransaction = totalInvestment;
-
-      const totalInvestmentBeforeTransactionWithCurrencyEffect =
-        totalInvestmentWithCurrencyEffect;
-
-      totalInvestment = totalInvestment.plus(transactionInvestment);
-
-      totalInvestmentWithCurrencyEffect =
-        totalInvestmentWithCurrencyEffect.plus(
-          transactionInvestmentWithCurrencyEffect
-        );
-
-      if (i >= indexOfStartOrder && !initialValue) {
-        if (
-          i === indexOfStartOrder &&
-          !valueOfInvestmentBeforeTransaction.eq(0)
-        ) {
-          initialValue = valueOfInvestmentBeforeTransaction;
-
-          initialValueWithCurrencyEffect =
-            valueOfInvestmentBeforeTransactionWithCurrencyEffect;
-        } else if (transactionInvestment.gt(0)) {
-          initialValue = transactionInvestment;
-
-          initialValueWithCurrencyEffect =
-            transactionInvestmentWithCurrencyEffect;
-        }
-      }
-
-      fees = fees.plus(order.feeInBaseCurrency ?? 0);
-
-      feesWithCurrencyEffect = feesWithCurrencyEffect.plus(
-        order.feeInBaseCurrencyWithCurrencyEffect ?? 0
-      );
-
-      totalUnits = totalUnits.plus(order.quantity.mul(getFactor(order.type)));
-
-      const valueOfInvestment = totalUnits.mul(order.unitPriceInBaseCurrency);
-
-      const valueOfInvestmentWithCurrencyEffect = totalUnits.mul(
-        order.unitPriceInBaseCurrencyWithCurrencyEffect
-      );
-
-      const grossPerformanceFromSell =
-        order.type === 'SELL'
-          ? order.unitPriceInBaseCurrency
-              .minus(lastAveragePrice)
-              .mul(order.quantity)
-          : new Big(0);
-
-      const grossPerformanceFromSellWithCurrencyEffect =
-        order.type === 'SELL'
-          ? order.unitPriceInBaseCurrencyWithCurrencyEffect
-              .minus(lastAveragePriceWithCurrencyEffect)
-              .mul(order.quantity)
-          : new Big(0);
-
-      grossPerformanceFromSells = grossPerformanceFromSells.plus(
-        grossPerformanceFromSell
-      );
-
-      grossPerformanceFromSellsWithCurrencyEffect =
-        grossPerformanceFromSellsWithCurrencyEffect.plus(
-          grossPerformanceFromSellWithCurrencyEffect
-        );
-
-      lastAveragePrice = totalQuantityFromBuyTransactions.eq(0)
-        ? new Big(0)
-        : totalInvestmentFromBuyTransactions.div(
-            totalQuantityFromBuyTransactions
-          );
-
-      lastAveragePriceWithCurrencyEffect = totalQuantityFromBuyTransactions.eq(
-        0
-      )
-        ? new Big(0)
-        : totalInvestmentFromBuyTransactionsWithCurrencyEffect.div(
-            totalQuantityFromBuyTransactions
-          );
-
-      if (PortfolioCalculator.ENABLE_LOGGING) {
-        console.log(
-          'grossPerformanceFromSells',
-          grossPerformanceFromSells.toNumber()
-        );
-        console.log(
-          'grossPerformanceFromSellWithCurrencyEffect',
-          grossPerformanceFromSellWithCurrencyEffect.toNumber()
-        );
-      }
-
-      const newGrossPerformance = valueOfInvestment
-        .minus(totalInvestment)
-        .plus(grossPerformanceFromSells);
-
-      const newGrossPerformanceWithCurrencyEffect =
-        valueOfInvestmentWithCurrencyEffect
-          .minus(totalInvestmentWithCurrencyEffect)
-          .plus(grossPerformanceFromSellsWithCurrencyEffect);
-
-      grossPerformance = newGrossPerformance;
-
-      grossPerformanceWithCurrencyEffect =
-        newGrossPerformanceWithCurrencyEffect;
-
-      if (order.itemType === 'start') {
-        feesAtStartDate = fees;
-        feesAtStartDateWithCurrencyEffect = feesWithCurrencyEffect;
-        grossPerformanceAtStartDate = grossPerformance;
-
-        grossPerformanceAtStartDateWithCurrencyEffect =
-          grossPerformanceWithCurrencyEffect;
-      }
-
-      if (i > indexOfStartOrder) {
-        // Only consider periods with an investment for the calculation of
-        // the time weighted investment
-        if (
-          valueOfInvestmentBeforeTransaction.gt(0) &&
-          ['BUY', 'SELL'].includes(order.type)
-        ) {
-          // Calculate the number of days since the previous order
-          const orderDate = new Date(order.date);
-          const previousOrderDate = new Date(orders[i - 1].date);
-
-          let daysSinceLastOrder = differenceInDays(
-            orderDate,
-            previousOrderDate
-          );
-          if (daysSinceLastOrder <= 0) {
-            // The time between two activities on the same day is unknown
-            // -> Set it to the smallest floating point number greater than 0
-            daysSinceLastOrder = Number.EPSILON;
-          }
-
-          // Sum up the total investment days since the start date to calculate
-          // the time weighted investment
-          totalInvestmentDays += daysSinceLastOrder;
-
-          sumOfTimeWeightedInvestments = sumOfTimeWeightedInvestments.add(
-            valueAtStartDate
-              .minus(investmentAtStartDate)
-              .plus(totalInvestmentBeforeTransaction)
-              .mul(daysSinceLastOrder)
-          );
-
-          sumOfTimeWeightedInvestmentsWithCurrencyEffect =
-            sumOfTimeWeightedInvestmentsWithCurrencyEffect.add(
-              valueAtStartDateWithCurrencyEffect
-                .minus(investmentAtStartDateWithCurrencyEffect)
-                .plus(totalInvestmentBeforeTransactionWithCurrencyEffect)
-                .mul(daysSinceLastOrder)
-            );
-        }
-
-        currentValues[order.date] = valueOfInvestment;
-
-        currentValuesWithCurrencyEffect[order.date] =
-          valueOfInvestmentWithCurrencyEffect;
-
-        netPerformanceValues[order.date] = grossPerformance
-          .minus(grossPerformanceAtStartDate)
-          .minus(fees.minus(feesAtStartDate));
-
-        netPerformanceValuesWithCurrencyEffect[order.date] =
-          grossPerformanceWithCurrencyEffect
-            .minus(grossPerformanceAtStartDateWithCurrencyEffect)
-            .minus(
-              feesWithCurrencyEffect.minus(feesAtStartDateWithCurrencyEffect)
-            );
-
-        investmentValuesAccumulated[order.date] = totalInvestment;
-
-        investmentValuesAccumulatedWithCurrencyEffect[order.date] =
-          totalInvestmentWithCurrencyEffect;
-
-        investmentValuesWithCurrencyEffect[order.date] = (
-          investmentValuesWithCurrencyEffect[order.date] ?? new Big(0)
-        ).add(transactionInvestmentWithCurrencyEffect);
-
-        timeWeightedInvestmentValues[order.date] =
-          totalInvestmentDays > 0
-            ? sumOfTimeWeightedInvestments.div(totalInvestmentDays)
-            : new Big(0);
-
-        timeWeightedInvestmentValuesWithCurrencyEffect[order.date] =
-          totalInvestmentDays > 0
-            ? sumOfTimeWeightedInvestmentsWithCurrencyEffect.div(
-                totalInvestmentDays
-              )
-            : new Big(0);
-      }
-
-      if (PortfolioCalculator.ENABLE_LOGGING) {
-        console.log('totalInvestment', totalInvestment.toNumber());
-
-        console.log(
-          'totalInvestmentWithCurrencyEffect',
-          totalInvestmentWithCurrencyEffect.toNumber()
-        );
-
-        console.log(
-          'totalGrossPerformance',
-          grossPerformance.minus(grossPerformanceAtStartDate).toNumber()
-        );
-
-        console.log(
-          'totalGrossPerformanceWithCurrencyEffect',
-          grossPerformanceWithCurrencyEffect
-            .minus(grossPerformanceAtStartDateWithCurrencyEffect)
-            .toNumber()
-        );
-      }
-
-      if (i === indexOfEndOrder) {
-        break;
-      }
-    }
-
-    const totalGrossPerformance = grossPerformance.minus(
-      grossPerformanceAtStartDate
-    );
-
-    const totalGrossPerformanceWithCurrencyEffect =
-      grossPerformanceWithCurrencyEffect.minus(
-        grossPerformanceAtStartDateWithCurrencyEffect
-      );
-
-    const totalNetPerformance = grossPerformance
-      .minus(grossPerformanceAtStartDate)
-      .minus(fees.minus(feesAtStartDate));
-
-    const timeWeightedAverageInvestmentBetweenStartAndEndDate =
-      totalInvestmentDays > 0
-        ? sumOfTimeWeightedInvestments.div(totalInvestmentDays)
-        : new Big(0);
-
-    const timeWeightedAverageInvestmentBetweenStartAndEndDateWithCurrencyEffect =
-      totalInvestmentDays > 0
-        ? sumOfTimeWeightedInvestmentsWithCurrencyEffect.div(
-            totalInvestmentDays
-          )
-        : new Big(0);
-
-    const grossPerformancePercentage =
-      timeWeightedAverageInvestmentBetweenStartAndEndDate.gt(0)
-        ? totalGrossPerformance.div(
-            timeWeightedAverageInvestmentBetweenStartAndEndDate
-          )
-        : new Big(0);
-
-    const grossPerformancePercentageWithCurrencyEffect =
-      timeWeightedAverageInvestmentBetweenStartAndEndDateWithCurrencyEffect.gt(
-        0
-      )
-        ? totalGrossPerformanceWithCurrencyEffect.div(
-            timeWeightedAverageInvestmentBetweenStartAndEndDateWithCurrencyEffect
-          )
-        : new Big(0);
-
-    const feesPerUnit = totalUnits.gt(0)
-      ? fees.minus(feesAtStartDate).div(totalUnits)
-      : new Big(0);
-
-    const feesPerUnitWithCurrencyEffect = totalUnits.gt(0)
-      ? feesWithCurrencyEffect
-          .minus(feesAtStartDateWithCurrencyEffect)
-          .div(totalUnits)
-      : new Big(0);
-
-    const netPerformancePercentage =
-      timeWeightedAverageInvestmentBetweenStartAndEndDate.gt(0)
-        ? totalNetPerformance.div(
-            timeWeightedAverageInvestmentBetweenStartAndEndDate
-          )
-        : new Big(0);
-
-    const netPerformancePercentageWithCurrencyEffectMap: {
-      [key: DateRange]: Big;
-    } = {};
-
-    const netPerformanceWithCurrencyEffectMap: {
-      [key: DateRange]: Big;
-    } = {};
-
-    for (const dateRange of [
-      '1d',
-      '1y',
-      '5y',
-      'max',
-      'mtd',
-      'wtd',
-      'ytd'
-      // TODO:
-      // ...eachYearOfInterval({ end, start })
-      //   .filter((date) => {
-      //     return !isThisYear(date);
-      //   })
-      //   .map((date) => {
-      //     return format(date, 'yyyy');
-      //   })
-    ] as DateRange[]) {
-      const dateInterval = getIntervalFromDateRange(dateRange);
-      const endDate = dateInterval.endDate;
-      let startDate = dateInterval.startDate;
-
-      if (isBefore(startDate, start)) {
-        startDate = start;
-      }
-
-      const rangeEndDateString = format(endDate, DATE_FORMAT);
-      const rangeStartDateString = format(startDate, DATE_FORMAT);
-
-      const currentValuesAtDateRangeStartWithCurrencyEffect =
-        currentValuesWithCurrencyEffect[rangeStartDateString] ?? new Big(0);
-
-      const investmentValuesAccumulatedAtStartDateWithCurrencyEffect =
-        investmentValuesAccumulatedWithCurrencyEffect[rangeStartDateString] ??
-        new Big(0);
-
-      const grossPerformanceAtDateRangeStartWithCurrencyEffect =
-        currentValuesAtDateRangeStartWithCurrencyEffect.minus(
-          investmentValuesAccumulatedAtStartDateWithCurrencyEffect
-        );
-
-      let average = new Big(0);
-      let dayCount = 0;
-
-      for (let i = this.chartDates.length - 1; i >= 0; i -= 1) {
-        const date = this.chartDates[i];
-
-        if (date > rangeEndDateString) {
-          continue;
-        } else if (date < rangeStartDateString) {
-          break;
-        }
-
-        if (
-          investmentValuesAccumulatedWithCurrencyEffect[date] instanceof Big &&
-          investmentValuesAccumulatedWithCurrencyEffect[date].gt(0)
-        ) {
-          average = average.add(
-            investmentValuesAccumulatedWithCurrencyEffect[date].add(
-              grossPerformanceAtDateRangeStartWithCurrencyEffect
-            )
-          );
-
-          dayCount++;
-        }
-      }
-
-      if (dayCount > 0) {
-        average = average.div(dayCount);
-      }
-
-      netPerformanceWithCurrencyEffectMap[dateRange] =
-        netPerformanceValuesWithCurrencyEffect[rangeEndDateString]?.minus(
-          // If the date range is 'max', take 0 as a start value. Otherwise,
-          // the value of the end of the day of the start date is taken which
-          // differs from the buying price.
-          dateRange === 'max'
-            ? new Big(0)
-            : (netPerformanceValuesWithCurrencyEffect[rangeStartDateString] ??
-                new Big(0))
-        ) ?? new Big(0);
-
-      netPerformancePercentageWithCurrencyEffectMap[dateRange] = average.gt(0)
-        ? netPerformanceWithCurrencyEffectMap[dateRange].div(average)
-        : new Big(0);
-    }
-
-    if (PortfolioCalculator.ENABLE_LOGGING) {
-      console.log(
-        `
-        ${symbol}
-        Unit price: ${orders[indexOfStartOrder].unitPrice.toFixed(
-          2
-        )} -> ${unitPriceAtEndDate.toFixed(2)}
-        Total investment: ${totalInvestment.toFixed(2)}
-        Total investment with currency effect: ${totalInvestmentWithCurrencyEffect.toFixed(
-          2
-        )}
-        Time weighted investment: ${timeWeightedAverageInvestmentBetweenStartAndEndDate.toFixed(
-          2
-        )}
-        Time weighted investment with currency effect: ${timeWeightedAverageInvestmentBetweenStartAndEndDateWithCurrencyEffect.toFixed(
-          2
-        )}
-        Total dividend: ${totalDividend.toFixed(2)}
-        Gross performance: ${totalGrossPerformance.toFixed(
-          2
-        )} / ${grossPerformancePercentage.mul(100).toFixed(2)}%
-        Gross performance with currency effect: ${totalGrossPerformanceWithCurrencyEffect.toFixed(
-          2
-        )} / ${grossPerformancePercentageWithCurrencyEffect
-          .mul(100)
-          .toFixed(2)}%
-        Fees per unit: ${feesPerUnit.toFixed(2)}
-        Fees per unit with currency effect: ${feesPerUnitWithCurrencyEffect.toFixed(
-          2
-        )}
-        Net performance: ${totalNetPerformance.toFixed(
-          2
-        )} / ${netPerformancePercentage.mul(100).toFixed(2)}%
-        Net performance with currency effect: ${netPerformancePercentageWithCurrencyEffectMap[
-          'max'
-        ].toFixed(2)}%`
-      );
-    }
-
-    return {
-      currentValues,
-      currentValuesWithCurrencyEffect,
-      feesWithCurrencyEffect,
-      grossPerformancePercentage,
-      grossPerformancePercentageWithCurrencyEffect,
-      initialValue,
-      initialValueWithCurrencyEffect,
-      investmentValuesAccumulated,
-      investmentValuesAccumulatedWithCurrencyEffect,
-      investmentValuesWithCurrencyEffect,
-      netPerformancePercentage,
-      netPerformancePercentageWithCurrencyEffectMap,
-      netPerformanceValues,
-      netPerformanceValuesWithCurrencyEffect,
-      netPerformanceWithCurrencyEffectMap,
-      timeWeightedInvestmentValues,
-      timeWeightedInvestmentValuesWithCurrencyEffect,
-      totalAccountBalanceInBaseCurrency,
-      totalDividend,
-      totalDividendInBaseCurrency,
-      totalInterest,
-      totalInterestInBaseCurrency,
-      totalInvestment,
-      totalInvestmentWithCurrencyEffect,
-      totalLiabilities,
-      totalLiabilitiesInBaseCurrency,
-      totalValuables,
-      totalValuablesInBaseCurrency,
-      grossPerformance: totalGrossPerformance,
-      grossPerformanceWithCurrencyEffect:
-        totalGrossPerformanceWithCurrencyEffect,
-      hasErrors: totalUnits.gt(0) && (!initialValue || !unitPriceAtEndDate),
-      netPerformance: totalNetPerformance,
-      timeWeightedInvestment:
-        timeWeightedAverageInvestmentBetweenStartAndEndDate,
-      timeWeightedInvestmentWithCurrencyEffect:
-        timeWeightedAverageInvestmentBetweenStartAndEndDateWithCurrencyEffect
-    };
   }
 }

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

@@ -295,7 +295,7 @@ export class PortfolioService {
       activities,
       filters,
       userId,
-      calculationType: PerformanceCalculationType.TWR,
+      calculationType: PerformanceCalculationType.ROAI,
       currency: this.request.user.Settings.settings.baseCurrency
     });
 
@@ -372,7 +372,7 @@ export class PortfolioService {
       activities,
       filters,
       userId,
-      calculationType: PerformanceCalculationType.TWR,
+      calculationType: PerformanceCalculationType.ROAI,
       currency: userCurrency
     });
 
@@ -680,7 +680,7 @@ export class PortfolioService {
     const portfolioCalculator = this.calculatorFactory.createCalculator({
       activities,
       userId,
-      calculationType: PerformanceCalculationType.TWR,
+      calculationType: PerformanceCalculationType.ROAI,
       currency: userCurrency
     });
 
@@ -950,7 +950,7 @@ export class PortfolioService {
       activities,
       filters,
       userId,
-      calculationType: PerformanceCalculationType.TWR,
+      calculationType: PerformanceCalculationType.ROAI,
       currency: this.request.user.Settings.settings.baseCurrency
     });
 
@@ -1116,7 +1116,7 @@ export class PortfolioService {
       activities,
       filters,
       userId,
-      calculationType: PerformanceCalculationType.TWR,
+      calculationType: PerformanceCalculationType.ROAI,
       currency: userCurrency
     });
 

apps/api/src/services/queues/portfolio-snapshot/portfolio-snapshot.processor.ts

@@ -68,7 +68,7 @@ export class PortfolioSnapshotProcessor {
       const portfolioCalculator = this.calculatorFactory.createCalculator({
         accountBalanceItems,
         activities,
-        calculationType: PerformanceCalculationType.TWR,
+        calculationType: PerformanceCalculationType.ROAI,
         currency: job.data.userCurrency,
         filters: job.data.filters,
         userId: job.data.userId

apps/client/src/app/components/portfolio-summary/portfolio-summary.component.html

@@ -117,8 +117,8 @@
       <ng-container i18n>Net Performance</ng-container>
       <abbr
         class="initialism ml-2 text-muted"
-        title="Time-Weighted Rate of Return"
+        title="Return on Average Investment"
-        >(TWR)</abbr
+        >(ROAI)</abbr
       >
     </div>
     <div class="flex-column flex-wrap justify-content-end">

apps/client/src/app/pages/portfolio/analysis/analysis-page.component.ts

@@ -161,7 +161,10 @@ export class AnalysisPageComponent implements OnDestroy, OnInit {
     }
 
     this.dataService
-      .fetchPrompt(mode)
+      .fetchPrompt({
+        mode,
+        filters: this.userService.getFilters()
+      })
       .pipe(takeUntil(this.unsubscribeSubject))
       .subscribe(({ prompt }) => {
         this.clipboard.copy(prompt);

apps/client/src/app/services/admin.service.ts

@@ -8,7 +8,6 @@ import {
   PROPERTY_API_KEY_GHOSTFOLIO
 } from '@ghostfolio/common/config';
 import { DEFAULT_PAGE_SIZE } from '@ghostfolio/common/config';
-import { DATE_FORMAT } from '@ghostfolio/common/helper';
 import {
   AssetProfileIdentifier,
   AdminData,
@@ -25,7 +24,6 @@ import { Injectable } from '@angular/core';
 import { SortDirection } from '@angular/material/sort';
 import { DataSource, MarketData, Platform } from '@prisma/client';
 import { JobStatus } from 'bull';
-import { format } from 'date-fns';
 import { switchMap } from 'rxjs';
 
 import { environment } from '../../environments/environment';
@@ -186,19 +184,8 @@ export class AdminService {
     );
   }
 
-  public gatherSymbol({
+  public gatherSymbol({ dataSource, symbol }: AssetProfileIdentifier) {
-    dataSource,
+    const url = `/api/v1/admin/gather/${dataSource}/${symbol}`;
-    date,
-    symbol
-  }: AssetProfileIdentifier & {
-    date?: Date;
-  }) {
-    let url = `/api/v1/admin/gather/${dataSource}/${symbol}`;
-
-    if (date) {
-      url = `${url}/${format(date, DATE_FORMAT)}`;
-    }
-
     return this.http.post<MarketData | void>(url, {});
   }
 

apps/client/src/app/services/data.service.ts

@@ -57,6 +57,7 @@ import { translate } from '@ghostfolio/ui/i18n';
 import { HttpClient, HttpParams } from '@angular/common/http';
 import { Injectable } from '@angular/core';
 import { SortDirection } from '@angular/material/sort';
+import { utc } from '@date-fns/utc';
 import {
   AccountBalance,
   DataSource,
@@ -281,7 +282,7 @@ export class DataService {
     symbol: string;
   }) {
     return this.http.get<IDataProviderHistoricalResponse>(
-      `/api/v1/exchange-rate/${symbol}/${format(date, DATE_FORMAT)}`
+      `/api/v1/exchange-rate/${symbol}/${format(date, DATE_FORMAT, { in: utc })}`
     );
   }
 
@@ -363,10 +364,7 @@ export class DataService {
     }
 
     return this.http.get<BenchmarkMarketDataDetails>(
-      `/api/v1/benchmarks/${dataSource}/${symbol}/${format(
+      `/api/v1/benchmarks/${dataSource}/${symbol}/${format(startDate, DATE_FORMAT, { in: utc })}`,
-        startDate,
-        DATE_FORMAT
-      )}`,
       { params }
     );
   }
@@ -655,8 +653,18 @@ export class DataService {
     return this.http.get<PortfolioReportResponse>('/api/v1/portfolio/report');
   }
 
-  public fetchPrompt(mode: AiPromptMode) {
+  public fetchPrompt({
-    return this.http.get<AiPromptResponse>(`/api/v1/ai/prompt/${mode}`);
+    filters,
+    mode
+  }: {
+    filters?: Filter[];
+    mode: AiPromptMode;
+  }) {
+    const params = this.buildFiltersAsQueryParams({ filters });
+
+    return this.http.get<AiPromptResponse>(`/api/v1/ai/prompt/${mode}`, {
+      params
+    });
   }
 
   public fetchPublicPortfolio(aAccessId: string) {

libs/common/src/lib/interfaces/account-balance.interface.ts

@@ -0,0 +1,4 @@
+export interface AccountBalance {
+  date: string;
+  value: number;
+}

libs/common/src/lib/interfaces/export.interface.ts

@@ -1,8 +1,10 @@
 import { Account, Order, Platform, Tag } from '@prisma/client';
 
+import { AccountBalance } from './account-balance.interface';
+
 export interface Export {
   accounts: (Omit<Account, 'createdAt' | 'updatedAt' | 'userId'> & {
-    balances: { date: string; value: number }[];
+    balances: AccountBalance[];
   })[];
   activities: (Omit<
     Order,

libs/common/src/lib/interfaces/index.ts

@@ -1,4 +1,5 @@
 import type { Access } from './access.interface';
+import type { AccountBalance } from './account-balance.interface';
 import type { Accounts } from './accounts.interface';
 import type { AdminData } from './admin-data.interface';
 import type { AdminJobs } from './admin-jobs.interface';
@@ -68,6 +69,7 @@ import type { XRayRulesSettings } from './x-ray-rules-settings.interface';
 
 export {
   Access,
+  AccountBalance,
   AccountBalancesResponse,
   Accounts,
   AdminData,

libs/ui/src/lib/historical-market-data-editor/historical-market-data-editor-dialog/historical-market-data-editor-dialog.component.ts

@@ -7,7 +7,8 @@ import {
   Component,
   CUSTOM_ELEMENTS_SCHEMA,
   Inject,
-  OnDestroy
+  OnDestroy,
+  OnInit
 } from '@angular/core';
 import { FormsModule, ReactiveFormsModule } from '@angular/forms';
 import { MatButtonModule } from '@angular/material/button';
@@ -41,7 +42,9 @@ import { HistoricalMarketDataEditorDialogParams } from './interfaces/interfaces'
   styleUrls: ['./historical-market-data-editor-dialog.scss'],
   templateUrl: 'historical-market-data-editor-dialog.html'
 })
-export class GfHistoricalMarketDataEditorDialogComponent implements OnDestroy {
+export class GfHistoricalMarketDataEditorDialogComponent
+  implements OnDestroy, OnInit
+{
   private unsubscribeSubject = new Subject<void>();
 
   public constructor(

package-lock.json

@@ -22,6 +22,7 @@
         "@angular/router": "19.2.1",
         "@angular/service-worker": "19.2.1",
         "@codewithdan/observable-store": "2.2.15",
+        "@date-fns/utc": "2.1.0",
         "@dfinity/agent": "0.15.7",
         "@dfinity/auth-client": "0.15.7",
         "@dfinity/candid": "0.15.7",
@@ -3113,6 +3114,11 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@date-fns/utc": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/@date-fns/utc/-/utc-2.1.0.tgz",
+      "integrity": "sha512-176grgAgU2U303rD2/vcOmNg0kGPbhzckuH1TEP2al7n0AQipZIy9P15usd2TKQCG1g+E1jX/ZVQSzs4sUDwgA=="
+    },
     "node_modules/@dfinity/agent": {
       "version": "0.15.7",
       "resolved": "https://registry.npmjs.org/@dfinity/agent/-/agent-0.15.7.tgz",

package.json

@@ -68,6 +68,7 @@
     "@angular/router": "19.2.1",
     "@angular/service-worker": "19.2.1",
     "@codewithdan/observable-store": "2.2.15",
+    "@date-fns/utc": "2.1.0",
     "@dfinity/agent": "0.15.7",
     "@dfinity/auth-client": "0.15.7",
     "@dfinity/candid": "0.15.7",