Resolve Merge Issues

apps/api/src/app/admin/admin.controller.ts

@@ -110,7 +110,7 @@ export class AdminController {
   @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
   public async gatherMissing(): Promise<void> {
     const assetProfileIdentifiers =
-      await this.dataGatheringService.getAllAssetProfileIdentifiers();
+      await this.dataGatheringService.getAllActiveAssetProfileIdentifiers();
 
     const promises = assetProfileIdentifiers.map(({ dataSource, symbol }) => {
       return this.dataGatheringService.gatherSymbolMissingOnly({
@@ -372,12 +372,16 @@ export class AdminController {
   ): Promise<EnhancedSymbolProfile> {
     return this.adminService.patchAssetProfileData(
       { dataSource, symbol },
-      assetProfile,
+      {
-      tags: {
+        ...assetProfile,
-        connect: assetProfileData.tags?.map(({ id }) => {
+        tags: {
-          return { id };
+          connect: assetProfile.tags?.map(({ id }) => {
-        }),
+            return { id };
-        disconnect: assetProfileData.tagsDisconnected?.map(({ id }) => ({ id }))
+          }),
+          disconnect: assetProfile.tagsDisconnected?.map(({ id }) => ({
+            id
+          }))
+        }
       }
     );
   }

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

@@ -60,43 +60,46 @@ export class OrderService {
       }
     ]);
     const symbolProfile: EnhancedSymbolProfile = promis[0];
-    const result = await this.symbolProfileService.updateSymbolProfile({
+    const result = await this.symbolProfileService.updateSymbolProfile(
-      assetClass: symbolProfile.assetClass,
+      { dataSource, symbol },
-      assetSubClass: symbolProfile.assetSubClass,
+      {
-      countries: symbolProfile.countries.reduce(
+        assetClass: symbolProfile.assetClass,
-        (all, v) => [...all, { code: v.code, weight: v.weight }],
+        assetSubClass: symbolProfile.assetSubClass,
-        []
+        countries: symbolProfile.countries.reduce(
-      ),
+          (all, v) => [...all, { code: v.code, weight: v.weight }],
-      currency: symbolProfile.currency,
+          []
-      dataSource,
+        ),
-      holdings: symbolProfile.holdings.reduce(
+        currency: symbolProfile.currency,
-        (all, v) => [
+        dataSource,
-          ...all,
+        holdings: symbolProfile.holdings.reduce(
-          { name: v.name, weight: v.allocationInPercentage }
+          (all, v) => [
-        ],
+            ...all,
-        []
+            { name: v.name, weight: v.allocationInPercentage }
-      ),
+          ],
-      name: symbolProfile.name,
+          []
-      sectors: symbolProfile.sectors.reduce(
+        ),
-        (all, v) => [...all, { name: v.name, weight: v.weight }],
+        name: symbolProfile.name,
-        []
+        sectors: symbolProfile.sectors.reduce(
-      ),
+          (all, v) => [...all, { name: v.name, weight: v.weight }],
-      symbol,
+          []
-      tags: {
+        ),
-        connectOrCreate: tags.map(({ id, name }) => {
+        symbol,
-          return {
+        tags: {
-            create: {
+          connectOrCreate: tags.map(({ id, name }) => {
-              id,
+            return {
-              name
+              create: {
-            },
+                id,
-            where: {
+                name
-              id
+              },
-            }
+              where: {
-          };
+                id
-        })
+              }
-      },
+            };
-      url: symbolProfile.url
+          })
-    });
+        },
+        url: symbolProfile.url
+      }
+    );
 
     this.eventEmitter.emit(
       PortfolioChangedEvent.getName(),

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

@@ -25,9 +25,9 @@ import {
 import { CurrentRateService } from '../../current-rate.service';
 import { DateQuery } from '../../interfaces/date-query.interface';
 import { PortfolioOrder } from '../../interfaces/portfolio-order.interface';
-import { TWRPortfolioCalculator } from '../twr/portfolio-calculator';
+import { RoaiPortfolioCalculator } from '../roai/portfolio-calculator';
 
-export class CPRPortfolioCalculator extends TWRPortfolioCalculator {
+export class CPRPortfolioCalculator extends RoaiPortfolioCalculator {
   private holdings: { [date: string]: { [symbol: string]: Big } } = {};
   private holdingCurrencies: { [symbol: string]: string } = {};
 

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

@@ -9,8 +9,6 @@ import { Filter, HistoricalDataItem } from '@ghostfolio/common/interfaces';
 
 import { Injectable } from '@nestjs/common';
 
-import { OrderService } from '../../order/order.service';
-import { CPRPortfolioCalculator } from './constantPortfolioReturn/portfolio-calculator';
 import { MwrPortfolioCalculator } from './mwr/portfolio-calculator';
 import { PortfolioCalculator } from './portfolio-calculator';
 import { RoaiPortfolioCalculator } from './roai/portfolio-calculator';
@@ -30,8 +28,7 @@ export class PortfolioCalculatorFactory {
     private readonly currentRateService: CurrentRateService,
     private readonly exchangeRateDataService: ExchangeRateDataService,
     private readonly portfolioSnapshotService: PortfolioSnapshotService,
-    private readonly redisCacheService: RedisCacheService,
+    private readonly redisCacheService: RedisCacheService
-    private readonly orderService: OrderService
   ) {}
 
   @LogPerformance
@@ -78,37 +75,31 @@ export class PortfolioCalculatorFactory {
           redisCacheService: this.redisCacheService
         });
       case PerformanceCalculationType.TWR:
-        return new CPRPortfolioCalculator(
+        return new TwrPortfolioCalculator({
-          {
+          accountBalanceItems,
-            accountBalanceItems,
+          activities,
-            activities,
+          currency,
-            currency,
+          currentRateService: this.currentRateService,
-            currentRateService: this.currentRateService,
+          userId,
-            userId,
+          configurationService: this.configurationService,
-            configurationService: this.configurationService,
+          exchangeRateDataService: this.exchangeRateDataService,
-            exchangeRateDataService: this.exchangeRateDataService,
+          portfolioSnapshotService: this.portfolioSnapshotService,
-            portfolioSnapshotService: this.portfolioSnapshotService,
+          redisCacheService: this.redisCacheService,
-            redisCacheService: this.redisCacheService,
+          filters
-            filters
+        });
-          },
-          this.orderService
-        );
       case PerformanceCalculationType.CPR:
-        return new CPRPortfolioCalculator(
+        return new RoaiPortfolioCalculator({
-          {
+          accountBalanceItems,
-            accountBalanceItems,
+          activities,
-            activities,
+          currency,
-            currency,
+          currentRateService: this.currentRateService,
-            currentRateService: this.currentRateService,
+          userId,
-            userId,
+          configurationService: this.configurationService,
-            configurationService: this.configurationService,
+          exchangeRateDataService: this.exchangeRateDataService,
-            exchangeRateDataService: this.exchangeRateDataService,
+          portfolioSnapshotService: this.portfolioSnapshotService,
-            portfolioSnapshotService: this.portfolioSnapshotService,
+          redisCacheService: this.redisCacheService,
-            redisCacheService: this.redisCacheService,
+          filters
-            filters
+        });
-          },
-          this.orderService
-        );
       default:
         throw new Error('Invalid calculation type');
     }

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

@@ -221,7 +221,8 @@ export class RoaiPortfolioCalculator extends PortfolioCalculator {
         totalLiabilities: new Big(0),
         totalLiabilitiesInBaseCurrency: new Big(0),
         totalValuables: new Big(0),
-        totalValuablesInBaseCurrency: new Big(0)
+        totalValuablesInBaseCurrency: new Big(0),
+        unitPrices: {}
       };
     }
 
@@ -271,7 +272,8 @@ export class RoaiPortfolioCalculator extends PortfolioCalculator {
         totalLiabilities: new Big(0),
         totalLiabilitiesInBaseCurrency: new Big(0),
         totalValuables: new Big(0),
-        totalValuablesInBaseCurrency: new Big(0)
+        totalValuablesInBaseCurrency: new Big(0),
+        unitPrices: {}
       };
     }
 
@@ -963,7 +965,8 @@ export class RoaiPortfolioCalculator extends PortfolioCalculator {
       timeWeightedInvestment:
         timeWeightedAverageInvestmentBetweenStartAndEndDate,
       timeWeightedInvestmentWithCurrencyEffect:
-        timeWeightedAverageInvestmentBetweenStartAndEndDateWithCurrencyEffect
+        timeWeightedAverageInvestmentBetweenStartAndEndDateWithCurrencyEffect,
+      unitPrices: marketSymbolMap[endDateString]
     };
   }
 }

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

@@ -19,920 +19,6 @@ export class TwrPortfolioCalculator extends PortfolioCalculator {
     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 grossPerformanceFromDividends = new Big(0);
-    let grossPerformanceFromDividendsWithCurrencyEffect = 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),
-        netPerformanceValuesPercentage: {},
-        unitPrices: {},
-        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),
-        netPerformanceValuesPercentage: {},
-        unitPrices: {}
-      };
-    }
-
-    // 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));
-        }
-      } else if (order.type === 'STAKE') {
-        transactionInvestment = new Big(0);
-
-        transactionInvestmentWithCurrencyEffect = new Big(0);
-
-        totalQuantityFromBuyTransactions =
-          totalQuantityFromBuyTransactions.plus(order.quantity);
-      }
-
-      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
-      );
-
-      ({
-        grossPerformanceFromSells,
-        grossPerformanceFromSellsWithCurrencyEffect
-      } = this.handleSellOrder(
-        order,
-        lastAveragePrice,
-        lastAveragePriceWithCurrencyEffect,
-        grossPerformanceFromSells,
-        grossPerformanceFromSellsWithCurrencyEffect
-      ));
-
-      ({
-        grossPerformanceFromDividends,
-        grossPerformanceFromDividendsWithCurrencyEffect
-      } = this.handleDividend(
-        order,
-        grossPerformanceFromDividends,
-        grossPerformanceFromDividendsWithCurrencyEffect,
-        currentExchangeRate,
-        exchangeRateAtOrderDate
-      ));
-
-      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(
-          'grossPerformanceFromSellsWithCurrencyEffect',
-          grossPerformanceFromSellsWithCurrencyEffect.toNumber()
-        );
-      }
-
-      const newGrossPerformance = valueOfInvestment
-        .minus(totalInvestment)
-        .plus(grossPerformanceFromSells)
-        .plus(grossPerformanceFromDividends);
-
-      const newGrossPerformanceWithCurrencyEffect =
-        valueOfInvestmentWithCurrencyEffect
-          .minus(totalInvestmentWithCurrencyEffect)
-          .plus(grossPerformanceFromSellsWithCurrencyEffect)
-          .plus(grossPerformanceFromDividendsWithCurrencyEffect);
-
-      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,
-      netPerformanceValuesPercentage: {},
-      unitPrices: {}
-    };
-  }
-
-  private handleSellOrder(
-    order: PortfolioOrderItem,
-    lastAveragePrice,
-    lastAveragePriceWithCurrencyEffect,
-    grossPerformanceFromSells,
-    grossPerformanceFromSellsWithCurrencyEffect
-  ) {
-    if (order.type === 'SELL') {
-      const grossPerformanceFromSell = order.unitPriceInBaseCurrency
-        .minus(lastAveragePrice)
-        .mul(order.quantity);
-
-      const grossPerformanceFromSellWithCurrencyEffect =
-        order.unitPriceInBaseCurrencyWithCurrencyEffect
-          .minus(lastAveragePriceWithCurrencyEffect)
-          .mul(order.quantity);
-
-      grossPerformanceFromSells = grossPerformanceFromSells.plus(
-        grossPerformanceFromSell
-      );
-
-      grossPerformanceFromSellsWithCurrencyEffect =
-        grossPerformanceFromSellsWithCurrencyEffect.plus(
-          grossPerformanceFromSellWithCurrencyEffect
-        );
-    }
-    return {
-      grossPerformanceFromSells,
-      grossPerformanceFromSellsWithCurrencyEffect
-    };
-  }
-
-  private handleDividend(
-    order: PortfolioOrderItem,
-    grossPerformanceFromDividends,
-    grossPerformanceFromDividendsWithCurrencyEffect,
-    currentExchangeRate: number,
-    exchangeRateAtDateOfOrder: number
-  ) {
-    if (order.type === 'DIVIDEND') {
-      const grossPerformanceFromDividend = order.unitPrice
-        .mul(currentExchangeRate)
-        .mul(order.quantity);
-
-      const grossPerformanceFromDividendWithCurrencyEffect = order.unitPrice
-        .mul(exchangeRateAtDateOfOrder)
-        .mul(order.quantity);
-
-      grossPerformanceFromDividends = grossPerformanceFromDividends.plus(
-        grossPerformanceFromDividend
-      );
-
-      grossPerformanceFromDividendsWithCurrencyEffect =
-        grossPerformanceFromDividendsWithCurrencyEffect.plus(
-          grossPerformanceFromDividendWithCurrencyEffect
-        );
-    }
-    return {
-      grossPerformanceFromDividends,
-      grossPerformanceFromDividendsWithCurrencyEffect
-    };
   }
 }

