Release 1.123.0 (#739)

* Eliminate currency, data source and symbol from order model

* Remove prefix for symbols with data source GHOSTFOLIO

* Update changelog

.gitignore

@@ -23,6 +23,7 @@
 !.vscode/settings.json
 
 # misc
+/.angular/cache
 /.sass-cache
 /connect.lock
 /coverage

.travis.yml

@@ -3,9 +3,28 @@ git:
   depth: false
 node_js:
   - 14
-before_script:
-  - yarn
-script:
-  - yarn format:check
-  - yarn test
-  - yarn build:all
+
+services:
+  - docker
+
+cache: yarn
+
+if: (type = pull_request) OR (tag IS present)
+
+jobs:
+  include:
+    - stage: Install dependencies
+      if: type = pull_request
+      script: yarn --frozen-lockfile
+    - stage: Check formatting
+      if: type = pull_request
+      script: yarn format:check
+    - stage: Execute tests
+      if: type = pull_request
+      script: yarn test
+    - stage: Build application
+      if: type = pull_request
+      script: yarn build:all
+    - stage: Build and publish docker image
+      if: tag IS present
+      script: ./publish-docker-image.sh

CHANGELOG.md

@@ -5,6 +5,620 @@ 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.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
+
+- Fixed the creation of (wealth) items
+
+## 1.114.0 - 10.02.2022
+
+### Added
+
+- Added support for (wealth) items
+
+### Todo
+
+- Apply data migration (`yarn database:migrate`)
+
+## 1.113.0 - 09.02.2022
+
+### Changed
+
+- Improved the position of the currency column in the accounts table
+- Improved the position of the currency column in the activities table
+
+### Fixed
+
+- Fixed an issue with the performance calculation in connection with fees in the new calculation engine
+
+## 1.112.1 - 06.02.2022
+
+### Fixed
+
+- Fixed the creation of the user account (missing access token)
+
+## 1.112.0 - 06.02.2022
+
+### Added
+
+- Added the export functionality to the position detail dialog
+
+### Changed
+
+- Improved the export functionality for activities (respect filtering)
+- Removed the _Admin_ user from the database seeding
+- Assigned the role `ADMIN` on sign up (only if there is no admin yet)
+- Upgraded `prisma` from version `3.8.1` to `3.9.1`
+
+### Fixed
+
+- Fixed an issue with the performance calculation in connection with a sell activity in the new calculation engine
+- Fixed the horizontal overflow in the accounts table
+- Fixed the horizontal overflow in the activities table
+- Fixed the total value of the activities table in the position detail dialog (absolute value)
+
+### Todo
+
+- Apply data migration (`yarn database:migrate`)
+
+## 1.111.0 - 03.02.2022
+
+### Added
+
+- Added support for deleting symbol profile data in the admin control panel
+
+### Changed
+
+- Used `dataSource` and `symbol` from `SymbolProfile` instead of the `order` object (in `ExportService` and `PortfolioService`)
+
+### Fixed
+
+- Fixed the symbol selection of the 7d data gathering
+
+## 1.110.0 - 02.02.2022
+
+### Fixed
+
+- Fixed the data source of the _Fear & Greed Index_ (market mood)
+
+### Todo
+
+- Apply data migration (`yarn database:migrate`)
+
+## 1.109.0 - 01.02.2022
+
+### Added
+
+- Added support for the (optional) `accountId` in the import functionality for activities
+- Added support for the (optional) `dataSource` in the import functionality for activities
+- Added support for the data source transformation
+- Added support for the cryptocurrency _Mina Protocol_ (`MINA-USD`)
+
+### Changed
+
+- Improved the usability of the form in the create or edit transaction dialog
+- Improved the consistent use of `symbol` in combination with `dataSource`
+- Removed the primary data source from the client
+
+### Removed
+
+- Removed the unused endpoint `GET api/order/:id`
+
+## 1.108.0 - 27.01.2022
+
+### Changed
+
+- Improved the annualized performance in the new calculation engine
+- Increased the historical data chart of the _Fear & Greed Index_ (market mood) to 90 days
+
+## 1.107.0 - 24.01.2022
+
+### Added
+
+- Added a new calculation engine (experimental)
+
+### Fixed
+
+- Fixed the styling in the footer row of the activities table
+
+## 1.106.0 - 23.01.2022
+
+### Added
+
+- Added the footer row with total fees and total value to the activities table
+
+### Changed
+
+- Extended the historical data view in the admin control panel
+- Upgraded _Stripe_ dependencies
+- Upgraded `prisma` from version `3.7.0` to `3.8.1`
+
+### Fixed
+
+- Improved the redirection on logout
+
+## 1.105.0 - 20.01.2022
+
+### Added
+
+- Added support for fetching multiple symbols in the `GOOGLE_SHEETS` data provider
+
+### Changed
+
+- Improved the data provider with grouping by data source and thereby reducing the number of requests
+
+### Fixed
+
+- Fixed the unresolved account names in the _X-ray_ section
+- Fixed the date conversion in the `GOOGLE_SHEETS` data provider
+
+## 1.104.0 - 16.01.2022
+
+### Fixed
+
+- Fixed the fallback to load currencies directly from the data provider
+- Fixed the missing symbol profile data connection in the import functionality for activities
+
+## 1.103.0 - 13.01.2022
+
+### Changed
+
+- Added links to the statistics section on the about page
+
+### Fixed
+
+- Fixed the currency of the value in the position detail dialog
+
+## 1.102.0 - 11.01.2022
+
+### Changed
+
+- Start eliminating `dataSource` from activity
+
+### Fixed
+
+- Fixed the support for multiple accounts with the same name
+- Fixed the preselected default account of the create activity dialog
+
+## 1.101.0 - 08.01.2022
+
+### Added
+
+- Added `GOOGLE_SHEETS` as a new data source type
+
+### Changed
+
+- Excluded the url pattern of shared portfolios in the `robots.txt` file
+
+### Todo
+
+- Apply data migration (`yarn database:migrate`)
+
+## 1.100.0 - 05.01.2022
+
+### Added
+
+- Added the _Top 3_ and _Bottom 3_ performers to the analysis page
+- Added a blog post
+
+### Fixed
+
+- Fixed the routing of the create activity dialog
+- Fixed the link color in the blog posts
+
+## 1.99.0 - 01.01.2022
+
+### Added
+
+- Exposed the profile data gathering by symbol as an endpoint
+
+### Changed
+
+- Improved the portfolio analysis page: show the y-axis and extend the chart in relation to the days in market
+- Restructured the about page
+- Start refactoring _transactions_ to _activities_
+- Refactored the demo user id
+- Upgraded `angular` from version `13.0.2` to `13.1.1`
+- Upgraded `chart.js` from version `3.5.0` to `3.7.0`
+- Upgraded `Nx` from version `13.3.0` to `13.4.1`
+
+### Fixed
+
+- Hid the data provider warning while loading
+- Fixed an exception with the market state caused by a failed data provider request
+- Fixed an exception in the portfolio position endpoint
+- Fixed the reload of the position detail dialog (with query parameters)
+- Fixed the missing mapping for Russia in the data enhancer for symbol profile data via _Trackinsight_
+
+## 1.98.0 - 29.12.2021
+
+### Added
+
+- Added the date range component to the holdings tab
+
+### Changed
+
+- Extended the statistics section on the about page (users in Slack community)
+
+### Fixed
+
+- Fixed the creation of historical data in the admin control panel (upsert instead of update)
+- Fixed the scrolling issue in the position detail dialog on mobile
+
+## 1.97.0 - 28.12.2021
+
+### Added
+
+- Added the transactions to the position detail dialog
+- Added support for dividend
+
+### Todo
+
+- Apply data migration (`yarn database:migrate`)
+
+## 1.96.0 - 27.12.2021
+
+### Changed
+
+- Made the data provider warning more discreet
+- Upgraded `http-status-codes` from version `2.1.4` to `2.2.0`
+- Upgraded `ngx-device-detector` from version `2.1.1` to `3.0.0`
+- Upgraded `ngx-markdown` from version `12.0.1` to `13.0.0`
+- Upgraded `ngx-stripe` from version `12.0.2` to `13.0.0`
+- Upgraded `prisma` from version `3.6.0` to `3.7.0`
+
+### Fixed
+
+- Fixed the file type detection in the import functionality for transactions
+
+## 1.95.0 - 26.12.2021
+
+### Added
+
+- Added a warning to the log if the data gathering fails
+
+### Fixed
+
+- Filtered potential `null` currencies
+- Improved the 7d data gathering optimization for currencies
+
+## 1.94.0 - 25.12.2021
+
+### Added
+
+- Added support for cryptocurrencies _Cosmos_ (`ATOM-USD`) and _Polkadot_ (`DOT-USD`)
+
+### Changed
+
+- Increased the historical data chart of the _Fear & Greed Index_ (market mood) to 30 days
+- Made the import functionality for transactions by `csv` files more flexible
+- Optimized the 7d data gathering (only consider symbols with incomplete market data)
+- Upgraded `prettier` from version `2.3.2` to `2.5.1`
+
+## 1.93.0 - 21.12.2021
+
+### Added
+
+- Added support for the cryptocurrency _Solana_ (`SOL-USD`)
+- Extended the documentation for self-hosting with the [official Ghostfolio Docker image](https://hub.docker.com/r/ghostfolio/ghostfolio)
+
+### Fixed
+
+- Converted errors to warnings in portfolio calculator
+
+## 1.92.0 - 19.12.2021
+
+### Added
+
+- Added a line chart to the historical data view in the admin control panel
+- Supported the update of historical data in the admin control panel
+
+### Fixed
+
+- Improved the redirection on logout
+- Fixed the permission for the system status page
+
+## 1.91.0 - 18.12.2021
+
+### Changed
+
+- Removed the redundant all time high and all time low from the performance endpoint
+
+### Fixed
+
+- Fixed the symbol conversion from _Yahoo Finance_ including a hyphen
+- Fixed hidden values (`0`) in the statistics section on the about page
+
+### Todo
+
+- Apply data migration (`yarn database:migrate`)
+
+## 1.90.0 - 14.12.2021
+
+### Added
+
+- Extended the validation in the import functionality for transactions by checking the currency of the data provider service
+- Added support for cryptocurrency _Uniswap_
+- Set up pipeline for docker build
+
+### Changed
+
+- Removed the default transactions import limit
+- Improved the landing page in dark mode
+
+### Fixed
+
+- Fixed `/bin/sh: prisma: not found` in docker build
+- Added `apk` in `Dockerfile` (`python3 g++ make openssl`)
+
+## 1.89.0 - 11.12.2021
+
+### Added
+
+- Extended the data gathering by symbol endpoint with an optional date
+
+### Changed
+
+- Upgraded `Nx` from version `13.2.2` to `13.3.0`
+- Upgraded `storybook` from version `6.4.0-rc.3` to `6.4.9`
+
+## 1.88.0 - 09.12.2021
+
+### Added
+
+- Added a coupon system
+
+## 1.87.0 - 07.12.2021
+
+### Added
+
+- Supported the management of additional currencies in the admin control panel
+- Introduced the system message
+- Introduced the read only mode
+
+### Changed
+
+- Increased the historical data chart of the _Fear & Greed Index_ (market mood) to 10 days
+- Upgraded `prisma` from version `2.30.2` to `3.6.0`
+
+## 1.86.0 - 04.12.2021
+
+### Added
+
+- Added the historical data chart of the _Fear & Greed Index_ (market mood)
+
+### Changed
+
+- Improved the historical data view in the admin control panel (hide invalid and future dates)
+- Enabled the import functionality for transactions by default
+- Converted the symbols to uppercase to avoid case-sensitive duplicates in the symbol profile model
+
+### Fixed
+
+- Improved the allocations by currency in combination with cash balances
+
+## 1.85.0 - 01.12.2021
+
+### Fixed
+
+- Fixed the data gathering of the _Fear & Greed Index_ (market mood)
+
+## 1.84.0 - 30.11.2021
+
+### Added
+
+- Exposed the data gathering by symbol as an endpoint
+
+## 1.83.0 - 29.11.2021
+
+### Changed
+
+- Removed the experimental API
+
+### Fixed
+
+- Eliminated the redundant storage of historical exchange rates
+
+## 1.82.0 - 28.11.2021
+
+### Added
+
+- Added tabs with routing to the admin control panel
+- Added a new tab to manage historical data to the admin control panel
+
+### Changed
+
+- Introduced tabs with routing to the home page
+
+## 1.81.0 - 27.11.2021
+
+### Added
+
+- Added the value to the position detail dialog
+
+### Changed
+
+- Upgraded `angular` from version `12.2.4` to `13.0.2`
+- Upgraded `angular-material-css-vars` from version `2.1.2` to `3.0.0`
+- Upgraded `nestjs` from version `7.6.18` to `8.2.3`
+- Upgraded `Nx` from version `12.8.0` to `13.2.2`
+- Upgraded `rxjs` from version `6.6.7` to `7.4.0`
+- Upgraded `storybook` from version `6.3.8` to `6.4.0-rc.3`
+
+### Fixed
+
+- Fixed the broken line charts showing value labels if openend from the allocations page
+- Fixed the click event for drafts in the transactions table
+
+## 1.80.0 - 23.11.2021
+
+### Added
+
+- Accentuated the all time high and the all time low
+
+## 1.79.0 - 21.11.2021
+
+### Added
+
+- Added the value column to the positions table
+- Added support for cryptocurrency _Algorand_
+
+### Changed
+
+- Locked the symbol input in the edit transaction dialog
+- Filtered the account selector by account type (`SECURITIES`) in the create or edit transaction dialog
+
+### Fixed
+
+- Fixed the search functionality for cryptocurrency symbols (do not show unsupported symbols)
+
+## 1.78.0 - 20.11.2021
+
+### Added
+
+- Added a testimonial section to the landing page
+
+### Fixed
+
+- Fixed the footer row border of the accounts table in dark mode
+
+## 1.77.0 - 16.11.2021
+
+### Changed
+
+- Hid the _Get Started_ button on the registration page
+
+### Fixed
+
+- Fixed the footer row of the accounts table on mobile
+- Fixed the transactions count calculation in the accounts table (exclude drafts)
+
+## 1.76.0 - 14.11.2021
+
+### Added
+
+- Added the footer row with buying power and net worth to the accounts table
+
+## 1.75.0 - 13.11.2021
+
+### Added
+
+- Added a logo to the log on the server start
+- Added the data gathering progress to the log and the admin control panel
+- Added the value column to the accounts table
+
 ## 1.74.0 - 11.11.2021
 
 ### Changed

Dockerfile

@@ -12,7 +12,8 @@ COPY ./package.json package.json
 COPY ./yarn.lock yarn.lock
 COPY ./prisma/schema.prisma prisma/schema.prisma
 
-RUN yarn
+RUN apk add --no-cache python3 g++ make openssl
+RUN yarn install
 
 # See https://github.com/nrwl/nx/issues/6586 for further details
 COPY ./decorate-angular-cli.js decorate-angular-cli.js

README.md

@@ -12,7 +12,7 @@
     <strong>Open Source Wealth Management Software made for Humans</strong>
   </p>
   <p>
-    <a href="https://ghostfol.io"><strong>Live Demo</strong></a> | <a href="https://ghostfol.io/pricing"><strong>Ghostfolio Premium</strong></a> | <a href="https://ghostfol.io/en/blog/2021/07/hello-ghostfolio"><strong>Blog</strong></a> | <a href="https://join.slack.com/t/ghostfolio/shared_invite/zt-vsaan64h-F_I0fEo5M0P88lP9ibCxFg"><strong>Slack</strong></a> | <a href="https://twitter.com/ghostfolio_"><strong>Twitter</strong></a>
+    <a href="https://ghostfol.io"><strong>Live Demo</strong></a> | <a href="https://ghostfol.io/pricing"><strong>Ghostfolio Premium</strong></a> | <a href="https://ghostfol.io/blog"><strong>Blog</strong></a> | <a href="https://join.slack.com/t/ghostfolio/shared_invite/zt-vsaan64h-F_I0fEo5M0P88lP9ibCxFg"><strong>Slack</strong></a> | <a href="https://twitter.com/ghostfolio_"><strong>Twitter</strong></a>
   </p>
   <p>
     <a href="#contributing">
@@ -34,28 +34,20 @@
 
 Our official **[Ghostfolio Premium](https://ghostfol.io/pricing)** cloud offering is the easiest way to get started. Due to the time it saves, this will be the best option for most people. The revenue is used for covering the hosting costs.
 
-If you prefer to run Ghostfolio on your own infrastructure, please find further instructions in the section [Run with Docker](#run-with-docker).
+If you prefer to run Ghostfolio on your own infrastructure (self-hosting), please find further instructions in the section [Run with Docker](#run-with-docker-self-hosting).
 
 ## Why Ghostfolio?
 
 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
@@ -81,34 +74,50 @@ The backend is based on [NestJS](https://nestjs.com) using [PostgreSQL](https://
 
 The frontend is built with [Angular](https://angular.io) and uses [Angular Material](https://material.angular.io) with utility classes from [Bootstrap](https://getbootstrap.com).
 
-## Run with Docker
+## Run with Docker (self-hosting)
 
 ### Prerequisites
 
 - [Docker](https://www.docker.com/products/docker-desktop)
 
-### Setup Docker Image
+### a. Run environment
 
-Run the following commands to build and start the Docker image:
+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-build-local.yml build
-docker-compose -f docker/docker-compose-build-local.yml up
+docker-compose -f docker/docker-compose.yml up -d
 ```
 
-### Setup Database
+#### Setup Database
 
 Run the following command to setup the database once Ghostfolio is running:
 
 ```bash
-docker-compose -f docker/docker-compose-build-local.yml exec ghostfolio yarn database:setup
+docker-compose -f docker/docker-compose.yml exec ghostfolio yarn database:setup
+```
+
+### b. Build and run environment
+
+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 -d
+```
+
+#### Setup Database
+
+Run the following command to setup the database once Ghostfolio is running:
+
+```bash
+docker-compose -f docker/docker-compose.build.yml exec ghostfolio yarn database:setup
 ```
 
 ### Fetch Historical Data
 
 Open http://localhost:3333 in your browser and accomplish these steps:
 
-1. Login as _Admin_ with the following _Security Token_: `ae76872ae8f3419c6d6f64bf51888ecbcc703927a342d815fafe486acdb938da07d0cf44fca211a0be74a423238f535362d390a41e81e633a9ce668a6e31cdf9`
+1. Create a new user via _Get Started_ (this first user will get the role `ADMIN`)
 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_
 
@@ -131,12 +140,10 @@ docker-compose -f docker/docker-compose-build-local.yml exec ghostfolio yarn dat
 ### Setup
 
 1. Run `yarn install`
-1. Run `cd docker`
-1. Run `docker compose up -d` to start [PostgreSQL](https://www.postgresql.org) and [Redis](https://redis.io)
-1. Run `cd -` to go back to the project root directory
+1. Run `docker-compose -f docker/docker-compose.dev.yml up -d` to start [PostgreSQL](https://www.postgresql.org) and [Redis](https://redis.io)
 1. Run `yarn database:setup` to initialize the database schema and populate your database with (example) data
-1. Start server and client (see [_Development_](#Development))
-1. Login as _Admin_ with the following _Security Token_: `ae76872ae8f3419c6d6f64bf51888ecbcc703927a342d815fafe486acdb938da07d0cf44fca211a0be74a423238f535362d390a41e81e633a9ce668a6e31cdf9`
+1. Start the server and the client (see [_Development_](#Development))
+1. Create a new user via _Get Started_ (this first user will get the role `ADMIN`)
 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_
 
@@ -167,6 +174,6 @@ Not sure what to work on? We have got some ideas. Please join the Ghostfolio [Sl
 
 ## License
 
-© 2021 [Ghostfolio](https://ghostfol.io)
+© 2022 [Ghostfolio](https://ghostfol.io)
 
 Licensed under the [AGPLv3 License](https://www.gnu.org/licenses/agpl-3.0.html).

angular.json

@@ -1,22 +1,5 @@
 {
   "version": 1,
-  "cli": {
-    "defaultCollection": "@nrwl/nest"
-  },
-  "defaultProject": "api",
-  "schematics": {
-    "@nrwl/angular:application": {
-      "linter": "eslint",
-      "unitTestRunner": "jest",
-      "e2eTestRunner": "cypress"
-    },
-    "@nrwl/angular:library": {
-      "linter": "eslint",
-      "unitTestRunner": "jest"
-    },
-    "@nrwl/nest": {},
-    "@nrwl/angular:component": {}
-  },
   "projects": {
     "api": {
       "root": "apps/api",
@@ -69,7 +52,8 @@
           },
           "outputs": ["coverage/apps/api"]
         }
-      }
+      },
+      "tags": []
     },
     "client": {
       "projectType": "application",
@@ -201,7 +185,8 @@
           },
           "outputs": ["coverage/apps/client"]
         }
-      }
+      },
+      "tags": []
     },
     "client-e2e": {
       "root": "apps/client-e2e",
@@ -221,7 +206,9 @@
             }
           }
         }
-      }
+      },
+      "tags": [],
+      "implicitDependencies": ["client"]
     },
     "common": {
       "root": "libs/common",
@@ -242,7 +229,8 @@
             "passWithNoTests": true
           }
         }
-      }
+      },
+      "tags": []
     },
     "ui": {
       "projectType": "library",
@@ -276,7 +264,8 @@
             "port": 4400,
             "config": {
               "configFolder": "libs/ui/.storybook"
-            }
+            },
+            "projectBuildConfig": "ui:build-storybook"
           },
           "configurations": {
             "ci": {
@@ -292,7 +281,8 @@
             "outputPath": "dist/storybook/ui",
             "config": {
               "configFolder": "libs/ui/.storybook"
-            }
+            },
+            "projectBuildConfig": "ui:build-storybook"
           },
           "configurations": {
             "ci": {
@@ -300,7 +290,8 @@
             }
           }
         }
-      }
+      },
+      "tags": []
     },
     "ui-e2e": {
       "root": "apps/ui-e2e",
@@ -326,7 +317,9 @@
             "lintFilePatterns": ["apps/ui-e2e/**/*.{js,ts}"]
           }
         }
-      }
+      },
+      "tags": [],
+      "implicitDependencies": ["ui"]
     }
   }
 }

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

@@ -1,9 +1,5 @@
 import { Access } from '@ghostfolio/common/interfaces';
