Release 1.132.0 (#808)

* Improve label

* Update changelog

CHANGELOG.md

@@ -5,6 +5,229 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 1.132.0 - 06.04.2022
+
+### Added
+
+- Added support for localization (date and number format) in user settings
+
+### Changed
+
+- Improved the label of the average price from _Ø Buy Price_ to _Average Unit Price_
+
+## 1.131.1 - 04.04.2022
+
+### Fixed
+
+- Fixed the missing API version in the _Stripe_ success callback url
+
+## 1.131.0 - 02.04.2022
+
+### Added
+
+- Added API versioning
+- Added more durations in the coupon system
+
+### Changed
+
+- Display the value in base currency in the accounts table on mobile
+- Display the value in base currency in the activities table on mobile
+- Renamed `orders` to `activities` in import and export functionality
+- Harmonized the algebraic sign of `currentGrossPerformancePercent` and `currentNetPerformancePercent` with `currentGrossPerformance` and `currentNetPerformance`
+- Improved the pricing page
+- Upgraded `prisma` from version `3.10.0` to `3.11.1`
+- Upgraded `yahoo-finance2` from version `2.2.0` to `2.3.0`
+
+## 1.130.0 - 30.03.2022
+
+### Added
+
+- Added a _FIRE_ (Financial Independence, Retire Early) section including the 4% rule
+- Added more durations in the coupon system
+
+### Fixed
+
+- Fixed an issue with the currency conversion (duplicate) in the account calculations
+
+## 1.129.0 - 26.03.2022
+
+### Added
+
+- Added the calculation for developed vs. emerging markets to the allocations page
+- Added a hover effect to the page tabs
+- Extended the feature overview page by _Bonds_ and _Emergency Fund_
+
+## 1.128.0 - 19.03.2022
+
+### Added
+
+- Added the attribute `defaultMarketPrice` to the scraper configuration to improve the support for bonds
+- Added a hover effect to the table style
+
+### Fixed
+
+- Fixed an issue with the user currency of the public page
+- Fixed an issue of the performance calculation with recent activities in the new calculation engine
+
+## 1.127.0 - 16.03.2022
+
+### Changed
+
+- Improved the error handling in the scraper configuration
+
+### Fixed
+
+- Fixed the support for multiple symbols of the data source `GHOSTFOLIO`
+
+## 1.126.0 - 14.03.2022
+
+### Added
+
+- Added support for bonds
+
+### Changed
+
+- Restructured the portfolio summary tab on the home page
+- Improved the tooltips in the portfolio proportion chart component by introducing multilines
+
+### Todo
+
+- Apply data migration (`yarn database:migrate`)
+
+## 1.125.0 - 12.03.2022
+
+### Added
+
+- Added support for an emergency fund
+- Added the contexts to the logger commands
+
+### Changed
+
+- Upgraded `Nx` from version `13.8.1` to `13.8.5`
+
+## 1.124.0 - 06.03.2022
+
+### Added
+
+- Added support for setting a duration in the coupon system
+
+### Changed
+
+- Upgraded `ngx-skeleton-loader` from version `2.9.1` to `5.0.0`
+- Upgraded `prisma` from version `3.9.1` to `3.10.0`
+- Upgraded `yahoo-finance2` from version `2.1.9` to `2.2.0`
+
+## 1.123.0 - 05.03.2022
+
+### Added
+
+- Included data provider errors in the API response
+
+### Changed
+
+- Removed the redundant attributes (`currency`, `dataSource`, `symbol`) of the activity model
+- Removed the prefix for symbols with the data source `GHOSTFOLIO`
+
+### Fixed
+
+- Improved the account calculations
+
+### Todo
+
+- Apply data migration (`yarn database:migrate`)
+
+## 1.122.0 - 01.03.2022
+
+### Added
+
+- Added support for click in the portfolio proportion chart component
+
+### Fixed
+
+- Fixed an issue with undefined currencies after creating an activity
+
+## 1.121.0 - 27.02.2022
+
+### Added
+
+- Added support for mutual funds
+- Added the url to the symbol profile model
+
+### Changed
+
+- Migrated from `yahoo-finance` to `yahoo-finance2`
+
+### Todo
+
+- Apply data migration (`yarn database:migrate`)
+
+## 1.120.0 - 25.02.2022
+
+### Changed
+
+- Distinguished the labels _Other_ and _Unknown_ in the portfolio proportion chart component
+- Improved the portfolio entry page
+
+### Fixed
+
+- Fixed the _Zen Mode_
+
+## 1.119.0 - 21.02.2022
+
+### Added
+
+- Added a trial for the subscription
+
+## 1.118.0 - 20.02.2022
+
+### Changed
+
+- Improved the calculation of the overall performance percentage in the new calculation engine
+- Displayed features in features overview page based on permissions
+- Extended the data points of historical data in the admin control panel
+
+## 1.117.0 - 19.02.2022
+
+### Changed
+
+- Moved the countries and sectors charts in the position detail dialog
+- Distinguished today's data point of historical data in the admin control panel
+- Restructured the server modules
+
+### Fixed
+
+- Fixed the allocations by account for non-unique account names
+- Added a fallback to the default account if the `accountId` is invalid in the import functionality for activities
+
+## 1.116.0 - 16.02.2022
+
+### Added
+
+- Added a service to tweet the current _Fear & Greed Index_ (market mood)
+
+### Changed
+
+- Improved the mobile layout of the position detail dialog (countries and sectors charts)
+
+### Fixed
+
+- Fixed the `maxItems` attribute of the portfolio proportion chart component
+- Fixed the time in market display of the portfolio summary tab on the home page
+
+## 1.115.0 - 13.02.2022
+
+### Added
+
+- Added a feature overview page
+- Added the asset and asset sub class to the position detail dialog
+- Added the countries and sectors to the position detail dialog
+
+### Changed
+
+- Upgraded `angular` from version `13.1.2` to `13.2.3`
+- Upgraded `Nx` from version `13.4.1` to `13.8.1`
+- Upgraded `storybook` from version `6.4.9` to `6.4.18`
+
 ## 1.114.1 - 10.02.2022
 
 ### Fixed

README.md

@@ -41,21 +41,13 @@ If you prefer to run Ghostfolio on your own infrastructure (self-hosting), pleas
 Ghostfolio is for you if you are...
 
 - 💼 trading stocks, ETFs or cryptocurrencies on multiple platforms
-
 - 🏦 pursuing a buy & hold strategy
-
 - 🎯 interested in getting insights of your portfolio composition
-
 - 👻 valuing privacy and data ownership
-
 - 🧘 into minimalism
-
 - 🧺 caring about diversifying your financial resources
-
 - 🆓 interested in financial independence
-
 - 🙅 saying no to spreadsheets in 2021
-
 - 😎 still reading this list
 
 ## Features
@@ -65,6 +57,7 @@ Ghostfolio is for you if you are...
 - ✅ Portfolio performance: Time-weighted rate of return (TWR) for `Today`, `YTD`, `1Y`, `5Y`, `Max`
 - ✅ Various charts
 - ✅ Static analysis to identify potential risks in your portfolio
+- ✅ Import and export transactions
 - ✅ Dark Mode
 - ✅ Zen Mode
 - ✅ Mobile-first design
@@ -86,13 +79,14 @@ The frontend is built with [Angular](https://angular.io) and uses [Angular Mater
 ### Prerequisites
 
 - [Docker](https://www.docker.com/products/docker-desktop)
+- A local copy of this Git repository (clone)
 
 ### a. Run environment
 
 Run the following command to start the Docker images from [Docker Hub](https://hub.docker.com/r/ghostfolio/ghostfolio):
 
 ```bash
-docker-compose -f docker/docker-compose.yml up
+docker-compose -f docker/docker-compose.yml up -d
 ```
 
 #### Setup Database
@@ -109,7 +103,7 @@ Run the following commands to build and start the Docker images:
 
 ```bash
 docker-compose -f docker/docker-compose.build.yml build
-docker-compose -f docker/docker-compose.build.yml up
+docker-compose -f docker/docker-compose.build.yml up -d
 ```
 
 #### Setup Database
@@ -128,13 +122,11 @@ Open http://localhost:3333 in your browser and accomplish these steps:
 1. Go to the _Admin Control Panel_ and click _Gather All Data_ to fetch historical data
 1. Click _Sign out_ and check out the _Live Demo_
 
-### Migrate Database
+### Upgrade Version
 
-With the following command you can keep your database schema in sync after a Ghostfolio version update:
-
-```bash
-docker-compose -f docker/docker-compose-build-local.yml exec ghostfolio yarn database:migrate
-```
+1. Increase the version of the `ghostfolio/ghostfolio` Docker image in `docker/docker-compose.yml`
+1. Run the following command to start the new Docker image: `docker-compose -f docker/docker-compose.yml up -d`
+1. Then, run the following command to keep your database schema in sync: `docker-compose -f docker/docker-compose.yml exec ghostfolio yarn database:migrate`
 
 ## Development
 
@@ -143,6 +135,7 @@ docker-compose -f docker/docker-compose-build-local.yml exec ghostfolio yarn dat
 - [Docker](https://www.docker.com/products/docker-desktop)
 - [Node.js](https://nodejs.org/en/download) (version 14+)
 - [Yarn](https://yarnpkg.com/en/docs/install)
+- A local copy of this Git repository (clone)
 
 ### Setup
 
@@ -169,10 +162,84 @@ Run `yarn start:client`
 
 Run `yarn start:storybook`
 
+### Migrate Database
+
+With the following command you can keep your database schema in sync:
+
+```bash
+yarn database:push
+```
+
 ## Testing
 
 Run `yarn test`
 
+## Public API (experimental)
+
+### Import Activities
+
+#### Request
+
+`POST http://localhost:3333/api/v1/import`
+
+#### Authorization: Bearer Token
+
+Set the header as follows:
+
+```
+"Authorization": "Bearer eyJh..."
+```
+
+#### Body
+
+```
+{
+  "activities": [
+    {
+      "currency": "USD",
+      "dataSource": "YAHOO",
+      "date": "2021-09-15T00:00:00.000Z",
+      "fee": 19,
+      "quantity": 5,
+      "symbol": "MSFT"
+      "type": "BUY",
+      "unitPrice": 298.58
+    }
+  ]
+}
+```
+
+| Field      | Type                | Description                                        |
+| ---------- | ------------------- | -------------------------------------------------- |
+| accountId  | string (`optional`) | Id of the account                                  |
+| currency   | string              | `CHF` \| `EUR` \| `USD` etc.                       |
+| dataSource | string              | `MANUAL` (for type `ITEM`) \| `YAHOO`              |
+| date       | string              | Date in the format `ISO-8601`                      |
+| fee        | number              | Fee of the activity                                |
+| quantity   | number              | Quantity of the activity                           |
+| symbol     | string              | Symbol of the activity (suitable for `dataSource`) |
+| type       | string              | `BUY` \| `DIVIDEND` \| `ITEM` \| `SELL`            |
+| unitPrice  | number              | Price per unit of the activity                     |
+
+#### Response
+
+##### Success
+
+`201 Created`
+
+##### Error
+
+`400 Bad Request`
+
+```
+{
+  "error": "Bad Request",
+  "message": [
+    "activities.1 is a duplicate activity"
+  ]
+}
+```
+
 ## Contributing
 
 Ghostfolio is **100% free** and **open source**. We encourage and support an active and healthy community that accepts contributions from the public - including you.

angular.json

@@ -9,7 +9,7 @@
       "schematics": {},
       "architect": {
         "build": {
-          "builder": "@nrwl/node:build",
+          "builder": "@nrwl/node:webpack",
           "options": {
             "outputPath": "dist/apps/api",
             "main": "apps/api/src/main.ts",
@@ -33,7 +33,7 @@
           "outputs": ["{options.outputPath}"]
         },
         "serve": {
-          "builder": "@nrwl/node:execute",
+          "builder": "@nrwl/node:node",
           "options": {
             "buildTarget": "api:build"
           }
@@ -264,7 +264,8 @@
             "port": 4400,
             "config": {
               "configFolder": "libs/ui/.storybook"
-            }
+            },
+            "projectBuildConfig": "ui:build-storybook"
           },
           "configurations": {
             "ci": {
@@ -280,7 +281,8 @@
             "outputPath": "dist/storybook/ui",
             "config": {
               "configFolder": "libs/ui/.storybook"
-            }
+            },
+            "projectBuildConfig": "ui:build-storybook"
           },
           "configurations": {
             "ci": {

apps/api/src/app/access/access.module.ts

@@ -1,4 +1,4 @@
-import { PrismaService } from '@ghostfolio/api/services/prisma.service';
+import { PrismaModule } from '@ghostfolio/api/services/prisma.module';
 import { Module } from '@nestjs/common';
 
 import { AccessController } from './access.controller';
@@ -7,7 +7,7 @@ import { AccessService } from './access.service';
 @Module({
   controllers: [AccessController],
   exports: [AccessService],
-  imports: [],
-  providers: [AccessService, PrismaService]
+  imports: [PrismaModule],
+  providers: [AccessService]
 })
 export class AccessModule {}

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

@@ -101,16 +101,18 @@ export class AccountController {
     ) {
       accountsWithAggregations = {
         ...nullifyValuesInObject(accountsWithAggregations, [
-          'totalBalance',
-          'totalValue'
+          'totalBalanceInBaseCurrency',
+          'totalValueInBaseCurrency'
         ]),
         accounts: nullifyValuesInObjects(accountsWithAggregations.accounts, [
           'balance',
+          'balanceInBaseCurrency',
           'convertedBalance',
           'fee',
           'quantity',
           'unitPrice',
-          'value'
+          'value',
+          'valueInBaseCurrency'
         ])
       };
     }

apps/api/src/app/account/account.module.ts

@@ -13,6 +13,7 @@ import { AccountService } from './account.service';
 
 @Module({
   controllers: [AccountController],
+  exports: [AccountService],
   imports: [
     ConfigurationModule,
     DataProviderModule,

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

@@ -2,6 +2,7 @@ import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-
 import { PrismaService } from '@ghostfolio/api/services/prisma.service';
 import { Injectable } from '@nestjs/common';
 import { Account, Order, Platform, Prisma } from '@prisma/client';
+import Big from 'big.js';
 
 import { CashDetails } from './interfaces/cash-details.interface';
 
@@ -105,21 +106,26 @@ export class AccountService {
     aUserId: string,
     aCurrency: string
   ): Promise<CashDetails> {
-    let totalCashBalance = 0;
+    let totalCashBalanceInBaseCurrency = new Big(0);
 
     const accounts = await this.accounts({
       where: { userId: aUserId }
     });
 
-    accounts.forEach((account) => {
-      totalCashBalance += this.exchangeRateDataService.toCurrency(
-        account.balance,
-        account.currency,
-        aCurrency
+    for (const account of accounts) {
+      totalCashBalanceInBaseCurrency = totalCashBalanceInBaseCurrency.plus(
+        this.exchangeRateDataService.toCurrency(
+          account.balance,
+          account.currency,
+          aCurrency
+        )
       );
-    });
+    }
 
-    return { accounts, balance: totalCashBalance };
+    return {
+      accounts,
+      balanceInBaseCurrency: totalCashBalanceInBaseCurrency.toNumber()
+    };
   }
 
   public async updateAccount(

apps/api/src/app/account/interfaces/cash-details.interface.ts

@@ -2,5 +2,5 @@ import { Account } from '@prisma/client';
 
 export interface CashDetails {
   accounts: Account[];
-  balance: number;
+  balanceInBaseCurrency: number;
 }

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

@@ -11,7 +11,8 @@ import {
   AdminData,
   AdminMarketData,
   AdminMarketDataDetails,
-  AdminMarketDataItem
+  AdminMarketDataItem,
+  UniqueAsset
 } from '@ghostfolio/common/interfaces';
 import { Injectable } from '@nestjs/common';
 import { DataSource, Property } from '@prisma/client';
@@ -30,13 +31,7 @@ export class AdminService {
     private readonly symbolProfileService: SymbolProfileService
   ) {}
 
-  public async deleteProfileData({
-    dataSource,
-    symbol
-  }: {
-    dataSource: DataSource;
-    symbol: string;
-  }) {
+  public async deleteProfileData({ dataSource, symbol }: UniqueAsset) {
     await this.marketDataService.deleteMany({ dataSource, symbol });
     await this.symbolProfileService.delete({ dataSource, symbol });
   }
@@ -137,10 +132,7 @@ export class AdminService {
   public async getMarketDataBySymbol({
     dataSource,
     symbol
-  }: {
-    dataSource: DataSource;
-    symbol: string;
-  }): Promise<AdminMarketDataDetails> {
+  }: UniqueAsset): Promise<AdminMarketDataDetails> {
     return {
       marketData: await this.marketDataService.marketDataItems({
         orderBy: {

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

@@ -8,6 +8,7 @@ import { DataGatheringModule } from '@ghostfolio/api/services/data-gathering.mod
 import { DataProviderModule } from '@ghostfolio/api/services/data-provider/data-provider.module';
 import { ExchangeRateDataModule } from '@ghostfolio/api/services/exchange-rate-data.module';
 import { PrismaModule } from '@ghostfolio/api/services/prisma.module';
+import { TwitterBotModule } from '@ghostfolio/api/services/twitter-bot/twitter-bot.module';
 import { Module } from '@nestjs/common';
 import { ConfigModule } from '@nestjs/config';
 import { ScheduleModule } from '@nestjs/schedule';
@@ -65,6 +66,7 @@ import { UserModule } from './user/user.module';
     }),
     SubscriptionModule,
     SymbolModule,
+    TwitterBotModule,
     UserModule
   ],
   controllers: [AppController],

apps/api/src/app/auth-device/auth-device.module.ts

@@ -1,18 +1,20 @@
 import { AuthDeviceController } from '@ghostfolio/api/app/auth-device/auth-device.controller';
 import { AuthDeviceService } from '@ghostfolio/api/app/auth-device/auth-device.service';
-import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
-import { PrismaService } from '@ghostfolio/api/services/prisma.service';
+import { ConfigurationModule } from '@ghostfolio/api/services/configuration.module';
+import { PrismaModule } from '@ghostfolio/api/services/prisma.module';
 import { Module } from '@nestjs/common';
 import { JwtModule } from '@nestjs/jwt';
 
 @Module({
   controllers: [AuthDeviceController],
   imports: [
+    ConfigurationModule,
     JwtModule.register({
       secret: process.env.JWT_SECRET_KEY,
       signOptions: { expiresIn: '180 days' }
-    })
+    }),
+    PrismaModule
   ],
-  providers: [AuthDeviceService, ConfigurationService, PrismaService]
+  providers: [AuthDeviceService]
 })
 export class AuthDeviceModule {}

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

@@ -9,7 +9,9 @@ import {
   Post,
   Req,
   Res,
-  UseGuards
+  UseGuards,
+  VERSION_NEUTRAL,
+  Version
 } from '@nestjs/common';
 import { AuthGuard } from '@nestjs/passport';
 import { StatusCodes, getReasonPhrase } from 'http-status-codes';
@@ -51,6 +53,7 @@ export class AuthController {
 
   @Get('google/callback')
   @UseGuards(AuthGuard('google'))
+  @Version(VERSION_NEUTRAL)
   public googleLoginCallback(@Req() req, @Res() res) {
     // Handles the Google OAuth2 callback
     const jwt: string = req.user.jwt;

apps/api/src/app/auth/auth.module.ts

@@ -2,8 +2,8 @@ import { AuthDeviceService } from '@ghostfolio/api/app/auth-device/auth-device.s
 import { WebAuthService } from '@ghostfolio/api/app/auth/web-auth.service';
 import { SubscriptionModule } from '@ghostfolio/api/app/subscription/subscription.module';
 import { UserModule } from '@ghostfolio/api/app/user/user.module';
-import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
-import { PrismaService } from '@ghostfolio/api/services/prisma.service';
+import { ConfigurationModule } from '@ghostfolio/api/services/configuration.module';
+import { PrismaModule } from '@ghostfolio/api/services/prisma.module';
 import { Module } from '@nestjs/common';
 import { JwtModule } from '@nestjs/jwt';
 
@@ -15,20 +15,20 @@ import { JwtStrategy } from './jwt.strategy';
 @Module({
   controllers: [AuthController],
   imports: [
+    ConfigurationModule,
     JwtModule.register({
       secret: process.env.JWT_SECRET_KEY,
       signOptions: { expiresIn: '180 days' }
     }),
+    PrismaModule,
     SubscriptionModule,
     UserModule
   ],
   providers: [
     AuthDeviceService,
     AuthService,
-    ConfigurationService,
     GoogleStrategy,
     JwtStrategy,
-    PrismaService,
     WebAuthService
   ]
 })

apps/api/src/app/auth/google.strategy.ts

@@ -42,7 +42,7 @@ export class GoogleStrategy extends PassportStrategy(Strategy, 'google') {
 
       done(null, user);
     } catch (error) {
-      Logger.error(error);
+      Logger.error(error, 'GoogleStrategy');
       done(error, false);
     }
   }

apps/api/src/app/auth/web-auth.service.ts

@@ -95,7 +95,7 @@ export class WebAuthService {
       };
       verification = await verifyRegistrationResponse(opts);
     } catch (error) {
-      Logger.error(error);
+      Logger.error(error, 'WebAuthService');
       throw new InternalServerErrorException(error.message);
     }
 
@@ -193,7 +193,7 @@ export class WebAuthService {
       };
       verification = verifyAuthenticationResponse(opts);
     } catch (error) {
-      Logger.error(error);
+      Logger.error(error, 'WebAuthService');
       throw new InternalServerErrorException({ error: error.message });
     }
 

apps/api/src/app/cache/cache.module.ts

@@ -1,30 +1,27 @@
 import { CacheService } from '@ghostfolio/api/app/cache/cache.service';
 import { RedisCacheModule } from '@ghostfolio/api/app/redis-cache/redis-cache.module';
-import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
+import { ConfigurationModule } from '@ghostfolio/api/services/configuration.module';
 import { DataGatheringModule } from '@ghostfolio/api/services/data-gathering.module';
-import { DataGatheringService } from '@ghostfolio/api/services/data-gathering.service';
 import { DataProviderModule } from '@ghostfolio/api/services/data-provider/data-provider.module';
 import { ExchangeRateDataModule } from '@ghostfolio/api/services/exchange-rate-data.module';
-import { PrismaService } from '@ghostfolio/api/services/prisma.service';
+import { PrismaModule } from '@ghostfolio/api/services/prisma.module';
 import { SymbolProfileModule } from '@ghostfolio/api/services/symbol-profile.module';
 import { Module } from '@nestjs/common';
 
 import { CacheController } from './cache.controller';
 
 @Module({
+  exports: [CacheService],
+  controllers: [CacheController],
   imports: [
+    ConfigurationModule,
     DataGatheringModule,
     DataProviderModule,
     ExchangeRateDataModule,
+    PrismaModule,
     RedisCacheModule,
     SymbolProfileModule
   ],
-  controllers: [CacheController],
-  providers: [
-    CacheService,
-    ConfigurationService,
-    DataGatheringService,
-    PrismaService
-  ]
+  providers: [CacheService]
 })
 export class CacheModule {}

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

@@ -1,13 +1,6 @@
 import { Export } from '@ghostfolio/common/interfaces';
 import type { RequestWithUser } from '@ghostfolio/common/types';
-import {
-  Controller,
-  Get,
-  Headers,
-  Inject,
-  Query,
-  UseGuards
-} from '@nestjs/common';
+import { Controller, Get, Inject, Query, UseGuards } from '@nestjs/common';
 import { REQUEST } from '@nestjs/core';
 import { AuthGuard } from '@nestjs/passport';
 

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

@@ -14,12 +14,10 @@ export class ExportService {
     activityIds?: string[];
     userId: string;
   }): Promise<Export> {
-    let orders = await this.prismaService.order.findMany({
+    let activities = await this.prismaService.order.findMany({
       orderBy: { date: 'desc' },
       select: {
         accountId: true,
-        currency: true,
-        dataSource: true,
         date: true,
         fee: true,
         id: true,
@@ -32,17 +30,16 @@ export class ExportService {
     });
 
     if (activityIds) {
-      orders = orders.filter((order) => {
-        return activityIds.includes(order.id);
+      activities = activities.filter((activity) => {
+        return activityIds.includes(activity.id);
       });
     }
 
     return {
       meta: { date: new Date().toISOString(), version: environment.version },
-      orders: orders.map(
+      activities: activities.map(
         ({
           accountId,
-          currency,
           date,
           fee,
           quantity,
@@ -52,12 +49,12 @@ export class ExportService {
         }) => {
           return {
             accountId,
-            currency,
             date,
             fee,
             quantity,
             type,
             unitPrice,
+            currency: SymbolProfile.currency,
             dataSource: SymbolProfile.dataSource,
             symbol: type === 'ITEM' ? SymbolProfile.name : SymbolProfile.symbol
           };

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

@@ -1,5 +1,4 @@
 import { CreateOrderDto } from '@ghostfolio/api/app/order/create-order.dto';
-import { Order } from '@prisma/client';
 import { Type } from 'class-transformer';
 import { IsArray, ValidateNested } from 'class-validator';
 
@@ -7,5 +6,5 @@ export class ImportDataDto {
   @IsArray()
   @Type(() => CreateOrderDto)
   @ValidateNested({ each: true })
-  orders: Order[];
+  activities: CreateOrderDto[];
 }

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

@@ -36,11 +36,11 @@ export class ImportController {
 
     try {
       return await this.importService.import({
-        orders: importData.orders,
+        activities: importData.activities,
         userId: this.request.user.id
       });
     } catch (error) {
-      Logger.error(error);
+      Logger.error(error, ImportController);
 
       throw new HttpException(
         {

apps/api/src/app/import/import.module.ts

@@ -1,4 +1,5 @@
-import { CacheService } from '@ghostfolio/api/app/cache/cache.service';
+import { AccountModule } from '@ghostfolio/api/app/account/account.module';
+import { CacheModule } from '@ghostfolio/api/app/cache/cache.module';
 import { OrderModule } from '@ghostfolio/api/app/order/order.module';
 import { RedisCacheModule } from '@ghostfolio/api/app/redis-cache/redis-cache.module';
 import { ConfigurationModule } from '@ghostfolio/api/services/configuration.module';
@@ -11,7 +12,10 @@ import { ImportController } from './import.controller';
 import { ImportService } from './import.service';
 
 @Module({
+  controllers: [ImportController],
   imports: [
+    AccountModule,
+    CacheModule,
     ConfigurationModule,
     DataGatheringModule,
     DataProviderModule,
@@ -19,7 +23,6 @@ import { ImportService } from './import.service';
     PrismaModule,
     RedisCacheModule
   ],
-  controllers: [ImportController],
-  providers: [CacheService, ImportService]
+  providers: [ImportService]
 })
 export class ImportModule {}

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

@@ -1,36 +1,44 @@
+import { AccountService } from '@ghostfolio/api/app/account/account.service';
+import { CreateOrderDto } from '@ghostfolio/api/app/order/create-order.dto';
 import { OrderService } from '@ghostfolio/api/app/order/order.service';
 import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
 import { DataProviderService } from '@ghostfolio/api/services/data-provider/data-provider.service';
 import { Injectable } from '@nestjs/common';
-import { Order } from '@prisma/client';
 import { isSameDay, parseISO } from 'date-fns';
 
 @Injectable()
 export class ImportService {
   public constructor(
+    private readonly accountService: AccountService,
     private readonly configurationService: ConfigurationService,
     private readonly dataProviderService: DataProviderService,
     private readonly orderService: OrderService
   ) {}
 
   public async import({
-    orders,
+    activities,
     userId
   }: {
-    orders: Partial<Order>[];
+    activities: Partial<CreateOrderDto>[];
     userId: string;
   }): Promise<void> {
-    for (const order of orders) {
-      if (!order.dataSource) {
-        if (order.type === 'ITEM') {
-          order.dataSource = 'MANUAL';
+    for (const activity of activities) {
+      if (!activity.dataSource) {
+        if (activity.type === 'ITEM') {
+          activity.dataSource = 'MANUAL';
         } else {
-          order.dataSource = this.dataProviderService.getPrimaryDataSource();
+          activity.dataSource = this.dataProviderService.getPrimaryDataSource();
         }
       }
     }
 
-    await this.validateOrders({ orders, userId });
+    await this.validateActivities({ activities, userId });
+
+    const accountIds = (await this.accountService.getAccounts(userId)).map(
+      (account) => {
+        return account.id;
+      }
+    );
 
     for (const {
       accountId,
@@ -42,21 +50,19 @@ export class ImportService {
       symbol,
       type,
       unitPrice
-    } of orders) {
+    } of activities) {
       await this.orderService.createOrder({
-        accountId,
-        currency,
-        dataSource,
         fee,
         quantity,
-        symbol,
         type,
         unitPrice,
         userId,
+        accountId: accountIds.includes(accountId) ? accountId : undefined,
         date: parseISO(<string>(<unknown>date)),
         SymbolProfile: {
           connectOrCreate: {
             create: {
+              currency,
               dataSource,
               symbol
             },
@@ -73,24 +79,25 @@ export class ImportService {
     }
   }
 
-  private async validateOrders({
-    orders,
+  private async validateActivities({
+    activities,
     userId
   }: {
-    orders: Partial<Order>[];
+    activities: Partial<CreateOrderDto>[];
     userId: string;
   }) {
     if (
-      orders?.length > this.configurationService.get('MAX_ORDERS_TO_IMPORT')
+      activities?.length > this.configurationService.get('MAX_ORDERS_TO_IMPORT')
     ) {
       throw new Error(
-        `Too many transactions (${this.configurationService.get(
+        `Too many activities (${this.configurationService.get(
           'MAX_ORDERS_TO_IMPORT'
         )} at most)`
       );
     }
 
-    const existingOrders = await this.orderService.orders({
+    const existingActivities = await this.orderService.orders({
+      include: { SymbolProfile: true },
       orderBy: { date: 'desc' },
       where: { userId }
     });
@@ -98,38 +105,38 @@ export class ImportService {
     for (const [
       index,
       { currency, dataSource, date, fee, quantity, symbol, type, unitPrice }
-    ] of orders.entries()) {
-      const duplicateOrder = existingOrders.find((order) => {
+    ] of activities.entries()) {
+      const duplicateActivity = existingActivities.find((activity) => {
         return (
-          order.currency === currency &&
-          order.dataSource === dataSource &&
-          isSameDay(order.date, parseISO(<string>(<unknown>date))) &&
-          order.fee === fee &&
-          order.quantity === quantity &&
-          order.symbol === symbol &&
-          order.type === type &&
-          order.unitPrice === unitPrice
+          activity.SymbolProfile.currency === currency &&
+          activity.SymbolProfile.dataSource === dataSource &&
+          isSameDay(activity.date, parseISO(<string>(<unknown>date))) &&
+          activity.fee === fee &&
+          activity.quantity === quantity &&
+          activity.SymbolProfile.symbol === symbol &&
+          activity.type === type &&
+          activity.unitPrice === unitPrice
         );
       });
 
-      if (duplicateOrder) {
-        throw new Error(`orders.${index} is a duplicate transaction`);
+      if (duplicateActivity) {
+        throw new Error(`activities.${index} is a duplicate activity`);
       }
 
       if (dataSource !== 'MANUAL') {
-        const result = await this.dataProviderService.get([
+        const quotes = await this.dataProviderService.getQuotes([
           { dataSource, symbol }
         ]);
 
-        if (result[symbol] === undefined) {
+        if (quotes[symbol] === undefined) {
           throw new Error(
-            `orders.${index}.symbol ("${symbol}") is not valid for the specified data source ("${dataSource}")`
+            `activities.${index}.symbol ("${symbol}") is not valid for the specified data source ("${dataSource}")`
           );
         }
 
-        if (result[symbol].currency !== currency) {
+        if (quotes[symbol].currency !== currency) {
           throw new Error(
-            `orders.${index}.currency ("${currency}") does not match with "${result[symbol].currency}"`
+            `activities.${index}.currency ("${currency}") does not match with "${quotes[symbol].currency}"`
           );
         }
       }

apps/api/src/app/info/info.module.ts

@@ -1,10 +1,9 @@
 import { RedisCacheModule } from '@ghostfolio/api/app/redis-cache/redis-cache.module';
-import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
+import { ConfigurationModule } from '@ghostfolio/api/services/configuration.module';
 import { DataGatheringModule } from '@ghostfolio/api/services/data-gathering.module';
-import { DataGatheringService } from '@ghostfolio/api/services/data-gathering.service';
 import { DataProviderModule } from '@ghostfolio/api/services/data-provider/data-provider.module';
 import { ExchangeRateDataModule } from '@ghostfolio/api/services/exchange-rate-data.module';
-import { PrismaService } from '@ghostfolio/api/services/prisma.service';
+import { PrismaModule } from '@ghostfolio/api/services/prisma.module';
 import { PropertyModule } from '@ghostfolio/api/services/property/property.module';
 import { SymbolProfileModule } from '@ghostfolio/api/services/symbol-profile.module';
 import { Module } from '@nestjs/common';
@@ -14,7 +13,9 @@ import { InfoController } from './info.controller';
 import { InfoService } from './info.service';
 
 @Module({
+  controllers: [InfoController],
   imports: [
+    ConfigurationModule,
     DataGatheringModule,
     DataProviderModule,
     ExchangeRateDataModule,
@@ -22,16 +23,11 @@ import { InfoService } from './info.service';
       secret: process.env.JWT_SECRET_KEY,
       signOptions: { expiresIn: '30 days' }
     }),
+    PrismaModule,
     PropertyModule,
     RedisCacheModule,
     SymbolProfileModule
   ],
-  controllers: [InfoController],
-  providers: [
-    ConfigurationService,
-    DataGatheringService,
-    InfoService,
-    PrismaService
-  ]
+  providers: [InfoService]
 })
 export class InfoModule {}

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

@@ -9,7 +9,8 @@ import {
   PROPERTY_IS_READ_ONLY_MODE,
   PROPERTY_SLACK_COMMUNITY_USERS,
   PROPERTY_STRIPE_CONFIG,
-  PROPERTY_SYSTEM_MESSAGE
+  PROPERTY_SYSTEM_MESSAGE,
+  ghostfolioFearAndGreedIndexDataSource
 } from '@ghostfolio/common/config';
 import { encodeDataSource } from '@ghostfolio/common/helper';
 import { InfoItem } from '@ghostfolio/common/interfaces';
@@ -18,7 +19,6 @@ import { Subscription } from '@ghostfolio/common/interfaces/subscription.interfa
 import { permissions } from '@ghostfolio/common/permissions';
 import { Injectable, Logger } from '@nestjs/common';
 import { JwtService } from '@nestjs/jwt';
-import { DataSource } from '@prisma/client';
 import * as bent from 'bent';
 import { subDays } from 'date-fns';
 
@@ -52,7 +52,9 @@ export class InfoService {
     }
 
     if (this.configurationService.get('ENABLE_FEATURE_FEAR_AND_GREED_INDEX')) {
-      info.fearAndGreedDataSource = encodeDataSource(DataSource.RAKUTEN);
+      info.fearAndGreedDataSource = encodeDataSource(
+        ghostfolioFearAndGreedIndexDataSource
+      );
     }
 
     if (this.configurationService.get('ENABLE_FEATURE_IMPORT')) {
@@ -142,7 +144,7 @@ export class InfoService {
       const contributors = await get();
       return contributors?.length;
     } catch (error) {
-      Logger.error(error);
+      Logger.error(error, 'InfoService');
 
       return undefined;
     }
@@ -163,7 +165,7 @@ export class InfoService {
       const { stargazers_count } = await get();
       return stargazers_count;
     } catch (error) {
-      Logger.error(error);
+      Logger.error(error, 'InfoService');
 
       return undefined;
     }

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

@@ -114,6 +114,7 @@ export class OrderController {
       SymbolProfile: {
         connectOrCreate: {
           create: {
+            currency: data.currency,
             dataSource: data.dataSource,
             symbol: data.symbol
           },
@@ -171,6 +172,14 @@ export class OrderController {
             id_userId: { id: accountId, userId: this.request.user.id }
           }
         },
+        SymbolProfile: {
+          connect: {
+            dataSource_symbol: {
+              dataSource: data.dataSource,
+              symbol: data.symbol
+            }
+          }
+        },
         User: { connect: { id: this.request.user.id } }
       },
       where: {

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

@@ -1,5 +1,5 @@
 import { AccountService } from '@ghostfolio/api/app/account/account.service';
-import { CacheService } from '@ghostfolio/api/app/cache/cache.service';
+import { CacheModule } from '@ghostfolio/api/app/cache/cache.module';
 import { RedisCacheModule } from '@ghostfolio/api/app/redis-cache/redis-cache.module';
 import { UserModule } from '@ghostfolio/api/app/user/user.module';
 import { ConfigurationModule } from '@ghostfolio/api/services/configuration.module';
@@ -15,7 +15,10 @@ import { OrderController } from './order.controller';
 import { OrderService } from './order.service';
 
 @Module({
+  controllers: [OrderController],
+  exports: [OrderService],
   imports: [
+    CacheModule,
     ConfigurationModule,
     DataGatheringModule,
     DataProviderModule,
@@ -26,8 +29,6 @@ import { OrderService } from './order.service';
     SymbolProfileModule,
     UserModule
   ],
-  controllers: [OrderController],
-  providers: [AccountService, CacheService, OrderService],
-  exports: [OrderService]
+  providers: [AccountService, OrderService]
 })
 export class OrderModule {}

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

@@ -53,7 +53,13 @@ export class OrderService {
   }
 
   public async createOrder(
-    data: Prisma.OrderCreateInput & { accountId?: string; userId: string }
+    data: Prisma.OrderCreateInput & {
+      accountId?: string;
+      currency?: string;
+      dataSource?: DataSource;
+      symbol?: string;
+      userId: string;
+    }
   ): Promise<Order> {
     const defaultAccount = (
       await this.accountService.getAccounts(data.userId)
@@ -71,15 +77,13 @@ export class OrderService {
     };
 
     if (data.type === 'ITEM') {
-      const currency = data.currency;
+      const currency = data.SymbolProfile.connectOrCreate.create.currency;
       const dataSource: DataSource = 'MANUAL';
       const id = uuidv4();
       const name = data.SymbolProfile.connectOrCreate.create.symbol;
 
       Account = undefined;
-      data.dataSource = dataSource;
       data.id = id;
-      data.symbol = null;
       data.SymbolProfile.connectOrCreate.create.currency = currency;
       data.SymbolProfile.connectOrCreate.create.dataSource = dataSource;
       data.SymbolProfile.connectOrCreate.create.name = name;
@@ -93,29 +97,32 @@ export class OrderService {
         data.SymbolProfile.connectOrCreate.create.symbol.toUpperCase();
     }
 
+    await this.dataGatheringService.gatherProfileData([
+      {
+        dataSource: data.SymbolProfile.connectOrCreate.create.dataSource,
+        symbol: data.SymbolProfile.connectOrCreate.create.symbol
+      }
+    ]);
+
     const isDraft = isAfter(data.date as Date, endOfToday());
 
     if (!isDraft) {
       // Gather symbol data of order in the background, if not draft
       this.dataGatheringService.gatherSymbols([
         {
-          dataSource: data.dataSource,
+          dataSource: data.SymbolProfile.connectOrCreate.create.dataSource,
           date: <Date>data.date,
           symbol: data.SymbolProfile.connectOrCreate.create.symbol
         }
       ]);
     }
 
-    this.dataGatheringService.gatherProfileData([
-      {
-        dataSource: data.dataSource,
-        symbol: data.SymbolProfile.connectOrCreate.create.symbol
-      }
-    ]);
-
     await this.cacheService.flush();
 
     delete data.accountId;
+    delete data.currency;
+    delete data.dataSource;
+    delete data.symbol;
     delete data.userId;
 
     const orderData: Prisma.OrderCreateInput = data;
@@ -193,50 +200,60 @@ export class OrderService {
         value,
         feeInBaseCurrency: this.exchangeRateDataService.toCurrency(
           order.fee,
-          order.currency,
+          order.SymbolProfile.currency,
           userCurrency
         ),
         valueInBaseCurrency: this.exchangeRateDataService.toCurrency(
           value,
-          order.currency,
+          order.SymbolProfile.currency,
           userCurrency
         )
       };
     });
   }
 
-  public async updateOrder(params: {
+  public async updateOrder({
+    data,
+    where
+  }: {
+    data: Prisma.OrderUpdateInput & {
+      currency?: string;
+      dataSource?: DataSource;
+      symbol?: string;
+    };
     where: Prisma.OrderWhereUniqueInput;
-    data: Prisma.OrderUpdateInput;
   }): Promise<Order> {
-    const { data, where } = params;
-
     if (data.Account.connect.id_userId.id === null) {
       delete data.Account;
     }
 
+    let isDraft = false;
+
     if (data.type === 'ITEM') {
-      const name = data.symbol;
+      const name = data.SymbolProfile.connect.dataSource_symbol.symbol;
 
-      data.symbol = null;
       data.SymbolProfile = { update: { name } };
-    }
+    } else {
+      isDraft = isAfter(data.date as Date, endOfToday());
 
-    const isDraft = isAfter(data.date as Date, endOfToday());
-
-    if (!isDraft) {
-      // Gather symbol data of order in the background, if not draft
-      this.dataGatheringService.gatherSymbols([
-        {
-          dataSource: <DataSource>data.dataSource,
-          date: <Date>data.date,
-          symbol: <string>data.symbol
-        }
-      ]);
+      if (!isDraft) {
+        // Gather symbol data of order in the background, if not draft
+        this.dataGatheringService.gatherSymbols([
+          {
+            dataSource: data.SymbolProfile.connect.dataSource_symbol.dataSource,
+            date: <Date>data.date,
+            symbol: data.SymbolProfile.connect.dataSource_symbol.symbol
+          }
+        ]);
+      }
     }
 
     await this.cacheService.flush();
 
+    delete data.currency;
+    delete data.dataSource;
+    delete data.symbol;
+
     return this.prismaService.order.update({
       data: {
         ...data,

apps/api/src/app/portfolio/current-rate.service.mock.ts

@@ -0,0 +1,60 @@
+import { parseDate, resetHours } from '@ghostfolio/common/helper';
+import { addDays, endOfDay, isBefore, isSameDay } from 'date-fns';
+
+import { GetValuesParams } from './interfaces/get-values-params.interface';
+
+function mockGetValue(symbol: string, date: Date) {
+  switch (symbol) {
+    case 'BALN.SW':
+      if (isSameDay(parseDate('2021-11-12'), date)) {
+        return { marketPrice: 146 };
+      } else if (isSameDay(parseDate('2021-11-22'), date)) {
+        return { marketPrice: 142.9 };
+      } else if (isSameDay(parseDate('2021-11-26'), date)) {
+        return { marketPrice: 139.9 };
+      } else if (isSameDay(parseDate('2021-11-30'), date)) {
+        return { marketPrice: 136.6 };
+      } else if (isSameDay(parseDate('2021-12-18'), date)) {
+        return { marketPrice: 148.9 };
+      }
+
+      return { marketPrice: 0 };
+
+    default:
+      return { marketPrice: 0 };
+  }
+}
+
+export const CurrentRateServiceMock = {
+  getValues: ({ dataGatheringItems, dateQuery }: GetValuesParams) => {
+    const result = [];
+    if (dateQuery.lt) {
+      for (
+        let date = resetHours(dateQuery.gte);
+        isBefore(date, endOfDay(dateQuery.lt));
+        date = addDays(date, 1)
+      ) {
+        for (const dataGatheringItem of dataGatheringItems) {
+          result.push({
+            date,
+            marketPrice: mockGetValue(dataGatheringItem.symbol, date)
+              .marketPrice,
+            symbol: dataGatheringItem.symbol
+          });
+        }
+      }
+    } else {
+      for (const date of dateQuery.in) {
+        for (const dataGatheringItem of dataGatheringItems) {
+          result.push({
+            date,
+            marketPrice: mockGetValue(dataGatheringItem.symbol, date)
+              .marketPrice,
+            symbol: dataGatheringItem.symbol
+          });
+        }
+      }
+    }
+    return Promise.resolve(result);
+  }
+};

apps/api/src/app/portfolio/current-rate.service.ts

@@ -40,7 +40,7 @@ export class CurrentRateService {
       const today = resetHours(new Date());
       promises.push(
         this.dataProviderService
-          .get(dataGatheringItems)
+          .getQuotes(dataGatheringItems)
           .then((dataResultProvider) => {
             const result = [];
             for (const dataGatheringItem of dataGatheringItems) {

apps/api/src/app/portfolio/interfaces/current-positions.interface.ts

@@ -1,8 +1,7 @@
-import { TimelinePosition } from '@ghostfolio/common/interfaces';
+import { ResponseError, TimelinePosition } from '@ghostfolio/common/interfaces';
 import Big from 'big.js';
 
-export interface CurrentPositions {
-  hasErrors: boolean;
+export interface CurrentPositions extends ResponseError {
   positions: TimelinePosition[];
   grossPerformance: Big;
   grossPerformancePercentage: Big;

apps/api/src/app/portfolio/interfaces/portfolio-position-detail.interface.ts

@@ -1,11 +1,8 @@
+import { EnhancedSymbolProfile } from '@ghostfolio/api/services/interfaces/symbol-profile.interface';
 import { OrderWithAccount } from '@ghostfolio/common/types';
-import { AssetClass, AssetSubClass } from '@prisma/client';
 
 export interface PortfolioPositionDetail {
-  assetClass?: AssetClass;
-  assetSubClass?: AssetSubClass;
   averagePrice: number;
-  currency: string;
   firstBuyDate: string;
   grossPerformance: number;
   grossPerformancePercent: number;
@@ -14,12 +11,11 @@ export interface PortfolioPositionDetail {
   marketPrice: number;
   maxPrice: number;
   minPrice: number;
-  name: string;
   netPerformance: number;
   netPerformancePercent: number;
   orders: OrderWithAccount[];
   quantity: number;
-  symbol: string;
+  SymbolProfile: EnhancedSymbolProfile;
   transactionCount: number;
   value: number;
 }

apps/api/src/app/portfolio/portfolio-calculator-new-baln-buy-and-sell.spec.ts

@@ -0,0 +1,96 @@
+import { CurrentRateService } from '@ghostfolio/api/app/portfolio/current-rate.service';
+import { parseDate } from '@ghostfolio/common/helper';
+import Big from 'big.js';
+
+import { CurrentRateServiceMock } from './current-rate.service.mock';
+import { PortfolioCalculatorNew } from './portfolio-calculator-new';
+
+jest.mock('@ghostfolio/api/app/portfolio/current-rate.service', () => {
+  return {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    CurrentRateService: jest.fn().mockImplementation(() => {
+      return CurrentRateServiceMock;
+    })
+  };
+});
+
+describe('PortfolioCalculatorNew', () => {
+  let currentRateService: CurrentRateService;
+
+  beforeEach(() => {
+    currentRateService = new CurrentRateService(null, null, null);
+  });
+
+  describe('get current positions', () => {
+    it.only('with BALN.SW buy and sell', async () => {
+      const portfolioCalculatorNew = new PortfolioCalculatorNew({
+        currentRateService,
+        currency: 'CHF',
+        orders: [
+          {
+            currency: 'CHF',
+            date: '2021-11-22',
+            dataSource: 'YAHOO',
+            fee: new Big(1.55),
+            name: 'Bâloise Holding AG',
+            quantity: new Big(2),
+            symbol: 'BALN.SW',
+            type: 'BUY',
+            unitPrice: new Big(142.9)
+          },
+          {
+            currency: 'CHF',
+            date: '2021-11-30',
+            dataSource: 'YAHOO',
+            fee: new Big(1.65),
+            name: 'Bâloise Holding AG',
+            quantity: new Big(2),
+            symbol: 'BALN.SW',
+            type: 'SELL',
+            unitPrice: new Big(136.6)
+          }
+        ]
+      });
+
+      portfolioCalculatorNew.computeTransactionPoints();
+
+      const spy = jest
+        .spyOn(Date, 'now')
+        .mockImplementation(() => parseDate('2021-12-18').getTime());
+
+      const currentPositions = await portfolioCalculatorNew.getCurrentPositions(
+        parseDate('2021-11-22')
+      );
+
+      spy.mockRestore();
+
+      expect(currentPositions).toEqual({
+        currentValue: new Big('0'),
+        errors: [],
+        grossPerformance: new Big('-12.6'),
+        grossPerformancePercentage: new Big('-0.0440867739678096571'),
+        hasErrors: false,
+        netPerformance: new Big('-15.8'),
+        netPerformancePercentage: new Big('-0.0552834149755073478'),
+        positions: [
+          {
+            averagePrice: new Big('0'),
+            currency: 'CHF',
+            dataSource: 'YAHOO',
+            firstBuyDate: '2021-11-22',
+            grossPerformance: new Big('-12.6'),
+            grossPerformancePercentage: new Big('-0.0440867739678096571'),
+            investment: new Big('0'),
+            netPerformance: new Big('-15.8'),
+            netPerformancePercentage: new Big('-0.0552834149755073478'),
+            marketPrice: 148.9,
+            quantity: new Big('0'),
+            symbol: 'BALN.SW',
+            transactionCount: 2
+          }
+        ],
+        totalInvestment: new Big('0')
+      });
+    });
+  });
+});

apps/api/src/app/portfolio/portfolio-calculator-new-baln-buy.spec.ts

@@ -0,0 +1,85 @@
+import { CurrentRateService } from '@ghostfolio/api/app/portfolio/current-rate.service';
+import { parseDate } from '@ghostfolio/common/helper';
+import Big from 'big.js';
+
+import { CurrentRateServiceMock } from './current-rate.service.mock';
+import { PortfolioCalculatorNew } from './portfolio-calculator-new';
+
+jest.mock('@ghostfolio/api/app/portfolio/current-rate.service', () => {
+  return {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    CurrentRateService: jest.fn().mockImplementation(() => {
+      return CurrentRateServiceMock;
+    })
+  };
+});
+
+describe('PortfolioCalculatorNew', () => {
+  let currentRateService: CurrentRateService;
+
+  beforeEach(() => {
+    currentRateService = new CurrentRateService(null, null, null);
+  });
+
+  describe('get current positions', () => {
+    it.only('with BALN.SW buy', async () => {
+      const portfolioCalculatorNew = new PortfolioCalculatorNew({
+        currentRateService,
+        currency: 'CHF',
+        orders: [
+          {
+            currency: 'CHF',
+            date: '2021-11-30',
+            dataSource: 'YAHOO',
+            fee: new Big(1.55),
+            name: 'Bâloise Holding AG',
+            quantity: new Big(2),
+            symbol: 'BALN.SW',
+            type: 'BUY',
+            unitPrice: new Big(136.6)
+          }
+        ]
+      });
+
+      portfolioCalculatorNew.computeTransactionPoints();
+
+      const spy = jest
+        .spyOn(Date, 'now')
+        .mockImplementation(() => parseDate('2021-12-18').getTime());
+
+      const currentPositions = await portfolioCalculatorNew.getCurrentPositions(
+        parseDate('2021-11-30')
+      );
+
+      spy.mockRestore();
+
+      expect(currentPositions).toEqual({
+        currentValue: new Big('297.8'),
+        errors: [],
+        grossPerformance: new Big('24.6'),
+        grossPerformancePercentage: new Big('0.09004392386530014641'),
+        hasErrors: false,
+        netPerformance: new Big('23.05'),
+        netPerformancePercentage: new Big('0.08437042459736456808'),
+        positions: [
+          {
+            averagePrice: new Big('136.6'),
+            currency: 'CHF',
+            dataSource: 'YAHOO',
+            firstBuyDate: '2021-11-30',
+            grossPerformance: new Big('24.6'),
+            grossPerformancePercentage: new Big('0.09004392386530014641'),
+            investment: new Big('273.2'),
+            netPerformance: new Big('23.05'),
+            netPerformancePercentage: new Big('0.08437042459736456808'),
+            marketPrice: 148.9,
+            quantity: new Big('2'),
+            symbol: 'BALN.SW',
+            transactionCount: 1
+          }
+        ],
+        totalInvestment: new Big('273.2')
+      });
+    });
+  });
+});

apps/api/src/app/portfolio/portfolio-calculator-new-no-orders.spec.ts

@@ -0,0 +1,56 @@
+import { CurrentRateService } from '@ghostfolio/api/app/portfolio/current-rate.service';
+import { parseDate } from '@ghostfolio/common/helper';
+import Big from 'big.js';
+
+import { CurrentRateServiceMock } from './current-rate.service.mock';
+import { PortfolioCalculatorNew } from './portfolio-calculator-new';
+
+jest.mock('@ghostfolio/api/app/portfolio/current-rate.service', () => {
+  return {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    CurrentRateService: jest.fn().mockImplementation(() => {
+      return CurrentRateServiceMock;
+    })
+  };
+});
+
+describe('PortfolioCalculatorNew', () => {
+  let currentRateService: CurrentRateService;
+
+  beforeEach(() => {
+    currentRateService = new CurrentRateService(null, null, null);
+  });
+
+  describe('get current positions', () => {
+    it('with no orders', async () => {
+      const portfolioCalculatorNew = new PortfolioCalculatorNew({
+        currentRateService,
+        currency: 'CHF',
+        orders: []
+      });
+
+      portfolioCalculatorNew.computeTransactionPoints();
+
+      const spy = jest
+        .spyOn(Date, 'now')
+        .mockImplementation(() => parseDate('2021-12-18').getTime());
+
+      const currentPositions = await portfolioCalculatorNew.getCurrentPositions(
+        new Date()
+      );
+
+      spy.mockRestore();
+
+      expect(currentPositions).toEqual({
+        currentValue: new Big(0),
+        grossPerformance: new Big(0),
+        grossPerformancePercentage: new Big(0),
+        hasErrors: false,
+        netPerformance: new Big(0),
+        netPerformancePercentage: new Big(0),
+        positions: [],
+        totalInvestment: new Big(0)
+      });
+    });
+  });
+});

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

@@ -1,7 +1,11 @@
 import { TimelineInfoInterface } from '@ghostfolio/api/app/portfolio/interfaces/timeline-info.interface';
 import { IDataGatheringItem } from '@ghostfolio/api/services/interfaces/interfaces';
 import { DATE_FORMAT, parseDate, resetHours } from '@ghostfolio/common/helper';
-import { TimelinePosition } from '@ghostfolio/common/interfaces';
+import {
+  ResponseError,
+  TimelinePosition,
+  UniqueAsset
+} from '@ghostfolio/common/interfaces';
 import { Logger } from '@nestjs/common';
 import { Type as TypeOfOrder } from '@prisma/client';
 import Big from 'big.js';
@@ -33,6 +37,11 @@ import { TransactionPointSymbol } from './interfaces/transaction-point-symbol.in
 import { TransactionPoint } from './interfaces/transaction-point.interface';
 
 export class PortfolioCalculatorNew {
+  private static readonly CALCULATE_PERCENTAGE_PERFORMANCE_WITH_MAX_INVESTMENT =
+    true;
+
+  private static readonly ENABLE_LOGGING = false;
+
   private currency: string;
   private currentRateService: CurrentRateService;
   private orders: PortfolioOrder[];
@@ -228,7 +237,9 @@ export class PortfolioCalculatorNew {
     const initialValues: { [symbol: string]: Big } = {};
 
     const positions: TimelinePosition[] = [];
-    let hasErrorsInSymbolMetrics = false;
+    let hasAnySymbolMetricsErrors = false;
+
+    const errors: ResponseError['errors'] = [];
 
     for (const item of lastTransactionPoint.items) {
       const marketValue = marketSymbolMap[todayString]?.[item.symbol];
@@ -246,8 +257,7 @@ export class PortfolioCalculatorNew {
         symbol: item.symbol
       });
 
-      hasErrorsInSymbolMetrics = hasErrorsInSymbolMetrics || hasErrors;
-
+      hasAnySymbolMetricsErrors = hasAnySymbolMetricsErrors || hasErrors;
       initialValues[item.symbol] = initialValue;
 
       positions.push({
@@ -271,290 +281,19 @@ export class PortfolioCalculatorNew {
         symbol: item.symbol,
         transactionCount: item.transactionCount
       });
+
+      if (hasErrors) {
+        errors.push({ dataSource: item.dataSource, symbol: item.symbol });
+      }
     }
+
     const overall = this.calculateOverallPerformance(positions, initialValues);
 
     return {
       ...overall,
+      errors,
       positions,
-      hasErrors: hasErrorsInSymbolMetrics || overall.hasErrors
-    };
-  }
-
-  public getSymbolMetrics({
-    marketSymbolMap,
-    start,
-    symbol
-  }: {
-    marketSymbolMap: {
-      [date: string]: { [symbol: string]: Big };
-    };
-    start: Date;
-    symbol: string;
-  }) {
-    let orders: PortfolioOrderItem[] = this.orders.filter((order) => {
-      return order.symbol === symbol;
-    });
-
-    if (orders.length <= 0) {
-      return {
-        hasErrors: false,
-        initialValue: new Big(0),
-        netPerformance: new Big(0),
-        netPerformancePercentage: new Big(0),
-        grossPerformance: new Big(0),
-        grossPerformancePercentage: new Big(0)
-      };
-    }
-
-    const dateOfFirstTransaction = new Date(first(orders).date);
-    const endDate = new Date(Date.now());
-
-    const unitPriceAtStartDate =
-      marketSymbolMap[format(start, DATE_FORMAT)]?.[symbol];
-
-    const unitPriceAtEndDate =
-      marketSymbolMap[format(endDate, DATE_FORMAT)]?.[symbol];
-
-    if (
-      !unitPriceAtEndDate ||
-      (!unitPriceAtStartDate && isBefore(dateOfFirstTransaction, start))
-    ) {
-      return {
-        hasErrors: true,
-        initialValue: new Big(0),
-        netPerformance: new Big(0),
-        netPerformancePercentage: new Big(0),
-        grossPerformance: new Big(0),
-        grossPerformancePercentage: new Big(0)
-      };
-    }
-
-    let feesAtStartDate = new Big(0);
-    let fees = new Big(0);
-    let grossPerformance = new Big(0);
-    let grossPerformanceAtStartDate = new Big(0);
-    let grossPerformanceFromSells = new Big(0);
-    let initialValue: Big;
-    let lastAveragePrice = new Big(0);
-    let lastTransactionInvestment = new Big(0);
-    let lastValueOfInvestmentBeforeTransaction = new Big(0);
-    let timeWeightedGrossPerformancePercentage = new Big(1);
-    let timeWeightedNetPerformancePercentage = new Big(1);
-    let totalInvestment = new Big(0);
-    let totalUnits = new Big(0);
-
-    const holdingPeriodPerformances: {
-      grossReturn: Big;
-      netReturn: Big;
-      valueOfInvestment: Big;
-    }[] = [];
-
-    // Add a synthetic order at the start and the end date
-    orders.push({
-      symbol,
-      currency: null,
-      date: format(start, DATE_FORMAT),
-      dataSource: null,
-      fee: new Big(0),
-      itemType: 'start',
-      name: '',
-      quantity: new Big(0),
-      type: TypeOfOrder.BUY,
-      unitPrice: unitPriceAtStartDate ?? new Big(0)
-    });
-
-    orders.push({
-      symbol,
-      currency: null,
-      date: format(endDate, DATE_FORMAT),
-      dataSource: null,
-      fee: new Big(0),
-      itemType: 'end',
-      name: '',
-      quantity: new Big(0),
-      type: TypeOfOrder.BUY,
-      unitPrice: unitPriceAtEndDate ?? new Big(0)
-    });
-
-    // Sort orders so that the start and end placeholder order are at the right
-    // position
-    orders = sortBy(orders, (order) => {
-      let sortIndex = new Date(order.date);
-
-      if (order.itemType === 'start') {
-        sortIndex = addMilliseconds(sortIndex, -1);
-      }
-
-      if (order.itemType === 'end') {
-        sortIndex = addMilliseconds(sortIndex, 1);
-      }
-
-      return sortIndex.getTime();
-    });
-
-    const indexOfStartOrder = orders.findIndex((order) => {
-      return order.itemType === 'start';
-    });
-
-    for (let i = 0; i < orders.length; i += 1) {
-      const order = orders[i];
-
-      const valueOfInvestmentBeforeTransaction = totalUnits.mul(
-        order.unitPrice
-      );
-
-      const transactionInvestment = order.quantity
-        .mul(order.unitPrice)
-        .mul(this.getFactor(order.type));
-
-      if (
-        !initialValue &&
-        order.itemType !== 'start' &&
-        order.itemType !== 'end'
-      ) {
-        initialValue = transactionInvestment;
-      }
-
-      fees = fees.plus(order.fee);
-
-      totalUnits = totalUnits.plus(
-        order.quantity.mul(this.getFactor(order.type))
-      );
-
-      const valueOfInvestment = totalUnits.mul(order.unitPrice);
-
-      const grossPerformanceFromSell =
-        order.type === TypeOfOrder.SELL
-          ? order.unitPrice.minus(lastAveragePrice).mul(order.quantity)
-          : new Big(0);
-
-      grossPerformanceFromSells = grossPerformanceFromSells.plus(
-        grossPerformanceFromSell
-      );
-
-      totalInvestment = totalInvestment
-        .plus(transactionInvestment)
-        .plus(grossPerformanceFromSell);
-
-      lastAveragePrice = totalUnits.eq(0)
-        ? new Big(0)
-        : totalInvestment.div(totalUnits);
-
-      const newGrossPerformance = valueOfInvestment
-        .minus(totalInvestment)
-        .plus(grossPerformanceFromSells);
-
-      if (
-        i > indexOfStartOrder &&
-        !lastValueOfInvestmentBeforeTransaction
-          .plus(lastTransactionInvestment)
-          .eq(0)
-      ) {
-        const grossHoldingPeriodReturn = valueOfInvestmentBeforeTransaction
-          .minus(
-            lastValueOfInvestmentBeforeTransaction.plus(
-              lastTransactionInvestment
-            )
-          )
-          .div(
-            lastValueOfInvestmentBeforeTransaction.plus(
-              lastTransactionInvestment
-            )
-          );
-
-        timeWeightedGrossPerformancePercentage =
-          timeWeightedGrossPerformancePercentage.mul(
-            new Big(1).plus(grossHoldingPeriodReturn)
-          );
-
-        const netHoldingPeriodReturn = valueOfInvestmentBeforeTransaction
-          .minus(fees.minus(feesAtStartDate))
-          .minus(
-            lastValueOfInvestmentBeforeTransaction.plus(
-              lastTransactionInvestment
-            )
-          )
-          .div(
-            lastValueOfInvestmentBeforeTransaction.plus(
-              lastTransactionInvestment
-            )
-          );
-
-        timeWeightedNetPerformancePercentage =
-          timeWeightedNetPerformancePercentage.mul(
-            new Big(1).plus(netHoldingPeriodReturn)
-          );
-
-        holdingPeriodPerformances.push({
-          grossReturn: grossHoldingPeriodReturn,
-          netReturn: netHoldingPeriodReturn,
-          valueOfInvestment: lastValueOfInvestmentBeforeTransaction.plus(
-            lastTransactionInvestment
-          )
-        });
-      }
-
-      grossPerformance = newGrossPerformance;
-
-      lastTransactionInvestment = transactionInvestment;
-
-      lastValueOfInvestmentBeforeTransaction =
-        valueOfInvestmentBeforeTransaction;
-
-      if (order.itemType === 'start') {
-        feesAtStartDate = fees;
-        grossPerformanceAtStartDate = grossPerformance;
-      }
-    }
-
-    timeWeightedGrossPerformancePercentage =
-      timeWeightedGrossPerformancePercentage.minus(1);
-
-    timeWeightedNetPerformancePercentage =
-      timeWeightedNetPerformancePercentage.minus(1);
-
-    const totalGrossPerformance = grossPerformance.minus(
-      grossPerformanceAtStartDate
-    );
-
-    const totalNetPerformance = grossPerformance
-      .minus(grossPerformanceAtStartDate)
-      .minus(fees.minus(feesAtStartDate));
-
-    let valueOfInvestmentSum = new Big(0);
-
-    for (const holdingPeriodPerformance of holdingPeriodPerformances) {
-      valueOfInvestmentSum = valueOfInvestmentSum.plus(
-        holdingPeriodPerformance.valueOfInvestment
-      );
-    }
-
-    let totalWeightedGrossPerformance = new Big(0);
-    let totalWeightedNetPerformance = new Big(0);
-
-    // Weight the holding period returns according to their value of investment
-    for (const holdingPeriodPerformance of holdingPeriodPerformances) {
-      totalWeightedGrossPerformance = totalWeightedGrossPerformance.plus(
-        holdingPeriodPerformance.grossReturn
-          .mul(holdingPeriodPerformance.valueOfInvestment)
-          .div(valueOfInvestmentSum)
-      );
-
-      totalWeightedNetPerformance = totalWeightedNetPerformance.plus(
-        holdingPeriodPerformance.netReturn
-          .mul(holdingPeriodPerformance.valueOfInvestment)
-          .div(valueOfInvestmentSum)
-      );
-    }
-
-    return {
-      initialValue,
-      hasErrors: !initialValue || !unitPriceAtEndDate,
-      netPerformance: totalNetPerformance,
-      netPerformancePercentage: totalWeightedNetPerformance,
-      grossPerformance: totalGrossPerformance,
-      grossPerformancePercentage: totalWeightedGrossPerformance
+      hasErrors: hasAnySymbolMetricsErrors || overall.hasErrors
     };
   }
 
@@ -672,16 +411,16 @@ export class PortfolioCalculatorNew {
 
   private calculateOverallPerformance(
     positions: TimelinePosition[],
-    initialValues: { [p: string]: Big }
+    initialValues: { [symbol: string]: Big }
   ) {
-    let hasErrors = false;
     let currentValue = new Big(0);
-    let totalInvestment = new Big(0);
     let grossPerformance = new Big(0);
     let grossPerformancePercentage = new Big(0);
+    let hasErrors = false;
     let netPerformance = new Big(0);
     let netPerformancePercentage = new Big(0);
-    let completeInitialValue = new Big(0);
+    let sumOfWeights = new Big(0);
+    let totalInvestment = new Big(0);
 
     for (const currentPosition of positions) {
       if (currentPosition.marketPrice) {
@@ -691,41 +430,50 @@ export class PortfolioCalculatorNew {
       } else {
         hasErrors = true;
       }
+
       totalInvestment = totalInvestment.plus(currentPosition.investment);
+
       if (currentPosition.grossPerformance) {
         grossPerformance = grossPerformance.plus(
           currentPosition.grossPerformance
         );
+
         netPerformance = netPerformance.plus(currentPosition.netPerformance);
       } else if (!currentPosition.quantity.eq(0)) {
         hasErrors = true;
       }
 
-      if (
-        currentPosition.grossPerformancePercentage &&
-        initialValues[currentPosition.symbol]
-      ) {
-        const currentInitialValue = initialValues[currentPosition.symbol];
-        completeInitialValue = completeInitialValue.plus(currentInitialValue);
+      if (currentPosition.grossPerformancePercentage) {
+        // Use the average from the initial value and the current investment as
+        // a weight
+        const weight = (initialValues[currentPosition.symbol] ?? new Big(0))
+          .plus(currentPosition.investment)
+          .div(2);
+
+        sumOfWeights = sumOfWeights.plus(weight);
+
         grossPerformancePercentage = grossPerformancePercentage.plus(
-          currentPosition.grossPerformancePercentage.mul(currentInitialValue)
+          currentPosition.grossPerformancePercentage.mul(weight)
         );
+
         netPerformancePercentage = netPerformancePercentage.plus(
-          currentPosition.netPerformancePercentage.mul(currentInitialValue)
+          currentPosition.netPerformancePercentage.mul(weight)
         );
       } else if (!currentPosition.quantity.eq(0)) {
         Logger.warn(
-          `Missing initial value for symbol ${currentPosition.symbol} at ${currentPosition.firstBuyDate}`
+          `Missing initial value for symbol ${currentPosition.symbol} at ${currentPosition.firstBuyDate}`,
+          'PortfolioCalculatorNew'
         );
         hasErrors = true;
       }
     }
 
-    if (!completeInitialValue.eq(0)) {
-      grossPerformancePercentage =
-        grossPerformancePercentage.div(completeInitialValue);
-      netPerformancePercentage =
-        netPerformancePercentage.div(completeInitialValue);
+    if (sumOfWeights.gt(0)) {
+      grossPerformancePercentage = grossPerformancePercentage.div(sumOfWeights);
+      netPerformancePercentage = netPerformancePercentage.div(sumOfWeights);
+    } else {
+      grossPerformancePercentage = new Big(0);
+      netPerformancePercentage = new Big(0);
     }
 
     return {
@@ -779,7 +527,8 @@ export class PortfolioCalculatorNew {
         } catch (error) {
           Logger.error(
             `Failed to fetch info for date ${startDate} with exception`,
-            error
+            error,
+            'PortfolioCalculatorNew'
           );
           return null;
         }
@@ -885,6 +634,356 @@ export class PortfolioCalculatorNew {
     }
   }
 
+  private getSymbolMetrics({
+    marketSymbolMap,
+    start,
+    symbol
+  }: {
+    marketSymbolMap: {
+      [date: string]: { [symbol: string]: Big };
+    };
+    start: Date;
+    symbol: string;
+  }) {
+    let orders: PortfolioOrderItem[] = this.orders.filter((order) => {
+      return order.symbol === symbol;
+    });
+
+    if (orders.length <= 0) {
+      return {
+        hasErrors: false,
+        initialValue: new Big(0),
+        netPerformance: new Big(0),
+        netPerformancePercentage: new Big(0),
+        grossPerformance: new Big(0),
+        grossPerformancePercentage: new Big(0)
+      };
+    }
+
+    const dateOfFirstTransaction = new Date(first(orders).date);
+    const endDate = new Date(Date.now());
+
+    const unitPriceAtStartDate =
+      marketSymbolMap[format(start, DATE_FORMAT)]?.[symbol];
+
+    const unitPriceAtEndDate =
+      marketSymbolMap[format(endDate, DATE_FORMAT)]?.[symbol];
+
+    if (
+      !unitPriceAtEndDate ||
+      (!unitPriceAtStartDate && isBefore(dateOfFirstTransaction, start))
+    ) {
+      return {
+        hasErrors: true,
+        initialValue: new Big(0),
+        netPerformance: new Big(0),
+        netPerformancePercentage: new Big(0),
+        grossPerformance: new Big(0),
+        grossPerformancePercentage: new Big(0)
+      };
+    }
+
+    let averagePriceAtEndDate = new Big(0);
+    let averagePriceAtStartDate = new Big(0);
+    let feesAtStartDate = new Big(0);
+    let fees = new Big(0);
+    let grossPerformance = new Big(0);
+    let grossPerformanceAtStartDate = new Big(0);
+    let grossPerformanceFromSells = new Big(0);
+    let initialValue: Big;
+    let investmentAtStartDate: Big;
+    let lastAveragePrice = new Big(0);
+    let lastTransactionInvestment = new Big(0);
+    let lastValueOfInvestmentBeforeTransaction = new Big(0);
+    let maxTotalInvestment = new Big(0);
+    let timeWeightedGrossPerformancePercentage = new Big(1);
+    let timeWeightedNetPerformancePercentage = new Big(1);
+    let totalInvestment = new Big(0);
+    let totalInvestmentWithGrossPerformanceFromSell = new Big(0);
+    let totalUnits = new Big(0);
+    let valueAtStartDate: Big;
+
+    // Add a synthetic order at the start and the end date
+    orders.push({
+      symbol,
+      currency: null,
+      date: format(start, DATE_FORMAT),
+      dataSource: null,
+      fee: new Big(0),
+      itemType: 'start',
+      name: '',
+      quantity: new Big(0),
+      type: TypeOfOrder.BUY,
+      unitPrice: unitPriceAtStartDate
+    });
+
+    orders.push({
+      symbol,
+      currency: null,
+      date: format(endDate, DATE_FORMAT),
+      dataSource: null,
+      fee: new Big(0),
+      itemType: 'end',
+      name: '',
+      quantity: new Big(0),
+      type: TypeOfOrder.BUY,
+      unitPrice: unitPriceAtEndDate
+    });
+
+    // Sort orders so that the start and end placeholder order are at the right
+    // position
+    orders = sortBy(orders, (order) => {
+      let sortIndex = new Date(order.date);
+
+      if (order.itemType === 'start') {
+        sortIndex = addMilliseconds(sortIndex, -1);
+      }
+
+      if (order.itemType === 'end') {
+        sortIndex = addMilliseconds(sortIndex, 1);
+      }
+
+      return sortIndex.getTime();
+    });
+
+    const indexOfStartOrder = orders.findIndex((order) => {
+      return order.itemType === 'start';
+    });
+
+    const indexOfEndOrder = orders.findIndex((order) => {
+      return order.itemType === 'end';
+    });
+
+    for (let i = 0; i < orders.length; i += 1) {
+      const order = orders[i];
+
+      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;
+      }
+
+      // Calculate the average start price as soon as any units are held
+      if (
+        averagePriceAtStartDate.eq(0) &&
+        i >= indexOfStartOrder &&
+        totalUnits.gt(0)
+      ) {
+        averagePriceAtStartDate = totalInvestment.div(totalUnits);
+      }
+
+      const valueOfInvestmentBeforeTransaction = totalUnits.mul(
+        order.unitPrice
+      );
+
+      if (!investmentAtStartDate && i >= indexOfStartOrder) {
+        investmentAtStartDate = totalInvestment ?? new Big(0);
+        valueAtStartDate = valueOfInvestmentBeforeTransaction;
+      }
+
+      const transactionInvestment = order.quantity
+        .mul(order.unitPrice)
+        .mul(this.getFactor(order.type));
+
+      totalInvestment = totalInvestment.plus(transactionInvestment);
+
+      if (i >= indexOfStartOrder && totalInvestment.gt(maxTotalInvestment)) {
+        maxTotalInvestment = totalInvestment;
+      }
+
+      if (i === indexOfEndOrder && totalUnits.gt(0)) {
+        averagePriceAtEndDate = totalInvestment.div(totalUnits);
+      }
+
+      if (i >= indexOfStartOrder && !initialValue) {
+        if (
+          i === indexOfStartOrder &&
+          !valueOfInvestmentBeforeTransaction.eq(0)
+        ) {
+          initialValue = valueOfInvestmentBeforeTransaction;
+        } else if (transactionInvestment.gt(0)) {
+          initialValue = transactionInvestment;
+        }
+      }
+
+      fees = fees.plus(order.fee);
+
+      totalUnits = totalUnits.plus(
+        order.quantity.mul(this.getFactor(order.type))
+      );
+
+      const valueOfInvestment = totalUnits.mul(order.unitPrice);
+
+      const grossPerformanceFromSell =
+        order.type === TypeOfOrder.SELL
+          ? order.unitPrice.minus(lastAveragePrice).mul(order.quantity)
+          : new Big(0);
+
+      grossPerformanceFromSells = grossPerformanceFromSells.plus(
+        grossPerformanceFromSell
+      );
+
+      totalInvestmentWithGrossPerformanceFromSell =
+        totalInvestmentWithGrossPerformanceFromSell
+          .plus(transactionInvestment)
+          .plus(grossPerformanceFromSell);
+
+      lastAveragePrice = totalUnits.eq(0)
+        ? new Big(0)
+        : totalInvestmentWithGrossPerformanceFromSell.div(totalUnits);
+
+      const newGrossPerformance = valueOfInvestment
+        .minus(totalInvestmentWithGrossPerformanceFromSell)
+        .plus(grossPerformanceFromSells);
+
+      if (
+        i > indexOfStartOrder &&
+        !lastValueOfInvestmentBeforeTransaction
+          .plus(lastTransactionInvestment)
+          .eq(0)
+      ) {
+        const grossHoldingPeriodReturn = valueOfInvestmentBeforeTransaction
+          .minus(
+            lastValueOfInvestmentBeforeTransaction.plus(
+              lastTransactionInvestment
+            )
+          )
+          .div(
+            lastValueOfInvestmentBeforeTransaction.plus(
+              lastTransactionInvestment
+            )
+          );
+
+        timeWeightedGrossPerformancePercentage =
+          timeWeightedGrossPerformancePercentage.mul(
+            new Big(1).plus(grossHoldingPeriodReturn)
+          );
+
+        const netHoldingPeriodReturn = valueOfInvestmentBeforeTransaction
+          .minus(fees.minus(feesAtStartDate))
+          .minus(
+            lastValueOfInvestmentBeforeTransaction.plus(
+              lastTransactionInvestment
+            )
+          )
+          .div(
+            lastValueOfInvestmentBeforeTransaction.plus(
+              lastTransactionInvestment
+            )
+          );
+
+        timeWeightedNetPerformancePercentage =
+          timeWeightedNetPerformancePercentage.mul(
+            new Big(1).plus(netHoldingPeriodReturn)
+          );
+      }
+
+      grossPerformance = newGrossPerformance;
+
+      lastTransactionInvestment = transactionInvestment;
+
+      lastValueOfInvestmentBeforeTransaction =
+        valueOfInvestmentBeforeTransaction;
+
+      if (order.itemType === 'start') {
+        feesAtStartDate = fees;
+        grossPerformanceAtStartDate = grossPerformance;
+      }
+    }
+
+    timeWeightedGrossPerformancePercentage =
+      timeWeightedGrossPerformancePercentage.minus(1);
+
+    timeWeightedNetPerformancePercentage =
+      timeWeightedNetPerformancePercentage.minus(1);
+
+    const totalGrossPerformance = grossPerformance.minus(
+      grossPerformanceAtStartDate
+    );
+
+    const totalNetPerformance = grossPerformance
+      .minus(grossPerformanceAtStartDate)
+      .minus(fees.minus(feesAtStartDate));
+
+    const maxInvestmentBetweenStartAndEndDate = valueAtStartDate.plus(
+      maxTotalInvestment.minus(investmentAtStartDate)
+    );
+
+    const grossPerformancePercentage =
+      PortfolioCalculatorNew.CALCULATE_PERCENTAGE_PERFORMANCE_WITH_MAX_INVESTMENT ||
+      averagePriceAtStartDate.eq(0) ||
+      averagePriceAtEndDate.eq(0) ||
+      orders[indexOfStartOrder].unitPrice.eq(0)
+        ? maxInvestmentBetweenStartAndEndDate.gt(0)
+          ? totalGrossPerformance.div(maxInvestmentBetweenStartAndEndDate)
+          : new Big(0)
+        : // This formula has the issue that buying more units with a price
+          // lower than the average buying price results in a positive
+          // performance even if the market price stays constant
+          unitPriceAtEndDate
+            .div(averagePriceAtEndDate)
+            .div(
+              orders[indexOfStartOrder].unitPrice.div(averagePriceAtStartDate)
+            )
+            .minus(1);
+
+    const feesPerUnit = totalUnits.gt(0)
+      ? fees.minus(feesAtStartDate).div(totalUnits)
+      : new Big(0);
+
+    const netPerformancePercentage =
+      PortfolioCalculatorNew.CALCULATE_PERCENTAGE_PERFORMANCE_WITH_MAX_INVESTMENT ||
+      averagePriceAtStartDate.eq(0) ||
+      averagePriceAtEndDate.eq(0) ||
+      orders[indexOfStartOrder].unitPrice.eq(0)
+        ? maxInvestmentBetweenStartAndEndDate.gt(0)
+          ? totalNetPerformance.div(maxInvestmentBetweenStartAndEndDate)
+          : new Big(0)
+        : // This formula has the issue that buying more units with a price
+          // lower than the average buying price results in a positive
+          // performance even if the market price stays constant
+          unitPriceAtEndDate
+            .minus(feesPerUnit)
+            .div(averagePriceAtEndDate)
+            .div(
+              orders[indexOfStartOrder].unitPrice.div(averagePriceAtStartDate)
+            )
+            .minus(1);
+
+    if (PortfolioCalculatorNew.ENABLE_LOGGING) {
+      console.log(
+        `
+        ${symbol}
+        Unit price: ${orders[indexOfStartOrder].unitPrice.toFixed(
+          2
+        )} -> ${unitPriceAtEndDate.toFixed(2)}
+        Average price: ${averagePriceAtStartDate.toFixed(
+          2
+        )} -> ${averagePriceAtEndDate.toFixed(2)}
+        Max. total investment: ${maxTotalInvestment.toFixed(2)}
+        Gross performance: ${totalGrossPerformance.toFixed(
+          2
+        )} / ${grossPerformancePercentage.mul(100).toFixed(2)}%
+        Fees per unit: ${feesPerUnit.toFixed(2)}
+        Net performance: ${totalNetPerformance.toFixed(
+          2
+        )} / ${netPerformancePercentage.mul(100).toFixed(2)}%`
+      );
+    }
+
+    return {
+      initialValue,
+      grossPerformancePercentage,
+      netPerformancePercentage,
+      hasErrors: totalUnits.gt(0) && (!initialValue || !unitPriceAtEndDate),
+      netPerformance: totalNetPerformance,
+      grossPerformance: totalGrossPerformance
+    };
+  }
+
   private isNextItemActive(
     timelineSpecification: TimelineSpecification[],
     currentDate: Date,

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

@@ -238,7 +238,10 @@ export class PortfolioCalculator {
         if (!marketSymbolMap[nextDate]?.[item.symbol]) {
           invalidSymbols.push(item.symbol);
           hasErrors = true;
-          Logger.warn(`Missing value for symbol ${item.symbol} at ${nextDate}`);
+          Logger.warn(
+            `Missing value for symbol ${item.symbol} at ${nextDate}`,
+            'PortfolioCalculator'
+          );
           continue;
         }
         let lastInvestment: Big = new Big(0);
@@ -270,7 +273,8 @@ export class PortfolioCalculator {
             invalidSymbols.push(item.symbol);
             hasErrors = true;
             Logger.warn(
-              `Missing value for symbol ${item.symbol} at ${currentDate}`
+              `Missing value for symbol ${item.symbol} at ${currentDate}`,
+              'PortfolioCalculator'
             );
             continue;
           }
@@ -514,7 +518,8 @@ export class PortfolioCalculator {
         );
       } else if (!currentPosition.quantity.eq(0)) {
         Logger.warn(
-          `Missing initial value for symbol ${currentPosition.symbol} at ${currentPosition.firstBuyDate}`
+          `Missing initial value for symbol ${currentPosition.symbol} at ${currentPosition.firstBuyDate}`,
+          'PortfolioCalculator'
         );
         hasErrors = true;
       }
@@ -581,7 +586,8 @@ export class PortfolioCalculator {
         } catch (error) {
           Logger.error(
             `Failed to fetch info for date ${startDate} with exception`,
-            error
+            error,
+            'PortfolioCalculator'
           );
           return null;
         }

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

@@ -13,8 +13,9 @@ export class PortfolioServiceStrategy {
     @Inject(REQUEST) private readonly request: RequestWithUser
   ) {}
 
-  public get() {
+  public get(newCalculationEngine?: boolean) {
     if (
+      newCalculationEngine ||
       this.request.user?.Settings?.settings?.['isNewCalculationEngine'] === true
     ) {
       return this.portfolioServiceNew;

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

@@ -14,7 +14,7 @@ import {
   PortfolioChart,
   PortfolioDetails,
   PortfolioInvestments,
-  PortfolioPerformance,
+  PortfolioPerformanceResponse,
   PortfolioPublicDetails,
   PortfolioReport,
   PortfolioSummary
@@ -33,6 +33,7 @@ import {
 } from '@nestjs/common';
 import { REQUEST } from '@nestjs/core';
 import { AuthGuard } from '@nestjs/passport';
+import { ViewMode } from '@prisma/client';
 import { StatusCodes, getReasonPhrase } from 'http-status-codes';
 
 import { PortfolioPositionDetail } from './interfaces/portfolio-position-detail.interface';
@@ -119,7 +120,7 @@ export class PortfolioController {
 
     const { accounts, holdings, hasErrors } =
       await this.portfolioServiceStrategy
-        .get()
+        .get(true)
         .getDetails(impersonationId, this.request.user.id, range);
 
     if (hasErrors || hasNotDefinedValuesInObject(holdings)) {
@@ -203,16 +204,18 @@ export class PortfolioController {
 
   @Get('performance')
   @UseGuards(AuthGuard('jwt'))
+  @UseInterceptors(TransformDataSourceInResponseInterceptor)
   public async getPerformance(
     @Headers('impersonation-id') impersonationId: string,
     @Query('range') range
-  ): Promise<{ hasErrors: boolean; performance: PortfolioPerformance }> {
+  ): Promise<PortfolioPerformanceResponse> {
     const performanceInformation = await this.portfolioServiceStrategy
       .get()
       .getPerformance(impersonationId, range);
 
     if (
       impersonationId ||
+      this.request.user.Settings.viewMode === ViewMode.ZEN ||
       this.userService.isRestrictedView(this.request.user)
     ) {
       performanceInformation.performance = nullifyValuesInObject(
@@ -274,7 +277,7 @@ export class PortfolioController {
     }
 
     const { holdings } = await this.portfolioServiceStrategy
-      .get()
+      .get(true)
       .getDetails(access.userId, access.userId);
 
     const portfolioPublicDetails: PortfolioPublicDetails = {
@@ -301,6 +304,7 @@ export class PortfolioController {
           allocationCurrent: portfolioPosition.allocationCurrent,
           countries: hasDetails ? portfolioPosition.countries : [],
           currency: portfolioPosition.currency,
+          markets: portfolioPosition.markets,
           name: portfolioPosition.name,
           sectors: hasDetails ? portfolioPosition.sectors : [],
           value: portfolioPosition.value / totalValue
@@ -316,6 +320,16 @@ export class PortfolioController {
   public async getSummary(
     @Headers('impersonation-id') impersonationId
   ): Promise<PortfolioSummary> {
+    if (
+      this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION') &&
+      this.request.user.subscription.type === 'Basic'
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
     let summary = await this.portfolioServiceStrategy
       .get()
       .getSummary(impersonationId);
@@ -331,6 +345,7 @@ export class PortfolioController {
         'currentNetPerformance',
         'currentValue',
         'dividend',
+        'emergencyFund',
         'fees',
         'items',
         'netWorth',
@@ -344,6 +359,7 @@ export class PortfolioController {
 
   @Get('position/:dataSource/:symbol')
   @UseInterceptors(TransformDataSourceInRequestInterceptor)
+  @UseInterceptors(TransformDataSourceInResponseInterceptor)
   @UseGuards(AuthGuard('jwt'))
   public async getPosition(
     @Headers('impersonation-id') impersonationId: string,

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

@@ -20,6 +20,7 @@ import { PortfolioServiceNew } from './portfolio.service-new';
 import { RulesService } from './rules.service';
 
 @Module({
+  controllers: [PortfolioController],
   exports: [PortfolioServiceStrategy],
   imports: [
     AccessModule,
@@ -34,7 +35,6 @@ import { RulesService } from './rules.service';
     SymbolProfileModule,
     UserModule
   ],
-  controllers: [PortfolioController],
   providers: [
     AccountService,
     CurrentRateService,

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

@@ -5,6 +5,8 @@ import { CurrentRateService } from '@ghostfolio/api/app/portfolio/current-rate.s
 import { PortfolioOrder } from '@ghostfolio/api/app/portfolio/interfaces/portfolio-order.interface';
 import { TimelineSpecification } from '@ghostfolio/api/app/portfolio/interfaces/timeline-specification.interface';
 import { TransactionPoint } from '@ghostfolio/api/app/portfolio/interfaces/transaction-point.interface';
+import { UserSettings } from '@ghostfolio/api/app/user/interfaces/user-settings.interface';
+import { UserService } from '@ghostfolio/api/app/user/user.service';
 import { AccountClusterRiskCurrentInvestment } from '@ghostfolio/api/models/rules/account-cluster-risk/current-investment';
 import { AccountClusterRiskInitialInvestment } from '@ghostfolio/api/models/rules/account-cluster-risk/initial-investment';
 import { AccountClusterRiskSingleAccount } from '@ghostfolio/api/models/rules/account-cluster-risk/single-account';
@@ -19,12 +21,16 @@ import { ImpersonationService } from '@ghostfolio/api/services/impersonation.ser
 import { MarketState } from '@ghostfolio/api/services/interfaces/interfaces';
 import { EnhancedSymbolProfile } from '@ghostfolio/api/services/interfaces/symbol-profile.interface';
 import { SymbolProfileService } from '@ghostfolio/api/services/symbol-profile.service';
-import { UNKNOWN_KEY, baseCurrency } from '@ghostfolio/common/config';
+import {
+  ASSET_SUB_CLASS_EMERGENCY_FUND,
+  UNKNOWN_KEY,
+  baseCurrency
+} from '@ghostfolio/common/config';
 import { DATE_FORMAT, parseDate } from '@ghostfolio/common/helper';
 import {
   Accounts,
   PortfolioDetails,
-  PortfolioPerformance,
+  PortfolioPerformanceResponse,
   PortfolioReport,
   PortfolioSummary,
   Position,
@@ -34,6 +40,7 @@ import { InvestmentItem } from '@ghostfolio/common/interfaces/investment-item.in
 import type {
   AccountWithValue,
   DateRange,
+  Market,
   OrderWithAccount,
   RequestWithUser
 } from '@ghostfolio/common/types';
@@ -65,6 +72,9 @@ import {
 import { PortfolioCalculatorNew } from './portfolio-calculator-new';
 import { RulesService } from './rules.service';
 
+const developedMarkets = require('../../assets/countries/developed-markets.json');
+const emergingMarkets = require('../../assets/countries/emerging-markets.json');
+
 @Injectable()
 export class PortfolioServiceNew {
   public constructor(
@@ -76,7 +86,8 @@ export class PortfolioServiceNew {
     private readonly orderService: OrderService,
     @Inject(REQUEST) private readonly request: RequestWithUser,
     private readonly rulesService: RulesService,
-    private readonly symbolProfileService: SymbolProfileService
+    private readonly symbolProfileService: SymbolProfileService,
+    private readonly userService: UserService
   ) {}
 
   public async getAccounts(aUserId: string): Promise<AccountWithValue[]> {
@@ -100,15 +111,22 @@ export class PortfolioServiceNew {
         }
       }
 
+      const valueInBaseCurrency = details.accounts[account.id]?.current ?? 0;
+
       const result = {
         ...account,
         transactionCount,
-        convertedBalance: this.exchangeRateDataService.toCurrency(
+        valueInBaseCurrency,
+        balanceInBaseCurrency: this.exchangeRateDataService.toCurrency(
           account.balance,
           account.currency,
           userCurrency
         ),
-        value: details.accounts[account.id]?.current ?? 0
+        value: this.exchangeRateDataService.toCurrency(
+          valueInBaseCurrency,
+          userCurrency,
+          account.currency
+        )
       };
 
       delete result.Order;
@@ -119,17 +137,26 @@ export class PortfolioServiceNew {
 
   public async getAccountsWithAggregations(aUserId: string): Promise<Accounts> {
     const accounts = await this.getAccounts(aUserId);
-    let totalBalance = 0;
-    let totalValue = 0;
+    let totalBalanceInBaseCurrency = new Big(0);
+    let totalValueInBaseCurrency = new Big(0);
     let transactionCount = 0;
 
     for (const account of accounts) {
-      totalBalance += account.convertedBalance;
-      totalValue += account.value;
+      totalBalanceInBaseCurrency = totalBalanceInBaseCurrency.plus(
+        account.balanceInBaseCurrency
+      );
+      totalValueInBaseCurrency = totalValueInBaseCurrency.plus(
+        account.valueInBaseCurrency
+      );
       transactionCount += account.transactionCount;
     }
 
-    return { accounts, totalBalance, totalValue, transactionCount };
+    return {
+      accounts,
+      transactionCount,
+      totalBalanceInBaseCurrency: totalBalanceInBaseCurrency.toNumber(),
+      totalValueInBaseCurrency: totalValueInBaseCurrency.toNumber()
+    };
   }
 
   public async getInvestments(
@@ -279,8 +306,15 @@ export class PortfolioServiceNew {
     aDateRange: DateRange = 'max'
   ): Promise<PortfolioDetails & { hasErrors: boolean }> {
     const userId = await this.getUserId(aImpersonationId, aUserId);
+    const user = await this.userService.user({ id: userId });
 
-    const userCurrency = this.request.user?.Settings?.currency ?? baseCurrency;
+    const emergencyFund = new Big(
+      (user.Settings?.settings as UserSettings)?.emergencyFund ?? 0
+    );
+    const userCurrency =
+      this.request.user?.Settings?.currency ??
+      user.Settings?.currency ??
+      baseCurrency;
 
     const { orders, portfolioOrders, transactionPoints } =
       await this.getTransactionPoints({
@@ -293,13 +327,11 @@ export class PortfolioServiceNew {
       orders: portfolioOrders
     });
 
-    if (transactionPoints?.length <= 0) {
-      return { accounts: {}, holdings: {}, hasErrors: false };
-    }
-
     portfolioCalculator.setTransactionPoints(transactionPoints);
 
-    const portfolioStart = parseDate(transactionPoints[0].date);
+    const portfolioStart = parseDate(
+      transactionPoints[0]?.date ?? format(new Date(), DATE_FORMAT)
+    );
     const startDate = this.getStartDate(aDateRange, portfolioStart);
     const currentPositions = await portfolioCalculator.getCurrentPositions(
       startDate
@@ -312,9 +344,11 @@ export class PortfolioServiceNew {
 
     const holdings: PortfolioDetails['holdings'] = {};
     const totalInvestment = currentPositions.totalInvestment.plus(
-      cashDetails.balance
+      cashDetails.balanceInBaseCurrency
+    );
+    const totalValue = currentPositions.currentValue.plus(
+      cashDetails.balanceInBaseCurrency
     );
-    const totalValue = currentPositions.currentValue.plus(cashDetails.balance);
 
     const dataGatheringItems = currentPositions.positions.map((position) => {
       return {
@@ -327,7 +361,7 @@ export class PortfolioServiceNew {
     );
 
     const [dataProviderResponses, symbolProfiles] = await Promise.all([
-      this.dataProviderService.get(dataGatheringItems),
+      this.dataProviderService.getQuotes(dataGatheringItems),
       this.symbolProfileService.getSymbolProfiles(symbols)
     ]);
 
@@ -350,7 +384,31 @@ export class PortfolioServiceNew {
       const value = item.quantity.mul(item.marketPrice);
       const symbolProfile = symbolProfileMap[item.symbol];
       const dataProviderResponse = dataProviderResponses[item.symbol];
+
+      const markets: { [key in Market]: number } = {
+        developedMarkets: 0,
+        emergingMarkets: 0,
+        otherMarkets: 0
+      };
+
+      for (const country of symbolProfile.countries) {
+        if (developedMarkets.includes(country.code)) {
+          markets.developedMarkets = new Big(markets.developedMarkets)
+            .plus(country.weight)
+            .toNumber();
+        } else if (emergingMarkets.includes(country.code)) {
+          markets.emergingMarkets = new Big(markets.emergingMarkets)
+            .plus(country.weight)
+            .toNumber();
+        } else {
+          markets.otherMarkets = new Big(markets.otherMarkets)
+            .plus(country.weight)
+            .toNumber();
+        }
+      }
+
       holdings[item.symbol] = {
+        markets,
         allocationCurrent: value.div(totalValue).toNumber(),
         allocationInvestment: item.investment.div(totalInvestment).toNumber(),
         assetClass: symbolProfile.assetClass,
@@ -358,7 +416,6 @@ export class PortfolioServiceNew {
         countries: symbolProfile.countries,
         currency: item.currency,
         dataSource: symbolProfile.dataSource,
-        exchange: dataProviderResponse.exchange,
         grossPerformance: item.grossPerformance?.toNumber() ?? 0,
         grossPerformancePercent:
           item.grossPerformancePercentage?.toNumber() ?? 0,
@@ -378,6 +435,7 @@ export class PortfolioServiceNew {
 
     const cashPositions = await this.getCashPositions({
       cashDetails,
+      emergencyFund,
       userCurrency,
       investment: totalInvestment,
       value: totalValue
@@ -417,7 +475,6 @@ export class PortfolioServiceNew {
     if (orders.length <= 0) {
       return {
         averagePrice: undefined,
-        currency: undefined,
         firstBuyDate: undefined,
         grossPerformance: undefined,
         grossPerformancePercent: undefined,
@@ -426,34 +483,33 @@ export class PortfolioServiceNew {
         marketPrice: undefined,
         maxPrice: undefined,
         minPrice: undefined,
-        name: undefined,
         netPerformance: undefined,
         netPerformancePercent: undefined,
         orders: [],
         quantity: undefined,
-        symbol: aSymbol,
+        SymbolProfile: undefined,
         transactionCount: undefined,
         value: undefined
       };
     }
 
-    const assetClass = orders[0].SymbolProfile?.assetClass;
-    const assetSubClass = orders[0].SymbolProfile?.assetSubClass;
-    const positionCurrency = orders[0].currency;
-    const name = orders[0].SymbolProfile?.name ?? '';
+    const positionCurrency = orders[0].SymbolProfile.currency;
+    const [SymbolProfile] = await this.symbolProfileService.getSymbolProfiles([
+      aSymbol
+    ]);
 
     const portfolioOrders: PortfolioOrder[] = orders
       .filter((order) => {
         return order.type === 'BUY' || order.type === 'SELL';
       })
       .map((order) => ({
-        currency: order.currency,
-        dataSource: order.SymbolProfile?.dataSource ?? order.dataSource,
+        currency: order.SymbolProfile.currency,
+        dataSource: order.SymbolProfile.dataSource,
         date: format(order.date, DATE_FORMAT),
         fee: new Big(order.fee),
         name: order.SymbolProfile?.name,
         quantity: new Big(order.quantity),
-        symbol: order.symbol,
+        symbol: order.SymbolProfile.symbol,
         type: order.type,
         unitPrice: new Big(order.unitPrice)
       }));
@@ -557,18 +613,15 @@ export class PortfolioServiceNew {
       }
 
       return {
-        assetClass,
-        assetSubClass,
-        currency,
         firstBuyDate,
         grossPerformance,
         investment,
         marketPrice,
         maxPrice,
         minPrice,
-        name,
         netPerformance,
         orders,
+        SymbolProfile,
         transactionCount,
         averagePrice: averagePrice.toNumber(),
         grossPerformancePercent:
@@ -576,7 +629,6 @@ export class PortfolioServiceNew {
         historicalData: historicalDataArray,
         netPerformancePercent: position.netPerformancePercentage?.toNumber(),
         quantity: quantity.toNumber(),
-        symbol: aSymbol,
         value: this.exchangeRateDataService.toCurrency(
           quantity.mul(marketPrice).toNumber(),
           currency,
@@ -584,7 +636,7 @@ export class PortfolioServiceNew {
         )
       };
     } else {
-      const currentData = await this.dataProviderService.get([
+      const currentData = await this.dataProviderService.getQuotes([
         { dataSource: DataSource.YAHOO, symbol: aSymbol }
       ]);
       const marketPrice = currentData[aSymbol]?.marketPrice;
@@ -621,15 +673,12 @@ export class PortfolioServiceNew {
       }
 
       return {
-        assetClass,
-        assetSubClass,
         marketPrice,
         maxPrice,
         minPrice,
-        name,
         orders,
+        SymbolProfile,
         averagePrice: 0,
-        currency: currentData[aSymbol]?.currency,
         firstBuyDate: undefined,
         grossPerformance: undefined,
         grossPerformancePercent: undefined,
@@ -638,7 +687,6 @@ export class PortfolioServiceNew {
         netPerformance: undefined,
         netPerformancePercent: undefined,
         quantity: 0,
-        symbol: aSymbol,
         transactionCount: undefined,
         value: 0
       };
@@ -689,7 +737,7 @@ export class PortfolioServiceNew {
     const symbols = positions.map((position) => position.symbol);
 
     const [dataProviderResponses, symbolProfiles] = await Promise.all([
-      this.dataProviderService.get(dataGatheringItem),
+      this.dataProviderService.getQuotes(dataGatheringItem),
       this.symbolProfileService.getSymbolProfiles(symbols)
     ]);
 
@@ -725,7 +773,7 @@ export class PortfolioServiceNew {
   public async getPerformance(
     aImpersonationId: string,
     aDateRange: DateRange = 'max'
-  ): Promise<{ hasErrors: boolean; performance: PortfolioPerformance }> {
+  ): Promise<PortfolioPerformanceResponse> {
     const userId = await this.getUserId(aImpersonationId, this.request.user.id);
 
     const { portfolioOrders, transactionPoints } =
@@ -762,22 +810,33 @@ export class PortfolioServiceNew {
 
     const hasErrors = currentPositions.hasErrors;
     const currentValue = currentPositions.currentValue.toNumber();
-    const currentGrossPerformance =
-      currentPositions.grossPerformance.toNumber();
-    const currentGrossPerformancePercent =
-      currentPositions.grossPerformancePercentage.toNumber();
-    const currentNetPerformance = currentPositions.netPerformance.toNumber();
-    const currentNetPerformancePercent =
-      currentPositions.netPerformancePercentage.toNumber();
+    const currentGrossPerformance = currentPositions.grossPerformance;
+    let currentGrossPerformancePercent =
+      currentPositions.grossPerformancePercentage;
+    const currentNetPerformance = currentPositions.netPerformance;
+    let currentNetPerformancePercent =
+      currentPositions.netPerformancePercentage;
+
+    if (currentGrossPerformance.mul(currentGrossPerformancePercent).lt(0)) {
+      // If algebraic sign is different, harmonize it
+      currentGrossPerformancePercent = currentGrossPerformancePercent.mul(-1);
+    }
+
+    if (currentNetPerformance.mul(currentNetPerformancePercent).lt(0)) {
+      // If algebraic sign is different, harmonize it
+      currentNetPerformancePercent = currentNetPerformancePercent.mul(-1);
+    }
 
     return {
+      errors: currentPositions.errors,
       hasErrors: currentPositions.hasErrors || hasErrors,
       performance: {
-        currentGrossPerformance,
-        currentGrossPerformancePercent,
-        currentNetPerformance,
-        currentNetPerformancePercent,
-        currentValue
+        currentValue,
+        currentGrossPerformance: currentGrossPerformance.toNumber(),
+        currentGrossPerformancePercent:
+          currentGrossPerformancePercent.toNumber(),
+        currentNetPerformance: currentNetPerformance.toNumber(),
+        currentNetPerformancePercent: currentNetPerformancePercent.toNumber()
       }
     };
   }
@@ -877,10 +936,11 @@ export class PortfolioServiceNew {
   public async getSummary(aImpersonationId: string): Promise<PortfolioSummary> {
     const userCurrency = this.request.user.Settings.currency;
     const userId = await this.getUserId(aImpersonationId, this.request.user.id);
+    const user = await this.userService.user({ id: userId });
 
     const performanceInformation = await this.getPerformance(aImpersonationId);
 
-    const { balance } = await this.accountService.getCashDetails(
+    const { balanceInBaseCurrency } = await this.accountService.getCashDetails(
       userId,
       userCurrency
     );
@@ -889,6 +949,9 @@ export class PortfolioServiceNew {
       userId
     });
     const dividend = this.getDividend(orders).toNumber();
+    const emergencyFund = new Big(
+      (user.Settings?.settings as UserSettings)?.emergencyFund ?? 0
+    );
     const fees = this.getFees(orders).toNumber();
     const firstOrderDate = orders[0]?.date;
     const items = this.getItems(orders).toNumber();
@@ -896,9 +959,10 @@ export class PortfolioServiceNew {
     const totalBuy = this.getTotalByType(orders, userCurrency, 'BUY');
     const totalSell = this.getTotalByType(orders, userCurrency, 'SELL');
 
+    const cash = new Big(balanceInBaseCurrency).minus(emergencyFund).toNumber();
     const committedFunds = new Big(totalBuy).minus(totalSell);
 
-    const netWorth = new Big(balance)
+    const netWorth = new Big(balanceInBaseCurrency)
       .plus(performanceInformation.performance.currentValue)
       .plus(items)
       .toNumber();
@@ -921,6 +985,7 @@ export class PortfolioServiceNew {
     return {
       ...performanceInformation.performance,
       annualizedPerformancePercent,
+      cash,
       dividend,
       fees,
       firstOrderDate,
@@ -928,8 +993,8 @@ export class PortfolioServiceNew {
       netWorth,
       totalBuy,
       totalSell,
-      cash: balance,
       committedFunds: committedFunds.toNumber(),
+      emergencyFund: emergencyFund.toNumber(),
       ordersCount: orders.filter((order) => {
         return order.type === 'BUY' || order.type === 'SELL';
       }).length
@@ -938,16 +1003,18 @@ export class PortfolioServiceNew {
 
   private async getCashPositions({
     cashDetails,
+    emergencyFund,
     investment,
     userCurrency,
     value
   }: {
     cashDetails: CashDetails;
+    emergencyFund: Big;
     investment: Big;
     value: Big;
     userCurrency: string;
   }) {
-    const cashPositions = {};
+    const cashPositions: PortfolioDetails['holdings'] = {};
 
     for (const account of cashDetails.accounts) {
       const convertedBalance = this.exchangeRateDataService.toCurrency(
@@ -971,6 +1038,7 @@ export class PortfolioServiceNew {
           assetSubClass: AssetClass.CASH,
           countries: [],
           currency: account.currency,
+          dataSource: undefined,
           grossPerformance: 0,
           grossPerformancePercent: 0,
           investment: convertedBalance,
@@ -988,6 +1056,28 @@ export class PortfolioServiceNew {
       }
     }
 
+    if (emergencyFund.gt(0)) {
+      cashPositions[ASSET_SUB_CLASS_EMERGENCY_FUND] = {
+        ...cashPositions[userCurrency],
+        assetSubClass: ASSET_SUB_CLASS_EMERGENCY_FUND,
+        investment: emergencyFund.toNumber(),
+        name: ASSET_SUB_CLASS_EMERGENCY_FUND,
+        symbol: ASSET_SUB_CLASS_EMERGENCY_FUND,
+        value: emergencyFund.toNumber()
+      };
+
+      cashPositions[userCurrency].investment = new Big(
+        cashPositions[userCurrency].investment
+      )
+        .minus(emergencyFund)
+        .toNumber();
+      cashPositions[userCurrency].value = new Big(
+        cashPositions[userCurrency].value
+      )
+        .minus(emergencyFund)
+        .toNumber();
+    }
+
     for (const symbol of Object.keys(cashPositions)) {
       // Calculate allocations for each currency
       cashPositions[symbol].allocationCurrent = new Big(
@@ -1017,7 +1107,7 @@ export class PortfolioServiceNew {
       .map((order) => {
         return this.exchangeRateDataService.toCurrency(
           new Big(order.quantity).mul(order.unitPrice).toNumber(),
-          order.currency,
+          order.SymbolProfile.currency,
           this.request.user.Settings.currency
         );
       })
@@ -1036,7 +1126,7 @@ export class PortfolioServiceNew {
       .map((order) => {
         return this.exchangeRateDataService.toCurrency(
           order.fee,
-          order.currency,
+          order.SymbolProfile.currency,
           this.request.user.Settings.currency
         );
       })
@@ -1058,7 +1148,7 @@ export class PortfolioServiceNew {
       .map((order) => {
         return this.exchangeRateDataService.toCurrency(
           new Big(order.quantity).mul(order.unitPrice).toNumber(),
-          order.currency,
+          order.SymbolProfile.currency,
           this.request.user.Settings.currency
         );
       })
@@ -1111,24 +1201,24 @@ export class PortfolioServiceNew {
     }
 
     const portfolioOrders: PortfolioOrder[] = orders.map((order) => ({
-      currency: order.currency,
-      dataSource: order.SymbolProfile?.dataSource ?? order.dataSource,
+      currency: order.SymbolProfile.currency,
+      dataSource: order.SymbolProfile.dataSource,
       date: format(order.date, DATE_FORMAT),
       fee: new Big(
         this.exchangeRateDataService.toCurrency(
           order.fee,
-          order.currency,
+          order.SymbolProfile.currency,
           userCurrency
         )
       ),
       name: order.SymbolProfile?.name,
       quantity: new Big(order.quantity),
-      symbol: order.symbol,
+      symbol: order.SymbolProfile.symbol,
       type: order.type,
       unitPrice: new Big(
         this.exchangeRateDataService.toCurrency(
           order.unitPrice,
-          order.currency,
+          order.SymbolProfile.currency,
           userCurrency
         )
       )
@@ -1164,22 +1254,18 @@ export class PortfolioServiceNew {
         return accountId === account.id;
       });
 
-      const convertedBalance = this.exchangeRateDataService.toCurrency(
-        account.balance,
-        account.currency,
-        userCurrency
-      );
       accounts[account.id] = {
-        balance: convertedBalance,
+        balance: account.balance,
         currency: account.currency,
-        current: convertedBalance,
+        current: account.balance,
         name: account.name,
-        original: convertedBalance
+        original: account.balance
       };
 
       for (const order of ordersByAccount) {
         let currentValueOfSymbol =
-          order.quantity * portfolioItemsNow[order.symbol].marketPrice;
+          order.quantity *
+          portfolioItemsNow[order.SymbolProfile.symbol].marketPrice;
         let originalValueOfSymbol = order.quantity * order.unitPrice;
 
         if (order.type === 'SELL') {
@@ -1229,7 +1315,7 @@ export class PortfolioServiceNew {
       .map((order) => {
         return this.exchangeRateDataService.toCurrency(
           order.quantity * order.unitPrice,
-          order.currency,
+          order.SymbolProfile.currency,
           currency
         );
       })

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

@@ -6,6 +6,8 @@ import { PortfolioOrder } from '@ghostfolio/api/app/portfolio/interfaces/portfol
 import { TimelineSpecification } from '@ghostfolio/api/app/portfolio/interfaces/timeline-specification.interface';
 import { TransactionPoint } from '@ghostfolio/api/app/portfolio/interfaces/transaction-point.interface';
 import { PortfolioCalculator } from '@ghostfolio/api/app/portfolio/portfolio-calculator';
+import { UserSettings } from '@ghostfolio/api/app/user/interfaces/user-settings.interface';
+import { UserService } from '@ghostfolio/api/app/user/user.service';
 import { AccountClusterRiskCurrentInvestment } from '@ghostfolio/api/models/rules/account-cluster-risk/current-investment';
 import { AccountClusterRiskInitialInvestment } from '@ghostfolio/api/models/rules/account-cluster-risk/initial-investment';
 import { AccountClusterRiskSingleAccount } from '@ghostfolio/api/models/rules/account-cluster-risk/single-account';
@@ -20,12 +22,16 @@ import { ImpersonationService } from '@ghostfolio/api/services/impersonation.ser
 import { MarketState } from '@ghostfolio/api/services/interfaces/interfaces';
 import { EnhancedSymbolProfile } from '@ghostfolio/api/services/interfaces/symbol-profile.interface';
 import { SymbolProfileService } from '@ghostfolio/api/services/symbol-profile.service';
-import { UNKNOWN_KEY, baseCurrency } from '@ghostfolio/common/config';
+import {
+  ASSET_SUB_CLASS_EMERGENCY_FUND,
+  UNKNOWN_KEY,
+  baseCurrency
+} from '@ghostfolio/common/config';
 import { DATE_FORMAT, parseDate } from '@ghostfolio/common/helper';
 import {
   Accounts,
   PortfolioDetails,
-  PortfolioPerformance,
+  PortfolioPerformanceResponse,
   PortfolioReport,
   PortfolioSummary,
   Position,
@@ -75,7 +81,8 @@ export class PortfolioService {
     private readonly orderService: OrderService,
     @Inject(REQUEST) private readonly request: RequestWithUser,
     private readonly rulesService: RulesService,
-    private readonly symbolProfileService: SymbolProfileService
+    private readonly symbolProfileService: SymbolProfileService,
+    private readonly userService: UserService
   ) {}
 
   public async getAccounts(aUserId: string): Promise<AccountWithValue[]> {
@@ -99,15 +106,22 @@ export class PortfolioService {
         }
       }
 
+      const valueInBaseCurrency = details.accounts[account.id]?.current ?? 0;
+
       const result = {
         ...account,
         transactionCount,
-        convertedBalance: this.exchangeRateDataService.toCurrency(
+        valueInBaseCurrency,
+        balanceInBaseCurrency: this.exchangeRateDataService.toCurrency(
           account.balance,
           account.currency,
           userCurrency
         ),
-        value: details.accounts[account.id]?.current ?? 0
+        value: this.exchangeRateDataService.toCurrency(
+          valueInBaseCurrency,
+          userCurrency,
+          account.currency
+        )
       };
 
       delete result.Order;
@@ -118,17 +132,26 @@ export class PortfolioService {
 
   public async getAccountsWithAggregations(aUserId: string): Promise<Accounts> {
     const accounts = await this.getAccounts(aUserId);
-    let totalBalance = 0;
-    let totalValue = 0;
+    let totalBalanceInBaseCurrency = new Big(0);
+    let totalValueInBaseCurrency = new Big(0);
     let transactionCount = 0;
 
     for (const account of accounts) {
-      totalBalance += account.convertedBalance;
-      totalValue += account.value;
+      totalBalanceInBaseCurrency = totalBalanceInBaseCurrency.plus(
+        account.balanceInBaseCurrency
+      );
+      totalValueInBaseCurrency = totalValueInBaseCurrency.plus(
+        account.valueInBaseCurrency
+      );
       transactionCount += account.transactionCount;
     }
 
-    return { accounts, totalBalance, totalValue, transactionCount };
+    return {
+      accounts,
+      transactionCount,
+      totalBalanceInBaseCurrency: totalBalanceInBaseCurrency.toNumber(),
+      totalValueInBaseCurrency: totalValueInBaseCurrency.toNumber()
+    };
   }
 
   public async getInvestments(
@@ -270,8 +293,15 @@ export class PortfolioService {
     aDateRange: DateRange = 'max'
   ): Promise<PortfolioDetails & { hasErrors: boolean }> {
     const userId = await this.getUserId(aImpersonationId, aUserId);
+    const user = await this.userService.user({ id: userId });
 
-    const userCurrency = this.request.user?.Settings?.currency ?? baseCurrency;
+    const emergencyFund = new Big(
+      (user.Settings?.settings as UserSettings)?.emergencyFund ?? 0
+    );
+    const userCurrency =
+      this.request.user?.Settings?.currency ??
+      user.Settings?.currency ??
+      baseCurrency;
     const portfolioCalculator = new PortfolioCalculator(
       this.currentRateService,
       userCurrency
@@ -281,13 +311,11 @@ export class PortfolioService {
       userId
     });
 
-    if (transactionPoints?.length <= 0) {
-      return { accounts: {}, holdings: {}, hasErrors: false };
-    }
-
     portfolioCalculator.setTransactionPoints(transactionPoints);
 
-    const portfolioStart = parseDate(transactionPoints[0].date);
+    const portfolioStart = parseDate(
+      transactionPoints[0]?.date ?? format(new Date(), DATE_FORMAT)
+    );
     const startDate = this.getStartDate(aDateRange, portfolioStart);
     const currentPositions = await portfolioCalculator.getCurrentPositions(
       startDate
@@ -300,9 +328,11 @@ export class PortfolioService {
 
     const holdings: PortfolioDetails['holdings'] = {};
     const totalInvestment = currentPositions.totalInvestment.plus(
-      cashDetails.balance
+      cashDetails.balanceInBaseCurrency
+    );
+    const totalValue = currentPositions.currentValue.plus(
+      cashDetails.balanceInBaseCurrency
     );
-    const totalValue = currentPositions.currentValue.plus(cashDetails.balance);
 
     const dataGatheringItems = currentPositions.positions.map((position) => {
       return {
@@ -315,7 +345,7 @@ export class PortfolioService {
     );
 
     const [dataProviderResponses, symbolProfiles] = await Promise.all([
-      this.dataProviderService.get(dataGatheringItems),
+      this.dataProviderService.getQuotes(dataGatheringItems),
       this.symbolProfileService.getSymbolProfiles(symbols)
     ]);
 
@@ -346,7 +376,6 @@ export class PortfolioService {
         countries: symbolProfile.countries,
         currency: item.currency,
         dataSource: symbolProfile.dataSource,
-        exchange: dataProviderResponse.exchange,
         grossPerformance: item.grossPerformance?.toNumber() ?? 0,
         grossPerformancePercent:
           item.grossPerformancePercentage?.toNumber() ?? 0,
@@ -366,6 +395,7 @@ export class PortfolioService {
 
     const cashPositions = await this.getCashPositions({
       cashDetails,
+      emergencyFund,
       userCurrency,
       investment: totalInvestment,
       value: totalValue
@@ -405,7 +435,6 @@ export class PortfolioService {
     if (orders.length <= 0) {
       return {
         averagePrice: undefined,
-        currency: undefined,
         firstBuyDate: undefined,
         grossPerformance: undefined,
         grossPerformancePercent: undefined,
@@ -414,34 +443,33 @@ export class PortfolioService {
         marketPrice: undefined,
         maxPrice: undefined,
         minPrice: undefined,
-        name: undefined,
         netPerformance: undefined,
         netPerformancePercent: undefined,
         orders: [],
         quantity: undefined,
-        symbol: aSymbol,
+        SymbolProfile: undefined,
         transactionCount: undefined,
         value: undefined
       };
     }
 
-    const assetClass = orders[0].SymbolProfile?.assetClass;
-    const assetSubClass = orders[0].SymbolProfile?.assetSubClass;
-    const positionCurrency = orders[0].currency;
-    const name = orders[0].SymbolProfile?.name ?? '';
+    const positionCurrency = orders[0].SymbolProfile.currency;
+    const [SymbolProfile] = await this.symbolProfileService.getSymbolProfiles([
+      aSymbol
+    ]);
 
     const portfolioOrders: PortfolioOrder[] = orders
       .filter((order) => {
         return order.type === 'BUY' || order.type === 'SELL';
       })
       .map((order) => ({
-        currency: order.currency,
-        dataSource: order.SymbolProfile?.dataSource ?? order.dataSource,
+        currency: order.SymbolProfile.currency,
+        dataSource: order.SymbolProfile.dataSource,
         date: format(order.date, DATE_FORMAT),
         fee: new Big(order.fee),
         name: order.SymbolProfile?.name,
         quantity: new Big(order.quantity),
-        symbol: order.symbol,
+        symbol: order.SymbolProfile.symbol,
         type: order.type,
         unitPrice: new Big(order.unitPrice)
       }));
@@ -543,25 +571,22 @@ export class PortfolioService {
       }
 
       return {
-        assetClass,
-        assetSubClass,
-        currency,
         firstBuyDate,
         grossPerformance,
         investment,
         marketPrice,
         maxPrice,
         minPrice,
-        name,
         netPerformance,
         orders,
+        SymbolProfile,
         transactionCount,
         averagePrice: averagePrice.toNumber(),
-        grossPerformancePercent: position.grossPerformancePercentage.toNumber(),
+        grossPerformancePercent:
+          position.grossPerformancePercentage?.toNumber(),
         historicalData: historicalDataArray,
-        netPerformancePercent: position.netPerformancePercentage.toNumber(),
+        netPerformancePercent: position.netPerformancePercentage?.toNumber(),
         quantity: quantity.toNumber(),
-        symbol: aSymbol,
         value: this.exchangeRateDataService.toCurrency(
           quantity.mul(marketPrice).toNumber(),
           currency,
@@ -569,7 +594,7 @@ export class PortfolioService {
         )
       };
     } else {
-      const currentData = await this.dataProviderService.get([
+      const currentData = await this.dataProviderService.getQuotes([
         { dataSource: DataSource.YAHOO, symbol: aSymbol }
       ]);
       const marketPrice = currentData[aSymbol]?.marketPrice;
@@ -606,15 +631,12 @@ export class PortfolioService {
       }
 
       return {
-        assetClass,
-        assetSubClass,
         marketPrice,
         maxPrice,
         minPrice,
-        name,
         orders,
+        SymbolProfile,
         averagePrice: 0,
-        currency: currentData[aSymbol]?.currency,
         firstBuyDate: undefined,
         grossPerformance: undefined,
         grossPerformancePercent: undefined,
@@ -623,7 +645,6 @@ export class PortfolioService {
         netPerformance: undefined,
         netPerformancePercent: undefined,
         quantity: 0,
-        symbol: aSymbol,
         transactionCount: undefined,
         value: 0
       };
@@ -670,7 +691,7 @@ export class PortfolioService {
     const symbols = positions.map((position) => position.symbol);
 
     const [dataProviderResponses, symbolProfiles] = await Promise.all([
-      this.dataProviderService.get(dataGatheringItem),
+      this.dataProviderService.getQuotes(dataGatheringItem),
       this.symbolProfileService.getSymbolProfiles(symbols)
     ]);
 
@@ -706,7 +727,7 @@ export class PortfolioService {
   public async getPerformance(
     aImpersonationId: string,
     aDateRange: DateRange = 'max'
-  ): Promise<{ hasErrors: boolean; performance: PortfolioPerformance }> {
+  ): Promise<PortfolioPerformanceResponse> {
     const userId = await this.getUserId(aImpersonationId, this.request.user.id);
 
     const portfolioCalculator = new PortfolioCalculator(
@@ -855,10 +876,11 @@ export class PortfolioService {
   public async getSummary(aImpersonationId: string): Promise<PortfolioSummary> {
     const userCurrency = this.request.user.Settings.currency;
     const userId = await this.getUserId(aImpersonationId, this.request.user.id);
+    const user = await this.userService.user({ id: userId });
 
     const performanceInformation = await this.getPerformance(aImpersonationId);
 
-    const { balance } = await this.accountService.getCashDetails(
+    const { balanceInBaseCurrency } = await this.accountService.getCashDetails(
       userId,
       userCurrency
     );
@@ -867,6 +889,9 @@ export class PortfolioService {
       userId
     });
     const dividend = this.getDividend(orders).toNumber();
+    const emergencyFund = new Big(
+      (user.Settings?.settings as UserSettings)?.emergencyFund ?? 0
+    );
     const fees = this.getFees(orders).toNumber();
     const firstOrderDate = orders[0]?.date;
     const items = this.getItems(orders).toNumber();
@@ -874,15 +899,17 @@ export class PortfolioService {
     const totalBuy = this.getTotalByType(orders, userCurrency, 'BUY');
     const totalSell = this.getTotalByType(orders, userCurrency, 'SELL');
 
+    const cash = new Big(balanceInBaseCurrency).minus(emergencyFund).toNumber();
     const committedFunds = new Big(totalBuy).minus(totalSell);
 
-    const netWorth = new Big(balance)
+    const netWorth = new Big(balanceInBaseCurrency)
       .plus(performanceInformation.performance.currentValue)
       .plus(items)
       .toNumber();
 
     return {
       ...performanceInformation.performance,
+      cash,
       dividend,
       fees,
       firstOrderDate,
@@ -892,8 +919,8 @@ export class PortfolioService {
       totalSell,
       annualizedPerformancePercent:
         performanceInformation.performance.annualizedPerformancePercent,
-      cash: balance,
       committedFunds: committedFunds.toNumber(),
+      emergencyFund: emergencyFund.toNumber(),
       ordersCount: orders.filter((order) => {
         return order.type === 'BUY' || order.type === 'SELL';
       }).length
@@ -902,16 +929,18 @@ export class PortfolioService {
 
   private async getCashPositions({
     cashDetails,
+    emergencyFund,
     investment,
     userCurrency,
     value
   }: {
     cashDetails: CashDetails;
+    emergencyFund: Big;
     investment: Big;
     userCurrency: string;
     value: Big;
   }) {
-    const cashPositions = {};
+    const cashPositions: PortfolioDetails['holdings'] = {};
 
     for (const account of cashDetails.accounts) {
       const convertedBalance = this.exchangeRateDataService.toCurrency(
@@ -935,6 +964,7 @@ export class PortfolioService {
           assetSubClass: AssetClass.CASH,
           countries: [],
           currency: account.currency,
+          dataSource: undefined,
           grossPerformance: 0,
           grossPerformancePercent: 0,
           investment: convertedBalance,
@@ -952,6 +982,28 @@ export class PortfolioService {
       }
     }
 
+    if (emergencyFund.gt(0)) {
+      cashPositions[ASSET_SUB_CLASS_EMERGENCY_FUND] = {
+        ...cashPositions[userCurrency],
+        assetSubClass: ASSET_SUB_CLASS_EMERGENCY_FUND,
+        investment: emergencyFund.toNumber(),
+        name: ASSET_SUB_CLASS_EMERGENCY_FUND,
+        symbol: ASSET_SUB_CLASS_EMERGENCY_FUND,
+        value: emergencyFund.toNumber()
+      };
+
+      cashPositions[userCurrency].investment = new Big(
+        cashPositions[userCurrency].investment
+      )
+        .minus(emergencyFund)
+        .toNumber();
+      cashPositions[userCurrency].value = new Big(
+        cashPositions[userCurrency].value
+      )
+        .minus(emergencyFund)
+        .toNumber();
+    }
+
     for (const symbol of Object.keys(cashPositions)) {
       // Calculate allocations for each currency
       cashPositions[symbol].allocationCurrent = new Big(
@@ -981,7 +1033,7 @@ export class PortfolioService {
       .map((order) => {
         return this.exchangeRateDataService.toCurrency(
           new Big(order.quantity).mul(order.unitPrice).toNumber(),
-          order.currency,
+          order.SymbolProfile.currency,
           this.request.user.Settings.currency
         );
       })
@@ -1000,7 +1052,7 @@ export class PortfolioService {
       .map((order) => {
         return this.exchangeRateDataService.toCurrency(
           order.fee,
-          order.currency,
+          order.SymbolProfile.currency,
           this.request.user.Settings.currency
         );
       })
@@ -1022,7 +1074,7 @@ export class PortfolioService {
       .map((order) => {
         return this.exchangeRateDataService.toCurrency(
           new Big(order.quantity).mul(order.unitPrice).toNumber(),
-          order.currency,
+          order.SymbolProfile.currency,
           this.request.user.Settings.currency
         );
       })
@@ -1074,24 +1126,24 @@ export class PortfolioService {
     }
 
     const portfolioOrders: PortfolioOrder[] = orders.map((order) => ({
-      currency: order.currency,
-      dataSource: order.SymbolProfile?.dataSource ?? order.dataSource,
+      currency: order.SymbolProfile.currency,
+      dataSource: order.SymbolProfile.dataSource,
       date: format(order.date, DATE_FORMAT),
       fee: new Big(
         this.exchangeRateDataService.toCurrency(
           order.fee,
-          order.currency,
+          order.SymbolProfile.currency,
           userCurrency
         )
       ),
       name: order.SymbolProfile?.name,
       quantity: new Big(order.quantity),
-      symbol: order.symbol,
+      symbol: order.SymbolProfile.symbol,
       type: order.type,
       unitPrice: new Big(
         this.exchangeRateDataService.toCurrency(
           order.unitPrice,
-          order.currency,
+          order.SymbolProfile.currency,
           userCurrency
         )
       )
@@ -1123,22 +1175,18 @@ export class PortfolioService {
         return accountId === account.id;
       });
 
-      const convertedBalance = this.exchangeRateDataService.toCurrency(
-        account.balance,
-        account.currency,
-        userCurrency
-      );
       accounts[account.id] = {
-        balance: convertedBalance,
+        balance: account.balance,
         currency: account.currency,
-        current: convertedBalance,
+        current: account.balance,
         name: account.name,
-        original: convertedBalance
+        original: account.balance
       };
 
       for (const order of ordersByAccount) {
         let currentValueOfSymbol =
-          order.quantity * portfolioItemsNow[order.symbol].marketPrice;
+          order.quantity *
+          portfolioItemsNow[order.SymbolProfile.symbol].marketPrice;
         let originalValueOfSymbol = order.quantity * order.unitPrice;
 
         if (order.type === 'SELL') {
@@ -1188,7 +1236,7 @@ export class PortfolioService {
       .map((order) => {
         return this.exchangeRateDataService.toCurrency(
           order.quantity * order.unitPrice,
-          order.currency,
+          order.SymbolProfile.currency,
           currency
         );
       })

apps/api/src/app/redis-cache/redis-cache.module.ts

@@ -1,3 +1,4 @@
+import { ConfigurationModule } from '@ghostfolio/api/services/configuration.module';
 import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
 import { CacheModule, Module } from '@nestjs/common';
 import { ConfigModule, ConfigService } from '@nestjs/config';
@@ -17,9 +18,10 @@ import { RedisCacheService } from './redis-cache.service';
         store: redisStore,
         ttl: configurationService.get('CACHE_TTL')
       })
-    })
+    }),
+    ConfigurationModule
   ],
-  providers: [ConfigurationService, RedisCacheService],
+  providers: [RedisCacheService],
   exports: [RedisCacheService]
 })
 export class RedisCacheModule {}

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

@@ -46,22 +46,25 @@ export class SubscriptionController {
       ((await this.propertyService.getByKey(PROPERTY_COUPONS)) as Coupon[]) ??
       [];
 
-    const isValid = coupons.some((coupon) => {
-      return coupon.code === couponCode;
+    const coupon = coupons.find((currentCoupon) => {
+      return currentCoupon.code === couponCode;
     });
 
-    if (!isValid) {
+    if (coupon === undefined) {
       throw new HttpException(
         getReasonPhrase(StatusCodes.BAD_REQUEST),
         StatusCodes.BAD_REQUEST
       );
     }
 
-    await this.subscriptionService.createSubscription(this.request.user.id);
+    await this.subscriptionService.createSubscription({
+      duration: coupon.duration,
+      userId: this.request.user.id
+    });
 
     // Destroy coupon
-    coupons = coupons.filter((coupon) => {
-      return coupon.code !== couponCode;
+    coupons = coupons.filter((currentCoupon) => {
+      return currentCoupon.code !== couponCode;
     });
     await this.propertyService.put({
       key: PROPERTY_COUPONS,
@@ -69,7 +72,8 @@ export class SubscriptionController {
     });
 
     Logger.log(
-      `Subscription for user '${this.request.user.id}' has been created with coupon`
+      `Subscription for user '${this.request.user.id}' has been created with a coupon for ${coupon.duration}`,
+      'SubscriptionController'
     );
 
     return {
@@ -84,7 +88,10 @@ export class SubscriptionController {
       req.query.checkoutSessionId
     );
 
-    Logger.log(`Subscription for user '${userId}' has been created via Stripe`);
+    Logger.log(
+      `Subscription for user '${userId}' has been created via Stripe`,
+      'SubscriptionController'
+    );
 
     res.redirect(`${this.configurationService.get('ROOT_URL')}/account`);
   }
@@ -101,7 +108,7 @@ export class SubscriptionController {
         userId: this.request.user.id
       });
     } catch (error) {
-      Logger.error(error);
+      Logger.error(error, 'SubscriptionController');
 
       throw new HttpException(
         getReasonPhrase(StatusCodes.BAD_REQUEST),

apps/api/src/app/subscription/subscription.module.ts

@@ -1,5 +1,5 @@
-import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
-import { PrismaService } from '@ghostfolio/api/services/prisma.service';
+import { ConfigurationModule } from '@ghostfolio/api/services/configuration.module';
+import { PrismaModule } from '@ghostfolio/api/services/prisma.module';
 import { PropertyModule } from '@ghostfolio/api/services/property/property.module';
 import { Module } from '@nestjs/common';
 
@@ -7,9 +7,9 @@ import { SubscriptionController } from './subscription.controller';
 import { SubscriptionService } from './subscription.service';
 
 @Module({
-  imports: [PropertyModule],
   controllers: [SubscriptionController],
-  providers: [ConfigurationService, PrismaService, SubscriptionService],
-  exports: [SubscriptionService]
+  exports: [SubscriptionService],
+  imports: [ConfigurationModule, PrismaModule, PropertyModule],
+  providers: [SubscriptionService]
 })
 export class SubscriptionModule {}

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

@@ -2,8 +2,9 @@ import { ConfigurationService } from '@ghostfolio/api/services/configuration.ser
 import { PrismaService } from '@ghostfolio/api/services/prisma.service';
 import { SubscriptionType } from '@ghostfolio/common/types/subscription.type';
 import { Injectable, Logger } from '@nestjs/common';
-import { Subscription, User } from '@prisma/client';
-import { addDays, isBefore } from 'date-fns';
+import { Subscription } from '@prisma/client';
+import { addMilliseconds, isBefore } from 'date-fns';
+import ms, { StringValue } from 'ms';
 import Stripe from 'stripe';
 
 @Injectable()
@@ -44,7 +45,7 @@ export class SubscriptionService {
       payment_method_types: ['card'],
       success_url: `${this.configurationService.get(
         'ROOT_URL'
-      )}/api/subscription/stripe/callback?checkoutSessionId={CHECKOUT_SESSION_ID}`
+      )}/api/v1/subscription/stripe/callback?checkoutSessionId={CHECKOUT_SESSION_ID}`
     };
 
     if (couponId) {
@@ -64,13 +65,19 @@ export class SubscriptionService {
     };
   }
 
-  public async createSubscription(aUserId: string) {
+  public async createSubscription({
+    duration = '1 year',
+    userId
+  }: {
+    duration?: StringValue;
+    userId: string;
+  }) {
     await this.prismaService.subscription.create({
       data: {
-        expiresAt: addDays(new Date(), 365),
+        expiresAt: addMilliseconds(new Date(), ms(duration)),
         User: {
           connect: {
-            id: aUserId
+            id: userId
           }
         }
       }
@@ -83,7 +90,7 @@ export class SubscriptionService {
         aCheckoutSessionId
       );
 
-      await this.createSubscription(session.client_reference_id);
+      await this.createSubscription({ userId: session.client_reference_id });
 
       await this.stripe.customers.update(session.customer as string, {
         description: session.client_reference_id
@@ -91,7 +98,7 @@ export class SubscriptionService {
 
       return session.client_reference_id;
     } catch (error) {
-      Logger.error(error);
+      Logger.error(error, 'SubscriptionService');
     }
   }
 

apps/api/src/app/symbol/symbol.module.ts

@@ -8,13 +8,14 @@ import { SymbolController } from './symbol.controller';
 import { SymbolService } from './symbol.service';
 
 @Module({
+  controllers: [SymbolController],
+  exports: [SymbolService],
   imports: [
     ConfigurationModule,
     DataProviderModule,
     MarketDataModule,
     PrismaModule
   ],
-  controllers: [SymbolController],
   providers: [SymbolService]
 })
 export class SymbolModule {}

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

@@ -27,8 +27,10 @@ export class SymbolService {
     dataGatheringItem: IDataGatheringItem;
     includeHistoricalData?: number;
   }): Promise<SymbolItem> {
-    const response = await this.dataProviderService.get([dataGatheringItem]);
-    const { currency, marketPrice } = response[dataGatheringItem.symbol] ?? {};
+    const quotes = await this.dataProviderService.getQuotes([
+      dataGatheringItem
+    ]);
+    const { currency, marketPrice } = quotes[dataGatheringItem.symbol] ?? {};
 
     if (dataGatheringItem.dataSource && marketPrice) {
       let historicalData: HistoricalDataItem[] = [];
@@ -93,7 +95,7 @@ export class SymbolService {
       results.items = items;
       return results;
     } catch (error) {
-      Logger.error(error);
+      Logger.error(error, 'SymbolService');
 
       throw error;
     }

apps/api/src/app/user/interfaces/user-settings.interface.ts

@@ -1,3 +1,6 @@
 export interface UserSettings {
+  emergencyFund?: number;
+  locale?: string;
+  isNewCalculationEngine?: boolean;
   isRestrictedView?: boolean;
 }

apps/api/src/app/user/update-user-setting.dto.ts

@@ -1,6 +1,10 @@
-import { IsBoolean, IsOptional } from 'class-validator';
+import { IsBoolean, IsNumber, IsOptional, IsString } from 'class-validator';
 
 export class UpdateUserSettingDto {
+  @IsNumber()
+  @IsOptional()
+  emergencyFund?: number;
+
   @IsBoolean()
   @IsOptional()
   isNewCalculationEngine?: boolean;
@@ -8,4 +12,8 @@ export class UpdateUserSettingDto {
   @IsBoolean()
   @IsOptional()
   isRestrictedView?: boolean;
+
+  @IsString()
+  @IsOptional()
+  locale?: string;
 }

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

@@ -2,17 +2,14 @@ import { ConfigurationService } from '@ghostfolio/api/services/configuration.ser
 import { PropertyService } from '@ghostfolio/api/services/property/property.service';
 import { PROPERTY_IS_READ_ONLY_MODE } from '@ghostfolio/common/config';
 import { User } from '@ghostfolio/common/interfaces';
-import {
-  hasPermission,
-  hasRole,
-  permissions
-} from '@ghostfolio/common/permissions';
+import { hasPermission, permissions } from '@ghostfolio/common/permissions';
 import type { RequestWithUser } from '@ghostfolio/common/types';
 import {
   Body,
   Controller,
   Delete,
   Get,
+  Headers,
   HttpException,
   Inject,
   Param,
@@ -23,7 +20,6 @@ import {
 import { REQUEST } from '@nestjs/core';
 import { JwtService } from '@nestjs/jwt';
 import { AuthGuard } from '@nestjs/passport';
-import { Provider, Role } from '@prisma/client';
 import { User as UserModel } from '@prisma/client';
 import { StatusCodes, getReasonPhrase } from 'http-status-codes';
 
@@ -64,8 +60,13 @@ export class UserController {
 
   @Get()
   @UseGuards(AuthGuard('jwt'))
-  public async getUser(@Param('id') id: string): Promise<User> {
-    return this.userService.getUser(this.request.user);
+  public async getUser(
+    @Headers('accept-language') acceptLanguage: string
+  ): Promise<User> {
+    return this.userService.getUser(
+      this.request.user,
+      acceptLanguage?.split(',')?.[0]
+    );
   }
 
   @Post()
@@ -119,7 +120,7 @@ export class UserController {
     };
 
     for (const key in userSettings) {
-      if (userSettings[key] === false) {
+      if (userSettings[key] === false || userSettings[key] === null) {
         delete userSettings[key];
       }
     }

apps/api/src/app/user/user.module.ts

@@ -1,6 +1,6 @@
 import { SubscriptionModule } from '@ghostfolio/api/app/subscription/subscription.module';
-import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
-import { PrismaService } from '@ghostfolio/api/services/prisma.service';
+import { ConfigurationModule } from '@ghostfolio/api/services/configuration.module';
+import { PrismaModule } from '@ghostfolio/api/services/prisma.module';
 import { PropertyModule } from '@ghostfolio/api/services/property/property.module';
 import { Module } from '@nestjs/common';
 import { JwtModule } from '@nestjs/jwt';
@@ -9,16 +9,18 @@ import { UserController } from './user.controller';
 import { UserService } from './user.service';
 
 @Module({
+  controllers: [UserController],
+  exports: [UserService],
   imports: [
+    ConfigurationModule,
     JwtModule.register({
       secret: process.env.JWT_SECRET_KEY,
       signOptions: { expiresIn: '30 days' }
     }),
+    PrismaModule,
     PropertyModule,
     SubscriptionModule
   ],
-  controllers: [UserController],
-  providers: [ConfigurationService, PrismaService, UserService],
-  exports: [UserService]
+  providers: [UserService]
 })
 export class UserModule {}

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

@@ -15,7 +15,7 @@ import {
 } from '@ghostfolio/common/permissions';
 import { SubscriptionType } from '@ghostfolio/common/types/subscription.type';
 import { Injectable } from '@nestjs/common';
-import { Prisma, Provider, Role, User, ViewMode } from '@prisma/client';
+import { Prisma, Role, User, ViewMode } from '@prisma/client';
 
 import { UserSettingsParams } from './interfaces/user-settings-params.interface';
 import { UserSettings } from './interfaces/user-settings.interface';
@@ -33,14 +33,17 @@ export class UserService {
     private readonly subscriptionService: SubscriptionService
   ) {}
 
-  public async getUser({
-    Account,
-    alias,
-    id,
-    permissions,
-    Settings,
-    subscription
-  }: UserWithSettings): Promise<IUser> {
+  public async getUser(
+    {
+      Account,
+      alias,
+      id,
+      permissions,
+      Settings,
+      subscription
+    }: UserWithSettings,
+    aLocale = locale
+  ): Promise<IUser> {
     const access = await this.prismaService.access.findMany({
       include: {
         User: true
@@ -63,8 +66,8 @@ export class UserService {
       accounts: Account,
       settings: {
         ...(<UserSettings>Settings.settings),
-        locale,
         baseCurrency: Settings?.currency ?? UserService.DEFAULT_CURRENCY,
+        locale: (<UserSettings>Settings.settings)?.locale ?? aLocale,
         viewMode: Settings?.viewMode ?? ViewMode.DEFAULT
       }
     };

apps/api/src/assets/countries/developed-markets.json

@@ -0,0 +1,26 @@
+[
+  "AT",
+  "AU",
+  "BE",
+  "CA",
+  "CH",
+  "DE",
+  "DK",
+  "ES",
+  "FI",
+  "FR",
+  "GB",
+  "HK",
+  "IE",
+  "IL",
+  "IT",
+  "JP",
+  "LU",
+  "NL",
+  "NO",
+  "NZ",
+  "PT",
+  "SE",
+  "SG",
+  "US"
+]

apps/api/src/assets/countries/emerging-markets.json

@@ -0,0 +1,28 @@
+[
+  "AE",
+  "BR",
+  "CL",
+  "CN",
+  "CO",
+  "CY",
+  "CZ",
+  "EG",
+  "GR",
+  "HK",
+  "HU",
+  "ID",
+  "IN",
+  "KR",
+  "KW",
+  "MX",
+  "MY",
+  "PE",
+  "PH",
+  "PL",
+  "QA",
+  "SA",
+  "TH",
+  "TR",
+  "TW",
+  "ZA"
+]

apps/api/src/interceptors/transform-data-source-in-response.interceptor.ts

@@ -32,7 +32,6 @@ export class TransformDataSourceInResponseInterceptor<T>
               activity.SymbolProfile.dataSource = encodeDataSource(
                 activity.SymbolProfile.dataSource
               );
-              activity.dataSource = encodeDataSource(activity.dataSource);
               return activity;
             });
           }
@@ -41,6 +40,14 @@ export class TransformDataSourceInResponseInterceptor<T>
             data.dataSource = encodeDataSource(data.dataSource);
           }
 
+          if (data.errors) {
+            for (const error of data.errors) {
+              if (error.dataSource) {
+                error.dataSource = encodeDataSource(error.dataSource);
+              }
+            }
+          }
+
           if (data.holdings) {
             for (const symbol of Object.keys(data.holdings)) {
               if (data.holdings[symbol].dataSource) {
@@ -64,6 +71,12 @@ export class TransformDataSourceInResponseInterceptor<T>
               return position;
             });
           }
+
+          if (data.SymbolProfile) {
+            data.SymbolProfile.dataSource = encodeDataSource(
+              data.SymbolProfile.dataSource
+            );
+          }
         }
 
         return data;

apps/api/src/main.ts

@@ -1,4 +1,4 @@
-import { Logger, ValidationPipe } from '@nestjs/common';
+import { Logger, ValidationPipe, VersioningType } from '@nestjs/common';
 import { NestFactory } from '@nestjs/core';
 
 import { AppModule } from './app/app.module';
@@ -7,8 +7,11 @@ import { environment } from './environments/environment';
 async function bootstrap() {
   const app = await NestFactory.create(AppModule);
   app.enableCors();
-  const globalPrefix = 'api';
-  app.setGlobalPrefix(globalPrefix);
+  app.enableVersioning({
+    defaultVersion: '1',
+    type: VersioningType.URI
+  });
+  app.setGlobalPrefix('api');
   app.useGlobalPipes(
     new ValidationPipe({
       forbidNonWhitelisted: true,

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

@@ -1,10 +1,10 @@
 import { RuleSettings } from '@ghostfolio/api/models/interfaces/rule-settings.interface';
 import { UserSettings } from '@ghostfolio/api/models/interfaces/user-settings.interface';
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data.service';
 import {
   PortfolioDetails,
   PortfolioPosition
 } from '@ghostfolio/common/interfaces';
-import { ExchangeRateDataService } from 'apps/api/src/services/exchange-rate-data.service';
 
 import { Rule } from '../../rule';
 

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

@@ -1,7 +1,7 @@
 import { RuleSettings } from '@ghostfolio/api/models/interfaces/rule-settings.interface';
 import { UserSettings } from '@ghostfolio/api/models/interfaces/user-settings.interface';
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data.service';
 import { PortfolioDetails } from '@ghostfolio/common/interfaces';
-import { ExchangeRateDataService } from 'apps/api/src/services/exchange-rate-data.service';
 
 import { Rule } from '../../rule';
 

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

@@ -1,7 +1,7 @@
 import { CurrentPositions } from '@ghostfolio/api/app/portfolio/interfaces/current-positions.interface';
 import { RuleSettings } from '@ghostfolio/api/models/interfaces/rule-settings.interface';
 import { UserSettings } from '@ghostfolio/api/models/interfaces/user-settings.interface';
-import { ExchangeRateDataService } from 'apps/api/src/services/exchange-rate-data.service';
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data.service';
 
 import { Rule } from '../../rule';
 

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

@@ -1,7 +1,7 @@
 import { CurrentPositions } from '@ghostfolio/api/app/portfolio/interfaces/current-positions.interface';
 import { RuleSettings } from '@ghostfolio/api/models/interfaces/rule-settings.interface';
 import { UserSettings } from '@ghostfolio/api/models/interfaces/user-settings.interface';
-import { ExchangeRateDataService } from 'apps/api/src/services/exchange-rate-data.service';
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data.service';
 
 import { Rule } from '../../rule';
 

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

@@ -1,7 +1,7 @@
 import { CurrentPositions } from '@ghostfolio/api/app/portfolio/interfaces/current-positions.interface';
 import { RuleSettings } from '@ghostfolio/api/models/interfaces/rule-settings.interface';
 import { UserSettings } from '@ghostfolio/api/models/interfaces/user-settings.interface';
-import { ExchangeRateDataService } from 'apps/api/src/services/exchange-rate-data.service';
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data.service';
 
 import { Rule } from '../../rule';
 

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

@@ -1,6 +1,6 @@
 import { RuleSettings } from '@ghostfolio/api/models/interfaces/rule-settings.interface';
 import { UserSettings } from '@ghostfolio/api/models/interfaces/user-settings.interface';
-import { ExchangeRateDataService } from 'apps/api/src/services/exchange-rate-data.service';
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data.service';
 
 import { Rule } from '../../rule';
 

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

@@ -39,6 +39,10 @@ export class ConfigurationService {
       ROOT_URL: str({ default: 'http://localhost:4200' }),
       STRIPE_PUBLIC_KEY: str({ default: '' }),
       STRIPE_SECRET_KEY: str({ default: '' }),
+      TWITTER_ACCESS_TOKEN: str({ default: 'dummyAccessToken' }),
+      TWITTER_ACCESS_TOKEN_SECRET: str({ default: 'dummyAccessTokenSecret' }),
+      TWITTER_API_KEY: str({ default: 'dummyApiKey' }),
+      TWITTER_API_SECRET: str({ default: 'dummyApiSecret' }),
       WEB_AUTH_RP_ID: host({ default: 'localhost' })
     });
   }

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

@@ -3,12 +3,14 @@ import { Cron, CronExpression } from '@nestjs/schedule';
 
 import { DataGatheringService } from './data-gathering.service';
 import { ExchangeRateDataService } from './exchange-rate-data.service';
+import { TwitterBotService } from './twitter-bot/twitter-bot.service';
 
 @Injectable()
 export class CronService {
   public constructor(
     private readonly dataGatheringService: DataGatheringService,
-    private readonly exchangeRateDataService: ExchangeRateDataService
+    private readonly exchangeRateDataService: ExchangeRateDataService,
+    private readonly twitterBotService: TwitterBotService
   ) {}
 
   @Cron(CronExpression.EVERY_MINUTE)
@@ -21,6 +23,11 @@ export class CronService {
     await this.exchangeRateDataService.loadCurrencies();
   }
 
+  @Cron(CronExpression.EVERY_DAY_AT_5PM)
+  public async runEveryDayAtFivePM() {
+    this.twitterBotService.tweetFearAndGreedIndex();
+  }
+
   @Cron(CronExpression.EVERY_WEEKEND)
   public async runEveryWeekend() {
     await this.dataGatheringService.gatherProfileData();

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

@@ -4,6 +4,7 @@ import {
   PROPERTY_LOCKED_DATA_GATHERING
 } from '@ghostfolio/common/config';
 import { DATE_FORMAT, resetHours } from '@ghostfolio/common/helper';
+import { UniqueAsset } from '@ghostfolio/common/interfaces';
 import { Inject, Injectable, Logger } from '@nestjs/common';
 import { DataSource } from '@prisma/client';
 import {
@@ -39,7 +40,7 @@ export class DataGatheringService {
     const isDataGatheringNeeded = await this.isDataGatheringNeeded();
 
     if (isDataGatheringNeeded) {
-      Logger.log('7d data gathering has been started.');
+      Logger.log('7d data gathering has been started.', 'DataGatheringService');
       console.time('data-gathering-7d');
 
       await this.prismaService.property.create({
@@ -63,7 +64,7 @@ export class DataGatheringService {
           where: { key: PROPERTY_LAST_DATA_GATHERING }
         });
       } catch (error) {
-        Logger.error(error);
+        Logger.error(error, 'DataGatheringService');
       }
 
       await this.prismaService.property.delete({
@@ -72,7 +73,10 @@ export class DataGatheringService {
         }
       });
 
-      Logger.log('7d data gathering has been completed.');
+      Logger.log(
+        '7d data gathering has been completed.',
+        'DataGatheringService'
+      );
       console.timeEnd('data-gathering-7d');
     }
   }
@@ -83,7 +87,10 @@ export class DataGatheringService {
     });
 
     if (!isDataGatheringLocked) {
-      Logger.log('Max data gathering has been started.');
+      Logger.log(
+        'Max data gathering has been started.',
+        'DataGatheringService'
+      );
       console.time('data-gathering-max');
 
       await this.prismaService.property.create({
@@ -107,7 +114,7 @@ export class DataGatheringService {
           where: { key: PROPERTY_LAST_DATA_GATHERING }
         });
       } catch (error) {
-        Logger.error(error);
+        Logger.error(error, 'DataGatheringService');
       }
 
       await this.prismaService.property.delete({
@@ -116,24 +123,24 @@ export class DataGatheringService {
         }
       });
 
-      Logger.log('Max data gathering has been completed.');
+      Logger.log(
+        'Max data gathering has been completed.',
+        'DataGatheringService'
+      );
       console.timeEnd('data-gathering-max');
     }
   }
 
-  public async gatherSymbol({
-    dataSource,
-    symbol
-  }: {
-    dataSource: DataSource;
-    symbol: string;
-  }) {
+  public async gatherSymbol({ dataSource, symbol }: UniqueAsset) {
     const isDataGatheringLocked = await this.prismaService.property.findUnique({
       where: { key: PROPERTY_LOCKED_DATA_GATHERING }
     });
 
     if (!isDataGatheringLocked) {
-      Logger.log(`Symbol data gathering for ${symbol} has been started.`);
+      Logger.log(
+        `Symbol data gathering for ${symbol} has been started.`,
+        'DataGatheringService'
+      );
       console.time('data-gathering-symbol');
 
       await this.prismaService.property.create({
@@ -164,7 +171,7 @@ export class DataGatheringService {
           where: { key: PROPERTY_LAST_DATA_GATHERING }
         });
       } catch (error) {
-        Logger.error(error);
+        Logger.error(error, 'DataGatheringService');
       }
 
       await this.prismaService.property.delete({
@@ -173,7 +180,10 @@ export class DataGatheringService {
         }
       });
 
-      Logger.log(`Symbol data gathering for ${symbol} has been completed.`);
+      Logger.log(
+        `Symbol data gathering for ${symbol} has been completed.`,
+        'DataGatheringService'
+      );
       console.timeEnd('data-gathering-symbol');
     }
   }
@@ -210,42 +220,55 @@ export class DataGatheringService {
         });
       }
     } catch (error) {
-      Logger.error(error);
+      Logger.error(error, 'DataGatheringService');
     } finally {
       return undefined;
     }
   }
 
   public async gatherProfileData(aDataGatheringItems?: IDataGatheringItem[]) {
-    Logger.log('Profile data gathering has been started.');
+    Logger.log(
+      'Profile data gathering has been started.',
+      'DataGatheringService'
+    );
     console.time('data-gathering-profile');
 
-    let dataGatheringItems = aDataGatheringItems;
+    let dataGatheringItems = aDataGatheringItems?.filter(
+      (dataGatheringItem) => {
+        return dataGatheringItem.dataSource !== 'MANUAL';
+      }
+    );
 
     if (!dataGatheringItems) {
       dataGatheringItems = await this.getSymbolsProfileData();
     }
 
-    const currentData = await this.dataProviderService.get(dataGatheringItems);
+    const assetProfiles = await this.dataProviderService.getAssetProfiles(
+      dataGatheringItems
+    );
     const symbolProfiles = await this.symbolProfileService.getSymbolProfiles(
       dataGatheringItems.map(({ symbol }) => {
         return symbol;
       })
     );
 
-    for (const [symbol, response] of Object.entries(currentData)) {
+    for (const [symbol, assetProfile] of Object.entries(assetProfiles)) {
       const symbolMapping = symbolProfiles.find((symbolProfile) => {
         return symbolProfile.symbol === symbol;
       })?.symbolMapping;
 
       for (const dataEnhancer of this.dataEnhancers) {
         try {
-          currentData[symbol] = await dataEnhancer.enhance({
-            response,
+          assetProfiles[symbol] = await dataEnhancer.enhance({
+            response: assetProfile,
             symbol: symbolMapping?.[dataEnhancer.getName()] ?? symbol
           });
         } catch (error) {
-          Logger.error(`Failed to enhance data for symbol ${symbol}`, error);
+          Logger.error(
+            `Failed to enhance data for symbol ${symbol} by ${dataEnhancer.getName()}`,
+            error,
+            'DataGatheringService'
+          );
         }
       }
 
@@ -256,8 +279,9 @@ export class DataGatheringService {
         currency,
         dataSource,
         name,
-        sectors
-      } = currentData[symbol];
+        sectors,
+        url
+      } = assetProfiles[symbol];
 
       try {
         await this.prismaService.symbolProfile.upsert({
@@ -269,7 +293,8 @@ export class DataGatheringService {
             dataSource,
             name,
             sectors,
-            symbol
+            symbol,
+            url
           },
           update: {
             assetClass,
@@ -277,7 +302,8 @@ export class DataGatheringService {
             countries,
             currency,
             name,
-            sectors
+            sectors,
+            url
           },
           where: {
             dataSource_symbol: {
@@ -287,11 +313,18 @@ export class DataGatheringService {
           }
         });
       } catch (error) {
-        Logger.error(`${symbol}: ${error?.meta?.cause}`);
+        Logger.error(
+          `${symbol}: ${error?.meta?.cause}`,
+          error,
+          'DataGatheringService'
+        );
       }
     }
 
-    Logger.log('Profile data gathering has been completed.');
+    Logger.log(
+      'Profile data gathering has been completed.',
+      'DataGatheringService'
+    );
     console.timeEnd('data-gathering-profile');
   }
 
@@ -300,6 +333,10 @@ export class DataGatheringService {
     let symbolCounter = 0;
 
     for (const { dataSource, date, symbol } of aSymbolsWithStartDate) {
+      if (dataSource === 'MANUAL') {
+        continue;
+      }
+
       this.dataGatheringProgress = symbolCounter / aSymbolsWithStartDate.length;
 
       try {
@@ -347,10 +384,11 @@ export class DataGatheringService {
             } catch {}
           } else {
             Logger.warn(
-              `Failed to gather data for symbol ${symbol} at ${format(
+              `Failed to gather data for symbol ${symbol} from ${dataSource} at ${format(
                 currentDate,
                 DATE_FORMAT
-              )}.`
+              )}.`,
+              'DataGatheringService'
             );
           }
 
@@ -366,14 +404,15 @@ export class DataGatheringService {
         }
       } catch (error) {
         hasError = true;
-        Logger.error(error);
+        Logger.error(error, 'DataGatheringService');
       }
 
       if (symbolCounter > 0 && symbolCounter % 100 === 0) {
         Logger.log(
           `Data gathering progress: ${(
             this.dataGatheringProgress * 100
-          ).toFixed(2)}%`
+          ).toFixed(2)}%`,
+          'DataGatheringService'
         );
       }
 
@@ -463,7 +502,7 @@ export class DataGatheringService {
   }
 
   public async reset() {
-    Logger.log('Data gathering has been reset.');
+    Logger.log('Data gathering has been reset.', 'DataGatheringService');
 
     await this.prismaService.property.deleteMany({
       where: {
@@ -538,19 +577,24 @@ export class DataGatheringService {
   }
 
   private async getSymbolsProfileData(): Promise<IDataGatheringItem[]> {
-    const distinctOrders = await this.prismaService.order.findMany({
-      distinct: ['symbol'],
-      orderBy: [{ symbol: 'asc' }],
-      select: { dataSource: true, symbol: true }
+    const symbolProfiles = await this.prismaService.symbolProfile.findMany({
+      orderBy: [{ symbol: 'asc' }]
     });
 
-    return distinctOrders.filter((distinctOrder) => {
-      return (
-        distinctOrder.dataSource !== DataSource.GHOSTFOLIO &&
-        distinctOrder.dataSource !== DataSource.MANUAL &&
-        distinctOrder.dataSource !== DataSource.RAKUTEN
-      );
-    });
+    return symbolProfiles
+      .filter((symbolProfile) => {
+        return (
+          symbolProfile.dataSource !== DataSource.GHOSTFOLIO &&
+          symbolProfile.dataSource !== DataSource.MANUAL &&
+          symbolProfile.dataSource !== DataSource.RAKUTEN
+        );
+      })
+      .map((symbolProfile) => {
+        return {
+          dataSource: symbolProfile.dataSource,
+          symbol: symbolProfile.symbol
+        };
+      });
   }
 
   private async isDataGatheringNeeded() {

apps/api/src/services/data-provider/alpha-vantage/alpha-vantage.service.ts

@@ -1,16 +1,16 @@
 import { LookupItem } from '@ghostfolio/api/app/symbol/interfaces/lookup-item.interface';
 import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
-import { DATE_FORMAT } from '@ghostfolio/common/helper';
-import { Granularity } from '@ghostfolio/common/types';
-import { Injectable, Logger } from '@nestjs/common';
-import { DataSource } from '@prisma/client';
-import { isAfter, isBefore, parse } from 'date-fns';
-
+import { DataProviderInterface } from '@ghostfolio/api/services/data-provider/interfaces/data-provider.interface';
 import {
   IDataProviderHistoricalResponse,
   IDataProviderResponse
-} from '../../interfaces/interfaces';
-import { DataProviderInterface } from '../interfaces/data-provider.interface';
+} from '@ghostfolio/api/services/interfaces/interfaces';
+import { DATE_FORMAT } from '@ghostfolio/common/helper';
+import { Granularity } from '@ghostfolio/common/types';
+import { Injectable, Logger } from '@nestjs/common';
+import { DataSource, SymbolProfile } from '@prisma/client';
+import { isAfter, isBefore, parse } from 'date-fns';
+
 import { IAlphaVantageHistoricalResponse } from './interfaces/interfaces';
 
 @Injectable()
@@ -29,25 +29,23 @@ export class AlphaVantageService implements DataProviderInterface {
     return !!this.configurationService.get('ALPHA_VANTAGE_API_KEY');
   }
 
-  public async get(
-    aSymbols: string[]
-  ): Promise<{ [symbol: string]: IDataProviderResponse }> {
-    return {};
+  public async getAssetProfile(
+    aSymbol: string
+  ): Promise<Partial<SymbolProfile>> {
+    return {
+      dataSource: this.getName()
+    };
   }
 
   public async getHistorical(
-    aSymbols: string[],
+    aSymbol: string,
     aGranularity: Granularity = 'day',
     from: Date,
     to: Date
   ): Promise<{
     [symbol: string]: { [date: string]: IDataProviderHistoricalResponse };
   }> {
-    if (aSymbols.length <= 0) {
-      return {};
-    }
-
-    const symbol = aSymbols[0];
+    const symbol = aSymbol;
 
     try {
       const historicalData: {
@@ -78,7 +76,7 @@ export class AlphaVantageService implements DataProviderInterface {
 
       return response;
     } catch (error) {
-      Logger.error(error, symbol);
+      Logger.error(error, 'AlphaVantageService');
 
       return {};
     }
@@ -88,6 +86,12 @@ export class AlphaVantageService implements DataProviderInterface {
     return DataSource.ALPHA_VANTAGE;
   }
 
+  public async getQuotes(
+    aSymbols: string[]
+  ): Promise<{ [symbol: string]: IDataProviderResponse }> {
+    return {};
+  }
+
   public async search(aQuery: string): Promise<{ items: LookupItem[] }> {
     const result = await this.alphaVantage.data.search(aQuery);
 

apps/api/src/services/data-provider/data-enhancer/trackinsight/trackinsight.service.ts

@@ -1,5 +1,7 @@
 import { DataEnhancerInterface } from '@ghostfolio/api/services/data-provider/interfaces/data-enhancer.interface';
-import { IDataProviderResponse } from '@ghostfolio/api/services/interfaces/interfaces';
+import { Country } from '@ghostfolio/common/interfaces/country.interface';
+import { Sector } from '@ghostfolio/common/interfaces/sector.interface';
+import { SymbolProfile } from '@prisma/client';
 import bent from 'bent';
 
 const getJSON = bent('json');
@@ -21,9 +23,9 @@ export class TrackinsightDataEnhancerService implements DataEnhancerInterface {
     response,
     symbol
   }: {
-    response: IDataProviderResponse;
+    response: Partial<SymbolProfile>;
     symbol: string;
-  }): Promise<IDataProviderResponse> {
+  }): Promise<Partial<SymbolProfile>> {
     if (
       !(response.assetClass === 'EQUITY' && response.assetSubClass === 'ETF')
     ) {
@@ -40,7 +42,10 @@ export class TrackinsightDataEnhancerService implements DataEnhancerInterface {
       );
     });
 
-    if (!response.countries || response.countries.length === 0) {
+    if (
+      !response.countries ||
+      (response.countries as unknown as Country[]).length === 0
+    ) {
       response.countries = [];
       for (const [name, value] of Object.entries<any>(holdings.countries)) {
         let countryCode: string;
@@ -65,7 +70,10 @@ export class TrackinsightDataEnhancerService implements DataEnhancerInterface {
       }
     }
 
-    if (!response.sectors || response.sectors.length === 0) {
+    if (
+      !response.sectors ||
+      (response.sectors as unknown as Sector[]).length === 0
+    ) {
       response.sectors = [];
       for (const [name, value] of Object.entries<any>(holdings.sectors)) {
         response.sectors.push({

apps/api/src/services/data-provider/data-provider.service.ts

@@ -10,7 +10,7 @@ import { PrismaService } from '@ghostfolio/api/services/prisma.service';
 import { DATE_FORMAT } from '@ghostfolio/common/helper';
 import { Granularity } from '@ghostfolio/common/types';
 import { Inject, Injectable, Logger } from '@nestjs/common';
-import { DataSource, MarketData } from '@prisma/client';
+import { DataSource, MarketData, SymbolProfile } from '@prisma/client';
 import { format, isValid } from 'date-fns';
 import { groupBy, isEmpty } from 'lodash';
 
@@ -23,42 +23,6 @@ export class DataProviderService {
     private readonly prismaService: PrismaService
   ) {}
 
-  public async get(items: IDataGatheringItem[]): Promise<{
-    [symbol: string]: IDataProviderResponse;
-  }> {
-    const response: {
-      [symbol: string]: IDataProviderResponse;
-    } = {};
-
-    const itemsGroupedByDataSource = groupBy(items, (item) => item.dataSource);
-
-    const promises = [];
-
-    for (const [dataSource, dataGatheringItems] of Object.entries(
-      itemsGroupedByDataSource
-    )) {
-      const symbols = dataGatheringItems.map((dataGatheringItem) => {
-        return dataGatheringItem.symbol;
-      });
-
-      const promise = Promise.resolve(
-        this.getDataProvider(DataSource[dataSource]).get(symbols)
-      );
-
-      promises.push(
-        promise.then((result) => {
-          for (const [symbol, dataProviderResponse] of Object.entries(result)) {
-            response[symbol] = dataProviderResponse;
-          }
-        })
-      );
-    }
-
-    await Promise.all(promises);
-
-    return response;
-  }
-
   public async getHistorical(
     aItems: IDataGatheringItem[],
     aGranularity: Granularity = 'month',
@@ -118,7 +82,7 @@ export class DataProviderService {
         return r;
       }, {});
     } catch (error) {
-      Logger.error(error);
+      Logger.error(error, 'DataProviderService');
     } finally {
       return response;
     }
@@ -144,7 +108,7 @@ export class DataProviderService {
       if (dataProvider.canHandle(symbol)) {
         promises.push(
           dataProvider
-            .getHistorical([symbol], undefined, from, to)
+            .getHistorical(symbol, undefined, from, to)
             .then((data) => ({ data: data?.[symbol], symbol }))
         );
       }
@@ -158,6 +122,82 @@ export class DataProviderService {
     return result;
   }
 
+  public getPrimaryDataSource(): DataSource {
+    return DataSource[this.configurationService.get('DATA_SOURCE_PRIMARY')];
+  }
+
+  public async getAssetProfiles(items: IDataGatheringItem[]): Promise<{
+    [symbol: string]: Partial<SymbolProfile>;
+  }> {
+    const response: {
+      [symbol: string]: Partial<SymbolProfile>;
+    } = {};
+
+    const itemsGroupedByDataSource = groupBy(items, (item) => item.dataSource);
+
+    const promises = [];
+
+    for (const [dataSource, dataGatheringItems] of Object.entries(
+      itemsGroupedByDataSource
+    )) {
+      const symbols = dataGatheringItems.map((dataGatheringItem) => {
+        return dataGatheringItem.symbol;
+      });
+
+      for (const symbol of symbols) {
+        const promise = Promise.resolve(
+          this.getDataProvider(DataSource[dataSource]).getAssetProfile(symbol)
+        );
+
+        promises.push(
+          promise.then((symbolProfile) => {
+            response[symbol] = symbolProfile;
+          })
+        );
+      }
+    }
+
+    await Promise.all(promises);
+
+    return response;
+  }
+
+  public async getQuotes(items: IDataGatheringItem[]): Promise<{
+    [symbol: string]: IDataProviderResponse;
+  }> {
+    const response: {
+      [symbol: string]: IDataProviderResponse;
+    } = {};
+
+    const itemsGroupedByDataSource = groupBy(items, (item) => item.dataSource);
+
+    const promises = [];
+
+    for (const [dataSource, dataGatheringItems] of Object.entries(
+      itemsGroupedByDataSource
+    )) {
+      const symbols = dataGatheringItems.map((dataGatheringItem) => {
+        return dataGatheringItem.symbol;
+      });
+
+      const promise = Promise.resolve(
+        this.getDataProvider(DataSource[dataSource]).getQuotes(symbols)
+      );
+
+      promises.push(
+        promise.then((result) => {
+          for (const [symbol, dataProviderResponse] of Object.entries(result)) {
+            response[symbol] = dataProviderResponse;
+          }
+        })
+      );
+    }
+
+    await Promise.all(promises);
+
+    return response;
+  }
+
   public async search(aQuery: string): Promise<{ items: LookupItem[] }> {
     const promises: Promise<{ items: LookupItem[] }>[] = [];
     let lookupItems: LookupItem[] = [];
@@ -184,10 +224,6 @@ export class DataProviderService {
     };
   }
 
-  public getPrimaryDataSource(): DataSource {
-    return DataSource[this.configurationService.get('DATA_SOURCE_PRIMARY')];
-  }
-
   private getDataProvider(providerName: DataSource) {
     for (const dataProviderInterface of this.dataProviderInterfaces) {
       if (dataProviderInterface.getName() === providerName) {

apps/api/src/services/data-provider/ghostfolio-scraper-api/ghostfolio-scraper-api.service.ts

@@ -7,17 +7,13 @@ import {
 } from '@ghostfolio/api/services/interfaces/interfaces';
 import { PrismaService } from '@ghostfolio/api/services/prisma.service';
 import { SymbolProfileService } from '@ghostfolio/api/services/symbol-profile.service';
-import {
-  DATE_FORMAT,
-  getYesterday,
-  isGhostfolioScraperApiSymbol
-} from '@ghostfolio/common/helper';
+import { DATE_FORMAT, getYesterday } from '@ghostfolio/common/helper';
 import { Granularity } from '@ghostfolio/common/types';
 import { Injectable, Logger } from '@nestjs/common';
-import { DataSource } from '@prisma/client';
+import { DataSource, SymbolProfile } from '@prisma/client';
 import * as bent from 'bent';
 import * as cheerio from 'cheerio';
-import { format } from 'date-fns';
+import { addDays, format, isBefore } from 'date-fns';
 
 @Injectable()
 export class GhostfolioScraperApiService implements DataProviderInterface {
@@ -29,73 +25,61 @@ export class GhostfolioScraperApiService implements DataProviderInterface {
   ) {}
 
   public canHandle(symbol: string) {
-    return isGhostfolioScraperApiSymbol(symbol);
+    return true;
   }
 
-  public async get(
-    aSymbols: string[]
-  ): Promise<{ [symbol: string]: IDataProviderResponse }> {
-    if (aSymbols.length <= 0) {
-      return {};
-    }
-
-    try {
-      const [symbol] = aSymbols;
-      const [symbolProfile] = await this.symbolProfileService.getSymbolProfiles(
-        [symbol]
-      );
-
-      const { marketPrice } = await this.prismaService.marketData.findFirst({
-        orderBy: {
-          date: 'desc'
-        },
-        where: {
-          symbol
-        }
-      });
-
-      return {
-        [symbol]: {
-          marketPrice,
-          currency: symbolProfile?.currency,
-          dataSource: this.getName(),
-          marketState: MarketState.delayed
-        }
-      };
-    } catch (error) {
-      Logger.error(error);
-    }
-
-    return {};
+  public async getAssetProfile(
+    aSymbol: string
+  ): Promise<Partial<SymbolProfile>> {
+    return {
+      dataSource: this.getName()
+    };
   }
 
   public async getHistorical(
-    aSymbols: string[],
+    aSymbol: string,
     aGranularity: Granularity = 'day',
     from: Date,
     to: Date
   ): Promise<{
     [symbol: string]: { [date: string]: IDataProviderHistoricalResponse };
   }> {
-    if (aSymbols.length <= 0) {
-      return {};
-    }
-
     try {
-      const [symbol] = aSymbols;
+      const symbol = aSymbol;
+
       const [symbolProfile] = await this.symbolProfileService.getSymbolProfiles(
         [symbol]
       );
-      const scraperConfiguration = symbolProfile?.scraperConfiguration;
+      const { defaultMarketPrice, selector, url } =
+        symbolProfile.scraperConfiguration;
 
-      const get = bent(scraperConfiguration?.url, 'GET', 'string', 200, {});
+      if (defaultMarketPrice) {
+        const historical: {
+          [symbol: string]: { [date: string]: IDataProviderHistoricalResponse };
+        } = {
+          [symbol]: {}
+        };
+        let date = from;
+
+        while (isBefore(date, to)) {
+          historical[symbol][format(date, DATE_FORMAT)] = {
+            marketPrice: defaultMarketPrice
+          };
+
+          date = addDays(date, 1);
+        }
+
+        return historical;
+      } else if (selector === undefined || url === undefined) {
+        return {};
+      }
+
+      const get = bent(url, 'GET', 'string', 200, {});
 
       const html = await get();
       const $ = cheerio.load(html);
 
-      const value = this.extractNumberFromString(
-        $(scraperConfiguration?.selector).text()
-      );
+      const value = this.extractNumberFromString($(selector).text());
 
       return {
         [symbol]: {
@@ -105,7 +89,7 @@ export class GhostfolioScraperApiService implements DataProviderInterface {
         }
       };
     } catch (error) {
-      Logger.error(error);
+      Logger.error(error, 'GhostfolioScraperApiService');
     }
 
     return {};
@@ -115,6 +99,52 @@ export class GhostfolioScraperApiService implements DataProviderInterface {
     return DataSource.GHOSTFOLIO;
   }
 
+  public async getQuotes(
+    aSymbols: string[]
+  ): Promise<{ [symbol: string]: IDataProviderResponse }> {
+    const response: { [symbol: string]: IDataProviderResponse } = {};
+
+    if (aSymbols.length <= 0) {
+      return response;
+    }
+
+    try {
+      const symbolProfiles = await this.symbolProfileService.getSymbolProfiles(
+        aSymbols
+      );
+
+      const marketData = await this.prismaService.marketData.findMany({
+        distinct: ['symbol'],
+        orderBy: {
+          date: 'desc'
+        },
+        take: aSymbols.length,
+        where: {
+          symbol: {
+            in: aSymbols
+          }
+        }
+      });
+
+      for (const symbolProfile of symbolProfiles) {
+        response[symbolProfile.symbol] = {
+          currency: symbolProfile.currency,
+          dataSource: this.getName(),
+          marketPrice: marketData.find((marketDataItem) => {
+            return marketDataItem.symbol === symbolProfile.symbol;
+          }).marketPrice,
+          marketState: MarketState.delayed
+        };
+      }
+
+      return response;
+    } catch (error) {
+      Logger.error(error, 'GhostfolioScraperApiService');
+    }
+
+    return {};
+  }
+
   public async search(aQuery: string): Promise<{ items: LookupItem[] }> {
     const items = await this.prismaService.symbolProfile.findMany({
       select: {

apps/api/src/services/data-provider/ghostfolio-scraper-api/interfaces/scraper-configuration.interface.ts

@@ -1,4 +1,5 @@
 export interface ScraperConfiguration {
+  defaultMarketPrice?: number;
   selector: string;
   url: string;
 }

apps/api/src/services/data-provider/google-sheets/google-sheets.service.ts

@@ -11,7 +11,7 @@ import { SymbolProfileService } from '@ghostfolio/api/services/symbol-profile.se
 import { DATE_FORMAT, parseDate } from '@ghostfolio/common/helper';
 import { Granularity } from '@ghostfolio/common/types';
 import { Injectable, Logger } from '@nestjs/common';
-import { DataSource } from '@prisma/client';
+import { DataSource, SymbolProfile } from '@prisma/client';
 import { format } from 'date-fns';
 import { GoogleSpreadsheet } from 'google-spreadsheet';
 
@@ -27,7 +27,62 @@ export class GoogleSheetsService implements DataProviderInterface {
     return true;
   }
 
-  public async get(
+  public async getAssetProfile(
+    aSymbol: string
+  ): Promise<Partial<SymbolProfile>> {
+    return {
+      dataSource: this.getName()
+    };
+  }
+
+  public async getHistorical(
+    aSymbol: string,
+    aGranularity: Granularity = 'day',
+    from: Date,
+    to: Date
+  ): Promise<{
+    [symbol: string]: { [date: string]: IDataProviderHistoricalResponse };
+  }> {
+    try {
+      const symbol = aSymbol;
+
+      const sheet = await this.getSheet({
+        symbol,
+        sheetId: this.configurationService.get('GOOGLE_SHEETS_ID')
+      });
+
+      const rows = await sheet.getRows();
+
+      const historicalData: {
+        [date: string]: IDataProviderHistoricalResponse;
+      } = {};
+
+      rows
+        .filter((row, index) => {
+          return index >= 1;
+        })
+        .forEach((row) => {
+          const date = parseDate(row._rawData[0]);
+          const close = parseFloat(row._rawData[1]);
+
+          historicalData[format(date, DATE_FORMAT)] = { marketPrice: close };
+        });
+
+      return {
+        [symbol]: historicalData
+      };
+    } catch (error) {
+      Logger.error(error, 'GoogleSheetsService');
+    }
+
+    return {};
+  }
+
+  public getName(): DataSource {
+    return DataSource.GOOGLE_SHEETS;
+  }
+
+  public async getQuotes(
     aSymbols: string[]
   ): Promise<{ [symbol: string]: IDataProviderResponse }> {
     if (aSymbols.length <= 0) {
@@ -66,63 +121,12 @@ export class GoogleSheetsService implements DataProviderInterface {
 
       return response;
     } catch (error) {
-      Logger.error(error);
+      Logger.error(error, 'GoogleSheetsService');
     }
 
     return {};
   }
 
-  public async getHistorical(
-    aSymbols: string[],
-    aGranularity: Granularity = 'day',
-    from: Date,
-    to: Date
-  ): Promise<{
-    [symbol: string]: { [date: string]: IDataProviderHistoricalResponse };
-  }> {
-    if (aSymbols.length <= 0) {
-      return {};
-    }
-
-    try {
-      const [symbol] = aSymbols;
-
-      const sheet = await this.getSheet({
-        symbol,
-        sheetId: this.configurationService.get('GOOGLE_SHEETS_ID')
-      });
-
-      const rows = await sheet.getRows();
-
-      const historicalData: {
-        [date: string]: IDataProviderHistoricalResponse;
-      } = {};
-
-      rows
-        .filter((row, index) => {
-          return index >= 1;
-        })
-        .forEach((row) => {
-          const date = parseDate(row._rawData[0]);
-          const close = parseFloat(row._rawData[1]);
-
-          historicalData[format(date, DATE_FORMAT)] = { marketPrice: close };
-        });
-
-      return {
-        [symbol]: historicalData
-      };
-    } catch (error) {
-      Logger.error(error);
-    }
-
-    return {};
-  }
-
-  public getName(): DataSource {
-    return DataSource.GOOGLE_SHEETS;
-  }
-
   public async search(aQuery: string): Promise<{ items: LookupItem[] }> {
     const items = await this.prismaService.symbolProfile.findMany({
       select: {

apps/api/src/services/data-provider/interfaces/data-enhancer.interface.ts

@@ -1,13 +1,13 @@
-import { IDataProviderResponse } from '@ghostfolio/api/services/interfaces/interfaces';
+import { SymbolProfile } from '@prisma/client';
 
 export interface DataEnhancerInterface {
   enhance({
     response,
     symbol
   }: {
-    response: IDataProviderResponse;
+    response: Partial<SymbolProfile>;
     symbol: string;
-  }): Promise<IDataProviderResponse>;
+  }): Promise<Partial<SymbolProfile>>;
 
   getName(): string;
 }

apps/api/src/services/data-provider/interfaces/data-provider.interface.ts

@@ -4,23 +4,27 @@ import {
   IDataProviderResponse
 } from '@ghostfolio/api/services/interfaces/interfaces';
 import { Granularity } from '@ghostfolio/common/types';
-import { DataSource } from '@prisma/client';
+import { DataSource, SymbolProfile } from '@prisma/client';
 
 export interface DataProviderInterface {
   canHandle(symbol: string): boolean;
 
-  get(aSymbols: string[]): Promise<{ [symbol: string]: IDataProviderResponse }>;
+  getAssetProfile(aSymbol: string): Promise<Partial<SymbolProfile>>;
 
   getHistorical(
-    aSymbols: string[],
+    aSymbol: string,
     aGranularity: Granularity,
     from: Date,
     to: Date
   ): Promise<{
     [symbol: string]: { [date: string]: IDataProviderHistoricalResponse };
-  }>;
+  }>; // TODO: Return only one symbol
 
   getName(): DataSource;
 
+  getQuotes(
+    aSymbols: string[]
+  ): Promise<{ [symbol: string]: IDataProviderResponse }>;
+
   search(aQuery: string): Promise<{ items: LookupItem[] }>;
 }

apps/api/src/services/data-provider/manual/manual.service.ts

@@ -6,7 +6,7 @@ import {
 } from '@ghostfolio/api/services/interfaces/interfaces';
 import { Granularity } from '@ghostfolio/common/types';
 import { Injectable } from '@nestjs/common';
-import { DataSource } from '@prisma/client';
+import { DataSource, SymbolProfile } from '@prisma/client';
 
 @Injectable()
 export class ManualService implements DataProviderInterface {
@@ -16,14 +16,16 @@ export class ManualService implements DataProviderInterface {
     return false;
   }
 
-  public async get(
-    aSymbols: string[]
-  ): Promise<{ [symbol: string]: IDataProviderResponse }> {
-    return {};
+  public async getAssetProfile(
+    aSymbol: string
+  ): Promise<Partial<SymbolProfile>> {
+    return {
+      dataSource: this.getName()
+    };
   }
 
   public async getHistorical(
-    aSymbols: string[],
+    aSymbol: string,
     aGranularity: Granularity = 'day',
     from: Date,
     to: Date
@@ -37,6 +39,12 @@ export class ManualService implements DataProviderInterface {
     return DataSource.MANUAL;
   }
 
+  public async getQuotes(
+    aSymbols: string[]
+  ): Promise<{ [symbol: string]: IDataProviderResponse }> {
+    return {};
+  }
+
   public async search(aQuery: string): Promise<{ items: LookupItem[] }> {
     return { items: [] };
   }

apps/api/src/services/data-provider/rakuten-rapid-api/rakuten-rapid-api.service.ts

@@ -1,21 +1,20 @@
 import { LookupItem } from '@ghostfolio/api/app/symbol/interfaces/lookup-item.interface';
 import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
+import { DataProviderInterface } from '@ghostfolio/api/services/data-provider/interfaces/data-provider.interface';
+import {
+  IDataProviderHistoricalResponse,
+  IDataProviderResponse,
+  MarketState
+} from '@ghostfolio/api/services/interfaces/interfaces';
 import { PrismaService } from '@ghostfolio/api/services/prisma.service';
 import { ghostfolioFearAndGreedIndexSymbol } from '@ghostfolio/common/config';
 import { DATE_FORMAT, getToday, getYesterday } from '@ghostfolio/common/helper';
 import { Granularity } from '@ghostfolio/common/types';
 import { Injectable, Logger } from '@nestjs/common';
-import { DataSource } from '@prisma/client';
+import { DataSource, SymbolProfile } from '@prisma/client';
 import * as bent from 'bent';
 import { format, subMonths, subWeeks, subYears } from 'date-fns';
 
-import {
-  IDataProviderHistoricalResponse,
-  IDataProviderResponse,
-  MarketState
-} from '../../interfaces/interfaces';
-import { DataProviderInterface } from '../interfaces/data-provider.interface';
-
 @Injectable()
 export class RakutenRapidApiService implements DataProviderInterface {
   public static FEAR_AND_GREED_INDEX_NAME = 'Fear & Greed Index';
@@ -29,50 +28,24 @@ export class RakutenRapidApiService implements DataProviderInterface {
     return !!this.configurationService.get('RAKUTEN_RAPID_API_KEY');
   }
 
-  public async get(
-    aSymbols: string[]
-  ): Promise<{ [symbol: string]: IDataProviderResponse }> {
-    if (aSymbols.length <= 0) {
-      return {};
-    }
-
-    try {
-      const symbol = aSymbols[0];
-
-      if (symbol === ghostfolioFearAndGreedIndexSymbol) {
-        const fgi = await this.getFearAndGreedIndex();
-
-        return {
-          [ghostfolioFearAndGreedIndexSymbol]: {
-            currency: undefined,
-            dataSource: this.getName(),
-            marketPrice: fgi.now.value,
-            marketState: MarketState.open,
-            name: RakutenRapidApiService.FEAR_AND_GREED_INDEX_NAME
-          }
-        };
-      }
-    } catch (error) {
-      Logger.error(error);
-    }
-
-    return {};
+  public async getAssetProfile(
+    aSymbol: string
+  ): Promise<Partial<SymbolProfile>> {
+    return {
+      dataSource: this.getName()
+    };
   }
 
   public async getHistorical(
-    aSymbols: string[],
+    aSymbol: string,
     aGranularity: Granularity = 'day',
     from: Date,
     to: Date
   ): Promise<{
     [symbol: string]: { [date: string]: IDataProviderHistoricalResponse };
   }> {
-    if (aSymbols.length <= 0) {
-      return {};
-    }
-
     try {
-      const symbol = aSymbols[0];
+      const symbol = aSymbol;
 
       if (symbol === ghostfolioFearAndGreedIndexSymbol) {
         const fgi = await this.getFearAndGreedIndex();
@@ -129,6 +102,35 @@ export class RakutenRapidApiService implements DataProviderInterface {
     return DataSource.RAKUTEN;
   }
 
+  public async getQuotes(
+    aSymbols: string[]
+  ): Promise<{ [symbol: string]: IDataProviderResponse }> {
+    if (aSymbols.length <= 0) {
+      return {};
+    }
+
+    try {
+      const symbol = aSymbols[0];
+
+      if (symbol === ghostfolioFearAndGreedIndexSymbol) {
+        const fgi = await this.getFearAndGreedIndex();
+
+        return {
+          [ghostfolioFearAndGreedIndexSymbol]: {
+            currency: undefined,
+            dataSource: this.getName(),
+            marketPrice: fgi.now.value,
+            marketState: MarketState.open
+          }
+        };
+      }
+    } catch (error) {
+      Logger.error(error, 'RakutenRapidApiService');
+    }
+
+    return {};
+  }
+
   public async search(aQuery: string): Promise<{ items: LookupItem[] }> {
     return { items: [] };
   }
@@ -158,7 +160,7 @@ export class RakutenRapidApiService implements DataProviderInterface {
       const { fgi } = await get();
       return fgi;
     } catch (error) {
-      Logger.error(error);
+      Logger.error(error, 'RakutenRapidApiService');
 
       return undefined;
     }

apps/api/src/services/data-provider/yahoo-finance/interfaces/interfaces.ts

@@ -1,32 +0,0 @@
-export interface IYahooFinanceHistoricalResponse {
-  adjClose: number;
-  close: number;
-  date: Date;
-  high: number;
-  low: number;
-  open: number;
-  symbol: string;
-  volume: number;
-}
-
-export interface IYahooFinanceQuoteResponse {
-  price: IYahooFinancePrice;
-  summaryProfile: IYahooFinanceSummaryProfile;
-}
-
-export interface IYahooFinancePrice {
-  currency: string;
-  exchangeName: string;
-  longName: string;
-  marketState: string;
-  quoteType: string;
-  regularMarketPrice: number;
-  shortName: string;
-}
-
-export interface IYahooFinanceSummaryProfile {
-  country?: string;
-  industry?: string;
-  sector?: string;
-  website?: string;
-}

apps/api/src/services/data-provider/yahoo-finance/yahoo-finance.service.ts

@@ -1,31 +1,31 @@
 import { LookupItem } from '@ghostfolio/api/app/symbol/interfaces/lookup-item.interface';
 import { CryptocurrencyService } from '@ghostfolio/api/services/cryptocurrency/cryptocurrency.service';
-import { UNKNOWN_KEY, baseCurrency } from '@ghostfolio/common/config';
-import { DATE_FORMAT, isCurrency } from '@ghostfolio/common/helper';
-import { Granularity } from '@ghostfolio/common/types';
-import { Injectable, Logger } from '@nestjs/common';
-import { AssetClass, AssetSubClass, DataSource } from '@prisma/client';
-import * as bent from 'bent';
-import Big from 'big.js';
-import { countries } from 'countries-list';
-import { addDays, format, isSameDay } from 'date-fns';
-import * as yahooFinance from 'yahoo-finance';
-
+import { DataProviderInterface } from '@ghostfolio/api/services/data-provider/interfaces/data-provider.interface';
 import {
   IDataProviderHistoricalResponse,
   IDataProviderResponse,
   MarketState
-} from '../../interfaces/interfaces';
-import { DataProviderInterface } from '../interfaces/data-provider.interface';
+} from '@ghostfolio/api/services/interfaces/interfaces';
+import { baseCurrency } from '@ghostfolio/common/config';
+import { DATE_FORMAT, isCurrency } from '@ghostfolio/common/helper';
+import { Granularity } from '@ghostfolio/common/types';
+import { Injectable, Logger } from '@nestjs/common';
 import {
-  IYahooFinanceHistoricalResponse,
-  IYahooFinancePrice,
-  IYahooFinanceQuoteResponse
-} from './interfaces/interfaces';
+  AssetClass,
+  AssetSubClass,
+  DataSource,
+  SymbolProfile
+} from '@prisma/client';
+import * as bent from 'bent';
+import Big from 'big.js';
+import { countries } from 'countries-list';
+import { addDays, format, isSameDay } from 'date-fns';
+import yahooFinance from 'yahoo-finance2';
+import type { Price } from 'yahoo-finance2/dist/esm/src/modules/quoteSummary-iface';
 
 @Injectable()
 export class YahooFinanceService implements DataProviderInterface {
-  private yahooFinanceHostname = 'https://query1.finance.yahoo.com';
+  private readonly yahooFinanceHostname = 'https://query1.finance.yahoo.com';
 
   public constructor(
     private readonly cryptocurrencyService: CryptocurrencyService
@@ -73,7 +73,124 @@ export class YahooFinanceService implements DataProviderInterface {
     return aSymbol;
   }
 
-  public async get(
+  public async getAssetProfile(
+    aSymbol: string
+  ): Promise<Partial<SymbolProfile>> {
+    const response: Partial<SymbolProfile> = {};
+
+    try {
+      const symbol = this.convertToYahooFinanceSymbol(aSymbol);
+      const assetProfile = await yahooFinance.quoteSummary(symbol, {
+        modules: ['price', 'summaryProfile']
+      });
+
+      const { assetClass, assetSubClass } = this.parseAssetClass(
+        assetProfile.price
+      );
+
+      response.assetClass = assetClass;
+      response.assetSubClass = assetSubClass;
+      response.currency = assetProfile.price.currency;
+      response.dataSource = this.getName();
+      response.name =
+        assetProfile.price.longName || assetProfile.price.shortName || symbol;
+      response.symbol = aSymbol;
+
+      if (
+        assetSubClass === AssetSubClass.STOCK &&
+        assetProfile.summaryProfile?.country
+      ) {
+        // Add country if asset is stock and country available
+
+        try {
+          const [code] = Object.entries(countries).find(([, country]) => {
+            return country.name === assetProfile.summaryProfile?.country;
+          });
+
+          if (code) {
+            response.countries = [{ code, weight: 1 }];
+          }
+        } catch {}
+
+        if (assetProfile.summaryProfile?.sector) {
+          response.sectors = [
+            { name: assetProfile.summaryProfile?.sector, weight: 1 }
+          ];
+        }
+      }
+
+      const url = assetProfile.summaryProfile?.website;
+      if (url) {
+        response.url = url;
+      }
+    } catch {}
+
+    return response;
+  }
+
+  public async getHistorical(
+    aSymbol: string,
+    aGranularity: Granularity = 'day',
+    from: Date,
+    to: Date
+  ): Promise<{
+    [symbol: string]: { [date: string]: IDataProviderHistoricalResponse };
+  }> {
+    if (isSameDay(from, to)) {
+      to = addDays(to, 1);
+    }
+
+    const yahooFinanceSymbol = this.convertToYahooFinanceSymbol(aSymbol);
+
+    try {
+      const historicalResult = await yahooFinance.historical(
+        yahooFinanceSymbol,
+        {
+          interval: '1d',
+          period1: format(from, DATE_FORMAT),
+          period2: format(to, DATE_FORMAT)
+        }
+      );
+
+      const response: {
+        [symbol: string]: { [date: string]: IDataProviderHistoricalResponse };
+      } = {};
+
+      // Convert symbol back
+      const symbol = this.convertFromYahooFinanceSymbol(yahooFinanceSymbol);
+
+      response[symbol] = {};
+
+      for (const historicalItem of historicalResult) {
+        let marketPrice = historicalItem.close;
+
+        if (symbol === 'USDGBp') {
+          // Convert GPB to GBp (pence)
+          marketPrice = new Big(marketPrice).mul(100).toNumber();
+        }
+
+        response[symbol][format(historicalItem.date, DATE_FORMAT)] = {
+          marketPrice,
+          performance: historicalItem.open - historicalItem.close
+        };
+      }
+
+      return response;
+    } catch (error) {
+      Logger.warn(
+        `Skipping yahooFinance2.getHistorical("${aSymbol}"): [${error.name}] ${error.message}`,
+        'YahooFinanceService'
+      );
+
+      return {};
+    }
+  }
+
+  public getName(): DataSource {
+    return DataSource.YAHOO;
+  }
+
+  public async getQuotes(
     aSymbols: string[]
   ): Promise<{ [symbol: string]: IDataProviderResponse }> {
     if (aSymbols.length <= 0) {
@@ -86,141 +203,43 @@ export class YahooFinanceService implements DataProviderInterface {
     try {
       const response: { [symbol: string]: IDataProviderResponse } = {};
 
-      const data: {
-        [symbol: string]: IYahooFinanceQuoteResponse;
-      } = await yahooFinance.quote({
-        modules: ['price', 'summaryProfile'],
-        symbols: yahooFinanceSymbols
-      });
+      const quotes = await yahooFinance.quote(yahooFinanceSymbols);
 
-      for (const [yahooFinanceSymbol, value] of Object.entries(data)) {
+      for (const quote of quotes) {
         // Convert symbols back
-        const symbol = this.convertFromYahooFinanceSymbol(yahooFinanceSymbol);
-
-        const { assetClass, assetSubClass } = this.parseAssetClass(value.price);
+        const symbol = this.convertFromYahooFinanceSymbol(quote.symbol);
 
         response[symbol] = {
-          assetClass,
-          assetSubClass,
-          currency: value.price?.currency,
+          currency: quote.currency,
           dataSource: this.getName(),
-          exchange: this.parseExchange(value.price?.exchangeName),
           marketState:
-            value.price?.marketState === 'REGULAR' ||
+            quote.marketState === 'REGULAR' ||
             this.cryptocurrencyService.isCryptocurrency(symbol)
               ? MarketState.open
               : MarketState.closed,
-          marketPrice: value.price?.regularMarketPrice || 0,
-          name: value.price?.longName || value.price?.shortName || symbol
+          marketPrice: quote.regularMarketPrice || 0
         };
 
-        if (value.price?.currency === 'GBp') {
-          // Convert GBp (pence) to GBP
-          response[symbol].currency = 'GBP';
-          response[symbol].marketPrice = new Big(
-            value.price?.regularMarketPrice ?? 0
-          )
-            .div(100)
-            .toNumber();
-        }
-
-        // Add country if stock and available
-        if (
-          assetSubClass === AssetSubClass.STOCK &&
-          value.summaryProfile?.country
-        ) {
-          try {
-            const [code] = Object.entries(countries).find(([, country]) => {
-              return country.name === value.summaryProfile?.country;
-            });
-
-            if (code) {
-              response[symbol].countries = [{ code, weight: 1 }];
-            }
-          } catch {}
-
-          if (value.summaryProfile?.sector) {
-            response[symbol].sectors = [
-              { name: value.summaryProfile?.sector, weight: 1 }
-            ];
-          }
-        }
-
-        // Add url if available
-        const url = value.summaryProfile?.website;
-        if (url) {
-          response[symbol].url = url;
-        }
-      }
-
-      return response;
-    } catch (error) {
-      Logger.error(error);
-
-      return {};
-    }
-  }
-
-  public async getHistorical(
-    aSymbols: string[],
-    aGranularity: Granularity = 'day',
-    from: Date,
-    to: Date
-  ): Promise<{
-    [symbol: string]: { [date: string]: IDataProviderHistoricalResponse };
-  }> {
-    if (aSymbols.length <= 0) {
-      return {};
-    }
-
-    if (isSameDay(from, to)) {
-      to = addDays(to, 1);
-    }
-
-    const yahooFinanceSymbols = aSymbols.map((symbol) => {
-      return this.convertToYahooFinanceSymbol(symbol);
-    });
-
-    try {
-      const historicalData: {
-        [symbol: string]: IYahooFinanceHistoricalResponse[];
-      } = await yahooFinance.historical({
-        symbols: yahooFinanceSymbols,
-        from: format(from, DATE_FORMAT),
-        to: format(to, DATE_FORMAT)
-      });
-
-      const response: {
-        [symbol: string]: { [date: string]: IDataProviderHistoricalResponse };
-      } = {};
-
-      for (const [yahooFinanceSymbol, timeSeries] of Object.entries(
-        historicalData
-      )) {
-        // Convert symbols back
-        const symbol = this.convertFromYahooFinanceSymbol(yahooFinanceSymbol);
-        response[symbol] = {};
-
-        timeSeries.forEach((timeSerie) => {
-          response[symbol][format(timeSerie.date, DATE_FORMAT)] = {
-            marketPrice: timeSerie.close,
-            performance: timeSerie.open - timeSerie.close
+        if (symbol === 'USDGBP' && yahooFinanceSymbols.includes('USDGBp=X')) {
+          // Convert GPB to GBp (pence)
+          response['USDGBp'] = {
+            ...response[symbol],
+            currency: 'GBp',
+            marketPrice: new Big(response[symbol].marketPrice)
+              .mul(100)
+              .toNumber()
           };
-        });
+        }
       }
 
       return response;
     } catch (error) {
-      Logger.error(error);
+      Logger.error(error, 'YahooFinanceService');
 
       return {};
     }
   }
 
-  public getName(): DataSource {
-    return DataSource.YAHOO;
-  }
-
   public async search(aQuery: string): Promise<{ items: LookupItem[] }> {
     const items: LookupItem[] = [];
 
@@ -236,7 +255,7 @@ export class YahooFinanceService implements DataProviderInterface {
 
       const searchResult = await get();
 
-      const symbols: string[] = searchResult.quotes
+      const quotes = searchResult.quotes
         .filter((quote) => {
           // filter out undefined symbols
           return quote.symbol;
@@ -247,8 +266,7 @@ export class YahooFinanceService implements DataProviderInterface {
               this.cryptocurrencyService.isCryptocurrency(
                 symbol.replace(new RegExp(`-${baseCurrency}$`), baseCurrency)
               )) ||
-            quoteType === 'EQUITY' ||
-            quoteType === 'ETF'
+            ['EQUITY', 'ETF', 'MUTUALFUND'].includes(quoteType)
           );
         })
         .filter(({ quoteType, symbol }) => {
@@ -259,27 +277,34 @@ export class YahooFinanceService implements DataProviderInterface {
           }
 
           return true;
-        })
-        .map(({ symbol }) => {
-          return symbol;
         });
 
-      const marketData = await this.get(symbols);
+      const marketData = await this.getQuotes(
+        quotes.map(({ symbol }) => {
+          return symbol;
+        })
+      );
 
       for (const [symbol, value] of Object.entries(marketData)) {
+        const quote = quotes.find((currentQuote: any) => {
+          return currentQuote.symbol === symbol;
+        });
+
         items.push({
           symbol,
           currency: value.currency,
           dataSource: this.getName(),
-          name: value.name
+          name: quote?.longname || quote?.shortname || symbol
         });
       }
-    } catch {}
+    } catch (error) {
+      Logger.error(error, 'YahooFinanceService');
+    }
 
     return { items };
   }
 
-  private parseAssetClass(aPrice: IYahooFinancePrice): {
+  private parseAssetClass(aPrice: Price): {
     assetClass: AssetClass;
     assetSubClass: AssetSubClass;
   } {
@@ -299,16 +324,12 @@ export class YahooFinanceService implements DataProviderInterface {
         assetClass = AssetClass.EQUITY;
         assetSubClass = AssetSubClass.ETF;
         break;
+      case 'mutualfund':
+        assetClass = AssetClass.EQUITY;
+        assetSubClass = AssetSubClass.MUTUALFUND;
+        break;
     }
 
     return { assetClass, assetSubClass };
   }
-
-  private parseExchange(aString: string): string {
-    if (aString?.toLowerCase() === 'ccc') {
-      return UNKNOWN_KEY;
-    }
-
-    return aString;
-  }
 }

apps/api/src/services/exchange-rate-data.service.ts

@@ -2,7 +2,7 @@ import { PROPERTY_CURRENCIES, baseCurrency } from '@ghostfolio/common/config';
 import { DATE_FORMAT, getYesterday } from '@ghostfolio/common/helper';
 import { Injectable, Logger } from '@nestjs/common';
 import { format } from 'date-fns';
-import { isEmpty, isNumber, uniq } from 'lodash';
+import { isNumber, uniq } from 'lodash';
 
 import { DataProviderService } from './data-provider/data-provider.service';
 import { IDataGatheringItem } from './interfaces/interfaces';
@@ -61,7 +61,7 @@ export class ExchangeRateDataService {
     if (Object.keys(result).length !== this.currencyPairs.length) {
       // Load currencies directly from data provider as a fallback
       // if historical data is not fully available
-      const historicalData = await this.dataProviderService.get(
+      const historicalData = await this.dataProviderService.getQuotes(
         this.currencyPairs.map(({ dataSource, symbol }) => {
           return { dataSource, symbol };
         })
@@ -114,6 +114,10 @@ export class ExchangeRateDataService {
     aFromCurrency: string,
     aToCurrency: string
   ) {
+    if (aValue === 0) {
+      return 0;
+    }
+
     const hasNaN = Object.values(this.exchangeRates).some((exchangeRate) => {
       return isNaN(exchangeRate);
     });
@@ -145,7 +149,8 @@ export class ExchangeRateDataService {
 
     // Fallback with error, if currencies are not available
     Logger.error(
-      `No exchange rate has been found for ${aFromCurrency}${aToCurrency}`
+      `No exchange rate has been found for ${aFromCurrency}${aToCurrency}`,
+      'ExchangeRateDataService'
     );
     return aValue;
   }
@@ -187,12 +192,7 @@ export class ExchangeRateDataService {
       await this.prismaService.symbolProfile.findMany({
         distinct: ['currency'],
         orderBy: [{ currency: 'asc' }],
-        select: { currency: true },
-        where: {
-          currency: {
-            not: null
-          }
-        }
+        select: { currency: true }
       })
     ).forEach((symbolProfile) => {
       currencies.push(symbolProfile.currency);
@@ -206,7 +206,7 @@ export class ExchangeRateDataService {
       currencies = currencies.concat(customCurrencies);
     }
 
-    return uniq(currencies).sort();
+    return uniq(currencies).filter(Boolean).sort();
   }
 
   private prepareCurrencyPairs(aCurrencies: string[]) {

apps/api/src/services/interfaces/environment.interface.ts

@@ -30,5 +30,9 @@ export interface Environment extends CleanedEnvAccessors {
   ROOT_URL: string;
   STRIPE_PUBLIC_KEY: string;
   STRIPE_SECRET_KEY: string;
+  TWITTER_ACCESS_TOKEN: string;
+  TWITTER_ACCESS_TOKEN_SECRET: string;
+  TWITTER_API_KEY: string;
+  TWITTER_API_SECRET: string;
   WEB_AUTH_RP_ID: string;
 }

apps/api/src/services/interfaces/interfaces.ts

@@ -33,19 +33,10 @@ export interface IDataProviderHistoricalResponse {
 }
 
 export interface IDataProviderResponse {
-  assetClass?: AssetClass;
-  assetSubClass?: AssetSubClass;
-  countries?: { code: string; weight: number }[];
   currency: string;
   dataSource: DataSource;
-  exchange?: string;
-  marketChange?: number;
-  marketChangePercent?: number;
   marketPrice: number;
   marketState: MarketState;
-  name?: string;
-  sectors?: { name: string; weight: number }[];
-  url?: string;
 }
 
 export interface IDataGatheringItem {

apps/api/src/services/market-data.service.ts

@@ -2,6 +2,7 @@ import { UpdateMarketDataDto } from '@ghostfolio/api/app/admin/update-market-dat
 import { DateQuery } from '@ghostfolio/api/app/portfolio/interfaces/date-query.interface';
 import { PrismaService } from '@ghostfolio/api/services/prisma.service';
 import { resetHours } from '@ghostfolio/common/helper';
+import { UniqueAsset } from '@ghostfolio/common/interfaces';
 import { Injectable } from '@nestjs/common';
 import { DataSource, MarketData, Prisma } from '@prisma/client';
 
@@ -9,13 +10,7 @@ import { DataSource, MarketData, Prisma } from '@prisma/client';
 export class MarketDataService {
   public constructor(private readonly prismaService: PrismaService) {}
 
-  public async deleteMany({
-    dataSource,
-    symbol
-  }: {
-    dataSource: DataSource;
-    symbol: string;
-  }) {
+  public async deleteMany({ dataSource, symbol }: UniqueAsset) {
     return this.prismaService.marketData.deleteMany({
       where: {
         dataSource,

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

@@ -79,6 +79,7 @@ export class SymbolProfileService {
 
     if (scraperConfiguration) {
       return {
+        defaultMarketPrice: scraperConfiguration.defaultMarketPrice as number,
         selector: scraperConfiguration.selector as string,
         url: scraperConfiguration.url as string
       };

apps/api/src/services/twitter-bot/twitter-bot.module.ts

@@ -0,0 +1,11 @@
+import { SymbolModule } from '@ghostfolio/api/app/symbol/symbol.module';
+import { ConfigurationModule } from '@ghostfolio/api/services/configuration.module';
+import { TwitterBotService } from '@ghostfolio/api/services/twitter-bot/twitter-bot.service';
+import { Module } from '@nestjs/common';
+
+@Module({
+  exports: [TwitterBotService],
+  imports: [ConfigurationModule, SymbolModule],
+  providers: [TwitterBotService]
+})
+export class TwitterBotModule {}

apps/api/src/services/twitter-bot/twitter-bot.service.ts

@@ -0,0 +1,65 @@
+import { SymbolService } from '@ghostfolio/api/app/symbol/symbol.service';
+import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
+import {
+  ghostfolioFearAndGreedIndexDataSource,
+  ghostfolioFearAndGreedIndexSymbol
+} from '@ghostfolio/common/config';
+import { resolveFearAndGreedIndex } from '@ghostfolio/common/helper';
+import { Injectable, Logger } from '@nestjs/common';
+import { isSunday } from 'date-fns';
+import { TwitterApi, TwitterApiReadWrite } from 'twitter-api-v2';
+
+@Injectable()
+export class TwitterBotService {
+  private twitterClient: TwitterApiReadWrite;
+
+  public constructor(
+    private readonly configurationService: ConfigurationService,
+    private readonly symbolService: SymbolService
+  ) {
+    this.twitterClient = new TwitterApi({
+      accessSecret: this.configurationService.get(
+        'TWITTER_ACCESS_TOKEN_SECRET'
+      ),
+      accessToken: this.configurationService.get('TWITTER_ACCESS_TOKEN'),
+      appKey: this.configurationService.get('TWITTER_API_KEY'),
+      appSecret: this.configurationService.get('TWITTER_API_SECRET')
+    }).readWrite;
+  }
+
+  public async tweetFearAndGreedIndex() {
+    if (
+      !this.configurationService.get('ENABLE_FEATURE_FEAR_AND_GREED_INDEX') ||
+      isSunday(new Date())
+    ) {
+      return;
+    }
+
+    try {
+      const symbolItem = await this.symbolService.get({
+        dataGatheringItem: {
+          dataSource: ghostfolioFearAndGreedIndexDataSource,
+          symbol: ghostfolioFearAndGreedIndexSymbol
+        }
+      });
+
+      if (symbolItem?.marketPrice) {
+        const { emoji, text } = resolveFearAndGreedIndex(
+          symbolItem.marketPrice
+        );
+
+        const status = `Current Market Mood: ${emoji} ${text} (${symbolItem.marketPrice}/100)\n\n#FearAndGreed #Markets #ServiceTweet`;
+        const { data: createdTweet } = await this.twitterClient.v2.tweet(
+          status
+        );
+
+        Logger.log(
+          `Fear & Greed Index has been tweeted: https://twitter.com/ghostfolio_/status/${createdTweet.id}`,
+          'TwitterBotService'
+        );
+      }
+    } catch (error) {
+      Logger.error(error, 'TwitterBotService');
+    }
+  }
+}

apps/client/src/app/adapter/date-formats.ts

@@ -1,16 +1,14 @@
-import {
-  DEFAULT_DATE_FORMAT,
-  DEFAULT_DATE_FORMAT_MONTH_YEAR
-} from '@ghostfolio/common/config';
+import { DEFAULT_DATE_FORMAT_MONTH_YEAR } from '@ghostfolio/common/config';
+import { getDateFormatString } from '@ghostfolio/common/helper';
 
 export const DateFormats = {
   display: {
-    dateInput: DEFAULT_DATE_FORMAT,
+    dateInput: getDateFormatString(),
     monthYearLabel: DEFAULT_DATE_FORMAT_MONTH_YEAR,
-    dateA11yLabel: DEFAULT_DATE_FORMAT,
+    dateA11yLabel: getDateFormatString(),
     monthYearA11yLabel: DEFAULT_DATE_FORMAT_MONTH_YEAR
   },
   parse: {
-    dateInput: DEFAULT_DATE_FORMAT
+    dateInput: getDateFormatString()
   }
 };

apps/client/src/app/app-routing.module.ts

@@ -66,6 +66,13 @@ const routes: Routes = [
         './pages/blog/2022/01/first-months-in-open-source/first-months-in-open-source-page.module'
       ).then((m) => m.FirstMonthsInOpenSourcePageModule)
   },
+  {
+    path: 'features',
+    loadChildren: () =>
+      import('./pages/features/features-page.module').then(
+        (m) => m.FeaturesPageModule
+      )
+  },
   {
     path: 'home',
     loadChildren: () =>
@@ -106,6 +113,13 @@ const routes: Routes = [
         (m) => m.AnalysisPageModule
       )
   },
+  {
+    path: 'portfolio/fire',
+    loadChildren: () =>
+      import('./pages/portfolio/fire/fire-page.module').then(
+        (m) => m.FirePageModule
+      )
+  },
   {
     path: 'portfolio/report',
     loadChildren: () =>

apps/client/src/app/components/accounts-table/accounts-table.component.html

@@ -78,32 +78,54 @@
   </ng-container>
 
   <ng-container matColumnDef="balance">
-    <th *matHeaderCellDef class="px-1 text-right" i18n mat-header-cell>
+    <th
+      *matHeaderCellDef
+      class="d-none d-lg-table-cell px-1 text-right"
+      i18n
+      mat-header-cell
+    >
       Cash Balance
     </th>
-    <td *matCellDef="let element" class="px-1 text-right" mat-cell>
+    <td
+      *matCellDef="let element"
+      class="d-none d-lg-table-cell px-1 text-right"
+      mat-cell
+    >
       <gf-value
         class="d-inline-block justify-content-end"
         [isCurrency]="true"
         [locale]="locale"
-        [value]="element.convertedBalance"
+        [value]="element.balance"
       ></gf-value>
     </td>
-    <td *matFooterCellDef class="px-1 text-right" mat-footer-cell>
+    <td
+      *matFooterCellDef
+      class="d-none d-lg-table-cell px-1 text-right"
+      mat-footer-cell
+    >
       <gf-value
         class="d-inline-block justify-content-end"
         [isCurrency]="true"
         [locale]="locale"
-        [value]="totalBalance"
+        [value]="totalBalanceInBaseCurrency"
       ></gf-value>
     </td>
   </ng-container>
 
   <ng-container matColumnDef="value">
-    <th *matHeaderCellDef class="px-1 text-right" i18n mat-header-cell>
+    <th
+      *matHeaderCellDef
+      class="d-none d-lg-table-cell px-1 text-right"
+      i18n
+      mat-header-cell
+    >
       Value
     </th>
-    <td *matCellDef="let element" class="px-1 text-right" mat-cell>
+    <td
+      *matCellDef="let element"
+      class="d-none d-lg-table-cell px-1 text-right"
+      mat-cell
+    >
       <gf-value
         class="d-inline-block justify-content-end"
         [isCurrency]="true"
@@ -111,12 +133,51 @@
         [value]="element.value"
       ></gf-value>
     </td>
-    <td *matFooterCellDef class="px-1 text-right" mat-footer-cell>
+    <td
+      *matFooterCellDef
+      class="d-none d-lg-table-cell px-1 text-right"
+      mat-footer-cell
+    >
       <gf-value
         class="d-inline-block justify-content-end"
         [isCurrency]="true"
         [locale]="locale"
-        [value]="totalValue"
+        [value]="totalValueInBaseCurrency"
+      ></gf-value>
+    </td>
+  </ng-container>
+
+  <ng-container matColumnDef="valueInBaseCurrency">
+    <th
+      *matHeaderCellDef
+      class="d-lg-none d-xl-none px-1 text-right"
+      i18n
+      mat-header-cell
+    >
+      Value
+    </th>
+    <td
+      *matCellDef="let element"
+      class="d-lg-none d-xl-none px-1 text-right"
+      mat-cell
+    >
+      <gf-value
+        class="d-inline-block justify-content-end"
+        [isCurrency]="true"
+        [locale]="locale"
+        [value]="element.valueInBaseCurrency"
+      ></gf-value>
+    </td>
+    <td
+      *matFooterCellDef
+      class="d-lg-none d-xl-none px-1 text-right"
+      mat-footer-cell
+    >
+      <gf-value
+        class="d-inline-block justify-content-end"
+        [isCurrency]="true"
+        [locale]="locale"
+        [value]="totalValueInBaseCurrency"
       ></gf-value>
     </td>
   </ng-container>

apps/client/src/app/components/accounts-table/accounts-table.component.ts

@@ -24,8 +24,8 @@ export class AccountsTableComponent implements OnChanges, OnDestroy, OnInit {
   @Input() deviceType: string;
   @Input() locale: string;
   @Input() showActions: boolean;
-  @Input() totalBalance: number;
-  @Input() totalValue: number;
+  @Input() totalBalanceInBaseCurrency: number;
+  @Input() totalValueInBaseCurrency: number;
   @Input() transactionCount: number;
 
   @Output() accountDeleted = new EventEmitter<string>();
@@ -50,7 +50,8 @@ export class AccountsTableComponent implements OnChanges, OnDestroy, OnInit {
       'transactions',
       'balance',
       'value',
-      'currency'
+      'currency',
+      'valueInBaseCurrency'
     ];
 
     if (this.showActions) {

apps/client/src/app/components/admin-market-data-detail/admin-market-data-detail.component.html

@@ -18,8 +18,10 @@
           available:
             marketDataByMonth[itemByMonth.key][
               i + 1 < 10 ? '0' + (i + 1) : i + 1
-            ]?.day ===
-            i + 1
+            ]?.marketPrice,
+          today: isToday(
+            itemByMonth.key + '-' + (i + 1 < 10 ? '0' + (i + 1) : i + 1)
+          )
         }"
         [title]="
           (itemByMonth.key + '-' + (i + 1 < 10 ? '0' + (i + 1) : i + 1)

apps/client/src/app/components/admin-market-data-detail/admin-market-data-detail.component.scss

@@ -25,5 +25,10 @@
     &.available {
       background-color: var(--success);
     }
+
+    &.today {
+      background-color: rgba(var(--palette-accent-500), 1);
+      cursor: default;
+    }
   }
 }

apps/client/src/app/components/admin-market-data-detail/admin-market-data-detail.component.ts

@@ -8,11 +8,22 @@ import {
   Output
 } from '@angular/core';
 import { MatDialog } from '@angular/material/dialog';
-import { DEFAULT_DATE_FORMAT } from '@ghostfolio/common/config';
-import { DATE_FORMAT } from '@ghostfolio/common/helper';
+import {
+  DATE_FORMAT,
+  getDateFormatString,
+  getLocale
+} from '@ghostfolio/common/helper';
 import { LineChartItem } from '@ghostfolio/ui/line-chart/interfaces/line-chart.interface';
 import { DataSource, MarketData } from '@prisma/client';
-import { format, isBefore, isValid, parse } from 'date-fns';
+import {
+  addDays,
+  format,
+  isBefore,
+  isSameDay,
+  isValid,
+  parse,
+  parseISO
+} from 'date-fns';
 import { DeviceDetectorService } from 'ngx-device-detector';
 import { Subject, takeUntil } from 'rxjs';
 
@@ -26,17 +37,21 @@ import { MarketDataDetailDialog } from './market-data-detail-dialog/market-data-
 })
 export class AdminMarketDataDetailComponent implements OnChanges, OnInit {
   @Input() dataSource: DataSource;
+  @Input() dateOfFirstActivity: string;
+  @Input() locale = getLocale();
   @Input() marketData: MarketData[];
   @Input() symbol: string;
 
   @Output() marketDataChanged = new EventEmitter<boolean>();
 
   public days = Array(31);
-  public defaultDateFormat = DEFAULT_DATE_FORMAT;
+  public defaultDateFormat: string;
   public deviceType: string;
   public historicalDataItems: LineChartItem[];
   public marketDataByMonth: {
-    [yearMonth: string]: { [day: string]: MarketData & { day: number } };
+    [yearMonth: string]: {
+      [day: string]: Pick<MarketData, 'date' | 'marketPrice'> & { day: number };
+    };
   } = {};
 
   private unsubscribeSubject = new Subject<void>();
@@ -51,15 +66,38 @@ export class AdminMarketDataDetailComponent implements OnChanges, OnInit {
   public ngOnInit() {}
 
   public ngOnChanges() {
+    this.defaultDateFormat = getDateFormatString(this.locale);
+
     this.historicalDataItems = this.marketData.map((marketDataItem) => {
       return {
         date: format(marketDataItem.date, DATE_FORMAT),
         value: marketDataItem.marketPrice
       };
     });
+
+    let date = parseISO(this.dateOfFirstActivity);
+
+    const missingMarketData: Partial<MarketData>[] = [];
+
+    if (this.historicalDataItems?.[0]?.date) {
+      while (
+        isBefore(
+          date,
+          parse(this.historicalDataItems[0].date, DATE_FORMAT, new Date())
+        )
+      ) {
+        missingMarketData.push({
+          date,
+          marketPrice: undefined
+        });
+
+        date = addDays(date, 1);
+      }
+    }
+
     this.marketDataByMonth = {};
 
-    for (const marketDataItem of this.marketData) {
+    for (const marketDataItem of [...missingMarketData, ...this.marketData]) {
       const currentDay = parseInt(format(marketDataItem.date, 'd'), 10);
       const key = format(marketDataItem.date, 'yyyy-MM');
 
@@ -70,8 +108,9 @@ export class AdminMarketDataDetailComponent implements OnChanges, OnInit {
       this.marketDataByMonth[key][
         currentDay < 10 ? `0${currentDay}` : currentDay
       ] = {
-        ...marketDataItem,
-        day: currentDay
+        date: marketDataItem.date,
+        day: currentDay,
+        marketPrice: marketDataItem.marketPrice
       };
     }
   }
@@ -82,6 +121,11 @@ export class AdminMarketDataDetailComponent implements OnChanges, OnInit {
     return isValid(date) && isBefore(date, new Date());
   }
 
+  public isToday(aDateString: string) {
+    const date = parse(aDateString, DATE_FORMAT, new Date());
+    return isValid(date) && isSameDay(date, new Date());
+  }
+
   public onOpenMarketDataDetail({
     day,
     yearMonth
@@ -89,13 +133,18 @@ export class AdminMarketDataDetailComponent implements OnChanges, OnInit {
     day: string;
     yearMonth: string;
   }) {
+    const date = new Date(`${yearMonth}-${day}`);
     const marketPrice = this.marketDataByMonth[yearMonth]?.[day]?.marketPrice;
 
+    if (isSameDay(date, new Date())) {
+      return;
+    }
+
     const dialogRef = this.dialog.open(MarketDataDetailDialog, {
       data: {
+        date,
         marketPrice,
         dataSource: this.dataSource,
-        date: new Date(`${yearMonth}-${day}`),
         symbol: this.symbol
       },
       height: this.deviceType === 'mobile' ? '97.5vh' : '80vh',

apps/client/src/app/components/admin-market-data/admin-market-data.component.ts

@@ -7,7 +7,9 @@ import {
 } from '@angular/core';
 import { AdminService } from '@ghostfolio/client/services/admin.service';
 import { DataService } from '@ghostfolio/client/services/data.service';
-import { DEFAULT_DATE_FORMAT } from '@ghostfolio/common/config';
+import { UserService } from '@ghostfolio/client/services/user/user.service';
+import { getDateFormatString } from '@ghostfolio/common/helper';
+import { UniqueAsset, User } from '@ghostfolio/common/interfaces';
 import { AdminMarketDataItem } from '@ghostfolio/common/interfaces/admin-market-data.interface';
 import { DataSource, MarketData } from '@prisma/client';
 import { Subject } from 'rxjs';
@@ -22,9 +24,10 @@ import { takeUntil } from 'rxjs/operators';
 export class AdminMarketDataComponent implements OnDestroy, OnInit {
   public currentDataSource: DataSource;
   public currentSymbol: string;
-  public defaultDateFormat = DEFAULT_DATE_FORMAT;
+  public defaultDateFormat: string;
   public marketData: AdminMarketDataItem[] = [];
   public marketDataDetails: MarketData[] = [];
+  public user: User;
 
   private unsubscribeSubject = new Subject<void>();
 
@@ -34,8 +37,21 @@ export class AdminMarketDataComponent implements OnDestroy, OnInit {
   public constructor(
     private adminService: AdminService,
     private changeDetectorRef: ChangeDetectorRef,
-    private dataService: DataService
-  ) {}
+    private dataService: DataService,
+    private userService: UserService
+  ) {
+    this.userService.stateChanged
+      .pipe(takeUntil(this.unsubscribeSubject))
+      .subscribe((state) => {
+        if (state?.user) {
+          this.user = state.user;
+
+          this.defaultDateFormat = getDateFormatString(
+            this.user.settings.locale
+          );
+        }
+      });
+  }
 
   /**
    * Initializes the controller
@@ -44,39 +60,21 @@ export class AdminMarketDataComponent implements OnDestroy, OnInit {
     this.fetchAdminMarketData();
   }
 
-  public onDeleteProfileData({
-    dataSource,
-    symbol
-  }: {
-    dataSource: DataSource;
-    symbol: string;
-  }) {
+  public onDeleteProfileData({ dataSource, symbol }: UniqueAsset) {
     this.adminService
       .deleteProfileData({ dataSource, symbol })
       .pipe(takeUntil(this.unsubscribeSubject))
       .subscribe(() => {});
   }
 
-  public onGatherProfileDataBySymbol({
-    dataSource,
-    symbol
-  }: {
-    dataSource: DataSource;
-    symbol: string;
-  }) {
+  public onGatherProfileDataBySymbol({ dataSource, symbol }: UniqueAsset) {
     this.adminService
       .gatherProfileDataBySymbol({ dataSource, symbol })
       .pipe(takeUntil(this.unsubscribeSubject))
       .subscribe(() => {});
   }
 
-  public onGatherSymbol({
-    dataSource,
-    symbol
-  }: {
-    dataSource: DataSource;
-    symbol: string;
-  }) {
+  public onGatherSymbol({ dataSource, symbol }: UniqueAsset) {
     this.adminService
       .gatherSymbol({ dataSource, symbol })
       .pipe(takeUntil(this.unsubscribeSubject))
@@ -93,13 +91,7 @@ export class AdminMarketDataComponent implements OnDestroy, OnInit {
     }
   }
 
-  public setCurrentProfile({
-    dataSource,
-    symbol
-  }: {
-    dataSource: DataSource;
-    symbol: string;
-  }) {
+  public setCurrentProfile({ dataSource, symbol }: UniqueAsset) {
     this.marketDataDetails = [];
 
     if (this.currentSymbol === symbol) {
@@ -129,13 +121,7 @@ export class AdminMarketDataComponent implements OnDestroy, OnInit {
       });
   }
 
-  private fetchAdminMarketDataBySymbol({
-    dataSource,
-    symbol
-  }: {
-    dataSource: DataSource;
-    symbol: string;
-  }) {
+  private fetchAdminMarketDataBySymbol({ dataSource, symbol }: UniqueAsset) {
     this.adminService
       .fetchAdminMarketDataBySymbol({ dataSource, symbol })
       .pipe(takeUntil(this.unsubscribeSubject))

apps/client/src/app/components/admin-market-data/admin-market-data.html

@@ -64,6 +64,8 @@
               <td class="p-1" colspan="6">
                 <gf-admin-market-data-detail
                   [dataSource]="item.dataSource"
+                  [dateOfFirstActivity]="item.date"
+                  [locale]="user?.settings?.locale"
                   [marketData]="marketDataDetails"
                   [symbol]="item.symbol"
                   (marketDataChanged)="onMarketDataChanged($event)"

apps/client/src/app/components/admin-overview/admin-overview.component.ts

@@ -5,7 +5,6 @@ import { CacheService } from '@ghostfolio/client/services/cache.service';
 import { DataService } from '@ghostfolio/client/services/data.service';
 import { UserService } from '@ghostfolio/client/services/user/user.service';
 import {
-  DEFAULT_DATE_FORMAT,
   PROPERTY_COUPONS,
   PROPERTY_CURRENCIES,
   PROPERTY_IS_READ_ONLY_MODE,
@@ -20,6 +19,7 @@ import {
   parseISO
 } from 'date-fns';
 import { uniq } from 'lodash';
+import { StringValue } from 'ms';
 import { Subject } from 'rxjs';
 import { takeUntil } from 'rxjs/operators';
 
@@ -29,11 +29,11 @@ import { takeUntil } from 'rxjs/operators';
   templateUrl: './admin-overview.html'
 })
 export class AdminOverviewComponent implements OnDestroy, OnInit {
+  public couponDuration: StringValue = '30 days';
   public coupons: Coupon[];
   public customCurrencies: string[];
   public dataGatheringInProgress: boolean;
   public dataGatheringProgress: number;
-  public defaultDateFormat = DEFAULT_DATE_FORMAT;
   public exchangeRates: { label1: string; label2: string; value: number }[];
   public hasPermissionForSubscription: boolean;
   public hasPermissionForSystemMessage: boolean;
@@ -105,7 +105,10 @@ export class AdminOverviewComponent implements OnDestroy, OnInit {
   }
 
   public onAddCoupon() {
-    const coupons = [...this.coupons, { code: this.generateCouponCode(16) }];
+    const coupons = [
+      ...this.coupons,
+      { code: this.generateCouponCode(16), duration: this.couponDuration }
+    ];
     this.putCoupons(coupons);
   }
 
@@ -118,6 +121,10 @@ export class AdminOverviewComponent implements OnDestroy, OnInit {
     }
   }
 
+  public onChangeCouponDuration(aCouponDuration: StringValue) {
+    this.couponDuration = aCouponDuration;
+  }
+
   public onDeleteCoupon(aCouponCode: string) {
     const confirmation = confirm('Do you really want to delete this coupon?');
 

apps/client/src/app/components/admin-overview/admin-overview.html

@@ -156,11 +156,14 @@
               ></mat-slide-toggle>
             </div>
           </div>
-          <div *ngIf="hasPermissionForSubscription" class="d-flex my-3">
+          <div
+            *ngIf="hasPermissionForSubscription"
+            class="d-flex my-3 subscription"
+          >
             <div class="w-50" i18n>Coupons</div>
             <div class="w-50">
               <div *ngFor="let coupon of coupons">
-                <span>{{ coupon.code }}</span>
+                <span>{{ coupon.code }} ({{ coupon.duration }})</span>
                 <button
                   class="mini-icon mx-1 no-min-width px-2"
                   mat-button
@@ -170,10 +173,27 @@
                 </button>
               </div>
               <div class="mt-2">
-                <button color="primary" mat-flat-button (click)="onAddCoupon()">
-                  <ion-icon class="mr-1" name="add-outline"></ion-icon>
-                  <span i18n>Add Coupon</span>
-                </button>
+                <form #couponForm="ngForm">
+                  <mat-form-field appearance="outline" class="mr-2">
+                    <mat-select
+                      name="duration"
+                      [value]="couponDuration"
+                      (selectionChange)="onChangeCouponDuration($event.value)"
+                    >
+                      <mat-option value="7 days">7 Days</mat-option>
+                      <mat-option value="14 days">14 Days</mat-option>
+                      <mat-option value="30 days">30 Days</mat-option>
+                      <mat-option value="1 year">1 Year</mat-option>
+                    </mat-select>
+                  </mat-form-field>
+                  <button
+                    color="primary"
+                    mat-flat-button
+                    (click)="onAddCoupon()"
+                  >
+                    <span i18n>Add</span>
+                  </button>
+                </form>
               </div>
             </div>
           </div>

apps/client/src/app/components/admin-overview/admin-overview.module.ts

@@ -1,7 +1,9 @@
 import { CommonModule } from '@angular/common';
 import { CUSTOM_ELEMENTS_SCHEMA, NgModule } from '@angular/core';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
 import { MatButtonModule } from '@angular/material/button';
 import { MatCardModule } from '@angular/material/card';
+import { MatSelectModule } from '@angular/material/select';
 import { MatSlideToggleModule } from '@angular/material/slide-toggle';
 import { CacheService } from '@ghostfolio/client/services/cache.service';
 import { GfValueModule } from '@ghostfolio/ui/value';
@@ -12,11 +14,14 @@ import { AdminOverviewComponent } from './admin-overview.component';
   declarations: [AdminOverviewComponent],
   exports: [],
   imports: [
+    FormsModule,
     CommonModule,
     GfValueModule,
     MatButtonModule,
     MatCardModule,
-    MatSlideToggleModule
+    MatSelectModule,
+    MatSlideToggleModule,
+    ReactiveFormsModule
   ],
   providers: [CacheService],
   schemas: [CUSTOM_ELEMENTS_SCHEMA]

apps/client/src/app/components/admin-overview/admin-overview.scss

@@ -20,4 +20,10 @@
       }
     }
   }
+
+  .subscription {
+    .mat-form-field {
+      max-width: 100%;
+    }
+  }
 }

apps/client/src/app/components/admin-users/admin-users.html

@@ -14,12 +14,12 @@
                 Accounts
               </th>
               <th class="mat-header-cell px-1 py-2 text-right" i18n>
-                Transactions
+                Activities
               </th>
               <th class="mat-header-cell px-1 py-2 text-right" i18n>
                 Engagement per Day
               </th>
-              <th class="mat-header-cell px-1 py-2" i18n>Last Activitiy</th>
+              <th class="mat-header-cell px-1 py-2" i18n>Last Request</th>
               <th class="mat-header-cell px-1 py-2"></th>
             </tr>
           </thead>

apps/client/src/app/components/fear-and-greed-index/fear-and-greed-index.component.ts

@@ -24,12 +24,9 @@ export class FearAndGreedIndexComponent implements OnChanges, OnInit {
   public ngOnInit() {}
 
   public ngOnChanges() {
-    this.fearAndGreedIndexEmoji = resolveFearAndGreedIndex(
-      this.fearAndGreedIndex
-    ).emoji;
+    const { emoji, text } = resolveFearAndGreedIndex(this.fearAndGreedIndex);
 
-    this.fearAndGreedIndexText = resolveFearAndGreedIndex(
-      this.fearAndGreedIndex
-    ).text;
+    this.fearAndGreedIndexEmoji = emoji;
+    this.fearAndGreedIndexText = text;
   }
 }

apps/client/src/app/components/header/header.component.html

@@ -238,6 +238,17 @@
       ></gf-logo>
     </a>
     <span class="spacer"></span>
+    <a
+      class="d-none d-sm-block mx-1"
+      i18n
+      mat-flat-button
+      [ngClass]="{
+        'font-weight-bold': currentRoute === 'features',
+        'text-decoration-underline': currentRoute === 'features'
+      }"
+      [routerLink]="['/features']"
+      >Features</a
+    >
     <a
       class="d-none d-sm-block mx-1"
       i18n