apps/api/src/services/queues/data-gathering/data-gathering.service.ts

@@ -346,40 +346,14 @@ export class DataGatheringService {
     );
   }
 
-  public async gatherMissingDataSymbols({
+  public async getAllActiveAssetProfileIdentifiers(): Promise<
-    dataGatheringItems,
-    priority
-  }: {
-    dataGatheringItems: IDataGatheringItem[];
-    priority: number;
-  }) {
-    await this.addJobsToQueue(
-      dataGatheringItems.map(({ dataSource, date, symbol }) => {
-        return {
-          data: {
-            dataSource,
-            date,
-            symbol
-          },
-          name: GATHER_MISSING_HISTORICAL_MARKET_DATA_PROCESS_JOB_NAME,
-          opts: {
-            ...GATHER_MISSING_HISTORICAL_MARKET_DATA_PROCESS_JOB_OPTIONS,
-            priority,
-            jobId: `${getAssetProfileIdentifier({
-              dataSource,
-              symbol
-            })}-missing-${format(date, DATE_FORMAT)}`
-          }
-        };
-      })
-    );
-  }
-
-  public async getAllAssetProfileIdentifiers(): Promise<
     AssetProfileIdentifier[]
   > {
     const symbolProfiles = await this.prismaService.symbolProfile.findMany({
-      orderBy: [{ symbol: 'asc' }]
+      orderBy: [{ symbol: 'asc' }],
+      where: {
+        isActive: true
+      }
     });
 
     return symbolProfiles

apps/api/src/services/symbol-profile/symbol-profile.service.ts

@@ -23,59 +23,6 @@ import { continents, countries } from 'countries-list';
 export class SymbolProfileService {
   public constructor(private readonly prismaService: PrismaService) {}
 
-  public async add(
-    assetProfile: Prisma.SymbolProfileCreateInput
-  ): Promise<SymbolProfile | never> {
-    return this.prismaService.symbolProfile.create({ data: assetProfile });
-  }
-
-  public async delete({ dataSource, symbol }: AssetProfileIdentifier) {
-    return this.prismaService.symbolProfile.delete({
-      where: { dataSource_symbol: { dataSource, symbol } }
-    });
-  }
-
-  public async deleteById(id: string) {
-    return this.prismaService.symbolProfile.delete({
-      where: { id }
-    });
-  }
-
-  public async getActiveSymbolProfilesByUserSubscription({
-    withUserSubscription = false
-  }: {
-    withUserSubscription?: boolean;
-  }) {
-    return this.prismaService.symbolProfile.findMany({
-      include: {
-        Order: {
-          include: {
-            User: true
-          }
-        }
-      },
-      orderBy: [{ symbol: 'asc' }],
-      where: {
-        isActive: true,
-        Order: withUserSubscription
-          ? {
-              some: {
-                User: {
-                  Subscription: { some: { expiresAt: { gt: new Date() } } }
-                }
-              }
-            }
-          : {
-              every: {
-                User: {
-                  Subscription: { none: { expiresAt: { gt: new Date() } } }
-                }
-              }
-            }
-      }
-    });
-  }
-
   @LogPerformance
   public async getActiveSymbolProfilesByUserSubscription({
     withUserSubscription = false
@@ -146,6 +93,24 @@ export class SymbolProfileService {
       });
   }
 
+  public async add(
+    assetProfile: Prisma.SymbolProfileCreateInput
+  ): Promise<SymbolProfile | never> {
+    return this.prismaService.symbolProfile.create({ data: assetProfile });
+  }
+
+  public async delete({ dataSource, symbol }: AssetProfileIdentifier) {
+    return this.prismaService.symbolProfile.delete({
+      where: { dataSource_symbol: { dataSource, symbol } }
+    });
+  }
+
+  public async deleteById(id: string) {
+    return this.prismaService.symbolProfile.delete({
+      where: { id }
+    });
+  }
+
   public async getSymbolProfilesByIds(
     symbolProfileIds: string[]
   ): Promise<EnhancedSymbolProfile[]> {

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

@@ -195,32 +195,11 @@ export class AdminService {
 
   public gatherSymbolMissingOnly({
     dataSource,
-    date,
     symbol
   }: AssetProfileIdentifier & {
     date?: Date;
   }) {
-    let url = `/api/v1/admin/gatherMissing/${dataSource}/${symbol}`;
+    const url = `/api/v1/admin/gatherMissing/${dataSource}/${symbol}`;
-
-    if (date) {
-      url = `${url}/${format(date, DATE_FORMAT)}`;
-    }
-
-    return this.http.post<MarketData | void>(url, {});
-  }
-
-  public gatherSymbolMissingOnly({
-    dataSource,
-    date,
-    symbol
-  }: AssetProfileIdentifier & {
-    date?: Date;
-  }) {
-    let url = `/api/v1/admin/gatherMissing/${dataSource}/${symbol}`;
-
-    if (date) {
-      url = `${url}/${format(date, DATE_FORMAT)}`;
-    }
 
     return this.http.post<MarketData | void>(url, {});
   }

libs/common/src/lib/interfaces/symbol-metrics.interface.ts

@@ -28,9 +28,6 @@ export interface SymbolMetrics {
   };
   netPerformance: Big;
   netPerformancePercentage: Big;
-  netPerformanceValuesPercentage: {
-    [date: string]: Big;
-  };
   netPerformancePercentageWithCurrencyEffectMap: { [key: DateRange]: Big };
   netPerformanceValues: {
     [date: string]: Big;

tsconfig.base.json

@@ -10,16 +10,29 @@
     "importHelpers": true,
     "target": "es2015",
     "module": "esnext",
-    "typeRoots": ["node_modules/@types"],
+    "typeRoots": [
-    "lib": ["es2017", "dom"],
+      "node_modules/@types"
+    ],
+    "lib": [
+      "es2017",
+      "dom"
+    ],
     "skipLibCheck": true,
     "skipDefaultLibCheck": true,
     "baseUrl": ".",
     "paths": {
-      "@ghostfolio/api/*": ["apps/api/src/*"],
+      "@ghostfolio/api/*": [
-      "@ghostfolio/client/*": ["apps/client/src/app/*"],
+        "apps/api/src/*"
-      "@ghostfolio/common/*": ["libs/common/src/lib/*"],
+      ],
-      "@ghostfolio/ui/*": ["libs/ui/src/lib/*"]
+      "@ghostfolio/client/*": [
+        "apps/client/src/app/*"
+      ],
+      "@ghostfolio/common/*": [
+        "libs/common/src/lib/*"
+      ],
+      "@ghostfolio/ui/*": [
+        "libs/ui/src/lib/*"
+      ]
     },
     "noFallthroughCasesInSwitch": true,
     "forceConsistentCasingInFileNames": true,
@@ -35,5 +48,8 @@
     "noUnusedParameters": true,
     "allowUnreachableCode": true
   },
-  "exclude": ["node_modules", "tmp"]
+  "exclude": [
+    "node_modules",
+    "tmp"
+  ]
 }