-import {
-  getPermissions,
-  hasPermission,
-  permissions
-} from '@ghostfolio/common/permissions';
+import { hasPermission, permissions } from '@ghostfolio/common/permissions';
 import type { RequestWithUser } from '@ghostfolio/common/types';
 import {
   Body,
@@ -66,10 +62,7 @@ export class AccessController {
     @Body() data: CreateAccessDto
   ): Promise<AccessModel> {
     if (
-      !hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.createAccess
-      )
+      !hasPermission(this.request.user.permissions, permissions.createAccess)
     ) {
       throw new HttpException(
         getReasonPhrase(StatusCodes.FORBIDDEN),
@@ -86,10 +79,7 @@ export class AccessController {
   @UseGuards(AuthGuard('jwt'))
   public async deleteAccess(@Param('id') id: string): Promise<AccessModule> {
     if (
-      !hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.deleteAccess
-      )
+      !hasPermission(this.request.user.permissions, permissions.deleteAccess)
     ) {
       throw new HttpException(
         getReasonPhrase(StatusCodes.FORBIDDEN),

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/access/access.service.ts

@@ -24,7 +24,7 @@ export class AccessService {
     take?: number;
     cursor?: Prisma.AccessWhereUniqueInput;
     where?: Prisma.AccessWhereInput;
-    orderBy?: Prisma.AccessOrderByInput;
+    orderBy?: Prisma.AccessOrderByWithRelationInput;
   }): Promise<AccessWithGranteeUser[]> {
     const { include, skip, take, cursor, where, orderBy } = params;
 

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

@@ -1,11 +1,12 @@
+import { PortfolioServiceStrategy } from '@ghostfolio/api/app/portfolio/portfolio-service.strategy';
 import { UserService } from '@ghostfolio/api/app/user/user.service';
-import { nullifyValuesInObjects } from '@ghostfolio/api/helper/object.helper';
-import { ImpersonationService } from '@ghostfolio/api/services/impersonation.service';
 import {
-  getPermissions,
-  hasPermission,
-  permissions
-} from '@ghostfolio/common/permissions';
+  nullifyValuesInObject,
+  nullifyValuesInObjects
+} from '@ghostfolio/api/helper/object.helper';
+import { ImpersonationService } from '@ghostfolio/api/services/impersonation.service';
+import { Accounts } from '@ghostfolio/common/interfaces';
+import { hasPermission, permissions } from '@ghostfolio/common/permissions';
 import type { RequestWithUser } from '@ghostfolio/common/types';
 import {
   Body,
@@ -34,6 +35,7 @@ export class AccountController {
   public constructor(
     private readonly accountService: AccountService,
     private readonly impersonationService: ImpersonationService,
+    private readonly portfolioServiceStrategy: PortfolioServiceStrategy,
     @Inject(REQUEST) private readonly request: RequestWithUser,
     private readonly userService: UserService
   ) {}
@@ -42,10 +44,7 @@ export class AccountController {
   @UseGuards(AuthGuard('jwt'))
   public async deleteAccount(@Param('id') id: string): Promise<AccountModel> {
     if (
-      !hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.deleteAccount
-      )
+      !hasPermission(this.request.user.permissions, permissions.deleteAccount)
     ) {
       throw new HttpException(
         getReasonPhrase(StatusCodes.FORBIDDEN),
@@ -85,30 +84,40 @@ export class AccountController {
   @UseGuards(AuthGuard('jwt'))
   public async getAllAccounts(
     @Headers('impersonation-id') impersonationId
-  ): Promise<AccountModel[]> {
+  ): Promise<Accounts> {
     const impersonationUserId =
       await this.impersonationService.validateImpersonationId(
         impersonationId,
         this.request.user.id
       );
 
-    let accounts = await this.accountService.getAccounts(
-      impersonationUserId || this.request.user.id
-    );
+    let accountsWithAggregations = await this.portfolioServiceStrategy
+      .get()
+      .getAccountsWithAggregations(impersonationUserId || this.request.user.id);
 
     if (
       impersonationUserId ||
       this.userService.isRestrictedView(this.request.user)
     ) {
-      accounts = nullifyValuesInObjects(accounts, [
-        'balance',
-        'fee',
-        'quantity',
-        'unitPrice'
-      ]);
+      accountsWithAggregations = {
+        ...nullifyValuesInObject(accountsWithAggregations, [
+          'totalBalanceInBaseCurrency',
+          'totalValueInBaseCurrency'
+        ]),
+        accounts: nullifyValuesInObjects(accountsWithAggregations.accounts, [
+          'balance',
+          'balanceInBaseCurrency',
+          'convertedBalance',
+          'fee',
+          'quantity',
+          'unitPrice',
+          'value',
+          'valueInBaseCurrency'
+        ])
+      };
     }
 
-    return accounts;
+    return accountsWithAggregations;
   }
 
   @Get(':id')
@@ -128,10 +137,7 @@ export class AccountController {
     @Body() data: CreateAccountDto
   ): Promise<AccountModel> {
     if (
-      !hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.createAccount
-      )
+      !hasPermission(this.request.user.permissions, permissions.createAccount)
     ) {
       throw new HttpException(
         getReasonPhrase(StatusCodes.FORBIDDEN),
@@ -168,10 +174,7 @@ export class AccountController {
   @UseGuards(AuthGuard('jwt'))
   public async update(@Param('id') id: string, @Body() data: UpdateAccountDto) {
     if (
-      !hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.updateAccount
-      )
+      !hasPermission(this.request.user.permissions, permissions.updateAccount)
     ) {
       throw new HttpException(
         getReasonPhrase(StatusCodes.FORBIDDEN),

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

@@ -1,3 +1,4 @@
+import { PortfolioModule } from '@ghostfolio/api/app/portfolio/portfolio.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';
@@ -11,16 +12,18 @@ import { AccountController } from './account.controller';
 import { AccountService } from './account.service';
 
 @Module({
+  controllers: [AccountController],
+  exports: [AccountService],
   imports: [
     ConfigurationModule,
     DataProviderModule,
     ExchangeRateDataModule,
     ImpersonationModule,
-    RedisCacheModule,
+    PortfolioModule,
     PrismaModule,
+    RedisCacheModule,
     UserModule
   ],
-  controllers: [AccountController],
   providers: [AccountService]
 })
 export class AccountModule {}

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';
 
@@ -40,7 +41,7 @@ export class AccountService {
     take?: number;
     cursor?: Prisma.AccountWhereUniqueInput;
     where?: Prisma.AccountWhereInput;
-    orderBy?: Prisma.AccountOrderByInput;
+    orderBy?: Prisma.AccountOrderByWithRelationInput;
   }): Promise<
     (Account & {
       Order?: Order[];
@@ -85,7 +86,15 @@ export class AccountService {
     });
 
     return accounts.map((account) => {
-      const result = { ...account, transactionCount: account.Order.length };
+      let transactionCount = 0;
+
+      for (const order of account.Order) {
+        if (!order.isDraft) {
+          transactionCount += 1;
+        }
+      }
+
+      const result = { ...account, transactionCount };
 
       delete result.Order;
 
@@ -97,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.controller.ts

@@ -1,30 +1,40 @@
 import { DataGatheringService } from '@ghostfolio/api/services/data-gathering.service';
-import { AdminData } from '@ghostfolio/common/interfaces';
+import { MarketDataService } from '@ghostfolio/api/services/market-data.service';
+import { PropertyDto } from '@ghostfolio/api/services/property/property.dto';
 import {
-  getPermissions,
-  hasPermission,
-  permissions
-} from '@ghostfolio/common/permissions';
+  AdminData,
+  AdminMarketData,
+  AdminMarketDataDetails
+} from '@ghostfolio/common/interfaces';
+import { hasPermission, permissions } from '@ghostfolio/common/permissions';
 import type { RequestWithUser } from '@ghostfolio/common/types';
 import {
+  Body,
   Controller,
+  Delete,
   Get,
   HttpException,
   Inject,
+  Param,
   Post,
+  Put,
   UseGuards
 } from '@nestjs/common';
 import { REQUEST } from '@nestjs/core';
 import { AuthGuard } from '@nestjs/passport';
+import { DataSource, MarketData } from '@prisma/client';
+import { isDate } from 'date-fns';
 import { StatusCodes, getReasonPhrase } from 'http-status-codes';
 
 import { AdminService } from './admin.service';
+import { UpdateMarketDataDto } from './update-market-data.dto';
 
 @Controller('admin')
 export class AdminController {
   public constructor(
     private readonly adminService: AdminService,
     private readonly dataGatheringService: DataGatheringService,
+    private readonly marketDataService: MarketDataService,
     @Inject(REQUEST) private readonly request: RequestWithUser
   ) {}
 
@@ -33,7 +43,7 @@ export class AdminController {
   public async getAdminData(): Promise<AdminData> {
     if (
       !hasPermission(
-        getPermissions(this.request.user.role),
+        this.request.user.permissions,
         permissions.accessAdminControl
       )
     ) {
@@ -51,7 +61,7 @@ export class AdminController {
   public async gatherMax(): Promise<void> {
     if (
       !hasPermission(
-        getPermissions(this.request.user.role),
+        this.request.user.permissions,
         permissions.accessAdminControl
       )
     ) {
@@ -72,7 +82,7 @@ export class AdminController {
   public async gatherProfileData(): Promise<void> {
     if (
       !hasPermission(
-        getPermissions(this.request.user.role),
+        this.request.user.permissions,
         permissions.accessAdminControl
       )
     ) {
@@ -86,4 +96,199 @@ export class AdminController {
 
     return;
   }
+
+  @Post('gather/profile-data/:dataSource/:symbol')
+  @UseGuards(AuthGuard('jwt'))
+  public async gatherProfileDataForSymbol(
+    @Param('dataSource') dataSource: DataSource,
+    @Param('symbol') symbol: string
+  ): Promise<void> {
+    if (
+      !hasPermission(
+        this.request.user.permissions,
+        permissions.accessAdminControl
+      )
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    this.dataGatheringService.gatherProfileData([{ dataSource, symbol }]);
+
+    return;
+  }
+
+  @Post('gather/:dataSource/:symbol')
+  @UseGuards(AuthGuard('jwt'))
+  public async gatherSymbol(
+    @Param('dataSource') dataSource: DataSource,
+    @Param('symbol') symbol: string
+  ): Promise<void> {
+    if (
+      !hasPermission(
+        this.request.user.permissions,
+        permissions.accessAdminControl
+      )
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    this.dataGatheringService.gatherSymbol({ dataSource, symbol });
+
+    return;
+  }
+
+  @Post('gather/:dataSource/:symbol/:dateString')
+  @UseGuards(AuthGuard('jwt'))
+  public async gatherSymbolForDate(
+    @Param('dataSource') dataSource: DataSource,
+    @Param('dateString') dateString: string,
+    @Param('symbol') symbol: string
+  ): Promise<MarketData> {
+    if (
+      !hasPermission(
+        this.request.user.permissions,
+        permissions.accessAdminControl
+      )
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    const date = new Date(dateString);
+
+    if (!isDate(date)) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.BAD_REQUEST),
+        StatusCodes.BAD_REQUEST
+      );
+    }
+
+    return this.dataGatheringService.gatherSymbolForDate({
+      dataSource,
+      date,
+      symbol
+    });
+  }
+
+  @Get('market-data')
+  @UseGuards(AuthGuard('jwt'))
+  public async getMarketData(): Promise<AdminMarketData> {
+    if (
+      !hasPermission(
+        this.request.user.permissions,
+        permissions.accessAdminControl
+      )
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    return this.adminService.getMarketData();
+  }
+
+  @Get('market-data/:dataSource/:symbol')
+  @UseGuards(AuthGuard('jwt'))
+  public async getMarketDataBySymbol(
+    @Param('dataSource') dataSource: DataSource,
+    @Param('symbol') symbol: string
+  ): Promise<AdminMarketDataDetails> {
+    if (
+      !hasPermission(
+        this.request.user.permissions,
+        permissions.accessAdminControl
+      )
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    return this.adminService.getMarketDataBySymbol({ dataSource, symbol });
+  }
+
+  @Put('market-data/:dataSource/:symbol/:dateString')
+  @UseGuards(AuthGuard('jwt'))
+  public async update(
+    @Param('dataSource') dataSource: DataSource,
+    @Param('dateString') dateString: string,
+    @Param('symbol') symbol: string,
+    @Body() data: UpdateMarketDataDto
+  ) {
+    if (
+      !hasPermission(
+        this.request.user.permissions,
+        permissions.accessAdminControl
+      )
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    const date = new Date(dateString);
+
+    return this.marketDataService.updateMarketData({
+      data: { ...data, dataSource },
+      where: {
+        date_symbol: {
+          date,
+          symbol
+        }
+      }
+    });
+  }
+
+  @Delete('profile-data/:dataSource/:symbol')
+  @UseGuards(AuthGuard('jwt'))
+  public async deleteProfileData(
+    @Param('dataSource') dataSource: DataSource,
+    @Param('symbol') symbol: string
+  ): Promise<void> {
+    if (
+      !hasPermission(
+        this.request.user.permissions,
+        permissions.accessAdminControl
+      )
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    return this.adminService.deleteProfileData({ dataSource, symbol });
+  }
+
+  @Put('settings/:key')
+  @UseGuards(AuthGuard('jwt'))
+  public async updateProperty(
+    @Param('key') key: string,
+    @Body() data: PropertyDto
+  ) {
+    if (
+      !hasPermission(
+        this.request.user.permissions,
+        permissions.accessAdminControl
+      )
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    return await this.adminService.putSetting(key, data.value);
+  }
 }

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

@@ -3,7 +3,10 @@ import { ConfigurationModule } from '@ghostfolio/api/services/configuration.modu
 import { DataGatheringModule } from '@ghostfolio/api/services/data-gathering.module';
 import { DataProviderModule } from '@ghostfolio/api/services/data-provider/data-provider.module';
 import { ExchangeRateDataModule } from '@ghostfolio/api/services/exchange-rate-data.module';
+import { MarketDataModule } from '@ghostfolio/api/services/market-data.module';
 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';
 
 import { AdminController } from './admin.controller';
@@ -15,8 +18,11 @@ import { AdminService } from './admin.service';
     DataGatheringModule,
     DataProviderModule,
     ExchangeRateDataModule,
+    MarketDataModule,
     PrismaModule,
-    SubscriptionModule
+    PropertyModule,
+    SubscriptionModule,
+    SymbolProfileModule
   ],
   controllers: [AdminController],
   providers: [AdminService],

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

@@ -2,10 +2,20 @@ import { SubscriptionService } from '@ghostfolio/api/app/subscription/subscripti
 import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
 import { DataGatheringService } from '@ghostfolio/api/services/data-gathering.service';
 import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data.service';
+import { MarketDataService } from '@ghostfolio/api/services/market-data.service';
 import { PrismaService } from '@ghostfolio/api/services/prisma.service';
-import { baseCurrency } from '@ghostfolio/common/config';
-import { AdminData } from '@ghostfolio/common/interfaces';
+import { PropertyService } from '@ghostfolio/api/services/property/property.service';
+import { SymbolProfileService } from '@ghostfolio/api/services/symbol-profile.service';
+import { PROPERTY_CURRENCIES, baseCurrency } from '@ghostfolio/common/config';
+import {
+  AdminData,
+  AdminMarketData,
+  AdminMarketDataDetails,
+  AdminMarketDataItem,
+  UniqueAsset
+} from '@ghostfolio/common/interfaces';
 import { Injectable } from '@nestjs/common';
+import { DataSource, Property } from '@prisma/client';
 import { differenceInDays } from 'date-fns';
 
 @Injectable()
@@ -14,12 +24,22 @@ export class AdminService {
     private readonly configurationService: ConfigurationService,
     private readonly dataGatheringService: DataGatheringService,
     private readonly exchangeRateDataService: ExchangeRateDataService,
+    private readonly marketDataService: MarketDataService,
     private readonly prismaService: PrismaService,
-    private readonly subscriptionService: SubscriptionService
+    private readonly propertyService: PropertyService,
+    private readonly subscriptionService: SubscriptionService,
+    private readonly symbolProfileService: SymbolProfileService
   ) {}
 
+  public async deleteProfileData({ dataSource, symbol }: UniqueAsset) {
+    await this.marketDataService.deleteMany({ dataSource, symbol });
+    await this.symbolProfileService.delete({ dataSource, symbol });
+  }
+
   public async get(): Promise<AdminData> {
     return {
+      dataGatheringProgress:
+        await this.dataGatheringService.getDataGatheringProgress(),
       exchangeRates: this.exchangeRateDataService
         .getCurrencies()
         .filter((currency) => {
@@ -37,12 +57,112 @@ export class AdminService {
           };
         }),
       lastDataGathering: await this.getLastDataGathering(),
+      settings: await this.propertyService.get(),
       transactionCount: await this.prismaService.order.count(),
       userCount: await this.prismaService.user.count(),
       users: await this.getUsersWithAnalytics()
     };
   }
 
+  public async getMarketData(): Promise<AdminMarketData> {
+    const marketData = await this.prismaService.marketData.groupBy({
+      _count: true,
+      by: ['dataSource', 'symbol']
+    });
+
+    const currencyPairsToGather: AdminMarketDataItem[] =
+      this.exchangeRateDataService
+        .getCurrencyPairs()
+        .map(({ dataSource, symbol }) => {
+          const marketDataItemCount =
+            marketData.find((marketDataItem) => {
+              return (
+                marketDataItem.dataSource === dataSource &&
+                marketDataItem.symbol === symbol
+              );
+            })?._count ?? 0;
+
+          return {
+            dataSource,
+            marketDataItemCount,
+            symbol
+          };
+        });
+
+    const symbolProfilesToGather: AdminMarketDataItem[] = (
+      await this.prismaService.symbolProfile.findMany({
+        orderBy: [{ symbol: 'asc' }],
+        select: {
+          _count: {
+            select: { Order: true }
+          },
+          dataSource: true,
+          Order: {
+            orderBy: [{ date: 'asc' }],
+            select: { date: true },
+            take: 1
+          },
+          scraperConfiguration: true,
+          symbol: true
+        }
+      })
+    ).map((symbolProfile) => {
+      const marketDataItemCount =
+        marketData.find((marketDataItem) => {
+          return (
+            marketDataItem.dataSource === symbolProfile.dataSource &&
+            marketDataItem.symbol === symbolProfile.symbol
+          );
+        })?._count ?? 0;
+
+      return {
+        marketDataItemCount,
+        activityCount: symbolProfile._count.Order,
+        dataSource: symbolProfile.dataSource,
+        date: symbolProfile.Order?.[0]?.date,
+        symbol: symbolProfile.symbol
+      };
+    });
+
+    return {
+      marketData: [...currencyPairsToGather, ...symbolProfilesToGather]
+    };
+  }
+
+  public async getMarketDataBySymbol({
+    dataSource,
+    symbol
+  }: UniqueAsset): Promise<AdminMarketDataDetails> {
+    return {
+      marketData: await this.marketDataService.marketDataItems({
+        orderBy: {
+          date: 'asc'
+        },
+        where: {
+          dataSource,
+          symbol
+        }
+      })
+    };
+  }
+
+  public async putSetting(key: string, value: string) {
+    let response: Property;
+
+    if (value === '') {
+      response = await this.propertyService.delete({ key });
+    } else {
+      response = await this.propertyService.put({ key, value });
+    }
+
+    if (key === PROPERTY_CURRENCIES) {
+      await this.exchangeRateDataService.initialize();
+      await this.dataGatheringService.reset();
+    }
+
+    return response;
+  }
+
   private async getLastDataGathering() {
     const lastDataGathering =
       await this.dataGatheringService.getLastDataGathering();
@@ -58,7 +178,7 @@ export class AdminService {
       return 'IN_PROGRESS';
     }
 
-    return null;
+    return undefined;
   }
 
   private async getUsersWithAnalytics(): Promise<AdminData['users']> {

apps/api/src/app/admin/update-market-data.dto.ts

@@ -0,0 +1,6 @@
+import { IsNumber } from 'class-validator';
+
+export class UpdateMarketDataDto {
+  @IsNumber()
+  marketPrice: number;
+}

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';
@@ -19,7 +20,6 @@ import { AdminModule } from './admin/admin.module';
 import { AppController } from './app.controller';
 import { AuthModule } from './auth/auth.module';
 import { CacheModule } from './cache/cache.module';
-import { ExperimentalModule } from './experimental/experimental.module';
 import { ExportModule } from './export/export.module';
 import { ImportModule } from './import/import.module';
 import { InfoModule } from './info/info.module';
@@ -42,7 +42,6 @@ import { UserModule } from './user/user.module';
     DataGatheringModule,
     DataProviderModule,
     ExchangeRateDataModule,
-    ExperimentalModule,
     ExportModule,
     ImportModule,
     InfoModule,
@@ -67,6 +66,7 @@ import { UserModule } from './user/user.module';
     }),
     SubscriptionModule,
     SymbolModule,
+    TwitterBotModule,
     UserModule
   ],
   controllers: [AppController],

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

@@ -1,9 +1,5 @@
 import { AuthDeviceService } from '@ghostfolio/api/app/auth-device/auth-device.service';
-import {
-  getPermissions,
-  hasPermission,
-  permissions
-} from '@ghostfolio/common/permissions';
+import { hasPermission, permissions } from '@ghostfolio/common/permissions';
 import type { RequestWithUser } from '@ghostfolio/common/types';
 import {
   Controller,
@@ -29,7 +25,7 @@ export class AuthDeviceController {
   public async deleteAuthDevice(@Param('id') id: string): Promise<void> {
     if (
       !hasPermission(
-        getPermissions(this.request.user.role),
+        this.request.user.permissions,
         permissions.deleteAuthDevice
       )
     ) {

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-device/auth-device.service.ts

@@ -23,7 +23,7 @@ export class AuthDeviceService {
     take?: number;
     cursor?: Prisma.AuthDeviceWhereUniqueInput;
     where?: Prisma.AuthDeviceWhereInput;
-    orderBy?: Prisma.AuthDeviceOrderByInput;
+    orderBy?: Prisma.AuthDeviceOrderByWithRelationInput;
   }): Promise<AuthDevice[]> {
     const { skip, take, cursor, where, orderBy } = params;
     return this.prismaService.authDevice.findMany({

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

@@ -1,9 +1,9 @@
 import { AuthDeviceService } from '@ghostfolio/api/app/auth-device/auth-device.service';
 import { WebAuthService } from '@ghostfolio/api/app/auth/web-auth.service';
 import { SubscriptionModule } from '@ghostfolio/api/app/subscription/subscription.module';
-import { UserService } from '@ghostfolio/api/app/user/user.service';
-import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
-import { PrismaService } from '@ghostfolio/api/services/prisma.service';
+import { UserModule } from '@ghostfolio/api/app/user/user.module';
+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' }
     }),
-    SubscriptionModule
+    PrismaModule,
+    SubscriptionModule,
+    UserModule
   ],
   providers: [
     AuthDeviceService,
     AuthService,
-    ConfigurationService,
     GoogleStrategy,
     JwtStrategy,
-    PrismaService,
-    UserService,
     WebAuthService
   ]
 })

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/experimental/create-order.dto.ts

@@ -1,22 +0,0 @@
-import { Type } from '@prisma/client';
-import { IsISO8601, IsNumber, IsString } from 'class-validator';
-
-export class CreateOrderDto {
-  @IsString()
-  currency: string;
-
-  @IsISO8601()
-  date: string;
-
-  @IsNumber()
-  quantity: number;
-
-  @IsString()
-  symbol: string;
-
-  @IsString()
-  type: Type;
-
-  @IsNumber()
-  unitPrice: number;
-}

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

@@ -1,69 +0,0 @@
-import { baseCurrency, benchmarks } from '@ghostfolio/common/config';
-import { DATE_FORMAT } from '@ghostfolio/common/helper';
-import { isApiTokenAuthorized } from '@ghostfolio/common/permissions';
-import type { RequestWithUser } from '@ghostfolio/common/types';
-import {
-  Body,
-  Controller,
-  Get,
-  Headers,
-  HttpException,
-  Inject,
-  Param,
-  Post
-} from '@nestjs/common';
-import { REQUEST } from '@nestjs/core';
-import { parse } from 'date-fns';
-import { StatusCodes, getReasonPhrase } from 'http-status-codes';
-
-import { CreateOrderDto } from './create-order.dto';
-import { ExperimentalService } from './experimental.service';
-import { Data } from './interfaces/data.interface';
-
-@Controller('experimental')
-export class ExperimentalController {
-  public constructor(
-    private readonly experimentalService: ExperimentalService,
-    @Inject(REQUEST) private readonly request: RequestWithUser
-  ) {}
-
-  @Get('benchmarks')
-  public async getBenchmarks(
-    @Headers('Authorization') apiToken: string
-  ): Promise<string[]> {
-    if (!isApiTokenAuthorized(apiToken)) {
-      throw new HttpException(
-        getReasonPhrase(StatusCodes.FORBIDDEN),
-        StatusCodes.FORBIDDEN
-      );
-    }
-
-    return benchmarks.map(({ symbol }) => {
-      return symbol;
-    });
-  }
-
-  @Get('benchmarks/:symbol')
-  public async getBenchmark(
-    @Headers('Authorization') apiToken: string,
-    @Param('symbol') symbol: string
-  ): Promise<{ date: Date; marketPrice: number }[]> {
-    if (!isApiTokenAuthorized(apiToken)) {
-      throw new HttpException(
-        getReasonPhrase(StatusCodes.FORBIDDEN),
-        StatusCodes.FORBIDDEN
-      );
-    }
-
-    const marketData = await this.experimentalService.getBenchmark(symbol);
-
-    if (marketData?.length === 0) {
-      throw new HttpException(
-        getReasonPhrase(StatusCodes.NOT_FOUND),
-        StatusCodes.NOT_FOUND
-      );
-    }
-
-    return marketData;
-  }
-}

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

@@ -1,23 +0,0 @@
-import { AccountService } from '@ghostfolio/api/app/account/account.service';
-import { RedisCacheModule } from '@ghostfolio/api/app/redis-cache/redis-cache.module';
-import { ConfigurationModule } from '@ghostfolio/api/services/configuration.module';
-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 { Module } from '@nestjs/common';
-
-import { ExperimentalController } from './experimental.controller';
-import { ExperimentalService } from './experimental.service';
-
-@Module({
-  imports: [
-    ConfigurationModule,
-    DataProviderModule,
-    ExchangeRateDataModule,
-    RedisCacheModule,
-    PrismaModule
-  ],
-  controllers: [ExperimentalController],
-  providers: [AccountService, ExperimentalService]
-})
-export class ExperimentalModule {}

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

@@ -1,23 +0,0 @@
-import { AccountService } from '@ghostfolio/api/app/account/account.service';
-import { DataProviderService } from '@ghostfolio/api/services/data-provider/data-provider.service';
-import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data.service';
-import { PrismaService } from '@ghostfolio/api/services/prisma.service';
-import { Injectable } from '@nestjs/common';
-
-@Injectable()
-export class ExperimentalService {
-  public constructor(
-    private readonly accountService: AccountService,
-    private readonly dataProviderService: DataProviderService,
-    private readonly exchangeRateDataService: ExchangeRateDataService,
-    private readonly prismaService: PrismaService
-  ) {}
-
-  public async getBenchmark(aSymbol: string) {
-    return this.prismaService.marketData.findMany({
-      orderBy: { date: 'asc' },
-      select: { date: true, marketPrice: true },
-      where: { symbol: aSymbol }
-    });
-  }
-}

apps/api/src/app/experimental/interfaces/data.interface.ts

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

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

@@ -1,6 +1,13 @@
 import { Export } from '@ghostfolio/common/interfaces';
 import type { RequestWithUser } from '@ghostfolio/common/types';
-import { Controller, Get, Inject, UseGuards } from '@nestjs/common';
+import {
+  Controller,
+  Get,
+  Headers,
+  Inject,
+  Query,
+  UseGuards
+} from '@nestjs/common';
 import { REQUEST } from '@nestjs/core';
 import { AuthGuard } from '@nestjs/passport';
 
@@ -15,8 +22,11 @@ export class ExportController {
 
   @Get()
   @UseGuards(AuthGuard('jwt'))
-  public async export(): Promise<Export> {
-    return await this.exportService.export({
+  public async export(
+    @Query('activityIds') activityIds?: string[]
+  ): Promise<Export> {
+    return this.exportService.export({
+      activityIds,
       userId: this.request.user.id
     });
   }

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

@@ -7,25 +7,59 @@ import { Injectable } from '@nestjs/common';
 export class ExportService {
   public constructor(private readonly prismaService: PrismaService) {}
 
-  public async export({ userId }: { userId: string }): Promise<Export> {
-    const orders = await this.prismaService.order.findMany({
+  public async export({
+    activityIds,
+    userId
+  }: {
+    activityIds?: string[];
+    userId: string;
+  }): Promise<Export> {
+    let orders = await this.prismaService.order.findMany({
       orderBy: { date: 'desc' },
       select: {
-        currency: true,
-        dataSource: true,
+        accountId: true,
         date: true,
         fee: true,
+        id: true,
         quantity: true,
-        symbol: true,
+        SymbolProfile: true,
         type: true,
         unitPrice: true
       },
       where: { userId }
     });
 
+    if (activityIds) {
+      orders = orders.filter((order) => {
+        return activityIds.includes(order.id);
+      });
+    }
+
     return {
       meta: { date: new Date().toISOString(), version: environment.version },
-      orders
+      orders: orders.map(
+        ({
+          accountId,
+          date,
+          fee,
+          quantity,
+          SymbolProfile,
+          type,
+          unitPrice
+        }) => {
+          return {
+            accountId,
+            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[];
+  orders: CreateOrderDto[];
 }

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

@@ -1,5 +1,6 @@
-import { CacheService } from '@ghostfolio/api/app/cache/cache.service';
-import { OrderService } from '@ghostfolio/api/app/order/order.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';
 import { DataGatheringModule } from '@ghostfolio/api/services/data-gathering.module';
@@ -11,14 +12,17 @@ import { ImportController } from './import.controller';
 import { ImportService } from './import.service';
 
 @Module({
+  controllers: [ImportController],
   imports: [
+    AccountModule,
+    CacheModule,
     ConfigurationModule,
     DataGatheringModule,
     DataProviderModule,
+    OrderModule,
     PrismaModule,
     RedisCacheModule
   ],
-  controllers: [ImportController],
-  providers: [CacheService, ImportService, OrderService]
+  providers: [ImportService]
 })
 export class ImportModule {}

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

@@ -1,14 +1,16 @@
+import { AccountService } from '@ghostfolio/api/app/account/account.service';
 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';
+import { CreateOrderDto } from '@ghostfolio/api/app/order/create-order.dto';
 
 @Injectable()
 export class ImportService {
-  private static MAX_ORDERS_TO_IMPORT = 20;
-
   public constructor(
+    private readonly accountService: AccountService,
+    private readonly configurationService: ConfigurationService,
     private readonly dataProviderService: DataProviderService,
     private readonly orderService: OrderService
   ) {}
@@ -17,11 +19,27 @@ export class ImportService {
     orders,
     userId
   }: {
-    orders: Partial<Order>[];
+    orders: Partial<CreateOrderDto>[];
     userId: string;
   }): Promise<void> {
+    for (const order of orders) {
+      if (!order.dataSource) {
+        if (order.type === 'ITEM') {
+          order.dataSource = 'MANUAL';
+        } else {
+          order.dataSource = this.dataProviderService.getPrimaryDataSource();
+        }
+      }
+    }
+
     await this.validateOrders({ orders, userId });
 
+    const accountIds = (await this.accountService.getAccounts(userId)).map(
+      (account) => {
+        return account.id;
+      }
+    );
+
     for (const {
       accountId,
       currency,
@@ -34,19 +52,28 @@ export class ImportService {
       unitPrice
     } of orders) {
       await this.orderService.createOrder({
-        Account: {
-          connect: {
-            id_userId: { userId, id: 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
+            },
+            where: {
+              dataSource_symbol: {
+                dataSource,
+                symbol
+              }
+            }
+          }
+        },
         User: { connect: { id: userId } }
       });
     }
@@ -56,14 +83,21 @@ export class ImportService {
     orders,
     userId
   }: {
-    orders: Partial<Order>[];
+    orders: Partial<CreateOrderDto>[];
     userId: string;
   }) {
-    if (orders?.length > ImportService.MAX_ORDERS_TO_IMPORT) {
-      throw new Error('Too many transactions');
+    if (
+      orders?.length > this.configurationService.get('MAX_ORDERS_TO_IMPORT')
+    ) {
+      throw new Error(
+        `Too many transactions (${this.configurationService.get(
+          'MAX_ORDERS_TO_IMPORT'
+        )} at most)`
+      );
     }
 
     const existingOrders = await this.orderService.orders({
+      include: { SymbolProfile: true },
       orderBy: { date: 'desc' },
       where: { userId }
     });
@@ -74,12 +108,12 @@ export class ImportService {
     ] of orders.entries()) {
       const duplicateOrder = existingOrders.find((order) => {
         return (
-          order.currency === currency &&
-          order.dataSource === dataSource &&
+          order.SymbolProfile.currency === currency &&
+          order.SymbolProfile.dataSource === dataSource &&
           isSameDay(order.date, parseISO(<string>(<unknown>date))) &&
           order.fee === fee &&
           order.quantity === quantity &&
-          order.symbol === symbol &&
+          order.SymbolProfile.symbol === symbol &&
           order.type === type &&
           order.unitPrice === unitPrice
         );
@@ -89,14 +123,22 @@ export class ImportService {
         throw new Error(`orders.${index} is a duplicate transaction`);
       }
 
-      const result = await this.dataProviderService.get([
-        { dataSource, symbol }
-      ]);
+      if (dataSource !== 'MANUAL') {
+        const quotes = await this.dataProviderService.getQuotes([
+          { dataSource, symbol }
+        ]);
 
-      if (result[symbol] === undefined) {
-        throw new Error(
-          `orders.${index}.symbol ("${symbol}") is not valid for the specified data source ("${dataSource}")`
-        );
+        if (quotes[symbol] === undefined) {
+          throw new Error(
+            `orders.${index}.symbol ("${symbol}") is not valid for the specified data source ("${dataSource}")`
+          );
+        }
+
+        if (quotes[symbol].currency !== currency) {
+          throw new Error(
+            `orders.${index}.currency ("${currency}") does not match with "${quotes[symbol].currency}"`
+          );
+        }
       }
     }
   }

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

@@ -1,10 +1,10 @@
 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';
 import { JwtModule } from '@nestjs/jwt';
@@ -13,7 +13,9 @@ import { InfoController } from './info.controller';
 import { InfoService } from './info.service';
 
 @Module({
+  controllers: [InfoController],
   imports: [
+    ConfigurationModule,
     DataGatheringModule,
     DataProviderModule,
     ExchangeRateDataModule,
@@ -21,15 +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

@@ -1,9 +1,18 @@
 import { RedisCacheService } from '@ghostfolio/api/app/redis-cache/redis-cache.service';
 import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
 import { DataGatheringService } from '@ghostfolio/api/services/data-gathering.service';
-import { DataProviderService } from '@ghostfolio/api/services/data-provider/data-provider.service';
 import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data.service';
 import { PrismaService } from '@ghostfolio/api/services/prisma.service';
+import { PropertyService } from '@ghostfolio/api/services/property/property.service';
+import {
+  DEMO_USER_ID,
+  PROPERTY_IS_READ_ONLY_MODE,
+  PROPERTY_SLACK_COMMUNITY_USERS,
+  PROPERTY_STRIPE_CONFIG,
+  PROPERTY_SYSTEM_MESSAGE,
+  ghostfolioFearAndGreedIndexDataSource
+} from '@ghostfolio/common/config';
+import { encodeDataSource } from '@ghostfolio/common/helper';
 import { InfoItem } from '@ghostfolio/common/interfaces';
 import { Statistics } from '@ghostfolio/common/interfaces/statistics.interface';
 import { Subscription } from '@ghostfolio/common/interfaces/subscription.interface';
@@ -15,25 +24,26 @@ import { subDays } from 'date-fns';
 
 @Injectable()
 export class InfoService {
-  private static DEMO_USER_ID = '9b112b4d-3b7d-4bad-9bdd-3b0f7b4dac2f';
   private static CACHE_KEY_STATISTICS = 'STATISTICS';
 
   public constructor(
     private readonly configurationService: ConfigurationService,
-    private readonly dataProviderService: DataProviderService,
     private readonly exchangeRateDataService: ExchangeRateDataService,
     private readonly dataGatheringService: DataGatheringService,
     private readonly jwtService: JwtService,
     private readonly prismaService: PrismaService,
+    private readonly propertyService: PropertyService,
     private readonly redisCacheService: RedisCacheService
   ) {}
 
   public async get(): Promise<InfoItem> {
     const info: Partial<InfoItem> = {};
+    let isReadOnlyMode: boolean;
     const platforms = await this.prismaService.platform.findMany({
       orderBy: { name: 'asc' },
       select: { id: true, name: true }
     });
+    let systemMessage: string;
 
     const globalPermissions: string[] = [];
 
@@ -41,10 +51,22 @@ export class InfoService {
       globalPermissions.push(permissions.enableBlog);
     }
 
+    if (this.configurationService.get('ENABLE_FEATURE_FEAR_AND_GREED_INDEX')) {
+      info.fearAndGreedDataSource = encodeDataSource(
+        ghostfolioFearAndGreedIndexDataSource
+      );
+    }
+
     if (this.configurationService.get('ENABLE_FEATURE_IMPORT')) {
       globalPermissions.push(permissions.enableImport);
     }
 
+    if (this.configurationService.get('ENABLE_FEATURE_READ_ONLY_MODE')) {
+      isReadOnlyMode = (await this.propertyService.getByKey(
+        PROPERTY_IS_READ_ONLY_MODE
+      )) as boolean;
+    }
+
     if (this.configurationService.get('ENABLE_FEATURE_SOCIAL_LOGIN')) {
       globalPermissions.push(permissions.enableSocialLogin);
     }
@@ -59,14 +81,23 @@ export class InfoService {
       info.stripePublicKey = this.configurationService.get('STRIPE_PUBLIC_KEY');
     }
 
+    if (this.configurationService.get('ENABLE_FEATURE_SYSTEM_MESSAGE')) {
+      globalPermissions.push(permissions.enableSystemMessage);
+
+      systemMessage = (await this.propertyService.getByKey(
+        PROPERTY_SYSTEM_MESSAGE
+      )) as string;
+    }
+
     return {
       ...info,
       globalPermissions,
+      isReadOnlyMode,
       platforms,
+      systemMessage,
       currencies: this.exchangeRateDataService.getCurrencies(),
       demoAuthToken: this.getDemoAuthToken(),
       lastDataGathering: await this.getLastDataGathering(),
-      primaryDataSource: this.dataProviderService.getPrimaryDataSource(),
       statistics: await this.getStatistics(),
       subscriptions: await this.getSubscriptions()
     };
@@ -162,9 +193,15 @@ export class InfoService {
     });
   }
 
+  private async countSlackCommunityUsers() {
+    return (await this.propertyService.getByKey(
+      PROPERTY_SLACK_COMMUNITY_USERS
+    )) as string;
+  }
+
   private getDemoAuthToken() {
     return this.jwtService.sign({
-      id: InfoService.DEMO_USER_ID
+      id: DEMO_USER_ID
     });
   }
 
@@ -193,19 +230,19 @@ export class InfoService {
     } catch {}
 
     const activeUsers1d = await this.countActiveUsers(1);
-    const activeUsers7d = await this.countActiveUsers(7);
     const activeUsers30d = await this.countActiveUsers(30);
     const newUsers30d = await this.countNewUsers(30);
     const gitHubContributors = await this.countGitHubContributors();
     const gitHubStargazers = await this.countGitHubStargazers();
+    const slackCommunityUsers = await this.countSlackCommunityUsers();
 
     statistics = {
       activeUsers1d,
-      activeUsers7d,
       activeUsers30d,
       gitHubContributors,
       gitHubStargazers,
-      newUsers30d
+      newUsers30d,
+      slackCommunityUsers
     };
 
     await this.redisCacheService.set(
@@ -222,7 +259,7 @@ export class InfoService {
     }
 
     const stripeConfig = await this.prismaService.property.findUnique({
-      where: { key: 'STRIPE_CONFIG' }
+      where: { key: PROPERTY_STRIPE_CONFIG }
     });
 
     if (stripeConfig) {

apps/api/src/app/order/create-order.dto.ts

@@ -1,14 +1,22 @@
 import { DataSource, Type } from '@prisma/client';
-import { IsEnum, IsISO8601, IsNumber, IsString } from 'class-validator';
+import {
+  IsEnum,
+  IsISO8601,
+  IsNumber,
+  IsOptional,
+  IsString
+} from 'class-validator';
 
 export class CreateOrderDto {
   @IsString()
+  @IsOptional()
   accountId: string;
 
   @IsString()
   currency: string;
 
   @IsEnum(DataSource, { each: true })
+  @IsOptional()
   dataSource: DataSource;
 
   @IsISO8601()

apps/api/src/app/order/interfaces/activities.interface.ts

@@ -0,0 +1,10 @@
+import { OrderWithAccount } from '@ghostfolio/common/types';
+
+export interface Activities {
+  activities: Activity[];
+}
+
+export interface Activity extends OrderWithAccount {
+  feeInBaseCurrency: number;
+  valueInBaseCurrency: number;
+}

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

@@ -1,11 +1,9 @@
 import { UserService } from '@ghostfolio/api/app/user/user.service';
 import { nullifyValuesInObjects } from '@ghostfolio/api/helper/object.helper';
+import { TransformDataSourceInRequestInterceptor } from '@ghostfolio/api/interceptors/transform-data-source-in-request.interceptor';
+import { TransformDataSourceInResponseInterceptor } from '@ghostfolio/api/interceptors/transform-data-source-in-response.interceptor';
 import { ImpersonationService } from '@ghostfolio/api/services/impersonation.service';
-import {
-  getPermissions,
-  hasPermission,
-  permissions
-} from '@ghostfolio/common/permissions';
+import { hasPermission, permissions } from '@ghostfolio/common/permissions';
 import type { RequestWithUser } from '@ghostfolio/common/types';
 import {
   Body,
@@ -18,7 +16,8 @@ import {
   Param,
   Post,
   Put,
-  UseGuards
+  UseGuards,
+  UseInterceptors
 } from '@nestjs/common';
 import { REQUEST } from '@nestjs/core';
 import { AuthGuard } from '@nestjs/passport';
@@ -27,6 +26,7 @@ import { parseISO } from 'date-fns';
 import { StatusCodes, getReasonPhrase } from 'http-status-codes';
 
 import { CreateOrderDto } from './create-order.dto';
+import { Activities } from './interfaces/activities.interface';
 import { OrderService } from './order.service';
 import { UpdateOrderDto } from './update-order.dto';
 
@@ -43,10 +43,7 @@ export class OrderController {
   @UseGuards(AuthGuard('jwt'))
   public async deleteOrder(@Param('id') id: string): Promise<OrderModel> {
     if (
-      !hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.deleteOrder
-      )
+      !hasPermission(this.request.user.permissions, permissions.deleteOrder)
     ) {
       throw new HttpException(
         getReasonPhrase(StatusCodes.FORBIDDEN),
@@ -64,61 +61,46 @@ export class OrderController {
 
   @Get()
   @UseGuards(AuthGuard('jwt'))
+  @UseInterceptors(TransformDataSourceInResponseInterceptor)
   public async getAllOrders(
     @Headers('impersonation-id') impersonationId
-  ): Promise<OrderModel[]> {
+  ): Promise<Activities> {
     const impersonationUserId =
       await this.impersonationService.validateImpersonationId(
         impersonationId,
         this.request.user.id
       );
+    const userCurrency = this.request.user.Settings.currency;
 
-    let orders = await this.orderService.orders({
-      include: {
-        Account: {
-          include: {
-            Platform: true
-          }
-        },
-        SymbolProfile: {
-          select: {
-            name: true
-          }
-        }
-      },
-      orderBy: { date: 'desc' },
-      where: { userId: impersonationUserId || this.request.user.id }
+    let activities = await this.orderService.getOrders({
+      userCurrency,
+      includeDrafts: true,
+      userId: impersonationUserId || this.request.user.id
     });
 
     if (
       impersonationUserId ||
       this.userService.isRestrictedView(this.request.user)
     ) {
-      orders = nullifyValuesInObjects(orders, ['fee', 'quantity', 'unitPrice']);
+      activities = nullifyValuesInObjects(activities, [
+        'fee',
+        'feeInBaseCurrency',
+        'quantity',
+        'unitPrice',
+        'value',
+        'valueInBaseCurrency'
+      ]);
     }
 
-    return orders;
-  }
-
-  @Get(':id')
-  @UseGuards(AuthGuard('jwt'))
-  public async getOrderById(@Param('id') id: string): Promise<OrderModel> {
-    return this.orderService.order({
-      id_userId: {
-        id,
-        userId: this.request.user.id
-      }
-    });
+    return { activities };
   }
 
   @Post()
   @UseGuards(AuthGuard('jwt'))
+  @UseInterceptors(TransformDataSourceInRequestInterceptor)
   public async createOrder(@Body() data: CreateOrderDto): Promise<OrderModel> {
     if (
-      !hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.createOrder
-      )
+      !hasPermission(this.request.user.permissions, permissions.createOrder)
     ) {
       throw new HttpException(
         getReasonPhrase(StatusCodes.FORBIDDEN),
@@ -126,45 +108,35 @@ export class OrderController {
       );
     }
 
-    const date = parseISO(data.date);
-
-    const accountId = data.accountId;
-    delete data.accountId;
-
     return this.orderService.createOrder({
       ...data,
-      Account: {
-        connect: {
-          id_userId: { id: accountId, userId: this.request.user.id }
-        }
-      },
-      date,
+      date: parseISO(data.date),
       SymbolProfile: {
         connectOrCreate: {
+          create: {
+            currency: data.currency,
+            dataSource: data.dataSource,
+            symbol: data.symbol
+          },
           where: {
             dataSource_symbol: {
               dataSource: data.dataSource,
               symbol: data.symbol
             }
-          },
-          create: {
-            dataSource: data.dataSource,
-            symbol: data.symbol
           }
         }
       },
-      User: { connect: { id: this.request.user.id } }
+      User: { connect: { id: this.request.user.id } },
+      userId: this.request.user.id
     });
   }
 
   @Put(':id')
   @UseGuards(AuthGuard('jwt'))
+  @UseInterceptors(TransformDataSourceInRequestInterceptor)
   public async update(@Param('id') id: string, @Body() data: UpdateOrderDto) {
     if (
-      !hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.updateOrder
-      )
+      !hasPermission(this.request.user.permissions, permissions.updateOrder)
     ) {
       throw new HttpException(
         getReasonPhrase(StatusCodes.FORBIDDEN),
@@ -200,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,28 +1,34 @@
-import { CacheService } from '@ghostfolio/api/app/cache/cache.service';
+import { AccountService } from '@ghostfolio/api/app/account/account.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';
 import { DataGatheringModule } from '@ghostfolio/api/services/data-gathering.module';
 import { DataProviderModule } from '@ghostfolio/api/services/data-provider/data-provider.module';
+import { ExchangeRateDataModule } from '@ghostfolio/api/services/exchange-rate-data.module';
 import { ImpersonationModule } from '@ghostfolio/api/services/impersonation.module';
 import { PrismaModule } from '@ghostfolio/api/services/prisma.module';
+import { SymbolProfileModule } from '@ghostfolio/api/services/symbol-profile.module';
 import { Module } from '@nestjs/common';
 
 import { OrderController } from './order.controller';
 import { OrderService } from './order.service';
 
 @Module({
+  controllers: [OrderController],
+  exports: [OrderService],
   imports: [
+    CacheModule,
     ConfigurationModule,
     DataGatheringModule,
     DataProviderModule,
+    ExchangeRateDataModule,
     ImpersonationModule,
     PrismaModule,
     RedisCacheModule,
+    SymbolProfileModule,
     UserModule
   ],
-  controllers: [OrderController],
-  providers: [CacheService, OrderService],
-  exports: [OrderService]
+  providers: [AccountService, OrderService]
 })
 export class OrderModule {}

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

@@ -1,17 +1,27 @@
+import { AccountService } from '@ghostfolio/api/app/account/account.service';
 import { CacheService } from '@ghostfolio/api/app/cache/cache.service';
 import { DataGatheringService } from '@ghostfolio/api/services/data-gathering.service';
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data.service';
 import { PrismaService } from '@ghostfolio/api/services/prisma.service';
+import { SymbolProfileService } from '@ghostfolio/api/services/symbol-profile.service';
 import { OrderWithAccount } from '@ghostfolio/common/types';
 import { Injectable } from '@nestjs/common';
-import { DataSource, Order, Prisma } from '@prisma/client';
+import { DataSource, Order, Prisma, Type as TypeOfOrder } from '@prisma/client';
+import Big from 'big.js';
 import { endOfToday, isAfter } from 'date-fns';
+import { v4 as uuidv4 } from 'uuid';
+
+import { Activity } from './interfaces/activities.interface';
 
 @Injectable()
 export class OrderService {
   public constructor(
+    private readonly accountService: AccountService,
     private readonly cacheService: CacheService,
+    private readonly exchangeRateDataService: ExchangeRateDataService,
     private readonly dataGatheringService: DataGatheringService,
-    private readonly prismaService: PrismaService
+    private readonly prismaService: PrismaService,
+    private readonly symbolProfileService: SymbolProfileService
   ) {}
 
   public async order(
@@ -28,7 +38,7 @@ export class OrderService {
     take?: number;
     cursor?: Prisma.OrderWhereUniqueInput;
     where?: Prisma.OrderWhereInput;
-    orderBy?: Prisma.OrderOrderByInput;
+    orderBy?: Prisma.OrderOrderByWithRelationInput;
   }): Promise<OrderWithAccount[]> {
     const { include, skip, take, cursor, where, orderBy } = params;
 
@@ -42,29 +52,85 @@ export class OrderService {
     });
   }
 
-  public async createOrder(data: Prisma.OrderCreateInput): Promise<Order> {
+  public async createOrder(
+    data: Prisma.OrderCreateInput & {
+      accountId?: string;
+      currency?: string;
+      dataSource?: DataSource;
+      symbol?: string;
+      userId: string;
+    }
+  ): Promise<Order> {
+    const defaultAccount = (
+      await this.accountService.getAccounts(data.userId)
+    ).find((account) => {
+      return account.isDefault === true;
+    });
+
+    let Account = {
+      connect: {
+        id_userId: {
+          userId: data.userId,
+          id: data.accountId ?? defaultAccount?.id
+        }
+      }
+    };
+
+    if (data.type === 'ITEM') {
+      const currency = data.SymbolProfile.connectOrCreate.create.currency;
+      const dataSource: DataSource = 'MANUAL';
+      const id = uuidv4();
+      const name = data.SymbolProfile.connectOrCreate.create.symbol;
+
+      Account = undefined;
+      data.id = id;
+      data.SymbolProfile.connectOrCreate.create.currency = currency;
+      data.SymbolProfile.connectOrCreate.create.dataSource = dataSource;
+      data.SymbolProfile.connectOrCreate.create.name = name;
+      data.SymbolProfile.connectOrCreate.create.symbol = id;
+      data.SymbolProfile.connectOrCreate.where.dataSource_symbol = {
+        dataSource,
+        symbol: id
+      };
+    } else {
+      data.SymbolProfile.connectOrCreate.create.symbol =
+        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.symbol
+          symbol: data.SymbolProfile.connectOrCreate.create.symbol
         }
       ]);
     }
 
-    this.dataGatheringService.gatherProfileData([
-      { dataSource: data.dataSource, symbol: data.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;
+
     return this.prismaService.order.create({
       data: {
-        ...data,
+        ...orderData,
+        Account,
         isDraft
       }
     });
@@ -73,57 +139,121 @@ export class OrderService {
   public async deleteOrder(
     where: Prisma.OrderWhereUniqueInput
   ): Promise<Order> {
-    return this.prismaService.order.delete({
+    const order = await this.prismaService.order.delete({
       where
     });
+
+    if (order.type === 'ITEM') {
+      await this.symbolProfileService.deleteById(order.symbolProfileId);
+    }
+
+    return order;
   }
 
-  public getOrders({
+  public async getOrders({
     includeDrafts = false,
+    types,
+    userCurrency,
     userId
   }: {
     includeDrafts?: boolean;
+    types?: TypeOfOrder[];
+    userCurrency: string;
     userId: string;
-  }) {
+  }): Promise<Activity[]> {
     const where: Prisma.OrderWhereInput = { userId };
 
     if (includeDrafts === false) {
       where.isDraft = false;
     }
 
-    return this.orders({
-      where,
-      include: {
-        // eslint-disable-next-line @typescript-eslint/naming-convention
-        Account: true,
-        // eslint-disable-next-line @typescript-eslint/naming-convention
-        SymbolProfile: true
-      },
-      orderBy: { date: 'asc' }
+    if (types) {
+      where.OR = types.map((type) => {
+        return {
+          type: {
+            equals: type
+          }
+        };
+      });
+    }
+
+    return (
+      await this.orders({
+        where,
+        include: {
+          // eslint-disable-next-line @typescript-eslint/naming-convention
+          Account: {
+            include: {
+              Platform: true
+            }
+          },
+          // eslint-disable-next-line @typescript-eslint/naming-convention
+          SymbolProfile: true
+        },
+        orderBy: { date: 'asc' }
+      })
+    ).map((order) => {
+      const value = new Big(order.quantity).mul(order.unitPrice).toNumber();
+
+      return {
+        ...order,
+        value,
+        feeInBaseCurrency: this.exchangeRateDataService.toCurrency(
+          order.fee,
+          order.SymbolProfile.currency,
+          userCurrency
+        ),
+        valueInBaseCurrency: this.exchangeRateDataService.toCurrency(
+          value,
+          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;
+    }
 
-    const isDraft = isAfter(data.date as Date, endOfToday());
+    let isDraft = false;
 
-    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 (data.type === 'ITEM') {
+      const name = data.SymbolProfile.connect.dataSource_symbol.symbol;
+
+      data.SymbolProfile = { update: { name } };
+    } else {
+      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.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/order/update-order.dto.ts

@@ -1,7 +1,8 @@
 import { DataSource, Type } from '@prisma/client';
-import { IsISO8601, IsNumber, IsString } from 'class-validator';
+import { IsISO8601, IsNumber, IsOptional, IsString } from 'class-validator';
 
 export class UpdateOrderDto {
+  @IsOptional()
   @IsString()
   accountId: string;
 

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.spec.ts

@@ -1,11 +1,11 @@
 import { DataProviderService } from '@ghostfolio/api/services/data-provider/data-provider.service';
 import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data.service';
+import { MarketDataService } from '@ghostfolio/api/services/market-data.service';
 import { DataSource, MarketData } from '@prisma/client';
 
 import { CurrentRateService } from './current-rate.service';
-import { MarketDataService } from './market-data.service';
 
-jest.mock('./market-data.service', () => {
+jest.mock('@ghostfolio/api/services/market-data.service', () => {
   return {
     MarketDataService: jest.fn().mockImplementation(() => {
       return {
@@ -73,7 +73,7 @@ describe('CurrentRateService', () => {
 
   beforeAll(async () => {
     dataProviderService = new DataProviderService(null, [], null);
-    exchangeRateDataService = new ExchangeRateDataService(null, null);
+    exchangeRateDataService = new ExchangeRateDataService(null, null, null);
     marketDataService = new MarketDataService(null);
 
     await exchangeRateDataService.initialize();
@@ -85,19 +85,6 @@ describe('CurrentRateService', () => {
     );
   });
 
-  it('getValue', async () => {
-    expect(
-      await currentRateService.getValue({
-        currency: 'USD',
-        date: new Date(Date.UTC(2020, 0, 1, 0, 0, 0)),
-        symbol: 'AMZN',
-        userCurrency: 'CHF'
-      })
-    ).toMatchObject({
-      marketPrice: 1847.839966
-    });
-  });
-
   it('getValues', async () => {
     expect(
       await currentRateService.getValues({

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

@@ -1,14 +1,13 @@
 import { DataProviderService } from '@ghostfolio/api/services/data-provider/data-provider.service';
 import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data.service';
+import { MarketDataService } from '@ghostfolio/api/services/market-data.service';
 import { resetHours } from '@ghostfolio/common/helper';
 import { Injectable } from '@nestjs/common';
 import { isBefore, isToday } from 'date-fns';
 import { flatten } from 'lodash';
 
 import { GetValueObject } from './interfaces/get-value-object.interface';
-import { GetValueParams } from './interfaces/get-value-params.interface';
 import { GetValuesParams } from './interfaces/get-values-params.interface';
-import { MarketDataService } from './market-data.service';
 
 @Injectable()
 export class CurrentRateService {
@@ -18,46 +17,6 @@ export class CurrentRateService {
     private readonly marketDataService: MarketDataService
   ) {}
 
-  public async getValue({
-    currency,
-    date,
-    symbol,
-    userCurrency
-  }: GetValueParams): Promise<GetValueObject> {
-    if (isToday(date)) {
-      const dataProviderResult = await this.dataProviderService.get([
-        {
-          symbol,
-          dataSource: this.dataProviderService.getPrimaryDataSource()
-        }
-      ]);
-      return {
-        symbol,
-        date: resetHours(date),
-        marketPrice: dataProviderResult?.[symbol]?.marketPrice ?? 0
-      };
-    }
-
-    const marketData = await this.marketDataService.get({
-      date,
-      symbol
-    });
-
-    if (marketData) {
-      return {
-        date: marketData.date,
-        marketPrice: this.exchangeRateDataService.toCurrency(
-          marketData.marketPrice,
-          currency,
-          userCurrency
-        ),
-        symbol: marketData.symbol
-      };
-    }
-
-    throw new Error(`Value not found for ${symbol} at ${resetHours(date)}`);
-  }
-
   public async getValues({
     currencies,
     dataGatheringItems,
@@ -81,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,12 +1,11 @@
-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;
-  netAnnualizedPerformance: Big;
+  netAnnualizedPerformance?: Big;
   netPerformance: Big;
   netPerformancePercentage: Big;
   currentValue: Big;

apps/api/src/app/portfolio/interfaces/get-value-params.interface.ts

@@ -1,6 +0,0 @@
-export interface GetValueParams {
-  currency: string;
-  date: Date;
-  symbol: string;
-  userCurrency: string;
-}

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

@@ -0,0 +1,5 @@
+import { PortfolioOrder } from './portfolio-order.interface';
+
+export interface PortfolioOrderItem extends PortfolioOrder {
+  itemType?: '' | 'start' | 'end';
+}

apps/api/src/app/portfolio/interfaces/portfolio-order.interface.ts

@@ -1,5 +1,4 @@
-import { OrderType } from '@ghostfolio/api/models/order-type';
-import { DataSource } from '@prisma/client';
+import { DataSource, Type as TypeOfOrder } from '@prisma/client';
 import Big from 'big.js';
 
 export interface PortfolioOrder {
@@ -10,6 +9,6 @@ export interface PortfolioOrder {
   name: string;
   quantity: Big;
   symbol: string;
-  type: OrderType;
+  type: TypeOfOrder;
   unitPrice: Big;
 }

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

@@ -1,10 +1,8 @@
-import { AssetClass, AssetSubClass } from '@prisma/client';
+import { EnhancedSymbolProfile } from '@ghostfolio/api/services/interfaces/symbol-profile.interface';
+import { OrderWithAccount } from '@ghostfolio/common/types';
 
 export interface PortfolioPositionDetail {
-  assetClass?: AssetClass;
-  assetSubClass?: AssetSubClass;
   averagePrice: number;
-  currency: string;
   firstBuyDate: string;
   grossPerformance: number;
   grossPerformancePercent: number;
@@ -13,12 +11,19 @@ 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;
+}
+
+export interface HistoricalDataContainer {
+  isAllTimeHigh: boolean;
+  isAllTimeLow: boolean;
+  items: HistoricalDataItem[];
 }
 
 export interface HistoricalDataItem {

apps/api/src/app/portfolio/interfaces/timeline-info.interface.ts

@@ -0,0 +1,8 @@
+import { TimelinePeriod } from '@ghostfolio/api/app/portfolio/interfaces/timeline-period.interface';
+import Big from 'big.js';
+
+export interface TimelineInfoInterface {
+  maxNetPerformance: Big;
+  minNetPerformance: Big;
+  timelinePeriods: TimelinePeriod[];
+}

apps/api/src/app/portfolio/market-data.service.ts

@@ -1,51 +0,0 @@
-import { PrismaService } from '@ghostfolio/api/services/prisma.service';
-import { resetHours } from '@ghostfolio/common/helper';
-import { Injectable } from '@nestjs/common';
-import { MarketData } from '@prisma/client';
-
-import { DateQuery } from './interfaces/date-query.interface';
-
-@Injectable()
-export class MarketDataService {
-  public constructor(private readonly prismaService: PrismaService) {}
-
-  public async get({
-    date,
-    symbol
-  }: {
-    date: Date;
-    symbol: string;
-  }): Promise<MarketData> {
-    return await this.prismaService.marketData.findFirst({
-      where: {
-        symbol,
-        date: resetHours(date)
-      }
-    });
-  }
-
-  public async getRange({
-    dateQuery,
-    symbols
-  }: {
-    dateQuery: DateQuery;
-    symbols: string[];
-  }): Promise<MarketData[]> {
-    return await this.prismaService.marketData.findMany({
-      orderBy: [
-        {
-          date: 'asc'
-        },
-        {
-          symbol: 'asc'
-        }
-      ],
-      where: {
-        date: dateQuery,
-        symbol: {
-          in: symbols
-        }
-      }
-    });
-  }
-}

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.spec.ts

@@ -0,0 +1,73 @@
+import Big from 'big.js';
+
+import { CurrentRateService } from './current-rate.service';
+import { PortfolioCalculatorNew } from './portfolio-calculator-new';
+
+describe('PortfolioCalculatorNew', () => {
+  let currentRateService: CurrentRateService;
+
+  beforeEach(() => {
+    currentRateService = new CurrentRateService(null, null, null);
+  });
+
+  describe('annualized performance percentage', () => {
+    const portfolioCalculatorNew = new PortfolioCalculatorNew({
+      currentRateService,
+      currency: 'USD',
+      orders: []
+    });
+
+    it('Get annualized performance', async () => {
+      expect(
+        portfolioCalculatorNew
+          .getAnnualizedPerformancePercent({
+            daysInMarket: NaN, // differenceInDays of date-fns returns NaN for the same day
+            netPerformancePercent: new Big(0)
+          })
+          .toNumber()
+      ).toEqual(0);
+
+      expect(
+        portfolioCalculatorNew
+          .getAnnualizedPerformancePercent({
+            daysInMarket: 0,
+            netPerformancePercent: new Big(0)
+          })
+          .toNumber()
+      ).toEqual(0);
+
+      /**
+       * Source: https://www.readyratios.com/reference/analysis/annualized_rate.html
+       */
+      expect(
+        portfolioCalculatorNew
+          .getAnnualizedPerformancePercent({
+            daysInMarket: 65, // < 1 year
+            netPerformancePercent: new Big(0.1025)
+          })
+          .toNumber()
+      ).toBeCloseTo(0.729705);
+
+      expect(
+        portfolioCalculatorNew
+          .getAnnualizedPerformancePercent({
+            daysInMarket: 365, // 1 year
+            netPerformancePercent: new Big(0.05)
+          })
+          .toNumber()
+      ).toBeCloseTo(0.05);
+
+      /**
+       * Source: https://www.investopedia.com/terms/a/annualized-total-return.asp#annualized-return-formula-and-calculation
+       */
+      expect(
+        portfolioCalculatorNew
+          .getAnnualizedPerformancePercent({
+            daysInMarket: 575, // > 1 year
+            netPerformancePercent: new Big(0.2374)
+          })
+          .toNumber()
+      ).toBeCloseTo(0.145);
+    });
+  });
+});

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

@@ -0,0 +1,969 @@
+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 {
+  ResponseError,
+  TimelinePosition,
+  UniqueAsset
+} from '@ghostfolio/common/interfaces';
+import { Logger } from '@nestjs/common';
+import { Type as TypeOfOrder } from '@prisma/client';
+import Big from 'big.js';
+import {
+  addDays,
+  addMilliseconds,
+  addMonths,
+  addYears,
+  endOfDay,
+  format,
+  isAfter,
+  isBefore,
+  max,
+  min
+} from 'date-fns';
+import { first, flatten, isNumber, sortBy } from 'lodash';
+
+import { CurrentRateService } from './current-rate.service';
+import { CurrentPositions } from './interfaces/current-positions.interface';
+import { GetValueObject } from './interfaces/get-value-object.interface';
+import { PortfolioOrderItem } from './interfaces/portfolio-calculator.interface';
+import { PortfolioOrder } from './interfaces/portfolio-order.interface';
+import { TimelinePeriod } from './interfaces/timeline-period.interface';
+import {
+  Accuracy,
+  TimelineSpecification
+} from './interfaces/timeline-specification.interface';
+import { TransactionPointSymbol } from './interfaces/transaction-point-symbol.interface';
+import { TransactionPoint } from './interfaces/transaction-point.interface';
+
+export class PortfolioCalculatorNew {
+  private static readonly ENABLE_LOGGING = false;
+
+  private currency: string;
+  private currentRateService: CurrentRateService;
+  private orders: PortfolioOrder[];
+  private transactionPoints: TransactionPoint[];
+
+  public constructor({
+    currency,
+    currentRateService,
+    orders
+  }: {
+    currency: string;
+    currentRateService: CurrentRateService;
+    orders: PortfolioOrder[];
+  }) {
+    this.currency = currency;
+    this.currentRateService = currentRateService;
+    this.orders = orders;
+
+    this.orders.sort((a, b) => a.date.localeCompare(b.date));
+  }
+
+  public computeTransactionPoints() {
+    this.transactionPoints = [];
+    const symbols: { [symbol: string]: TransactionPointSymbol } = {};
+
+    let lastDate: string = null;
+    let lastTransactionPoint: TransactionPoint = null;
+    for (const order of this.orders) {
+      const currentDate = order.date;
+
+      let currentTransactionPointItem: TransactionPointSymbol;
+      const oldAccumulatedSymbol = symbols[order.symbol];
+
+      const factor = this.getFactor(order.type);
+      const unitPrice = new Big(order.unitPrice);
+      if (oldAccumulatedSymbol) {
+        const newQuantity = order.quantity
+          .mul(factor)
+          .plus(oldAccumulatedSymbol.quantity);
+        currentTransactionPointItem = {
+          currency: order.currency,
+          dataSource: order.dataSource,
+          fee: order.fee.plus(oldAccumulatedSymbol.fee),
+          firstBuyDate: oldAccumulatedSymbol.firstBuyDate,
+          investment: newQuantity.eq(0)
+            ? new Big(0)
+            : unitPrice
+                .mul(order.quantity)
+                .mul(factor)
+                .plus(oldAccumulatedSymbol.investment),
+          quantity: newQuantity,
+          symbol: order.symbol,
+          transactionCount: oldAccumulatedSymbol.transactionCount + 1
+        };
+      } else {
+        currentTransactionPointItem = {
+          currency: order.currency,
+          dataSource: order.dataSource,
+          fee: order.fee,
+          firstBuyDate: order.date,
+          investment: unitPrice.mul(order.quantity).mul(factor),
+          quantity: order.quantity.mul(factor),
+          symbol: order.symbol,
+          transactionCount: 1
+        };
+      }
+
+      symbols[order.symbol] = currentTransactionPointItem;
+
+      const items = lastTransactionPoint?.items ?? [];
+      const newItems = items.filter(
+        (transactionPointItem) => transactionPointItem.symbol !== order.symbol
+      );
+      newItems.push(currentTransactionPointItem);
+      newItems.sort((a, b) => a.symbol.localeCompare(b.symbol));
+      if (lastDate !== currentDate || lastTransactionPoint === null) {
+        lastTransactionPoint = {
+          date: currentDate,
+          items: newItems
+        };
+        this.transactionPoints.push(lastTransactionPoint);
+      } else {
+        lastTransactionPoint.items = newItems;
+      }
+      lastDate = currentDate;
+    }
+  }
+
+  public getAnnualizedPerformancePercent({
+    daysInMarket,
+    netPerformancePercent
+  }: {
+    daysInMarket: number;
+    netPerformancePercent: Big;
+  }): Big {
+    if (isNumber(daysInMarket) && daysInMarket > 0) {
+      const exponent = new Big(365).div(daysInMarket).toNumber();
+      return new Big(
+        Math.pow(netPerformancePercent.plus(1).toNumber(), exponent)
+      ).minus(1);
+    }
+
+    return new Big(0);
+  }
+
+  public getTransactionPoints(): TransactionPoint[] {
+    return this.transactionPoints;
+  }
+
+  public setTransactionPoints(transactionPoints: TransactionPoint[]) {
+    this.transactionPoints = transactionPoints;
+  }
+
+  public async getCurrentPositions(start: Date): Promise<CurrentPositions> {
+    if (!this.transactionPoints?.length) {
+      return {
+        currentValue: new Big(0),
+        hasErrors: false,
+        grossPerformance: new Big(0),
+        grossPerformancePercentage: new Big(0),
+        netPerformance: new Big(0),
+        netPerformancePercentage: new Big(0),
+        positions: [],
+        totalInvestment: new Big(0)
+      };
+    }
+
+    const lastTransactionPoint =
+      this.transactionPoints[this.transactionPoints.length - 1];
+
+    // use Date.now() to use the mock for today
+    const today = new Date(Date.now());
+
+    let firstTransactionPoint: TransactionPoint = null;
+    let firstIndex = this.transactionPoints.length;
+    const dates = [];
+    const dataGatheringItems: IDataGatheringItem[] = [];
+    const currencies: { [symbol: string]: string } = {};
+
+    dates.push(resetHours(start));
+    for (const item of this.transactionPoints[firstIndex - 1].items) {
+      dataGatheringItems.push({
+        dataSource: item.dataSource,
+        symbol: item.symbol
+      });
+      currencies[item.symbol] = item.currency;
+    }
+    for (let i = 0; i < this.transactionPoints.length; i++) {
+      if (
+        !isBefore(parseDate(this.transactionPoints[i].date), start) &&
+        firstTransactionPoint === null
+      ) {
+        firstTransactionPoint = this.transactionPoints[i];
+        firstIndex = i;
+      }
+      if (firstTransactionPoint !== null) {
+        dates.push(resetHours(parseDate(this.transactionPoints[i].date)));
+      }
+    }
+
+    dates.push(resetHours(today));
+
+    const marketSymbols = await this.currentRateService.getValues({
+      currencies,
+      dataGatheringItems,
+      dateQuery: {
+        in: dates
+      },
+      userCurrency: this.currency
+    });
+
+    const marketSymbolMap: {
+      [date: string]: { [symbol: string]: Big };
+    } = {};
+
+    for (const marketSymbol of marketSymbols) {
+      const date = format(marketSymbol.date, DATE_FORMAT);
+      if (!marketSymbolMap[date]) {
+        marketSymbolMap[date] = {};
+      }
+      if (marketSymbol.marketPrice) {
+        marketSymbolMap[date][marketSymbol.symbol] = new Big(
+          marketSymbol.marketPrice
+        );
+      }
+    }
+
+    const todayString = format(today, DATE_FORMAT);
+
+    if (firstIndex > 0) {
+      firstIndex--;
+    }
+    const initialValues: { [symbol: string]: Big } = {};
+
+    const positions: TimelinePosition[] = [];
+    let hasAnySymbolMetricsErrors = false;
+
+    const errors: ResponseError['errors'] = [];
+
+    for (const item of lastTransactionPoint.items) {
+      const marketValue = marketSymbolMap[todayString]?.[item.symbol];
+
+      const {
+        grossPerformance,
+        grossPerformancePercentage,
+        hasErrors,
+        initialValue,
+        netPerformance,
+        netPerformancePercentage
+      } = this.getSymbolMetrics({
+        marketSymbolMap,
+        start,
+        symbol: item.symbol
+      });
+
+      hasAnySymbolMetricsErrors = hasAnySymbolMetricsErrors || hasErrors;
+      initialValues[item.symbol] = initialValue;
+
+      positions.push({
+        averagePrice: item.quantity.eq(0)
+          ? new Big(0)
+          : item.investment.div(item.quantity),
+        currency: item.currency,
+        dataSource: item.dataSource,
+        firstBuyDate: item.firstBuyDate,
+        grossPerformance: !hasErrors ? grossPerformance ?? null : null,
+        grossPerformancePercentage: !hasErrors
+          ? grossPerformancePercentage ?? null
+          : null,
+        investment: item.investment,
+        marketPrice: marketValue?.toNumber() ?? null,
+        netPerformance: !hasErrors ? netPerformance ?? null : null,
+        netPerformancePercentage: !hasErrors
+          ? netPerformancePercentage ?? null
+          : null,
+        quantity: item.quantity,
+        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: hasAnySymbolMetricsErrors || overall.hasErrors
+    };
+  }
+
+  public getInvestments(): { date: string; investment: Big }[] {
+    if (this.transactionPoints.length === 0) {
+      return [];
+    }
+
+    return this.transactionPoints.map((transactionPoint) => {
+      return {
+        date: transactionPoint.date,
+        investment: transactionPoint.items.reduce(
+          (investment, transactionPointSymbol) =>
+            investment.plus(transactionPointSymbol.investment),
+          new Big(0)
+        )
+      };
+    });
+  }
+
+  public async calculateTimeline(
+    timelineSpecification: TimelineSpecification[],
+    endDate: string
+  ): Promise<TimelineInfoInterface> {
+    if (timelineSpecification.length === 0) {
+      return {
+        maxNetPerformance: new Big(0),
+        minNetPerformance: new Big(0),
+        timelinePeriods: []
+      };
+    }
+
+    const startDate = timelineSpecification[0].start;
+    const start = parseDate(startDate);
+    const end = parseDate(endDate);
+
+    const timelinePeriodPromises: Promise<TimelineInfoInterface>[] = [];
+    let i = 0;
+    let j = -1;
+    for (
+      let currentDate = start;
+      !isAfter(currentDate, end);
+      currentDate = this.addToDate(
+        currentDate,
+        timelineSpecification[i].accuracy
+      )
+    ) {
+      if (this.isNextItemActive(timelineSpecification, currentDate, i)) {
+        i++;
+      }
+      while (
+        j + 1 < this.transactionPoints.length &&
+        !isAfter(parseDate(this.transactionPoints[j + 1].date), currentDate)
+      ) {
+        j++;
+      }
+
+      let periodEndDate = currentDate;
+      if (timelineSpecification[i].accuracy === 'day') {
+        let nextEndDate = end;
+        if (j + 1 < this.transactionPoints.length) {
+          nextEndDate = parseDate(this.transactionPoints[j + 1].date);
+        }
+        periodEndDate = min([
+          addMonths(currentDate, 3),
+          max([currentDate, nextEndDate])
+        ]);
+      }
+      const timePeriodForDates = this.getTimePeriodForDate(
+        j,
+        currentDate,
+        endOfDay(periodEndDate)
+      );
+      currentDate = periodEndDate;
+      if (timePeriodForDates != null) {
+        timelinePeriodPromises.push(timePeriodForDates);
+      }
+    }
+
+    const timelineInfoInterfaces: TimelineInfoInterface[] = await Promise.all(
+      timelinePeriodPromises
+    );
+    const minNetPerformance = timelineInfoInterfaces
+      .map((timelineInfo) => timelineInfo.minNetPerformance)
+      .filter((performance) => performance !== null)
+      .reduce((minPerformance, current) => {
+        if (minPerformance.lt(current)) {
+          return minPerformance;
+        } else {
+          return current;
+        }
+      });
+
+    const maxNetPerformance = timelineInfoInterfaces
+      .map((timelineInfo) => timelineInfo.maxNetPerformance)
+      .filter((performance) => performance !== null)
+      .reduce((maxPerformance, current) => {
+        if (maxPerformance.gt(current)) {
+          return maxPerformance;
+        } else {
+          return current;
+        }
+      });
+
+    const timelinePeriods = timelineInfoInterfaces.map(
+      (timelineInfo) => timelineInfo.timelinePeriods
+    );
+
+    return {
+      maxNetPerformance,
+      minNetPerformance,
+      timelinePeriods: flatten(timelinePeriods)
+    };
+  }
+
+  private calculateOverallPerformance(
+    positions: TimelinePosition[],
+    initialValues: { [symbol: string]: Big }
+  ) {
+    let currentValue = 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 sumOfWeights = new Big(0);
+    let totalInvestment = new Big(0);
+
+    for (const currentPosition of positions) {
+      if (currentPosition.marketPrice) {
+        currentValue = currentValue.plus(
+          new Big(currentPosition.marketPrice).mul(currentPosition.quantity)
+        );
+      } 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) {
+        // 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(weight)
+        );
+
+        netPerformancePercentage = netPerformancePercentage.plus(
+          currentPosition.netPerformancePercentage.mul(weight)
+        );
+      } else if (!currentPosition.quantity.eq(0)) {
+        Logger.warn(
+          `Missing initial value for symbol ${currentPosition.symbol} at ${currentPosition.firstBuyDate}`
+        );
+        hasErrors = true;
+      }
+    }
+
+    if (sumOfWeights.gt(0)) {
+      grossPerformancePercentage = grossPerformancePercentage.div(sumOfWeights);
+      netPerformancePercentage = netPerformancePercentage.div(sumOfWeights);
+    } else {
+      grossPerformancePercentage = new Big(0);
+      netPerformancePercentage = new Big(0);
+    }
+
+    return {
+      currentValue,
+      grossPerformance,
+      grossPerformancePercentage,
+      hasErrors,
+      netPerformance,
+      netPerformancePercentage,
+      totalInvestment
+    };
+  }
+
+  private async getTimePeriodForDate(
+    j: number,
+    startDate: Date,
+    endDate: Date
+  ): Promise<TimelineInfoInterface> {
+    let investment: Big = new Big(0);
+    let fees: Big = new Big(0);
+
+    const marketSymbolMap: {
+      [date: string]: { [symbol: string]: Big };
+    } = {};
+    if (j >= 0) {
+      const currencies: { [name: string]: string } = {};
+      const dataGatheringItems: IDataGatheringItem[] = [];
+
+      for (const item of this.transactionPoints[j].items) {
+        currencies[item.symbol] = item.currency;
+        dataGatheringItems.push({
+          dataSource: item.dataSource,
+          symbol: item.symbol
+        });
+        investment = investment.plus(item.investment);
+        fees = fees.plus(item.fee);
+      }
+
+      let marketSymbols: GetValueObject[] = [];
+      if (dataGatheringItems.length > 0) {
+        try {
+          marketSymbols = await this.currentRateService.getValues({
+            currencies,
+            dataGatheringItems,
+            dateQuery: {
+              gte: startDate,
+              lt: endOfDay(endDate)
+            },
+            userCurrency: this.currency
+          });
+        } catch (error) {
+          Logger.error(
+            `Failed to fetch info for date ${startDate} with exception`,
+            error
+          );
+          return null;
+        }
+      }
+
+      for (const marketSymbol of marketSymbols) {
+        const date = format(marketSymbol.date, DATE_FORMAT);
+        if (!marketSymbolMap[date]) {
+          marketSymbolMap[date] = {};
+        }
+        if (marketSymbol.marketPrice) {
+          marketSymbolMap[date][marketSymbol.symbol] = new Big(
+            marketSymbol.marketPrice
+          );
+        }
+      }
+    }
+
+    const results: TimelinePeriod[] = [];
+    let maxNetPerformance: Big = null;
+    let minNetPerformance: Big = null;
+    for (
+      let currentDate = startDate;
+      isBefore(currentDate, endDate);
+      currentDate = addDays(currentDate, 1)
+    ) {
+      let value = new Big(0);
+      const currentDateAsString = format(currentDate, DATE_FORMAT);
+      let invalid = false;
+      if (j >= 0) {
+        for (const item of this.transactionPoints[j].items) {
+          if (
+            !marketSymbolMap[currentDateAsString]?.hasOwnProperty(item.symbol)
+          ) {
+            invalid = true;
+            break;
+          }
+          value = value.plus(
+            item.quantity.mul(marketSymbolMap[currentDateAsString][item.symbol])
+          );
+        }
+      }
+      if (!invalid) {
+        const grossPerformance = value.minus(investment);
+        const netPerformance = grossPerformance.minus(fees);
+        if (
+          minNetPerformance === null ||
+          minNetPerformance.gt(netPerformance)
+        ) {
+          minNetPerformance = netPerformance;
+        }
+        if (
+          maxNetPerformance === null ||
+          maxNetPerformance.lt(netPerformance)
+        ) {
+          maxNetPerformance = netPerformance;
+        }
+
+        const result = {
+          grossPerformance,
+          investment,
+          netPerformance,
+          value,
+          date: currentDateAsString
+        };
+        results.push(result);
+      }
+    }
+
+    return {
+      maxNetPerformance,
+      minNetPerformance,
+      timelinePeriods: results
+    };
+  }
+
+  private getFactor(type: TypeOfOrder) {
+    let factor: number;
+
+    switch (type) {
+      case 'BUY':
+        factor = 1;
+        break;
+      case 'SELL':
+        factor = -1;
+        break;
+      default:
+        factor = 0;
+        break;
+    }
+
+    return factor;
+  }
+
+  private addToDate(date: Date, accuracy: Accuracy): Date {
+    switch (accuracy) {
+      case 'day':
+        return addDays(date, 1);
+      case 'month':
+        return addMonths(date, 1);
+      case 'year':
+        return addYears(date, 1);
+    }
+  }
+
+  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 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);
+
+    // 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
+      );
+
+      const transactionInvestment = order.quantity
+        .mul(order.unitPrice)
+        .mul(this.getFactor(order.type));
+
+      totalInvestment = totalInvestment.plus(transactionInvestment);
+
+      if (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 grossPerformancePercentage =
+      averagePriceAtStartDate.eq(0) ||
+      averagePriceAtEndDate.eq(0) ||
+      orders[indexOfStartOrder].unitPrice.eq(0)
+        ? totalGrossPerformance.div(maxTotalInvestment)
+        : 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 =
+      averagePriceAtStartDate.eq(0) ||
+      averagePriceAtEndDate.eq(0) ||
+      orders[indexOfStartOrder].unitPrice.eq(0)
+        ? totalNetPerformance.div(maxTotalInvestment)
+        : 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,
+    i: number
+  ) {
+    return (
+      i + 1 < timelineSpecification.length &&
+      !isBefore(currentDate, parseDate(timelineSpecification[i + 1].start))
+    );
+  }
+}

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

@@ -1,8 +1,9 @@
-import { OrderType } from '@ghostfolio/api/models/order-type';
+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 { Logger } from '@nestjs/common';
+import { Type as TypeOfOrder } from '@prisma/client';
 import Big from 'big.js';
 import {
   addDays,
@@ -68,7 +69,7 @@ export class PortfolioCalculator {
             : unitPrice
                 .mul(order.quantity)
                 .mul(factor)
-                .add(oldAccumulatedSymbol.investment),
+                .plus(oldAccumulatedSymbol.investment),
           quantity: newQuantity,
           symbol: order.symbol,
           transactionCount: oldAccumulatedSymbol.transactionCount + 1
@@ -237,9 +238,7 @@ export class PortfolioCalculator {
         if (!marketSymbolMap[nextDate]?.[item.symbol]) {
           invalidSymbols.push(item.symbol);
           hasErrors = true;
-          Logger.error(
-            `Missing value for symbol ${item.symbol} at ${nextDate}`
-          );
+          Logger.warn(`Missing value for symbol ${item.symbol} at ${nextDate}`);
           continue;
         }
         let lastInvestment: Big = new Big(0);
@@ -270,7 +269,7 @@ export class PortfolioCalculator {
           if (!initialValue) {
             invalidSymbols.push(item.symbol);
             hasErrors = true;
-            Logger.error(
+            Logger.warn(
               `Missing value for symbol ${item.symbol} at ${currentDate}`
             );
             continue;
@@ -355,7 +354,7 @@ export class PortfolioCalculator {
         date: transactionPoint.date,
         investment: transactionPoint.items.reduce(
           (investment, transactionPointSymbol) =>
-            investment.add(transactionPointSymbol.investment),
+            investment.plus(transactionPointSymbol.investment),
           new Big(0)
         )
       };
@@ -365,16 +364,20 @@ export class PortfolioCalculator {
   public async calculateTimeline(
     timelineSpecification: TimelineSpecification[],
     endDate: string
-  ): Promise<TimelinePeriod[]> {
+  ): Promise<TimelineInfoInterface> {
     if (timelineSpecification.length === 0) {
-      return [];
+      return {
+        maxNetPerformance: new Big(0),
+        minNetPerformance: new Big(0),
+        timelinePeriods: []
+      };
     }
 
     const startDate = timelineSpecification[0].start;
     const start = parseDate(startDate);
     const end = parseDate(endDate);
 
-    const timelinePeriodPromises: Promise<TimelinePeriod[]>[] = [];
+    const timelinePeriodPromises: Promise<TimelineInfoInterface>[] = [];
     let i = 0;
     let j = -1;
     for (
@@ -417,11 +420,40 @@ export class PortfolioCalculator {
       }
     }
 
-    const timelinePeriods: TimelinePeriod[][] = await Promise.all(
+    const timelineInfoInterfaces: TimelineInfoInterface[] = await Promise.all(
       timelinePeriodPromises
     );
+    const minNetPerformance = timelineInfoInterfaces
+      .map((timelineInfo) => timelineInfo.minNetPerformance)
+      .filter((performance) => performance !== null)
+      .reduce((minPerformance, current) => {
+        if (minPerformance.lt(current)) {
+          return minPerformance;
+        } else {
+          return current;
+        }
+      });
 
-    return flatten(timelinePeriods);
+    const maxNetPerformance = timelineInfoInterfaces
+      .map((timelineInfo) => timelineInfo.maxNetPerformance)
+      .filter((performance) => performance !== null)
+      .reduce((maxPerformance, current) => {
+        if (maxPerformance.gt(current)) {
+          return maxPerformance;
+        } else {
+          return current;
+        }
+      });
+
+    const timelinePeriods = timelineInfoInterfaces.map(
+      (timelineInfo) => timelineInfo.timelinePeriods
+    );
+
+    return {
+      maxNetPerformance,
+      minNetPerformance,
+      timelinePeriods: flatten(timelinePeriods)
+    };
   }
 
   private calculateOverallPerformance(
@@ -443,13 +475,13 @@ export class PortfolioCalculator {
 
     for (const currentPosition of positions) {
       if (currentPosition.marketPrice) {
-        currentValue = currentValue.add(
+        currentValue = currentValue.plus(
           new Big(currentPosition.marketPrice).mul(currentPosition.quantity)
         );
       } else {
         hasErrors = true;
       }
-      totalInvestment = totalInvestment.add(currentPosition.investment);
+      totalInvestment = totalInvestment.plus(currentPosition.investment);
       if (currentPosition.grossPerformance) {
         grossPerformance = grossPerformance.plus(
           currentPosition.grossPerformance
@@ -481,8 +513,8 @@ export class PortfolioCalculator {
           currentPosition.netPerformancePercentage.mul(currentInitialValue)
         );
       } else if (!currentPosition.quantity.eq(0)) {
-        Logger.error(
-          `Initial value is missing for symbol ${currentPosition.symbol}`
+        Logger.warn(
+          `Missing initial value for symbol ${currentPosition.symbol} at ${currentPosition.firstBuyDate}`
         );
         hasErrors = true;
       }
@@ -513,7 +545,7 @@ export class PortfolioCalculator {
     j: number,
     startDate: Date,
     endDate: Date
-  ): Promise<TimelinePeriod[]> {
+  ): Promise<TimelineInfoInterface> {
     let investment: Big = new Big(0);
     let fees: Big = new Big(0);
 
@@ -530,8 +562,8 @@ export class PortfolioCalculator {
           dataSource: item.dataSource,
           symbol: item.symbol
         });
-        investment = investment.add(item.investment);
-        fees = fees.add(item.fee);
+        investment = investment.plus(item.investment);
+        fees = fees.plus(item.fee);
       }
 
       let marketSymbols: GetValueObject[] = [];
@@ -569,6 +601,8 @@ export class PortfolioCalculator {
     }
 
     const results: TimelinePeriod[] = [];
+    let maxNetPerformance: Big = null;
+    let minNetPerformance: Big = null;
     for (
       let currentDate = startDate;
       isBefore(currentDate, endDate);
@@ -585,35 +619,53 @@ export class PortfolioCalculator {
             invalid = true;
             break;
           }
-          value = value.add(
+          value = value.plus(
             item.quantity.mul(marketSymbolMap[currentDateAsString][item.symbol])
           );
         }
       }
       if (!invalid) {
         const grossPerformance = value.minus(investment);
+        const netPerformance = grossPerformance.minus(fees);
+        if (
+          minNetPerformance === null ||
+          minNetPerformance.gt(netPerformance)
+        ) {
+          minNetPerformance = netPerformance;
+        }
+        if (
+          maxNetPerformance === null ||
+          maxNetPerformance.lt(netPerformance)
+        ) {
+          maxNetPerformance = netPerformance;
+        }
+
         const result = {
           grossPerformance,
           investment,
+          netPerformance,
           value,
-          date: currentDateAsString,
-          netPerformance: grossPerformance.minus(fees)
+          date: currentDateAsString
         };
         results.push(result);
       }
     }
 
-    return results;
+    return {
+      maxNetPerformance,
+      minNetPerformance,
+      timelinePeriods: results
+    };
   }
 
-  private getFactor(type: OrderType) {
+  private getFactor(type: TypeOfOrder) {
     let factor: number;
 
     switch (type) {
-      case OrderType.Buy:
+      case 'BUY':
         factor = 1;
         break;
-      case OrderType.Sell:
+      case 'SELL':
         factor = -1;
         break;
       default:

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

@@ -0,0 +1,25 @@
+import type { RequestWithUser } from '@ghostfolio/common/types';
+import { Inject, Injectable } from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
+
+import { PortfolioService } from './portfolio.service';
+import { PortfolioServiceNew } from './portfolio.service-new';
+
+@Injectable()
+export class PortfolioServiceStrategy {
+  public constructor(
+    private readonly portfolioService: PortfolioService,
+    private readonly portfolioServiceNew: PortfolioServiceNew,
+    @Inject(REQUEST) private readonly request: RequestWithUser
+  ) {}
+
+  public get() {
+    if (
+      this.request.user?.Settings?.settings?.['isNewCalculationEngine'] === true
+    ) {
+      return this.portfolioServiceNew;
+    }
+
+    return this.portfolioService;
+  }
+}

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

@@ -4,17 +4,21 @@ import {
   hasNotDefinedValuesInObject,
   nullifyValuesInObject
 } from '@ghostfolio/api/helper/object.helper';
+import { TransformDataSourceInRequestInterceptor } from '@ghostfolio/api/interceptors/transform-data-source-in-request.interceptor';
+import { TransformDataSourceInResponseInterceptor } from '@ghostfolio/api/interceptors/transform-data-source-in-response.interceptor';
 import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
 import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data.service';
 import { baseCurrency } from '@ghostfolio/common/config';
+import { parseDate } from '@ghostfolio/common/helper';
 import {
+  PortfolioChart,
   PortfolioDetails,
-  PortfolioPerformance,
+  PortfolioInvestments,
+  PortfolioPerformanceResponse,
   PortfolioPublicDetails,
   PortfolioReport,
   PortfolioSummary
 } from '@ghostfolio/common/interfaces';
-import { InvestmentItem } from '@ghostfolio/common/interfaces/investment-item.interface';
 import type { RequestWithUser } from '@ghostfolio/common/types';
 import {
   Controller,
@@ -24,20 +28,17 @@ import {
   Inject,
   Param,
   Query,
-  Res,
-  UseGuards
+  UseGuards,
+  UseInterceptors
 } from '@nestjs/common';
 import { REQUEST } from '@nestjs/core';
 import { AuthGuard } from '@nestjs/passport';
-import { Response } from 'express';
+import { ViewMode } from '@prisma/client';
 import { StatusCodes, getReasonPhrase } from 'http-status-codes';
 
-import {
-  HistoricalDataItem,
-  PortfolioPositionDetail
-} from './interfaces/portfolio-position-detail.interface';
+import { PortfolioPositionDetail } from './interfaces/portfolio-position-detail.interface';
 import { PortfolioPositions } from './interfaces/portfolio-positions.interface';
-import { PortfolioService } from './portfolio.service';
+import { PortfolioServiceStrategy } from './portfolio-service.strategy';
 
 @Controller('portfolio')
 export class PortfolioController {
@@ -45,71 +46,31 @@ export class PortfolioController {
     private readonly accessService: AccessService,
     private readonly configurationService: ConfigurationService,
     private readonly exchangeRateDataService: ExchangeRateDataService,
-    private readonly portfolioService: PortfolioService,
+    private readonly portfolioServiceStrategy: PortfolioServiceStrategy,
     @Inject(REQUEST) private readonly request: RequestWithUser,
     private readonly userService: UserService
   ) {}
 
-  @Get('investments')
-  @UseGuards(AuthGuard('jwt'))
-  public async findAll(
-    @Headers('impersonation-id') impersonationId,
-    @Res() res: Response
-  ): Promise<InvestmentItem[]> {
-    if (
-      this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION') &&
-      this.request.user.subscription.type === 'Basic'
-    ) {
-      res.status(StatusCodes.FORBIDDEN);
-      return <any>res.json([]);
-    }
-
-    let investments = await this.portfolioService.getInvestments(
-      impersonationId
-    );
-
-    if (
-      impersonationId ||
-      this.userService.isRestrictedView(this.request.user)
-    ) {
-      const maxInvestment = investments.reduce(
-        (investment, item) => Math.max(investment, item.investment),
-        1
-      );
-
-      investments = investments.map((item) => ({
-        date: item.date,
-        investment: item.investment / maxInvestment
-      }));
-    }
-
-    return <any>res.json(investments);
-  }
-
   @Get('chart')
   @UseGuards(AuthGuard('jwt'))
   public async getChart(
-    @Headers('impersonation-id') impersonationId,
-    @Query('range') range,
-    @Res() res: Response
-  ): Promise<HistoricalDataItem[]> {
-    let chartData = await this.portfolioService.getChart(
-      impersonationId,
-      range
-    );
+    @Headers('impersonation-id') impersonationId: string,
+    @Query('range') range
+  ): Promise<PortfolioChart> {
+    const historicalDataContainer = await this.portfolioServiceStrategy
+      .get()
+      .getChart(impersonationId, range);
 
-    let hasNullValue = false;
+    let chartData = historicalDataContainer.items;
+
+    let hasError = false;
 
     chartData.forEach((chartDataItem) => {
       if (hasNotDefinedValuesInObject(chartDataItem)) {
-        hasNullValue = true;
+        hasError = true;
       }
     });
 
-    if (hasNullValue) {
-      res.status(StatusCodes.ACCEPTED);
-    }
-
     if (
       impersonationId ||
       this.userService.isRestrictedView(this.request.user)
@@ -130,33 +91,40 @@ export class PortfolioController {
       });
     }
 
-    return <any>res.json(chartData);
+    return {
+      hasError,
+      chart: chartData,
+      isAllTimeHigh: historicalDataContainer.isAllTimeHigh,
+      isAllTimeLow: historicalDataContainer.isAllTimeLow
+    };
   }
 
   @Get('details')
   @UseGuards(AuthGuard('jwt'))
+  @UseInterceptors(TransformDataSourceInResponseInterceptor)
   public async getDetails(
-    @Headers('impersonation-id') impersonationId,
-    @Query('range') range,
-    @Res() res: Response
-  ): Promise<PortfolioDetails> {
+    @Headers('impersonation-id') impersonationId: string,
+    @Query('range') range
+  ): Promise<PortfolioDetails & { hasError: boolean }> {
     if (
       this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION') &&
       this.request.user.subscription.type === 'Basic'
     ) {
-      res.status(StatusCodes.FORBIDDEN);
-      return <any>res.json({ accounts: {}, holdings: {} });
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
     }
 
+    let hasError = false;
+
     const { accounts, holdings, hasErrors } =
-      await this.portfolioService.getDetails(
-        impersonationId,
-        this.request.user.id,
-        range
-      );
+      await this.portfolioServiceStrategy
+        .get()
+        .getDetails(impersonationId, this.request.user.id, range);
 
     if (hasErrors || hasNotDefinedValuesInObject(holdings)) {
-      res.status(StatusCodes.ACCEPTED);
+      hasError = true;
     }
 
     if (
@@ -194,54 +162,81 @@ export class PortfolioController {
       }
     }
 
-    return <any>res.json({ accounts, holdings });
+    return { accounts, hasError, holdings };
   }
 
-  @Get('performance')
+  @Get('investments')
   @UseGuards(AuthGuard('jwt'))
-  public async getPerformance(
-    @Headers('impersonation-id') impersonationId,
-    @Query('range') range,
-    @Res() res: Response
-  ): Promise<PortfolioPerformance> {
-    const performanceInformation = await this.portfolioService.getPerformance(
-      impersonationId,
-      range
-    );
-
-    if (performanceInformation?.hasErrors) {
-      res.status(StatusCodes.ACCEPTED);
+  public async getInvestments(
+    @Headers('impersonation-id') impersonationId: string
+  ): Promise<PortfolioInvestments> {
+    if (
+      this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION') &&
+      this.request.user.subscription.type === 'Basic'
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
     }
 
-    let performance = performanceInformation.performance;
+    let investments = await this.portfolioServiceStrategy
+      .get()
+      .getInvestments(impersonationId);
+
     if (
       impersonationId ||
       this.userService.isRestrictedView(this.request.user)
     ) {
-      performance = nullifyValuesInObject(performance, [
-        'currentGrossPerformance',
-        'currentValue'
-      ]);
+      const maxInvestment = investments.reduce(
+        (investment, item) => Math.max(investment, item.investment),
+        1
+      );
+
+      investments = investments.map((item) => ({
+        date: item.date,
+        investment: item.investment / maxInvestment
+      }));
     }
 
-    return <any>res.json(performance);
+    return { firstOrderDate: parseDate(investments[0]?.date), investments };
+  }
+
+  @Get('performance')
+  @UseGuards(AuthGuard('jwt'))
+  @UseInterceptors(TransformDataSourceInResponseInterceptor)
+  public async getPerformance(
+    @Headers('impersonation-id') impersonationId: string,
+    @Query('range') range
+  ): 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(
+        performanceInformation.performance,
+        ['currentGrossPerformance', 'currentValue']
+      );
+    }
+
+    return performanceInformation;
   }
 
   @Get('positions')
   @UseGuards(AuthGuard('jwt'))
+  @UseInterceptors(TransformDataSourceInResponseInterceptor)
   public async getPositions(
-    @Headers('impersonation-id') impersonationId,
-    @Query('range') range,
-    @Res() res: Response
+    @Headers('impersonation-id') impersonationId: string,
+    @Query('range') range
   ): Promise<PortfolioPositions> {
-    const result = await this.portfolioService.getPositions(
-      impersonationId,
-      range
-    );
-
-    if (result?.hasErrors) {
-      res.status(StatusCodes.ACCEPTED);
-    }
+    const result = await this.portfolioServiceStrategy
+      .get()
+      .getPositions(impersonationId, range);
 
     if (
       impersonationId ||
@@ -257,13 +252,12 @@ export class PortfolioController {
       });
     }
 
-    return <any>res.json(result);
+    return result;
   }
 
   @Get('public/:accessId')
   public async getPublic(
-    @Param('accessId') accessId,
-    @Res() res: Response
+    @Param('accessId') accessId
   ): Promise<PortfolioPublicDetails> {
     const access = await this.accessService.access({ id: accessId });
     const user = await this.userService.user({
@@ -271,8 +265,10 @@ export class PortfolioController {
     });
 
     if (!access) {
-      res.status(StatusCodes.NOT_FOUND);
-      return <any>res.json({ accounts: {}, holdings: {} });
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.NOT_FOUND),
+        StatusCodes.NOT_FOUND
+      );
     }
 
     let hasDetails = true;
@@ -280,10 +276,9 @@ export class PortfolioController {
       hasDetails = user.subscription.type === 'Premium';
     }
 
-    const { holdings } = await this.portfolioService.getDetails(
-      access.userId,
-      access.userId
-    );
+    const { holdings } = await this.portfolioServiceStrategy
+      .get()
+      .getDetails(access.userId, access.userId);
 
     const portfolioPublicDetails: PortfolioPublicDetails = {
       hasDetails,
@@ -316,7 +311,7 @@ export class PortfolioController {
       }
     }
 
-    return <any>res.json(portfolioPublicDetails);
+    return portfolioPublicDetails;
   }
 
   @Get('summary')
@@ -324,7 +319,9 @@ export class PortfolioController {
   public async getSummary(
     @Headers('impersonation-id') impersonationId
   ): Promise<PortfolioSummary> {
-    let summary = await this.portfolioService.getSummary(impersonationId);
+    let summary = await this.portfolioServiceStrategy
+      .get()
+      .getSummary(impersonationId);
 
     if (
       impersonationId ||
@@ -336,7 +333,9 @@ export class PortfolioController {
         'currentGrossPerformance',
         'currentNetPerformance',
         'currentValue',
+        'dividend',
         'fees',
+        'items',
         'netWorth',
         'totalBuy',
         'totalSell'
@@ -346,16 +345,18 @@ export class PortfolioController {
     return summary;
   }
 
-  @Get('position/:symbol')
+  @Get('position/:dataSource/:symbol')
+  @UseInterceptors(TransformDataSourceInRequestInterceptor)
+  @UseInterceptors(TransformDataSourceInResponseInterceptor)
   @UseGuards(AuthGuard('jwt'))
   public async getPosition(
-    @Headers('impersonation-id') impersonationId,
+    @Headers('impersonation-id') impersonationId: string,
+    @Param('dataSource') dataSource,
     @Param('symbol') symbol
   ): Promise<PortfolioPositionDetail> {
-    let position = await this.portfolioService.getPosition(
-      impersonationId,
-      symbol
-    );
+    let position = await this.portfolioServiceStrategy
+      .get()
+      .getPosition(dataSource, impersonationId, symbol);
 
     if (position) {
       if (
@@ -366,7 +367,9 @@ export class PortfolioController {
           'grossPerformance',
           'investment',
           'netPerformance',
-          'quantity'
+          'orders',
+          'quantity',
+          'value'
         ]);
       }
 
@@ -382,19 +385,18 @@ export class PortfolioController {
   @Get('report')
   @UseGuards(AuthGuard('jwt'))
   public async getReport(
-    @Headers('impersonation-id') impersonationId,
-    @Res() res: Response
+    @Headers('impersonation-id') impersonationId: string
   ): Promise<PortfolioReport> {
     if (
       this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION') &&
       this.request.user.subscription.type === 'Basic'
     ) {
-      res.status(StatusCodes.FORBIDDEN);
-      return <any>res.json({ rules: [] });
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
     }
 
-    return <any>(
-      res.json(await this.portfolioService.getReport(impersonationId))
-    );
+    return await this.portfolioServiceStrategy.get().getReport(impersonationId);
   }
 }

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

@@ -7,17 +7,21 @@ 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 { ImpersonationModule } from '@ghostfolio/api/services/impersonation.module';
+import { MarketDataModule } from '@ghostfolio/api/services/market-data.module';
 import { PrismaModule } from '@ghostfolio/api/services/prisma.module';
 import { SymbolProfileModule } from '@ghostfolio/api/services/symbol-profile.module';
 import { Module } from '@nestjs/common';
 
 import { CurrentRateService } from './current-rate.service';
-import { MarketDataService } from './market-data.service';
+import { PortfolioServiceStrategy } from './portfolio-service.strategy';
 import { PortfolioController } from './portfolio.controller';
 import { PortfolioService } from './portfolio.service';
+import { PortfolioServiceNew } from './portfolio.service-new';
 import { RulesService } from './rules.service';
 
 @Module({
+  controllers: [PortfolioController],
+  exports: [PortfolioServiceStrategy],
   imports: [
     AccessModule,
     ConfigurationModule,
@@ -25,17 +29,18 @@ import { RulesService } from './rules.service';
     DataProviderModule,
     ExchangeRateDataModule,
     ImpersonationModule,
+    MarketDataModule,
     OrderModule,
     PrismaModule,
     SymbolProfileModule,
     UserModule
   ],
-  controllers: [PortfolioController],
   providers: [
     AccountService,
     CurrentRateService,
-    MarketDataService,
     PortfolioService,
+    PortfolioServiceNew,
+    PortfolioServiceStrategy,
     RulesService
   ]
 })

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

@@ -6,7 +6,6 @@ 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 { OrderType } from '@ghostfolio/api/models/order-type';
 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';
@@ -21,15 +20,12 @@ 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,
-  ghostfolioCashSymbol
-} from '@ghostfolio/common/config';
+import { UNKNOWN_KEY, baseCurrency } from '@ghostfolio/common/config';
 import { DATE_FORMAT, parseDate } from '@ghostfolio/common/helper';
 import {
+  Accounts,
   PortfolioDetails,
-  PortfolioPerformance,
+  PortfolioPerformanceResponse,
   PortfolioReport,
   PortfolioSummary,
   Position,
@@ -37,6 +33,7 @@ import {
 } from '@ghostfolio/common/interfaces';
 import { InvestmentItem } from '@ghostfolio/common/interfaces/investment-item.interface';
 import type {
+  AccountWithValue,
   DateRange,
   OrderWithAccount,
   RequestWithUser
@@ -54,12 +51,14 @@ import {
   parse,
   parseISO,
   setDayOfYear,
+  startOfDay,
   subDays,
   subYears
 } from 'date-fns';
-import { isEmpty } from 'lodash';
+import { isEmpty, sortBy } from 'lodash';
 
 import {
+  HistoricalDataContainer,
   HistoricalDataItem,
   PortfolioPositionDetail
 } from './interfaces/portfolio-position-detail.interface';
@@ -79,6 +78,75 @@ export class PortfolioService {
     private readonly symbolProfileService: SymbolProfileService
   ) {}
 
+  public async getAccounts(aUserId: string): Promise<AccountWithValue[]> {
+    const [accounts, details] = await Promise.all([
+      this.accountService.accounts({
+        include: { Order: true, Platform: true },
+        orderBy: { name: 'asc' },
+        where: { userId: aUserId }
+      }),
+      this.getDetails(aUserId, aUserId)
+    ]);
+
+    const userCurrency = this.request.user.Settings.currency;
+
+    return accounts.map((account) => {
+      let transactionCount = 0;
+
+      for (const order of account.Order) {
+        if (!order.isDraft) {
+          transactionCount += 1;
+        }
+      }
+
+      const value = details.accounts[account.id]?.current ?? 0;
+
+      const result = {
+        ...account,
+        transactionCount,
+        value,
+        balanceInBaseCurrency: this.exchangeRateDataService.toCurrency(
+          account.balance,
+          account.currency,
+          userCurrency
+        ),
+        valueInBaseCurrency: this.exchangeRateDataService.toCurrency(
+          value,
+          account.currency,
+          userCurrency
+        )
+      };
+
+      delete result.Order;
+
+      return result;
+    });
+  }
+
+  public async getAccountsWithAggregations(aUserId: string): Promise<Accounts> {
+    const accounts = await this.getAccounts(aUserId);
+    let totalBalanceInBaseCurrency = new Big(0);
+    let totalValueInBaseCurrency = new Big(0);
+    let transactionCount = 0;
+
+    for (const account of accounts) {
+      totalBalanceInBaseCurrency = totalBalanceInBaseCurrency.plus(
+        account.balanceInBaseCurrency
+      );
+      totalValueInBaseCurrency = totalValueInBaseCurrency.plus(
+        account.valueInBaseCurrency
+      );
+      transactionCount += account.transactionCount;
+    }
+
+    return {
+      accounts,
+      transactionCount,
+      totalBalanceInBaseCurrency: totalBalanceInBaseCurrency.toNumber(),
+      totalValueInBaseCurrency: totalValueInBaseCurrency.toNumber()
+    };
+  }
+
   public async getInvestments(
     aImpersonationId: string
   ): Promise<InvestmentItem[]> {
@@ -98,18 +166,39 @@ export class PortfolioService {
       return [];
     }
 
-    return portfolioCalculator.getInvestments().map((item) => {
+    const investments = portfolioCalculator.getInvestments().map((item) => {
       return {
         date: item.date,
         investment: item.investment.toNumber()
       };
     });
+
+    // Add investment of today
+    const investmentOfToday = investments.filter((investment) => {
+      return investment.date === format(new Date(), DATE_FORMAT);
+    });
+
+    if (investmentOfToday.length <= 0) {
+      const pastInvestments = investments.filter((investment) => {
+        return isBefore(parseDate(investment.date), new Date());
+      });
+      const lastInvestment = pastInvestments[pastInvestments.length - 1];
+
+      investments.push({
+        date: format(new Date(), DATE_FORMAT),
+        investment: lastInvestment?.investment ?? 0
+      });
+    }
+
+    return sortBy(investments, (investment) => {
+      return investment.date;
+    });
   }
 
   public async getChart(
     aImpersonationId: string,
     aDateRange: DateRange = 'max'
-  ): Promise<HistoricalDataItem[]> {
+  ): Promise<HistoricalDataContainer> {
     const userId = await this.getUserId(aImpersonationId, this.request.user.id);
 
     const portfolioCalculator = new PortfolioCalculator(
@@ -120,14 +209,21 @@ export class PortfolioService {
     const { transactionPoints } = await this.getTransactionPoints({ userId });
     portfolioCalculator.setTransactionPoints(transactionPoints);
     if (transactionPoints.length === 0) {
-      return [];
+      return {
+        isAllTimeHigh: false,
+        isAllTimeLow: false,
+        items: []
+      };
     }
     let portfolioStart = parse(
       transactionPoints[0].date,
       DATE_FORMAT,
       new Date()
     );
-    portfolioStart = this.getStartDate(aDateRange, portfolioStart);
+
+    // Get start date for the full portfolio because of because of the
+    // min and max calculation
+    portfolioStart = this.getStartDate('max', portfolioStart);
 
     const timelineSpecification: TimelineSpecification[] = [
       {
@@ -136,18 +232,52 @@ export class PortfolioService {
       }
     ];
 
-    const timeline = await portfolioCalculator.calculateTimeline(
+    const timelineInfo = await portfolioCalculator.calculateTimeline(
       timelineSpecification,
       format(new Date(), DATE_FORMAT)
     );
 
-    return timeline
+    const timeline = timelineInfo.timelinePeriods;
+
+    const items = timeline
       .filter((timelineItem) => timelineItem !== null)
       .map((timelineItem) => ({
         date: timelineItem.date,
         marketPrice: timelineItem.value,
         value: timelineItem.netPerformance.toNumber()
       }));
+
+    let lastItem = null;
+    if (timeline.length > 0) {
+      lastItem = timeline[timeline.length - 1];
+    }
+
+    let isAllTimeHigh = timelineInfo.maxNetPerformance?.eq(
+      lastItem?.netPerformance
+    );
+    let isAllTimeLow = timelineInfo.minNetPerformance?.eq(
+      lastItem?.netPerformance
+    );
+    if (isAllTimeHigh && isAllTimeLow) {
+      isAllTimeHigh = false;
+      isAllTimeLow = false;
+    }
+
+    portfolioStart = startOfDay(
+      this.getStartDate(
+        aDateRange,
+        parse(transactionPoints[0].date, DATE_FORMAT, new Date())
+      )
+    );
+
+    return {
+      isAllTimeHigh,
+      isAllTimeLow,
+      items: items.filter((item) => {
+        // Filter items of date range
+        return !isAfter(portfolioStart, parseDate(item.date));
+      })
+    };
   }
 
   public async getDetails(
@@ -167,13 +297,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
@@ -186,9 +314,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 {
@@ -201,7 +331,7 @@ export class PortfolioService {
     );
 
     const [dataProviderResponses, symbolProfiles] = await Promise.all([
-      this.dataProviderService.get(dataGatheringItems),
+      this.dataProviderService.getQuotes(dataGatheringItems),
       this.symbolProfileService.getSymbolProfiles(symbols)
     ]);
 
@@ -231,7 +361,7 @@ export class PortfolioService {
         assetSubClass: symbolProfile.assetSubClass,
         countries: symbolProfile.countries,
         currency: item.currency,
-        exchange: dataProviderResponse.exchange,
+        dataSource: symbolProfile.dataSource,
         grossPerformance: item.grossPerformance?.toNumber() ?? 0,
         grossPerformancePercent:
           item.grossPerformancePercentage?.toNumber() ?? 0,
@@ -249,14 +379,18 @@ export class PortfolioService {
       };
     }
 
-    // TODO: Add a cash position for each currency
-    holdings[ghostfolioCashSymbol] = await this.getCashPosition({
+    const cashPositions = await this.getCashPositions({
       cashDetails,
+      userCurrency,
       investment: totalInvestment,
       value: totalValue
     });
 
-    const accounts = await this.getAccounts(
+    for (const symbol of Object.keys(cashPositions)) {
+      holdings[symbol] = cashPositions[symbol];
+    }
+
+    const accounts = await this.getValueOfAccounts(
       orders,
       portfolioItemsNow,
       userCurrency,
@@ -267,19 +401,25 @@ export class PortfolioService {
   }
 
   public async getPosition(
+    aDataSource: DataSource,
     aImpersonationId: string,
     aSymbol: string
   ): Promise<PortfolioPositionDetail> {
+    const userCurrency = this.request.user.Settings.currency;
     const userId = await this.getUserId(aImpersonationId, this.request.user.id);
 
-    const orders = (await this.orderService.getOrders({ userId })).filter(
-      (order) => order.symbol === aSymbol
-    );
+    const orders = (
+      await this.orderService.getOrders({ userCurrency, userId })
+    ).filter(({ SymbolProfile }) => {
+      return (
+        SymbolProfile.dataSource === aDataSource &&
+        SymbolProfile.symbol === aSymbol
+      );
+    });
 
     if (orders.length <= 0) {
       return {
         averagePrice: undefined,
-        currency: undefined,
         firstBuyDate: undefined,
         grossPerformance: undefined,
         grossPerformancePercent: undefined,
@@ -288,31 +428,36 @@ export class PortfolioService {
         marketPrice: undefined,
         maxPrice: undefined,
         minPrice: undefined,
-        name: undefined,
         netPerformance: undefined,
         netPerformancePercent: undefined,
+        orders: [],
         quantity: undefined,
-        symbol: aSymbol,
-        transactionCount: undefined
+        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.map((order) => ({
-      currency: order.currency,
-      dataSource: order.dataSource,
-      date: format(order.date, DATE_FORMAT),
-      fee: new Big(order.fee),
-      name: order.SymbolProfile?.name,
-      quantity: new Big(order.quantity),
-      symbol: order.symbol,
-      type: <OrderType>order.type,
-      unitPrice: new Big(order.unitPrice)
-    }));
+    const portfolioOrders: PortfolioOrder[] = orders
+      .filter((order) => {
+        return order.type === 'BUY' || order.type === 'SELL';
+      })
+      .map((order) => ({
+        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.SymbolProfile.symbol,
+        type: order.type,
+        unitPrice: new Big(order.unitPrice)
+      }));
 
     const portfolioCalculator = new PortfolioCalculator(
       this.currentRateService,
@@ -342,19 +487,18 @@ export class PortfolioService {
       } = position;
 
       // Convert investment, gross and net performance to currency of user
-      const userCurrency = this.request.user.Settings.currency;
       const investment = this.exchangeRateDataService.toCurrency(
-        position.investment.toNumber(),
+        position.investment?.toNumber(),
         currency,
         userCurrency
       );
       const grossPerformance = this.exchangeRateDataService.toCurrency(
-        position.grossPerformance.toNumber(),
+        position.grossPerformance?.toNumber(),
         currency,
         userCurrency
       );
       const netPerformance = this.exchangeRateDataService.toCurrency(
-        position.netPerformance.toNumber(),
+        position.netPerformance?.toNumber(),
         currency,
         userCurrency
       );
@@ -412,27 +556,30 @@ 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,
+          userCurrency
+        )
       };
     } else {
-      const currentData = await this.dataProviderService.get([
+      const currentData = await this.dataProviderService.getQuotes([
         { dataSource: DataSource.YAHOO, symbol: aSymbol }
       ]);
       const marketPrice = currentData[aSymbol]?.marketPrice;
@@ -469,14 +616,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,
@@ -485,8 +630,8 @@ export class PortfolioService {
         netPerformance: undefined,
         netPerformancePercent: undefined,
         quantity: 0,
-        symbol: aSymbol,
-        transactionCount: undefined
+        transactionCount: undefined,
+        value: 0
       };
     }
   }
@@ -531,7 +676,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)
     ]);
 
@@ -551,7 +696,9 @@ export class PortfolioService {
           grossPerformancePercentage:
             position.grossPerformancePercentage?.toNumber() ?? null,
           investment: new Big(position.investment).toNumber(),
-          marketState: dataProviderResponses[position.symbol].marketState,
+          marketState:
+            dataProviderResponses[position.symbol]?.marketState ??
+            MarketState.delayed,
           name: symbolProfileMap[position.symbol].name,
           netPerformance: position.netPerformance?.toNumber() ?? null,
           netPerformancePercentage:
@@ -565,7 +712,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(
@@ -617,27 +764,11 @@ export class PortfolioService {
         currentGrossPerformancePercent,
         currentNetPerformance,
         currentNetPerformancePercent,
-        currentValue: currentValue
+        currentValue
       }
     };
   }
 
-  public getFees(orders: OrderWithAccount[], date = new Date(0)) {
-    return orders
-      .filter((order) => {
-        // Filter out all orders before given date
-        return isBefore(date, new Date(order.date));
-      })
-      .map((order) => {
-        return this.exchangeRateDataService.toCurrency(
-          order.fee,
-          order.currency,
-          this.request.user.Settings.currency
-        );
-      })
-      .reduce((previous, current) => previous + current, 0);
-  }
-
   public async getReport(impersonationId: string): Promise<PortfolioReport> {
     const currency = this.request.user.Settings.currency;
     const userId = await this.getUserId(impersonationId, this.request.user.id);
@@ -667,7 +798,7 @@ export class PortfolioService {
     for (const position of currentPositions.positions) {
       portfolioItemsNow[position.symbol] = position;
     }
-    const accounts = await this.getAccounts(
+    const accounts = await this.getValueOfAccounts(
       orders,
       portfolioItemsNow,
       currency,
@@ -718,7 +849,7 @@ export class PortfolioService {
             new FeeRatioInitialInvestment(
               this.exchangeRateDataService,
               currentPositions.totalInvestment.toNumber(),
-              this.getFees(orders)
+              this.getFees(orders).toNumber()
             )
           ],
           { baseCurrency: currency }
@@ -728,73 +859,183 @@ export class PortfolioService {
   }
 
   public async getSummary(aImpersonationId: string): Promise<PortfolioSummary> {
-    const currency = this.request.user.Settings.currency;
+    const userCurrency = this.request.user.Settings.currency;
     const userId = await this.getUserId(aImpersonationId, this.request.user.id);
 
     const performanceInformation = await this.getPerformance(aImpersonationId);
 
-    const { balance } = await this.accountService.getCashDetails(
+    const { balanceInBaseCurrency } = await this.accountService.getCashDetails(
       userId,
-      currency
+      userCurrency
     );
-    const orders = await this.orderService.getOrders({ userId });
-    const fees = this.getFees(orders);
+    const orders = await this.orderService.getOrders({
+      userCurrency,
+      userId
+    });
+    const dividend = this.getDividend(orders).toNumber();
+    const fees = this.getFees(orders).toNumber();
     const firstOrderDate = orders[0]?.date;
+    const items = this.getItems(orders).toNumber();
 
-    const totalBuy = this.getTotalByType(orders, currency, TypeOfOrder.BUY);
-    const totalSell = this.getTotalByType(orders, currency, TypeOfOrder.SELL);
+    const totalBuy = this.getTotalByType(orders, userCurrency, 'BUY');
+    const totalSell = this.getTotalByType(orders, userCurrency, 'SELL');
 
-    const committedFunds = new Big(totalBuy).sub(totalSell);
+    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,
+      dividend,
       fees,
       firstOrderDate,
+      items,
       netWorth,
-      cash: balance,
+      totalBuy,
+      totalSell,
+      annualizedPerformancePercent:
+        performanceInformation.performance.annualizedPerformancePercent,
+      cash: balanceInBaseCurrency,
       committedFunds: committedFunds.toNumber(),
-      ordersCount: orders.length,
-      totalBuy: totalBuy,
-      totalSell: totalSell
+      ordersCount: orders.filter((order) => {
+        return order.type === 'BUY' || order.type === 'SELL';
+      }).length
     };
   }
 
-  private async getCashPosition({
+  private async getCashPositions({
     cashDetails,
     investment,
+    userCurrency,
     value
   }: {
     cashDetails: CashDetails;
     investment: Big;
+    userCurrency: string;
     value: Big;
   }) {
-    const cashValue = new Big(cashDetails.balance);
+    const cashPositions = {};
 
-    return {
-      allocationCurrent: cashValue.div(value).toNumber(),
-      allocationInvestment: cashValue.div(investment).toNumber(),
-      assetClass: AssetClass.CASH,
-      assetSubClass: AssetClass.CASH,
-      countries: [],
-      currency: 'CHF',
-      grossPerformance: 0,
-      grossPerformancePercent: 0,
-      investment: cashValue.toNumber(),
-      marketPrice: 0,
-      marketState: MarketState.open,
-      name: 'Cash',
-      netPerformance: 0,
-      netPerformancePercent: 0,
-      quantity: 0,
-      sectors: [],
-      symbol: ghostfolioCashSymbol,
-      transactionCount: 0,
-      value: cashValue.toNumber()
-    };
+    for (const account of cashDetails.accounts) {
+      const convertedBalance = this.exchangeRateDataService.toCurrency(
+        account.balance,
+        account.currency,
+        userCurrency
+      );
+
+      if (convertedBalance === 0) {
+        continue;
+      }
+
+      if (cashPositions[account.currency]) {
+        cashPositions[account.currency].investment += convertedBalance;
+        cashPositions[account.currency].value += convertedBalance;
+      } else {
+        cashPositions[account.currency] = {
+          allocationCurrent: 0,
+          allocationInvestment: 0,
+          assetClass: AssetClass.CASH,
+          assetSubClass: AssetClass.CASH,
+          countries: [],
+          currency: account.currency,
+          grossPerformance: 0,
+          grossPerformancePercent: 0,
+          investment: convertedBalance,
+          marketPrice: 0,
+          marketState: MarketState.open,
+          name: account.currency,
+          netPerformance: 0,
+          netPerformancePercent: 0,
+          quantity: 0,
+          sectors: [],
+          symbol: account.currency,
+          transactionCount: 0,
+          value: convertedBalance
+        };
+      }
+    }
+
+    for (const symbol of Object.keys(cashPositions)) {
+      // Calculate allocations for each currency
+      cashPositions[symbol].allocationCurrent = new Big(
+        cashPositions[symbol].value
+      )
+        .div(value)
+        .toNumber();
+      cashPositions[symbol].allocationInvestment = new Big(
+        cashPositions[symbol].investment
+      )
+        .div(investment)
+        .toNumber();
+    }
+
+    return cashPositions;
+  }
+
+  private getDividend(orders: OrderWithAccount[], date = new Date(0)) {
+    return orders
+      .filter((order) => {
+        // Filter out all orders before given date and type dividend
+        return (
+          isBefore(date, new Date(order.date)) &&
+          order.type === TypeOfOrder.DIVIDEND
+        );
+      })
+      .map((order) => {
+        return this.exchangeRateDataService.toCurrency(
+          new Big(order.quantity).mul(order.unitPrice).toNumber(),
+          order.SymbolProfile.currency,
+          this.request.user.Settings.currency
+        );
+      })
+      .reduce(
+        (previous, current) => new Big(previous).plus(current),
+        new Big(0)
+      );
+  }
+
+  private getFees(orders: OrderWithAccount[], date = new Date(0)) {
+    return orders
+      .filter((order) => {
+        // Filter out all orders before given date
+        return isBefore(date, new Date(order.date));
+      })
+      .map((order) => {
+        return this.exchangeRateDataService.toCurrency(
+          order.fee,
+          order.SymbolProfile.currency,
+          this.request.user.Settings.currency
+        );
+      })
+      .reduce(
+        (previous, current) => new Big(previous).plus(current),
+        new Big(0)
+      );
+  }
+
+  private getItems(orders: OrderWithAccount[], date = new Date(0)) {
+    return orders
+      .filter((order) => {
+        // Filter out all orders before given date and type item
+        return (
+          isBefore(date, new Date(order.date)) &&
+          order.type === TypeOfOrder.ITEM
+        );
+      })
+      .map((order) => {
+        return this.exchangeRateDataService.toCurrency(
+          new Big(order.quantity).mul(order.unitPrice).toNumber(),
+          order.SymbolProfile.currency,
+          this.request.user.Settings.currency
+        );
+      })
+      .reduce(
+        (previous, current) => new Big(previous).plus(current),
+        new Big(0)
+      );
   }
 
   private getStartDate(aDateRange: DateRange, portfolioStart: Date) {
@@ -825,32 +1066,38 @@ export class PortfolioService {
     transactionPoints: TransactionPoint[];
     orders: OrderWithAccount[];
   }> {
-    const orders = await this.orderService.getOrders({ includeDrafts, userId });
+    const userCurrency = this.request.user?.Settings?.currency ?? baseCurrency;
+
+    const orders = await this.orderService.getOrders({
+      includeDrafts,
+      userCurrency,
+      userId,
+      types: ['BUY', 'SELL']
+    });
 
     if (orders.length <= 0) {
       return { transactionPoints: [], orders: [] };
     }
 
-    const userCurrency = this.request.user?.Settings?.currency ?? baseCurrency;
     const portfolioOrders: PortfolioOrder[] = orders.map((order) => ({
-      currency: order.currency,
-      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,
-      type: <OrderType>order.type,
+      symbol: order.SymbolProfile.symbol,
+      type: order.type,
       unitPrice: new Big(
         this.exchangeRateDataService.toCurrency(
           order.unitPrice,
-          order.currency,
+          order.SymbolProfile.currency,
           userCurrency
         )
       )
@@ -867,7 +1114,7 @@ export class PortfolioService {
     };
   }
 
-  private async getAccounts(
+  private async getValueOfAccounts(
     orders: OrderWithAccount[],
     portfolioItemsNow: { [p: string]: TimelinePosition },
     userCurrency: string,
@@ -882,46 +1129,36 @@ export class PortfolioService {
         return accountId === account.id;
       });
 
-      if (ordersByAccount.length <= 0) {
-        // Add account without orders
-        const balance = this.exchangeRateDataService.toCurrency(
-          account.balance,
-          account.currency,
-          userCurrency
-        );
-        accounts[account.name] = {
-          current: balance,
-          original: balance
-        };
-
-        continue;
-      }
+      accounts[account.id] = {
+        balance: account.balance,
+        currency: account.currency,
+        current: account.balance,
+        name: account.name,
+        original: account.balance
+      };
 
       for (const order of ordersByAccount) {
-        let currentValueOfSymbol = this.exchangeRateDataService.toCurrency(
-          order.quantity * portfolioItemsNow[order.symbol].marketPrice,
-          order.currency,
-          userCurrency
-        );
-        let originalValueOfSymbol = this.exchangeRateDataService.toCurrency(
-          order.quantity * order.unitPrice,
-          order.currency,
-          userCurrency
-        );
+        let currentValueOfSymbol =
+          order.quantity *
+          portfolioItemsNow[order.SymbolProfile.symbol].marketPrice;
+        let originalValueOfSymbol = order.quantity * order.unitPrice;
 
         if (order.type === 'SELL') {
           currentValueOfSymbol *= -1;
           originalValueOfSymbol *= -1;
         }
 
-        if (accounts[order.Account?.name || UNKNOWN_KEY]?.current) {
-          accounts[order.Account?.name || UNKNOWN_KEY].current +=
+        if (accounts[order.Account?.id || UNKNOWN_KEY]?.current) {
+          accounts[order.Account?.id || UNKNOWN_KEY].current +=
             currentValueOfSymbol;
-          accounts[order.Account?.name || UNKNOWN_KEY].original +=
+          accounts[order.Account?.id || UNKNOWN_KEY].original +=
             originalValueOfSymbol;
         } else {
-          accounts[order.Account?.name || UNKNOWN_KEY] = {
+          accounts[order.Account?.id || UNKNOWN_KEY] = {
+            balance: 0,
+            currency: order.Account?.currency,
             current: currentValueOfSymbol,
+            name: account.name,
             original: originalValueOfSymbol
           };
         }
@@ -953,7 +1190,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

@@ -1,9 +1,13 @@
 import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
+import { PropertyService } from '@ghostfolio/api/services/property/property.service';
+import { PROPERTY_COUPONS } from '@ghostfolio/common/config';
+import { Coupon } from '@ghostfolio/common/interfaces';
 import type { RequestWithUser } from '@ghostfolio/common/types';
 import {
   Body,
   Controller,
   Get,
+  HttpCode,
   HttpException,
   Inject,
   Logger,
@@ -22,16 +26,66 @@ import { SubscriptionService } from './subscription.service';
 export class SubscriptionController {
   public constructor(
     private readonly configurationService: ConfigurationService,
+    private readonly propertyService: PropertyService,
     @Inject(REQUEST) private readonly request: RequestWithUser,
     private readonly subscriptionService: SubscriptionService
   ) {}
 
+  @Post('redeem-coupon')
+  @HttpCode(StatusCodes.OK)
+  @UseGuards(AuthGuard('jwt'))
+  public async redeemCoupon(@Body() { couponCode }: { couponCode: string }) {
+    if (!this.request.user) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    let coupons =
+      ((await this.propertyService.getByKey(PROPERTY_COUPONS)) as Coupon[]) ??
+      [];
+
+    const isValid = coupons.some((coupon) => {
+      return coupon.code === couponCode;
+    });
+
+    if (!isValid) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.BAD_REQUEST),
+        StatusCodes.BAD_REQUEST
+      );
+    }
+
+    await this.subscriptionService.createSubscription(this.request.user.id);
+
+    // Destroy coupon
+    coupons = coupons.filter((coupon) => {
+      return coupon.code !== couponCode;
+    });
+    await this.propertyService.put({
+      key: PROPERTY_COUPONS,
+      value: JSON.stringify(coupons)
+    });
+
+    Logger.log(
+      `Subscription for user '${this.request.user.id}' has been created with coupon`
+    );
+
+    return {
+      message: getReasonPhrase(StatusCodes.OK),
+      statusCode: StatusCodes.OK
+    };
+  }
+
   @Get('stripe/callback')
   public async stripeCallback(@Req() req, @Res() res) {
-    await this.subscriptionService.createSubscription(
+    const userId = await this.subscriptionService.createSubscriptionViaStripe(
       req.query.checkoutSessionId
     );
 
+    Logger.log(`Subscription for user '${userId}' has been created via Stripe`);
+
     res.redirect(`${this.configurationService.get('ROOT_URL')}/account`);
   }
 

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

@@ -1,14 +1,15 @@
-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 { SubscriptionController } from './subscription.controller';
 import { SubscriptionService } from './subscription.service';
 
 @Module({
-  imports: [],
   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,7 +2,7 @@ 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 } from '@prisma/client';
+import { Subscription, User } from '@prisma/client';
 import { addDays, isBefore } from 'date-fns';
 import Stripe from 'stripe';
 
@@ -64,26 +64,32 @@ export class SubscriptionService {
     };
   }
 
-  public async createSubscription(aCheckoutSessionId: string) {
+  public async createSubscription(aUserId: string) {
+    await this.prismaService.subscription.create({
+      data: {
+        expiresAt: addDays(new Date(), 365),
+        User: {
+          connect: {
+            id: aUserId
+          }
+        }
+      }
+    });
+  }
+
+  public async createSubscriptionViaStripe(aCheckoutSessionId: string) {
     try {
       const session = await this.stripe.checkout.sessions.retrieve(
         aCheckoutSessionId
       );
 
-      await this.prismaService.subscription.create({
-        data: {
-          expiresAt: addDays(new Date(), 365),
-          User: {
-            connect: {
-              id: session.client_reference_id
-            }
-          }
-        }
-      });
+      await this.createSubscription(session.client_reference_id);
 
       await this.stripe.customers.update(session.customer as string, {
         description: session.client_reference_id
       });
+
+      return session.client_reference_id;
     } catch (error) {
       Logger.error(error);
     }

apps/api/src/app/symbol/interfaces/symbol-item.interface.ts

@@ -1,7 +1,9 @@
+import { HistoricalDataItem } from '@ghostfolio/api/app/portfolio/interfaces/portfolio-position-detail.interface';
 import { DataSource } from '@prisma/client';
 
 export interface SymbolItem {
   currency: string;
   dataSource: DataSource;
+  historicalData: HistoricalDataItem[];
   marketPrice: number;
 }

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

@@ -1,18 +1,19 @@
-import type { RequestWithUser } from '@ghostfolio/common/types';
+import { TransformDataSourceInRequestInterceptor } from '@ghostfolio/api/interceptors/transform-data-source-in-request.interceptor';
+import { TransformDataSourceInResponseInterceptor } from '@ghostfolio/api/interceptors/transform-data-source-in-response.interceptor';
+import { IDataProviderHistoricalResponse } from '@ghostfolio/api/services/interfaces/interfaces';
 import {
   Controller,
   Get,
   HttpException,
-  Inject,
   Param,
   Query,
-  UseGuards
+  UseGuards,
+  UseInterceptors
 } from '@nestjs/common';
-import { REQUEST } from '@nestjs/core';
 import { AuthGuard } from '@nestjs/passport';
 import { DataSource } from '@prisma/client';
 import { StatusCodes, getReasonPhrase } from 'http-status-codes';
-import { isEmpty } from 'lodash';
+import { isDate, isEmpty } from 'lodash';
 
 import { LookupItem } from './interfaces/lookup-item.interface';
 import { SymbolItem } from './interfaces/symbol-item.interface';
@@ -20,22 +21,19 @@ import { SymbolService } from './symbol.service';
 
 @Controller('symbol')
 export class SymbolController {
-  public constructor(
-    private readonly symbolService: SymbolService,
-    @Inject(REQUEST) private readonly request: RequestWithUser
-  ) {}
+  public constructor(private readonly symbolService: SymbolService) {}
 
   /**
    * Must be before /:symbol
    */
   @Get('lookup')
   @UseGuards(AuthGuard('jwt'))
+  @UseInterceptors(TransformDataSourceInResponseInterceptor)
   public async lookupSymbol(
     @Query() { query = '' }
   ): Promise<{ items: LookupItem[] }> {
     try {
-      const encodedQuery = encodeURIComponent(query.toLowerCase());
-      return this.symbolService.lookup(encodedQuery);
+      return this.symbolService.lookup(query.toLowerCase());
     } catch {
       throw new HttpException(
         getReasonPhrase(StatusCodes.INTERNAL_SERVER_ERROR),
@@ -49,9 +47,12 @@ export class SymbolController {
    */
   @Get(':dataSource/:symbol')
   @UseGuards(AuthGuard('jwt'))
+  @UseInterceptors(TransformDataSourceInRequestInterceptor)
+  @UseInterceptors(TransformDataSourceInResponseInterceptor)
   public async getSymbolData(
     @Param('dataSource') dataSource: DataSource,
-    @Param('symbol') symbol: string
+    @Param('symbol') symbol: string,
+    @Query('includeHistoricalData') includeHistoricalData?: number
   ): Promise<SymbolItem> {
     if (!DataSource[dataSource]) {
       throw new HttpException(
@@ -60,7 +61,10 @@ export class SymbolController {
       );
     }
 
-    const result = await this.symbolService.get({ dataSource, symbol });
+    const result = await this.symbolService.get({
+      includeHistoricalData,
+      dataGatheringItem: { dataSource, symbol }
+    });
 
     if (!result || isEmpty(result)) {
       throw new HttpException(
@@ -71,4 +75,27 @@ export class SymbolController {
 
     return result;
   }
+
+  @Get(':dataSource/:symbol/:dateString')
+  @UseGuards(AuthGuard('jwt'))
+  public async gatherSymbolForDate(
+    @Param('dataSource') dataSource: DataSource,
+    @Param('dateString') dateString: string,
+    @Param('symbol') symbol: string
+  ): Promise<IDataProviderHistoricalResponse> {
+    const date = new Date(dateString);
+
+    if (!isDate(date)) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.BAD_REQUEST),
+        StatusCodes.BAD_REQUEST
+      );
+    }
+
+    return this.symbolService.getForDate({
+      dataSource,
+      date,
+      symbol
+    });
+  }
 }

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

@@ -1,5 +1,6 @@
 import { ConfigurationModule } from '@ghostfolio/api/services/configuration.module';
 import { DataProviderModule } from '@ghostfolio/api/services/data-provider/data-provider.module';
+import { MarketDataModule } from '@ghostfolio/api/services/market-data.module';
 import { PrismaModule } from '@ghostfolio/api/services/prisma.module';
 import { Module } from '@nestjs/common';
 
@@ -7,8 +8,14 @@ import { SymbolController } from './symbol.controller';
 import { SymbolService } from './symbol.service';
 
 @Module({
-  imports: [ConfigurationModule, DataProviderModule, PrismaModule],
   controllers: [SymbolController],
+  exports: [SymbolService],
+  imports: [
+    ConfigurationModule,
+    DataProviderModule,
+    MarketDataModule,
+    PrismaModule
+  ],
   providers: [SymbolService]
 })
 export class SymbolModule {}

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

@@ -1,8 +1,14 @@
+import { HistoricalDataItem } from '@ghostfolio/api/app/portfolio/interfaces/portfolio-position-detail.interface';
 import { DataProviderService } from '@ghostfolio/api/services/data-provider/data-provider.service';
-import { IDataGatheringItem } from '@ghostfolio/api/services/interfaces/interfaces';
-import { PrismaService } from '@ghostfolio/api/services/prisma.service';
+import {
+  IDataGatheringItem,
+  IDataProviderHistoricalResponse
+} from '@ghostfolio/api/services/interfaces/interfaces';
+import { MarketDataService } from '@ghostfolio/api/services/market-data.service';
+import { DATE_FORMAT } from '@ghostfolio/common/helper';
 import { Injectable, Logger } from '@nestjs/common';
 import { DataSource } from '@prisma/client';
+import { format, subDays } from 'date-fns';
 
 import { LookupItem } from './interfaces/lookup-item.interface';
 import { SymbolItem } from './interfaces/symbol-item.interface';
@@ -11,16 +17,43 @@ import { SymbolItem } from './interfaces/symbol-item.interface';
 export class SymbolService {
   public constructor(
     private readonly dataProviderService: DataProviderService,
-    private readonly prismaService: PrismaService
+    private readonly marketDataService: MarketDataService
   ) {}
 
-  public async get(dataGatheringItem: IDataGatheringItem): Promise<SymbolItem> {
-    const response = await this.dataProviderService.get([dataGatheringItem]);
-    const { currency, marketPrice } = response[dataGatheringItem.symbol] ?? {};
+  public async get({
+    dataGatheringItem,
+    includeHistoricalData
+  }: {
+    dataGatheringItem: IDataGatheringItem;
+    includeHistoricalData?: number;
+  }): Promise<SymbolItem> {
+    const quotes = await this.dataProviderService.getQuotes([
+      dataGatheringItem
+    ]);
+    const { currency, marketPrice } = quotes[dataGatheringItem.symbol] ?? {};
 
     if (dataGatheringItem.dataSource && marketPrice) {
+      let historicalData: HistoricalDataItem[] = [];
+
+      if (includeHistoricalData > 0) {
+        const days = includeHistoricalData;
+
+        const marketData = await this.marketDataService.getRange({
+          dateQuery: { gte: subDays(new Date(), days) },
+          symbols: [dataGatheringItem.symbol]
+        });
+
+        historicalData = marketData.map(({ date, marketPrice: value }) => {
+          return {
+            value,
+            date: date.toISOString()
+          };
+        });
+      }
+
       return {
         currency,
+        historicalData,
         marketPrice,
         dataSource: dataGatheringItem.dataSource
       };
@@ -29,6 +62,27 @@ export class SymbolService {
     return undefined;
   }
 
+  public async getForDate({
+    dataSource,
+    date,
+    symbol
+  }: {
+    dataSource: DataSource;
+    date: Date;
+    symbol: string;
+  }): Promise<IDataProviderHistoricalResponse> {
+    const historicalData = await this.dataProviderService.getHistoricalRaw(
+      [{ dataSource, symbol }],
+      date,
+      date
+    );
+
+    return {
+      marketPrice:
+        historicalData?.[symbol]?.[format(date, DATE_FORMAT)]?.marketPrice
+    };
+  }
+
   public async lookup(aQuery: string): Promise<{ items: LookupItem[] }> {
     const results: { items: LookupItem[] } = { items: [] };
 
@@ -39,32 +93,6 @@ export class SymbolService {
     try {
       const { items } = await this.dataProviderService.search(aQuery);
       results.items = items;
-
-      // Add custom symbols
-      const ghostfolioSymbolProfiles =
-        await this.prismaService.symbolProfile.findMany({
-          select: {
-            currency: true,
-            dataSource: true,
-            name: true,
-            symbol: true
-          },
-          where: {
-            AND: [
-              {
-                dataSource: DataSource.GHOSTFOLIO,
-                name: {
-                  startsWith: aQuery
-                }
-              }
-            ]
-          }
-        });
-
-      for (const ghostfolioSymbolProfile of ghostfolioSymbolProfiles) {
-        results.items.push(ghostfolioSymbolProfile);
-      }
-
       return results;
     } catch (error) {
       Logger.error(error);

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

@@ -1,4 +1,7 @@
+import { Role } from '@prisma/client';
+
 export interface UserItem {
   accessToken?: string;
   authToken: string;
+  role: Role;
 }

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

@@ -1,6 +1,11 @@
-import { IsBoolean } from 'class-validator';
+import { IsBoolean, IsOptional } from 'class-validator';
 
 export class UpdateUserSettingDto {
   @IsBoolean()
+  @IsOptional()
+  isNewCalculationEngine?: boolean;
+
+  @IsBoolean()
+  @IsOptional()
   isRestrictedView?: boolean;
 }

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

@@ -1,7 +1,10 @@
+import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
+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 {
-  getPermissions,
   hasPermission,
+  hasRole,
   permissions
 } from '@ghostfolio/common/permissions';
 import type { RequestWithUser } from '@ghostfolio/common/types';
@@ -20,7 +23,7 @@ import {
 import { REQUEST } from '@nestjs/core';
 import { JwtService } from '@nestjs/jwt';
 import { AuthGuard } from '@nestjs/passport';
-import { Provider } from '@prisma/client';
+import { Provider, Role } from '@prisma/client';
 import { User as UserModel } from '@prisma/client';
 import { StatusCodes, getReasonPhrase } from 'http-status-codes';
 
@@ -34,7 +37,9 @@ import { UserService } from './user.service';
 @Controller('user')
 export class UserController {
   public constructor(
+    private readonly configurationService: ConfigurationService,
     private jwtService: JwtService,
+    private readonly propertyService: PropertyService,
     @Inject(REQUEST) private readonly request: RequestWithUser,
     private readonly userService: UserService
   ) {}
@@ -43,10 +48,7 @@ export class UserController {
   @UseGuards(AuthGuard('jwt'))
   public async deleteUser(@Param('id') id: string): Promise<UserModel> {
     if (
-      !hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.deleteUser
-      ) ||
+      !hasPermission(this.request.user.permissions, permissions.deleteUser) ||
       id === this.request.user.id
     ) {
       throw new HttpException(
@@ -68,12 +70,28 @@ export class UserController {
 
   @Post()
   public async signupUser(): Promise<UserItem> {
-    const { accessToken, id } = await this.userService.createUser({
-      provider: Provider.ANONYMOUS
+    if (this.configurationService.get('ENABLE_FEATURE_READ_ONLY_MODE')) {
+      const isReadOnlyMode = (await this.propertyService.getByKey(
+        PROPERTY_IS_READ_ONLY_MODE
+      )) as boolean;
+
+      if (isReadOnlyMode) {
+        throw new HttpException(
+          getReasonPhrase(StatusCodes.FORBIDDEN),
+          StatusCodes.FORBIDDEN
+        );
+      }
+    }
+
+    const hasAdmin = await this.userService.hasAdmin();
+
+    const { accessToken, id, role } = await this.userService.createUser({
+      role: hasAdmin ? 'USER' : 'ADMIN'
     });
 
     return {
       accessToken,
+      role,
       authToken: this.jwtService.sign({
         id
       })
@@ -85,7 +103,7 @@ export class UserController {
   public async updateUserSetting(@Body() data: UpdateUserSettingDto) {
     if (
       !hasPermission(
-        getPermissions(this.request.user.role),
+        this.request.user.permissions,
         permissions.updateUserSettings
       )
     ) {
@@ -100,6 +118,12 @@ export class UserController {
       ...data
     };
 
+    for (const key in userSettings) {
+      if (userSettings[key] === false) {
+        delete userSettings[key];
+      }
+    }
+
     return await this.userService.updateUserSetting({
       userSettings,
       userId: this.request.user.id
@@ -111,7 +135,7 @@ export class UserController {
   public async updateUserSettings(@Body() data: UpdateUserSettingsDto) {
     if (
       !hasPermission(
-        getPermissions(this.request.user.role),
+        this.request.user.permissions,
         permissions.updateUserSettings
       )
     ) {
@@ -127,10 +151,7 @@ export class UserController {
     };
 
     if (
-      hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.updateViewMode
-      )
+      hasPermission(this.request.user.permissions, permissions.updateViewMode)
     ) {
       userSettings.viewMode = data.viewMode;
     }

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

@@ -1,6 +1,7 @@
 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';
 
@@ -8,15 +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

@@ -1,12 +1,21 @@
 import { SubscriptionService } from '@ghostfolio/api/app/subscription/subscription.service';
 import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
 import { PrismaService } from '@ghostfolio/api/services/prisma.service';
-import { baseCurrency, locale } from '@ghostfolio/common/config';
+import { PropertyService } from '@ghostfolio/api/services/property/property.service';
+import {
+  PROPERTY_IS_READ_ONLY_MODE,
+  baseCurrency,
+  locale
+} from '@ghostfolio/common/config';
 import { User as IUser, UserWithSettings } from '@ghostfolio/common/interfaces';
-import { getPermissions, permissions } from '@ghostfolio/common/permissions';
+import {
+  getPermissions,
+  hasRole,
+  permissions
+} from '@ghostfolio/common/permissions';
 import { SubscriptionType } from '@ghostfolio/common/types/subscription.type';
 import { Injectable } from '@nestjs/common';
-import { Prisma, Provider, User, ViewMode } from '@prisma/client';
+import { Prisma, Provider, Role, User, ViewMode } from '@prisma/client';
 
 import { UserSettingsParams } from './interfaces/user-settings-params.interface';
 import { UserSettings } from './interfaces/user-settings.interface';
@@ -20,6 +29,7 @@ export class UserService {
   public constructor(
     private readonly configurationService: ConfigurationService,
     private readonly prismaService: PrismaService,
+    private readonly propertyService: PropertyService,
     private readonly subscriptionService: SubscriptionService
   ) {}
 
@@ -60,6 +70,18 @@ export class UserService {
     };
   }
 
+  public async hasAdmin() {
+    const usersWithAdminRole = await this.users({
+      where: {
+        role: {
+          equals: 'ADMIN'
+        }
+      }
+    });
+
+    return usersWithAdminRole.length > 0;
+  }
+
   public isRestrictedView(aUser: UserWithSettings) {
     return (aUser.Settings.settings as UserSettings)?.isRestrictedView ?? false;
   }
@@ -74,12 +96,32 @@ export class UserService {
 
     const user: UserWithSettings = userFromDatabase;
 
-    const currentPermissions = getPermissions(userFromDatabase.role);
+    let currentPermissions = getPermissions(userFromDatabase.role);
 
     if (this.configurationService.get('ENABLE_FEATURE_FEAR_AND_GREED_INDEX')) {
       currentPermissions.push(permissions.accessFearAndGreedIndex);
     }
 
+    if (this.configurationService.get('ENABLE_FEATURE_READ_ONLY_MODE')) {
+      if (hasRole(user, Role.ADMIN)) {
+        currentPermissions.push(permissions.toggleReadOnlyMode);
+      }
+
+      const isReadOnlyMode = (await this.propertyService.getByKey(
+        PROPERTY_IS_READ_ONLY_MODE
+      )) as boolean;
+
+      if (isReadOnlyMode) {
+        currentPermissions = currentPermissions.filter((permission) => {
+          return !(
+            permission.startsWith('create') ||
+            permission.startsWith('delete') ||
+            permission.startsWith('update')
+          );
+        });
+      }
+    }
+
     user.permissions = currentPermissions;
 
     if (userFromDatabase?.Settings) {
@@ -119,7 +161,7 @@ export class UserService {
     take?: number;
     cursor?: Prisma.UserWhereUniqueInput;
     where?: Prisma.UserWhereInput;
-    orderBy?: Prisma.UserOrderByInput;
+    orderBy?: Prisma.UserOrderByWithRelationInput;
   }): Promise<User[]> {
     const { skip, take, cursor, where, orderBy } = params;
     return this.prismaService.user.findMany({
@@ -138,7 +180,11 @@ export class UserService {
     return hash.digest('hex');
   }
 
-  public async createUser(data?: Prisma.UserCreateInput): Promise<User> {
+  public async createUser(data: Prisma.UserCreateInput): Promise<User> {
+    if (!data?.provider) {
+      data.provider = 'ANONYMOUS';
+    }
+
     let user = await this.prismaService.user.create({
       data: {
         ...data,
@@ -157,7 +203,7 @@ export class UserService {
       }
     });
 
-    if (data.provider === Provider.ANONYMOUS) {
+    if (data.provider === 'ANONYMOUS') {
       const accessToken = this.createAccessToken(
         user.id,
         this.getRandomString(10)

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

@@ -0,0 +1,39 @@
+import { decodeDataSource } from '@ghostfolio/common/helper';
+import {
+  CallHandler,
+  ExecutionContext,
+  Injectable,
+  NestInterceptor
+} from '@nestjs/common';
+import { Observable } from 'rxjs';
+
+import { ConfigurationService } from '../services/configuration.service';
+
+@Injectable()
+export class TransformDataSourceInRequestInterceptor<T>
+  implements NestInterceptor<T, any>
+{
+  public constructor(
+    private readonly configurationService: ConfigurationService
+  ) {}
+
+  public intercept(
+    context: ExecutionContext,
+    next: CallHandler<T>
+  ): Observable<any> {
+    const http = context.switchToHttp();
+    const request = http.getRequest();
+
+    if (this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION') === true) {
+      if (request.body.dataSource) {
+        request.body.dataSource = decodeDataSource(request.body.dataSource);
+      }
+
+      if (request.params.dataSource) {
+        request.params.dataSource = decodeDataSource(request.params.dataSource);
+      }
+    }
+
+    return next.handle();
+  }
+}

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

@@ -0,0 +1,86 @@
+import { encodeDataSource } from '@ghostfolio/common/helper';
+import {
+  CallHandler,
+  ExecutionContext,
+  Injectable,
+  NestInterceptor
+} from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+
+import { ConfigurationService } from '../services/configuration.service';
+
+@Injectable()
+export class TransformDataSourceInResponseInterceptor<T>
+  implements NestInterceptor<T, any>
+{
+  public constructor(
+    private readonly configurationService: ConfigurationService
+  ) {}
+
+  public intercept(
+    context: ExecutionContext,
+    next: CallHandler<T>
+  ): Observable<any> {
+    return next.handle().pipe(
+      map((data: any) => {
+        if (
+          this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION') === true
+        ) {
+          if (data.activities) {
+            data.activities.map((activity) => {
+              activity.SymbolProfile.dataSource = encodeDataSource(
+                activity.SymbolProfile.dataSource
+              );
+              return activity;
+            });
+          }
+
+          if (data.dataSource) {
+            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) {
+                data.holdings[symbol].dataSource = encodeDataSource(
+                  data.holdings[symbol].dataSource
+                );
+              }
+            }
+          }
+
+          if (data.items) {
+            data.items.map((item) => {
+              item.dataSource = encodeDataSource(item.dataSource);
+              return item;
+            });
+          }
+
+          if (data.positions) {
+            data.positions.map((position) => {
+              position.dataSource = encodeDataSource(position.dataSource);
+              return position;
+            });
+          }
+
+          if (data.SymbolProfile) {
+            data.SymbolProfile.dataSource = encodeDataSource(
+              data.SymbolProfile.dataSource
+            );
+          }
+        }
+
+        return data;
+      })
+    );
+  }
+}

apps/api/src/main.ts

@@ -2,6 +2,7 @@ import { Logger, ValidationPipe } from '@nestjs/common';
 import { NestFactory } from '@nestjs/core';
 
 import { AppModule } from './app/app.module';
+import { environment } from './environments/environment';
 
 async function bootstrap() {
   const app = await NestFactory.create(AppModule);
@@ -18,8 +19,21 @@ async function bootstrap() {
 
   const port = process.env.PORT || 3333;
   await app.listen(port, () => {
+    logLogo();
     Logger.log(`Listening at http://localhost:${port}`);
+    Logger.log('');
   });
 }
 
+function logLogo() {
+  Logger.log('   ________               __  ____      ___');
+  Logger.log('  / ____/ /_  ____  _____/ /_/ __/___  / (_)___');
+  Logger.log(' / / __/ __ \\/ __ \\/ ___/ __/ /_/ __ \\/ / / __ \\');
+  Logger.log('/ /_/ / / / / /_/ (__  ) /_/ __/ /_/ / / / /_/ /');
+  Logger.log(
+    `\\____/_/ /_/\\____/____/\\__/_/  \\____/_/_/\\____/ ${environment.version}`
+  );
+  Logger.log('');
+}
+
 bootstrap();

apps/api/src/models/order-type.ts

@@ -1,8 +0,0 @@
-export enum OrderType {
-  CorporateAction = 'CORPORATE_ACTION',
-  Bonus = 'BONUS',
-  Buy = 'BUY',
-  Dividend = 'DIVIDEND',
-  Sell = 'SELL',
-  Split = 'SPLIT'
-}

apps/api/src/models/order.ts

@@ -1,8 +1,7 @@
-import { Account, SymbolProfile } from '@prisma/client';
+import { Account, SymbolProfile, Type as TypeOfOrder } from '@prisma/client';
 import { v4 as uuidv4 } from 'uuid';
 
 import { IOrder } from '../services/interfaces/interfaces';
-import { OrderType } from './order-type';
 
 export class Order {
   private account: Account;
@@ -15,7 +14,7 @@ export class Order {
   private symbol: string;
   private symbolProfile: SymbolProfile;
   private total: number;
-  private type: OrderType;
+  private type: TypeOfOrder;
   private unitPrice: number;
 
   public constructor(data: IOrder) {

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

@@ -25,17 +25,17 @@ export class AccountClusterRiskCurrentInvestment extends Rule<Settings> {
       };
     } = {};
 
-    for (const account of Object.keys(this.accounts)) {
-      accounts[account] = {
-        name: account,
-        investment: this.accounts[account].current
+    for (const [accountId, account] of Object.entries(this.accounts)) {
+      accounts[accountId] = {
+        name: account.name,
+        investment: account.current
       };
     }
 
     let maxItem;
     let totalInvestment = 0;
 
-    Object.values(accounts).forEach((account) => {
+    for (const account of Object.values(accounts)) {
       if (!maxItem) {
         maxItem = account;
       }
@@ -47,7 +47,7 @@ export class AccountClusterRiskCurrentInvestment extends Rule<Settings> {
       if (account.investment > maxItem?.investment) {
         maxItem = account;
       }
-    });
+    }
 
     const maxInvestmentRatio = maxItem.investment / totalInvestment;
 

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

@@ -19,35 +19,35 @@ export class AccountClusterRiskInitialInvestment extends Rule<Settings> {
   }
 
   public evaluate(ruleSettings?: Settings) {
-    const platforms: {
+    const accounts: {
       [symbol: string]: Pick<PortfolioPosition, 'name'> & {
         investment: number;
       };
     } = {};
 
-    for (const account of Object.keys(this.accounts)) {
-      platforms[account] = {
-        name: account,
-        investment: this.accounts[account].original
+    for (const [accountId, account] of Object.entries(this.accounts)) {
+      accounts[accountId] = {
+        name: account.name,
+        investment: account.original
       };
     }
 
     let maxItem;
     let totalInvestment = 0;
 
-    Object.values(platforms).forEach((platform) => {
+    for (const account of Object.values(accounts)) {
       if (!maxItem) {
-        maxItem = platform;
+        maxItem = account;
       }
 
       // Calculate total investment
-      totalInvestment += platform.investment;
+      totalInvestment += account.investment;
 
       // Find maximum
-      if (platform.investment > maxItem?.investment) {
-        maxItem = platform;
+      if (account.investment > maxItem?.investment) {
+        maxItem = account;
       }
-    });
+    }
 
     const maxInvestmentRatio = maxItem.investment / totalInvestment;
 

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

@@ -2,7 +2,6 @@ import { Injectable } from '@nestjs/common';
 import { DataSource } from '@prisma/client';
 import { bool, cleanEnv, host, json, num, port, str } from 'envalid';
 
-import { environment } from '../environments/environment';
 import { Environment } from './interfaces/environment.interface';
 
 @Injectable()
@@ -14,18 +13,25 @@ export class ConfigurationService {
       ACCESS_TOKEN_SALT: str(),
       ALPHA_VANTAGE_API_KEY: str({ default: '' }),
       CACHE_TTL: num({ default: 1 }),
+      DATA_SOURCE_PRIMARY: str({ default: DataSource.YAHOO }),
       DATA_SOURCES: json({ default: JSON.stringify([DataSource.YAHOO]) }),
       ENABLE_FEATURE_BLOG: bool({ default: false }),
       ENABLE_FEATURE_CUSTOM_SYMBOLS: bool({ default: false }),
       ENABLE_FEATURE_FEAR_AND_GREED_INDEX: bool({ default: false }),
-      ENABLE_FEATURE_IMPORT: bool({ default: !environment.production }),
+      ENABLE_FEATURE_IMPORT: bool({ default: true }),
+      ENABLE_FEATURE_READ_ONLY_MODE: bool({ default: false }),
       ENABLE_FEATURE_SOCIAL_LOGIN: bool({ default: false }),
       ENABLE_FEATURE_STATISTICS: bool({ default: false }),
       ENABLE_FEATURE_SUBSCRIPTION: bool({ default: false }),
+      ENABLE_FEATURE_SYSTEM_MESSAGE: bool({ default: false }),
       GOOGLE_CLIENT_ID: str({ default: 'dummyClientId' }),
       GOOGLE_SECRET: str({ default: 'dummySecret' }),
+      GOOGLE_SHEETS_ACCOUNT: str({ default: '' }),
+      GOOGLE_SHEETS_ID: str({ default: '' }),
+      GOOGLE_SHEETS_PRIVATE_KEY: str({ default: '' }),
       JWT_SECRET_KEY: str({}),
       MAX_ITEM_IN_CACHE: num({ default: 9999 }),
+      MAX_ORDERS_TO_IMPORT: num({ default: Number.MAX_SAFE_INTEGER }),
       PORT: port({ default: 3333 }),
       RAKUTEN_RAPID_API_KEY: str({ default: '' }),
       REDIS_HOST: str({ default: 'localhost' }),
@@ -33,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/cryptocurrency/cryptocurrency.service.ts

@@ -10,7 +10,7 @@ export class CryptocurrencyService {
 
   public constructor() {}
 
-  public isCrypto(aSymbol = '') {
+  public isCryptocurrency(aSymbol = '') {
     const cryptocurrencySymbol = aSymbol.substring(0, aSymbol.length - 3);
     return this.getCryptocurrencies().includes(cryptocurrencySymbol);
   }

apps/api/src/services/cryptocurrency/custom-cryptocurrencies.json

@@ -1,6 +1,12 @@
 {
   "1INCH": "1inch",
+  "ALGO": "Algorand",
+  "ATOM": "Cosmos",
   "AVAX": "Avalanche",
+  "DOT": "Polkadot",
   "MATIC": "Polygon",
-  "SHIB": "Shiba Inu"
+  "MINA": "Mina Protocol",
+  "SHIB": "Shiba Inu",
+  "SOL": "Solana",
+  "UNI3": "Uniswap"
 }

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

@@ -1,9 +1,10 @@
 import { SymbolProfileService } from '@ghostfolio/api/services/symbol-profile.service';
 import {
-  benchmarks,
-  ghostfolioFearAndGreedIndexSymbol
+  PROPERTY_LAST_DATA_GATHERING,
+  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 {
@@ -16,9 +17,7 @@ import {
   subDays
 } from 'date-fns';
 
-import { ConfigurationService } from './configuration.service';
 import { DataProviderService } from './data-provider/data-provider.service';
-import { GhostfolioScraperApiService } from './data-provider/ghostfolio-scraper-api/ghostfolio-scraper-api.service';
 import { DataEnhancerInterface } from './data-provider/interfaces/data-enhancer.interface';
 import { ExchangeRateDataService } from './exchange-rate-data.service';
 import { IDataGatheringItem } from './interfaces/interfaces';
@@ -26,13 +25,13 @@ import { PrismaService } from './prisma.service';
 
 @Injectable()
 export class DataGatheringService {
+  private dataGatheringProgress: number;
+
   public constructor(
-    private readonly configurationService: ConfigurationService,
     @Inject('DataEnhancers')
     private readonly dataEnhancers: DataEnhancerInterface[],
     private readonly dataProviderService: DataProviderService,
     private readonly exchangeRateDataService: ExchangeRateDataService,
-    private readonly ghostfolioScraperApi: GhostfolioScraperApiService,
     private readonly prismaService: PrismaService,
     private readonly symbolProfileService: SymbolProfileService
   ) {}
@@ -46,7 +45,7 @@ export class DataGatheringService {
 
       await this.prismaService.property.create({
         data: {
-          key: 'LOCKED_DATA_GATHERING',
+          key: PROPERTY_LOCKED_DATA_GATHERING,
           value: new Date().toISOString()
         }
       });
@@ -58,11 +57,11 @@ export class DataGatheringService {
 
         await this.prismaService.property.upsert({
           create: {
-            key: 'LAST_DATA_GATHERING',
+            key: PROPERTY_LAST_DATA_GATHERING,
             value: new Date().toISOString()
           },
           update: { value: new Date().toISOString() },
-          where: { key: 'LAST_DATA_GATHERING' }
+          where: { key: PROPERTY_LAST_DATA_GATHERING }
         });
       } catch (error) {
         Logger.error(error);
@@ -70,7 +69,7 @@ export class DataGatheringService {
 
       await this.prismaService.property.delete({
         where: {
-          key: 'LOCKED_DATA_GATHERING'
+          key: PROPERTY_LOCKED_DATA_GATHERING
         }
       });
 
@@ -81,7 +80,7 @@ export class DataGatheringService {
 
   public async gatherMax() {
     const isDataGatheringLocked = await this.prismaService.property.findUnique({
-      where: { key: 'LOCKED_DATA_GATHERING' }
+      where: { key: PROPERTY_LOCKED_DATA_GATHERING }
     });
 
     if (!isDataGatheringLocked) {
@@ -90,7 +89,7 @@ export class DataGatheringService {
 
       await this.prismaService.property.create({
         data: {
-          key: 'LOCKED_DATA_GATHERING',
+          key: PROPERTY_LOCKED_DATA_GATHERING,
           value: new Date().toISOString()
         }
       });
@@ -102,11 +101,11 @@ export class DataGatheringService {
 
         await this.prismaService.property.upsert({
           create: {
-            key: 'LAST_DATA_GATHERING',
+            key: PROPERTY_LAST_DATA_GATHERING,
             value: new Date().toISOString()
           },
           update: { value: new Date().toISOString() },
-          where: { key: 'LAST_DATA_GATHERING' }
+          where: { key: PROPERTY_LAST_DATA_GATHERING }
         });
       } catch (error) {
         Logger.error(error);
@@ -114,7 +113,7 @@ export class DataGatheringService {
 
       await this.prismaService.property.delete({
         where: {
-          key: 'LOCKED_DATA_GATHERING'
+          key: PROPERTY_LOCKED_DATA_GATHERING
         }
       });
 
@@ -123,36 +122,134 @@ export class DataGatheringService {
     }
   }
 
+  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.`);
+      console.time('data-gathering-symbol');
+
+      await this.prismaService.property.create({
+        data: {
+          key: PROPERTY_LOCKED_DATA_GATHERING,
+          value: new Date().toISOString()
+        }
+      });
+
+      const symbols = (await this.getSymbolsMax()).filter(
+        (dataGatheringItem) => {
+          return (
+            dataGatheringItem.dataSource === dataSource &&
+            dataGatheringItem.symbol === symbol
+          );
+        }
+      );
+
+      try {
+        await this.gatherSymbols(symbols);
+
+        await this.prismaService.property.upsert({
+          create: {
+            key: PROPERTY_LAST_DATA_GATHERING,
+            value: new Date().toISOString()
+          },
+          update: { value: new Date().toISOString() },
+          where: { key: PROPERTY_LAST_DATA_GATHERING }
+        });
+      } catch (error) {
+        Logger.error(error);
+      }
+
+      await this.prismaService.property.delete({
+        where: {
+          key: PROPERTY_LOCKED_DATA_GATHERING
+        }
+      });
+
+      Logger.log(`Symbol data gathering for ${symbol} has been completed.`);
+      console.timeEnd('data-gathering-symbol');
+    }
+  }
+
+  public async gatherSymbolForDate({
+    dataSource,
+    date,
+    symbol
+  }: {
+    dataSource: DataSource;
+    date: Date;
+    symbol: string;
+  }) {
+    try {
+      const historicalData = await this.dataProviderService.getHistoricalRaw(
+        [{ dataSource, symbol }],
+        date,
+        date
+      );
+
+      const marketPrice =
+        historicalData[symbol][format(date, DATE_FORMAT)].marketPrice;
+
+      if (marketPrice) {
+        return await this.prismaService.marketData.upsert({
+          create: {
+            dataSource,
+            date,
+            marketPrice,
+            symbol
+          },
+          update: { marketPrice },
+          where: { date_symbol: { date, symbol } }
+        });
+      }
+    } catch (error) {
+      Logger.error(error);
+    } finally {
+      return undefined;
+    }
+  }
+
   public async gatherProfileData(aDataGatheringItems?: IDataGatheringItem[]) {
     Logger.log('Profile data gathering has been started.');
     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,
-            symbol: symbolMapping[dataEnhancer.getName()] ?? symbol
+          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
+          );
         }
       }
 
@@ -163,8 +260,9 @@ export class DataGatheringService {
         currency,
         dataSource,
         name,
-        sectors
-      } = currentData[symbol];
+        sectors,
+        url
+      } = assetProfiles[symbol];
 
       try {
         await this.prismaService.symbolProfile.upsert({
@@ -176,7 +274,8 @@ export class DataGatheringService {
             dataSource,
             name,
             sectors,
-            symbol
+            symbol,
+            url
           },
           update: {
             assetClass,
@@ -184,7 +283,8 @@ export class DataGatheringService {
             countries,
             currency,
             name,
-            sectors
+            sectors,
+            url
           },
           where: {
             dataSource_symbol: {
@@ -204,8 +304,15 @@ export class DataGatheringService {
 
   public async gatherSymbols(aSymbolsWithStartDate: IDataGatheringItem[]) {
     let hasError = false;
+    let symbolCounter = 0;
 
     for (const { dataSource, date, symbol } of aSymbolsWithStartDate) {
+      if (dataSource === 'MANUAL') {
+        continue;
+      }
+
+      this.dataGatheringProgress = symbolCounter / aSymbolsWithStartDate.length;
+
       try {
         const historicalData = await this.dataProviderService.getHistoricalRaw(
           [{ dataSource, symbol }],
@@ -238,16 +345,25 @@ export class DataGatheringService {
                 ?.marketPrice;
           }
 
-          try {
-            await this.prismaService.marketData.create({
-              data: {
-                dataSource,
-                symbol,
-                date: currentDate,
-                marketPrice: lastMarketPrice
-              }
-            });
-          } catch {}
+          if (lastMarketPrice) {
+            try {
+              await this.prismaService.marketData.create({
+                data: {
+                  dataSource,
+                  symbol,
+                  date: currentDate,
+                  marketPrice: lastMarketPrice
+                }
+              });
+            } catch {}
+          } else {
+            Logger.warn(
+              `Failed to gather data for symbol ${symbol} from ${dataSource} at ${format(
+                currentDate,
+                DATE_FORMAT
+              )}.`
+            );
+          }
 
           // Count month one up for iteration
           currentDate = new Date(
@@ -263,6 +379,16 @@ export class DataGatheringService {
         hasError = true;
         Logger.error(error);
       }
+
+      if (symbolCounter > 0 && symbolCounter % 100 === 0) {
+        Logger.log(
+          `Data gathering progress: ${(
+            this.dataGatheringProgress * 100
+          ).toFixed(2)}%`
+        );
+      }
+
+      symbolCounter += 1;
     }
 
     await this.exchangeRateDataService.initialize();
@@ -272,15 +398,25 @@ export class DataGatheringService {
     }
   }
 
+  public async getDataGatheringProgress() {
+    const isInProgress = await this.getIsInProgress();
+
+    if (isInProgress) {
+      return this.dataGatheringProgress;
+    }
+
+    return undefined;
+  }
+
   public async getIsInProgress() {
     return await this.prismaService.property.findUnique({
-      where: { key: 'LOCKED_DATA_GATHERING' }
+      where: { key: PROPERTY_LOCKED_DATA_GATHERING }
     });
   }
 
   public async getLastDataGathering() {
     const lastDataGathering = await this.prismaService.property.findUnique({
-      where: { key: 'LAST_DATA_GATHERING' }
+      where: { key: PROPERTY_LAST_DATA_GATHERING }
     });
 
     if (lastDataGathering?.value) {
@@ -290,73 +426,7 @@ export class DataGatheringService {
     return undefined;
   }
 
-  public async reset() {
-    Logger.log('Data gathering has been reset.');
-
-    await this.prismaService.property.deleteMany({
-      where: {
-        OR: [{ key: 'LAST_DATA_GATHERING' }, { key: 'LOCKED_DATA_GATHERING' }]
-      }
-    });
-  }
-
-  private getBenchmarksToGather(startDate: Date): IDataGatheringItem[] {
-    const benchmarksToGather = benchmarks.map(({ dataSource, symbol }) => {
-      return {
-        dataSource,
-        symbol,
-        date: startDate
-      };
-    });
-
-    if (this.configurationService.get('ENABLE_FEATURE_FEAR_AND_GREED_INDEX')) {
-      benchmarksToGather.push({
-        dataSource: DataSource.RAKUTEN,
-        date: startDate,
-        symbol: ghostfolioFearAndGreedIndexSymbol
-      });
-    }
-
-    return benchmarksToGather;
-  }
-
-  private async getSymbols7D(): Promise<IDataGatheringItem[]> {
-    const startDate = subDays(resetHours(new Date()), 7);
-
-    const symbolProfilesToGather = (
-      await this.prismaService.symbolProfile.findMany({
-        orderBy: [{ symbol: 'asc' }],
-        select: {
-          dataSource: true,
-          scraperConfiguration: true,
-          symbol: true
-        }
-      })
-    ).map((symbolProfile) => {
-      return {
-        ...symbolProfile,
-        date: startDate
-      };
-    });
-
-    const currencyPairsToGather = this.exchangeRateDataService
-      .getCurrencyPairs()
-      .map(({ dataSource, symbol }) => {
-        return {
-          dataSource,
-          symbol,
-          date: startDate
-        };
-      });
-
-    return [
-      ...this.getBenchmarksToGather(startDate),
-      ...currencyPairsToGather,
-      ...symbolProfilesToGather
-    ];
-  }
-
-  private async getSymbolsMax(): Promise<IDataGatheringItem[]> {
+  public async getSymbolsMax(): Promise<IDataGatheringItem[]> {
     const startDate =
       (
         await this.prismaService.order.findFirst({
@@ -386,6 +456,11 @@ export class DataGatheringService {
           },
           scraperConfiguration: true,
           symbol: true
+        },
+        where: {
+          dataSource: {
+            not: 'MANUAL'
+          }
         }
       })
     ).map((symbolProfile) => {
@@ -395,37 +470,110 @@ export class DataGatheringService {
       };
     });
 
-    return [
-      ...this.getBenchmarksToGather(startDate),
-      ...currencyPairsToGather,
-      ...symbolProfilesToGather
-    ];
+    return [...currencyPairsToGather, ...symbolProfilesToGather];
+  }
+
+  public async reset() {
+    Logger.log('Data gathering has been reset.');
+
+    await this.prismaService.property.deleteMany({
+      where: {
+        OR: [
+          { key: PROPERTY_LAST_DATA_GATHERING },
+          { key: PROPERTY_LOCKED_DATA_GATHERING }
+        ]
+      }
+    });
+  }
+
+  private async getSymbols7D(): Promise<IDataGatheringItem[]> {
+    const startDate = subDays(resetHours(new Date()), 7);
+
+    const symbolProfiles = await this.prismaService.symbolProfile.findMany({
+      orderBy: [{ symbol: 'asc' }],
+      select: {
+        dataSource: true,
+        scraperConfiguration: true,
+        symbol: true
+      },
+      where: {
+        dataSource: {
+          not: 'MANUAL'
+        }
+      }
+    });
+
+    // Only consider symbols with incomplete market data for the last
+    // 7 days
+    const symbolsNotToGather = (
+      await this.prismaService.marketData.groupBy({
+        _count: true,
+        by: ['symbol'],
+        where: {
+          date: { gt: startDate }
+        }
+      })
+    )
+      .filter((group) => {
+        return group._count >= 6;
+      })
+      .map((group) => {
+        return group.symbol;
+      });
+
+    const symbolProfilesToGather = symbolProfiles
+      .filter(({ symbol }) => {
+        return !symbolsNotToGather.includes(symbol);
+      })
+      .map((symbolProfile) => {
+        return {
+          ...symbolProfile,
+          date: startDate
+        };
+      });
+
+    const currencyPairsToGather = this.exchangeRateDataService
+      .getCurrencyPairs()
+      .filter(({ symbol }) => {
+        return !symbolsNotToGather.includes(symbol);
+      })
+      .map(({ dataSource, symbol }) => {
+        return {
+          dataSource,
+          symbol,
+          date: startDate
+        };
+      });
+
+    return [...currencyPairsToGather, ...symbolProfilesToGather];
   }
 
   private async getSymbolsProfileData(): Promise<IDataGatheringItem[]> {
-    const startDate = subDays(resetHours(new Date()), 7);
-
-    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 [...this.getBenchmarksToGather(startDate), ...distinctOrders].filter(
-      (distinctOrder) => {
+    return symbolProfiles
+      .filter((symbolProfile) => {
         return (
-          distinctOrder.dataSource !== DataSource.GHOSTFOLIO &&
-          distinctOrder.dataSource !== DataSource.RAKUTEN
+          symbolProfile.dataSource !== DataSource.GHOSTFOLIO &&
+          symbolProfile.dataSource !== DataSource.MANUAL &&
+          symbolProfile.dataSource !== DataSource.RAKUTEN
         );
-      }
-    );
+      })
+      .map((symbolProfile) => {
+        return {
+          dataSource: symbolProfile.dataSource,
+          symbol: symbolProfile.symbol
+        };
+      });
   }
 
   private async isDataGatheringNeeded() {
     const lastDataGathering = await this.getLastDataGathering();
 
     const isDataGatheringLocked = await this.prismaService.property.findUnique({
-      where: { key: 'LOCKED_DATA_GATHERING' }
+      where: { key: PROPERTY_LOCKED_DATA_GATHERING }
     });
 
     const diffInHours = differenceInHours(new Date(), lastDataGathering);

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: {
@@ -88,13 +86,19 @@ export class AlphaVantageService implements DataProviderInterface {
     return DataSource.ALPHA_VANTAGE;
   }
 
-  public async search(aSymbol: string): Promise<{ items: LookupItem[] }> {
-    const result = await this.alphaVantage.data.search(aSymbol);
+  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);
 
     return {
       items: result?.bestMatches?.map((bestMatch) => {
         return {
-          dataSource: DataSource.ALPHA_VANTAGE,
+          dataSource: this.getName(),
           name: bestMatch['2. name'],
           symbol: bestMatch['1. symbol']
         };

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');
@@ -7,6 +9,9 @@ const getJSON = bent('json');
 export class TrackinsightDataEnhancerService implements DataEnhancerInterface {
   private static baseUrl = 'https://data.trackinsight.com/holdings';
   private static countries = require('countries-list/dist/countries.json');
+  private static countriesMapping = {
+    'Russian Federation': 'Russia'
+  };
   private static sectorsMapping = {
     'Consumer Discretionary': 'Consumer Cyclical',
     'Consumer Defensive': 'Consumer Staples',
@@ -18,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')
     ) {
@@ -37,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;
@@ -45,7 +53,11 @@ export class TrackinsightDataEnhancerService implements DataEnhancerInterface {
         for (const [key, country] of Object.entries<any>(
           TrackinsightDataEnhancerService.countries
         )) {
-          if (country.name === name) {
+          if (
+            country.name === name ||
+            country.name ===
+              TrackinsightDataEnhancerService.countriesMapping[name]
+          ) {
             countryCode = key;
             break;
           }
@@ -58,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.module.ts

@@ -1,6 +1,8 @@
 import { ConfigurationModule } from '@ghostfolio/api/services/configuration.module';
 import { CryptocurrencyModule } from '@ghostfolio/api/services/cryptocurrency/cryptocurrency.module';
 import { GhostfolioScraperApiService } from '@ghostfolio/api/services/data-provider/ghostfolio-scraper-api/ghostfolio-scraper-api.service';
+import { GoogleSheetsService } from '@ghostfolio/api/services/data-provider/google-sheets/google-sheets.service';
+import { ManualService } from '@ghostfolio/api/services/data-provider/manual/manual.service';
 import { RakutenRapidApiService } from '@ghostfolio/api/services/data-provider/rakuten-rapid-api/rakuten-rapid-api.service';
 import { YahooFinanceService } from '@ghostfolio/api/services/data-provider/yahoo-finance/yahoo-finance.service';
 import { PrismaModule } from '@ghostfolio/api/services/prisma.module';
@@ -21,12 +23,16 @@ import { DataProviderService } from './data-provider.service';
     AlphaVantageService,
     DataProviderService,
     GhostfolioScraperApiService,
+    GoogleSheetsService,
+    ManualService,
     RakutenRapidApiService,
     YahooFinanceService,
     {
       inject: [
         AlphaVantageService,
         GhostfolioScraperApiService,
+        GoogleSheetsService,
+        ManualService,
         RakutenRapidApiService,
         YahooFinanceService
       ],
@@ -34,11 +40,15 @@ import { DataProviderService } from './data-provider.service';
       useFactory: (
         alphaVantageService,
         ghostfolioScraperApiService,
+        googleSheetsService,
+        manualService,
         rakutenRapidApiService,
         yahooFinanceService
       ) => [
         alphaVantageService,
         ghostfolioScraperApiService,
+        googleSheetsService,
+        manualService,
         rakutenRapidApiService,
         yahooFinanceService
       ]

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

@@ -10,9 +10,9 @@ 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 { format } from 'date-fns';
-import { isEmpty } from 'lodash';
+import { DataSource, MarketData, SymbolProfile } from '@prisma/client';
+import { format, isValid } from 'date-fns';
+import { groupBy, isEmpty } from 'lodash';
 
 @Injectable()
 export class DataProviderService {
@@ -23,33 +23,6 @@ export class DataProviderService {
     private readonly prismaService: PrismaService
   ) {}
 
-  public async get(items: IDataGatheringItem[]): Promise<{
-    [symbol: string]: IDataProviderResponse;
-  }> {
-    const response: {
-      [symbol: string]: IDataProviderResponse;
-    } = {};
-
-    for (const item of items) {
-      const dataProvider = this.getDataProvider(item.dataSource);
-      response[item.symbol] = (await dataProvider.get([item.symbol]))[
-        item.symbol
-      ];
-    }
-
-    const promises = [];
-    for (const symbol of Object.keys(response)) {
-      const promise = Promise.resolve(response[symbol]);
-      promises.push(
-        promise.then((currentResponse) => (response[symbol] = currentResponse))
-      );
-    }
-
-    await Promise.all(promises);
-
-    return response;
-  }
-
   public async getHistorical(
     aItems: IDataGatheringItem[],
     aGranularity: Granularity = 'month',
@@ -62,7 +35,7 @@ export class DataProviderService {
       [symbol: string]: { [date: string]: IDataProviderHistoricalResponse };
     } = {};
 
-    if (isEmpty(aItems)) {
+    if (isEmpty(aItems) || !isValid(from) || !isValid(to)) {
       return response;
     }
 
@@ -96,7 +69,7 @@ export class DataProviderService {
                         ORDER BY date;`;
 
       const marketDataByGranularity: MarketData[] =
-        await this.prismaService.$queryRaw(queryRaw);
+        await this.prismaService.$queryRawUnsafe(queryRaw);
 
       response = marketDataByGranularity.reduce((r, marketData) => {
         const { date, marketPrice, symbol } = marketData;
@@ -135,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 }))
         );
       }
@@ -149,13 +122,89 @@ export class DataProviderService {
     return result;
   }
 
-  public async search(aSymbol: string): Promise<{ items: LookupItem[] }> {
+  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[] = [];
 
     for (const dataSource of this.configurationService.get('DATA_SOURCES')) {
       promises.push(
-        this.getDataProvider(DataSource[dataSource]).search(aSymbol)
+        this.getDataProvider(DataSource[dataSource]).search(aQuery)
       );
     }
 
@@ -175,16 +224,13 @@ export class DataProviderService {
     };
   }
 
-  public getPrimaryDataSource(): DataSource {
-    return DataSource[this.configurationService.get('DATA_SOURCES')[0]];
-  }
-
   private getDataProvider(providerName: DataSource) {
     for (const dataProviderInterface of this.dataProviderInterfaces) {
       if (dataProviderInterface.getName() === providerName) {
         return dataProviderInterface;
       }
     }
+
     throw new Error('No data provider has been found.');
   }
 }

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

@@ -1,24 +1,19 @@
 import { LookupItem } from '@ghostfolio/api/app/symbol/interfaces/lookup-item.interface';
-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 { Granularity } from '@ghostfolio/common/types';
-import { Injectable, Logger } from '@nestjs/common';
-import { DataSource } from '@prisma/client';
-import * as bent from 'bent';
-import * as cheerio from 'cheerio';
-import { format } from 'date-fns';
-
+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 { PrismaService } from '@ghostfolio/api/services/prisma.service';
+import { SymbolProfileService } from '@ghostfolio/api/services/symbol-profile.service';
+import { DATE_FORMAT, getYesterday } from '@ghostfolio/common/helper';
+import { Granularity } from '@ghostfolio/common/types';
+import { Injectable, Logger } from '@nestjs/common';
+import { DataSource, SymbolProfile } from '@prisma/client';
+import * as bent from 'bent';
+import * as cheerio from 'cheerio';
+import { format } from 'date-fns';
 
 @Injectable()
 export class GhostfolioScraperApiService implements DataProviderInterface {
@@ -30,60 +25,28 @@ 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: DataSource.GHOSTFOLIO,
-          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]
       );
@@ -116,8 +79,72 @@ export class GhostfolioScraperApiService implements DataProviderInterface {
     return DataSource.GHOSTFOLIO;
   }
 
-  public async search(aSymbol: string): Promise<{ items: LookupItem[] }> {
-    return { items: [] };
+  public async getQuotes(
+    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 search(aQuery: string): Promise<{ items: LookupItem[] }> {
+    const items = await this.prismaService.symbolProfile.findMany({
+      select: {
+        currency: true,
+        dataSource: true,
+        name: true,
+        symbol: true
+      },
+      where: {
+        OR: [
+          {
+            dataSource: this.getName(),
+            name: {
+              mode: 'insensitive',
+              startsWith: aQuery
+            }
+          },
+          {
+            dataSource: this.getName(),
+            symbol: {
+              mode: 'insensitive',
+              startsWith: aQuery
+            }
+          }
+        ]
+      }
+    });
+
+    return { items };
   }
 
   private extractNumberFromString(aString: string): number {

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

@@ -0,0 +1,185 @@
+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 { SymbolProfileService } from '@ghostfolio/api/services/symbol-profile.service';
+import { DATE_FORMAT, parseDate } from '@ghostfolio/common/helper';
+import { Granularity } from '@ghostfolio/common/types';
+import { Injectable, Logger } from '@nestjs/common';
+import { DataSource, SymbolProfile } from '@prisma/client';
+import { format } from 'date-fns';
+import { GoogleSpreadsheet } from 'google-spreadsheet';
+
+@Injectable()
+export class GoogleSheetsService implements DataProviderInterface {
+  public constructor(
+    private readonly configurationService: ConfigurationService,
+    private readonly prismaService: PrismaService,
+    private readonly symbolProfileService: SymbolProfileService
+  ) {}
+
+  public canHandle(symbol: string) {
+    return true;
+  }
+
+  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);
+    }
+
+    return {};
+  }
+
+  public getName(): DataSource {
+    return DataSource.GOOGLE_SHEETS;
+  }
+
+  public async getQuotes(
+    aSymbols: string[]
+  ): Promise<{ [symbol: string]: IDataProviderResponse }> {
+    if (aSymbols.length <= 0) {
+      return {};
+    }
+
+    try {
+      const response: { [symbol: string]: IDataProviderResponse } = {};
+
+      const symbolProfiles = await this.symbolProfileService.getSymbolProfiles(
+        aSymbols
+      );
+
+      const sheet = await this.getSheet({
+        sheetId: this.configurationService.get('GOOGLE_SHEETS_ID'),
+        symbol: 'Overview'
+      });
+
+      const rows = await sheet.getRows();
+
+      for (const row of rows) {
+        const marketPrice = parseFloat(row['marketPrice']);
+        const symbol = row['symbol'];
+
+        if (aSymbols.includes(symbol)) {
+          response[symbol] = {
+            marketPrice,
+            currency: symbolProfiles.find((symbolProfile) => {
+              return symbolProfile.symbol === symbol;
+            })?.currency,
+            dataSource: this.getName(),
+            marketState: MarketState.delayed
+          };
+        }
+      }
+
+      return response;
+    } catch (error) {
+      Logger.error(error);
+    }
+
+    return {};
+  }
+
+  public async search(aQuery: string): Promise<{ items: LookupItem[] }> {
+    const items = await this.prismaService.symbolProfile.findMany({
+      select: {
+        currency: true,
+        dataSource: true,
+        name: true,
+        symbol: true
+      },
+      where: {
+        OR: [
+          {
+            dataSource: this.getName(),
+            name: {
+              mode: 'insensitive',
+              startsWith: aQuery
+            }
+          },
+          {
+            dataSource: this.getName(),
+            symbol: {
+              mode: 'insensitive',
+              startsWith: aQuery
+            }
+          }
+        ]
+      }
+    });
+
+    return { items };
+  }
+
+  private async getSheet({
+    sheetId,
+    symbol
+  }: {
+    sheetId: string;
+    symbol: string;
+  }) {
+    const doc = new GoogleSpreadsheet(sheetId);
+
+    await doc.useServiceAccountAuth({
+      client_email: this.configurationService.get('GOOGLE_SHEETS_ACCOUNT'),
+      private_key: this.configurationService
+        .get('GOOGLE_SHEETS_PRIVATE_KEY')
+        .replace(/\\n/g, '\n')
+    });
+
+    await doc.loadInfo();
+
+    const sheet = doc.sheetsByTitle[symbol];
+
+    await sheet.loadCells();
+
+    return sheet;
+  }
+}

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

@@ -1,27 +1,30 @@
 import { LookupItem } from '@ghostfolio/api/app/symbol/interfaces/lookup-item.interface';
-import { Granularity } from '@ghostfolio/common/types';
-import { DataSource } from '@prisma/client';
-
 import {
   IDataProviderHistoricalResponse,
   IDataProviderResponse
-} from '../../interfaces/interfaces';
+} from '@ghostfolio/api/services/interfaces/interfaces';
+import { Granularity } from '@ghostfolio/common/types';
+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;
 
-  search(aSymbol: string): Promise<{ items: LookupItem[] }>;
+  getQuotes(
+    aSymbols: string[]
+  ): Promise<{ [symbol: string]: IDataProviderResponse }>;
+
+  search(aQuery: string): Promise<{ items: LookupItem[] }>;
 }

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

@@ -0,0 +1,51 @@
+import { LookupItem } from '@ghostfolio/api/app/symbol/interfaces/lookup-item.interface';
+import { DataProviderInterface } from '@ghostfolio/api/services/data-provider/interfaces/data-provider.interface';
+import {
+  IDataProviderHistoricalResponse,
+  IDataProviderResponse
+} from '@ghostfolio/api/services/interfaces/interfaces';
+import { Granularity } from '@ghostfolio/common/types';
+import { Injectable } from '@nestjs/common';
+import { DataSource, SymbolProfile } from '@prisma/client';
+
+@Injectable()
+export class ManualService implements DataProviderInterface {
+  public constructor() {}
+
+  public canHandle(symbol: string) {
+    return false;
+  }
+
+  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 };
+  }> {
+    return {};
+  }
+
+  public getName(): DataSource {
+    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,25 +1,19 @@
 import { LookupItem } from '@ghostfolio/api/app/symbol/interfaces/lookup-item.interface';
 import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
-import { PrismaService } from '@ghostfolio/api/services/prisma.service';
-import { ghostfolioFearAndGreedIndexSymbol } from '@ghostfolio/common/config';
-import {
-  DATE_FORMAT,
-  getToday,
-  getYesterday,
-  isRakutenRapidApiSymbol
-} from '@ghostfolio/common/helper';
-import { Granularity } from '@ghostfolio/common/types';
-import { Injectable, Logger } from '@nestjs/common';
-import { DataSource } from '@prisma/client';
-import * as bent from 'bent';
-import { format, subMonths, subWeeks, subYears } from 'date-fns';
-
+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 { 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, SymbolProfile } from '@prisma/client';
+import * as bent from 'bent';
+import { format, subMonths, subWeeks, subYears } from 'date-fns';
 
 @Injectable()
 export class RakutenRapidApiService implements DataProviderInterface {
@@ -31,56 +25,27 @@ export class RakutenRapidApiService implements DataProviderInterface {
   ) {}
 
   public canHandle(symbol: string) {
-    return (
-      isRakutenRapidApiSymbol(symbol) &&
-      !!this.configurationService.get('RAKUTEN_RAPID_API_KEY')
-    );
+    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: DataSource.RAKUTEN,
-            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();
@@ -93,7 +58,7 @@ export class RakutenRapidApiService implements DataProviderInterface {
           await this.prismaService.marketData.create({
             data: {
               symbol,
-              dataSource: DataSource.RAKUTEN,
+              dataSource: this.getName(),
               date: subWeeks(getToday(), 1),
               marketPrice: fgi.oneWeekAgo.value
             }
@@ -102,7 +67,7 @@ export class RakutenRapidApiService implements DataProviderInterface {
           await this.prismaService.marketData.create({
             data: {
               symbol,
-              dataSource: DataSource.RAKUTEN,
+              dataSource: this.getName(),
               date: subMonths(getToday(), 1),
               marketPrice: fgi.oneMonthAgo.value
             }
@@ -111,7 +76,7 @@ export class RakutenRapidApiService implements DataProviderInterface {
           await this.prismaService.marketData.create({
             data: {
               symbol,
-              dataSource: DataSource.RAKUTEN,
+              dataSource: this.getName(),
               date: subYears(getToday(), 1),
               marketPrice: fgi.oneYearAgo.value
             }
@@ -137,7 +102,36 @@ export class RakutenRapidApiService implements DataProviderInterface {
     return DataSource.RAKUTEN;
   }
 
-  public async search(aSymbol: string): Promise<{ items: LookupItem[] }> {
+  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);
+    }
+
+    return {};
+  }
+
+  public async search(aQuery: string): Promise<{ items: LookupItem[] }> {
     return { items: [] };
   }
 

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.spec.ts

@@ -0,0 +1,60 @@
+import { CryptocurrencyService } from '@ghostfolio/api/services/cryptocurrency/cryptocurrency.service';
+
+import { YahooFinanceService } from './yahoo-finance.service';
+
+jest.mock(
+  '@ghostfolio/api/services/cryptocurrency/cryptocurrency.service',
+  () => {
+    return {
+      CryptocurrencyService: jest.fn().mockImplementation(() => {
+        return {
+          isCryptocurrency: (symbol: string) => {
+            switch (symbol) {
+              case 'BTCUSD':
+                return true;
+              case 'DOGEUSD':
+                return true;
+              default:
+                return false;
+            }
+          }
+        };
+      })
+    };
+  }
+);
+
+describe('YahooFinanceService', () => {
+  let cryptocurrencyService: CryptocurrencyService;
+  let yahooFinanceService: YahooFinanceService;
+
+  beforeAll(async () => {
+    cryptocurrencyService = new CryptocurrencyService();
+
+    yahooFinanceService = new YahooFinanceService(cryptocurrencyService);
+  });
+
+  it('convertFromYahooFinanceSymbol', async () => {
+    expect(
+      await yahooFinanceService.convertFromYahooFinanceSymbol('BRK-B')
+    ).toEqual('BRK-B');
+    expect(
+      await yahooFinanceService.convertFromYahooFinanceSymbol('BTC-USD')
+    ).toEqual('BTCUSD');
+    expect(
+      await yahooFinanceService.convertFromYahooFinanceSymbol('EURUSD=X')
+    ).toEqual('EURUSD');
+  });
+
+  it('convertToYahooFinanceSymbol', async () => {
+    expect(
+      await yahooFinanceService.convertToYahooFinanceSymbol('BTCUSD')
+    ).toEqual('BTC-USD');
+    expect(
+      await yahooFinanceService.convertToYahooFinanceSymbol('DOGEUSD')
+    ).toEqual('DOGE-USD');
+    expect(
+      await yahooFinanceService.convertToYahooFinanceSymbol('USDCHF')
+    ).toEqual('USDCHF=X');
+  });
+});