Release 1.165.0 (#1044 )

Clean up comments (#1043 )
* Clean up comments
2022-06-25 17:34:06 +02:00 · 2022-06-25 17:30:43 +02:00 · 2022-06-25 14:47:20 +02:00 · 2022-06-25 12:38:15 +02:00 · 2022-06-25 11:33:59 +02:00 · 2022-06-25 11:15:01 +02:00
383 changed files with 25040 additions and 15605 deletions
--- a/.env
+++ b/.env
@ -3,14 +3,14 @@ COMPOSE_PROJECT_NAME=ghostfolio-development
 # CACHE
 REDIS_HOST=localhost
 REDIS_PORT=6379
+REDIS_PASSWORD=<INSERT_REDIS_PASSWORD>

 # POSTGRES
 POSTGRES_DB=ghostfolio-db
 POSTGRES_USER=user
-POSTGRES_PASSWORD=password
+POSTGRES_PASSWORD=<INSERT_POSTGRES_PASSWORD>

-ACCESS_TOKEN_SALT=GHOSTFOLIO
+ACCESS_TOKEN_SALT=<INSERT_RANDOM_STRING>
 ALPHA_VANTAGE_API_KEY=
 DATABASE_URL=postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@localhost:5432/${POSTGRES_DB}?sslmode=prefer
-JWT_SECRET_KEY=123456
-PORT=3333
+JWT_SECRET_KEY=<INSERT_RANDOM_STRING>
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@ -0,0 +1 @@
+custom: ['https://www.buymeacoffee.com/ghostfolio']
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -5,6 +5,678 @@ 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.165.0 - 25.06.2022
+
+### Added
+
+- Added an icon and name column to the positions table
+- Added a reusable premium indicator component
+
+### Changed
+
+- Moved the positions table to a dedicated section (_Holdings_)
+- Changed the data gathering by symbol endpoint to delete data first
+
+## 1.164.0 - 23.06.2022
+
+### Added
+
+- Added the positions table including performance to the public page
+
+## 1.163.0 - 22.06.2022
+
+### Changed
+
+- Improved the onboarding for iOS
+
+## 1.162.0 - 18.06.2022
+
+### Added
+
+- Added a _Privacy Policy_ page
+
+### Changed
+
+- Simplified the header
+
+### Fixed
+
+- Fixed an issue with the currency inconsistency in the _Yahoo Finance_ service (convert from `ILA` to `ILS`)
+
+## 1.161.1 - 16.06.2022
+
+### Added
+
+- Added the vertical hover line to inspect data points in the performance chart on the home page
+
+### Changed
+
+- Improved the landing page
+- Upgraded `angular` from version `13.3.6` to `14.0.2`
+- Upgraded `Nx` from version `14.1.4` to `14.3.5`
+- Upgraded `storybook` from version `6.4.22` to `6.5.9`
+
+### Fixed
+
+- Improved the error handling of missing market prices
+
+## 1.160.0 - 15.06.2022
+
+### Fixed
+
+- Fixed the `No data provider has been found` error in the search (regression after `envalid` upgrade to `7.3.1` in Ghostfolio `1.157.0`)
+
+## 1.159.0 - 15.06.2022
+
+### Changed
+
+- Changed the default `HOST` to `0.0.0.0`
+- Refactored the endpoint of the public page (filter by equity)
+
+## 1.158.1 - 12.06.2022
+
+### Added
+
+- Extended the queue jobs view in the admin control panel by a data dialog
+
+### Changed
+
+- Exposed the environment variable `HOST`
+- Decreased the number of attempts of queue jobs from `20` to `10` (fail earlier)
+- Improved the message for data provider errors in the client
+- Changed the label from _Balance_ to _Cash Balance_ in the account dialog
+- Restructured the documentation for self-hosting
+
+## 1.157.0 - 11.06.2022
+
+### Added
+
+- Extended the queue jobs view in the admin control panel by the number of attempts and the status
+
+### Changed
+
+- Migrated the historical market data gathering to the queue design pattern
+- Refreshed the cryptocurrencies list to support more coins by default
+- Increased the historical data chart of the _Fear & Greed Index_ (market mood) to 180 days
+- Upgraded `chart.js` from version `3.7.0` to `3.8.0`
+- Upgraded `envalid` from version `7.2.1` to `7.3.1`
+
+### Fixed
+
+- Reloaded the accounts of a user after creating, editing or deleting one
+- Excluded empty items in the activities filter
+
+## 1.156.0 - 05.06.2022
+
+### Added
+
+- Added the user id to the account page
+- Added a new view with jobs of the queue to the admin control panel
+
+### Changed
+
+- Simplified the features page
+- Restructured the _FIRE_ section
+- Upgraded `@simplewebauthn/browser` and `@simplewebauthn/server` from version `4.1.0` to `5.2.1`
+
+### Fixed
+
+- Fixed the `docker-compose` files to resolve variables correctly
+
+## 1.155.0 - 29.05.2022
+
+### Added
+
+- Added `EOD_HISTORICAL_DATA` as a new data source type
+
+### Changed
+
+- Exposed the environment variable `REDIS_PASSWORD`
+
+### Fixed
+
+- Fixed the empty state of the portfolio proportion chart component (with 2 levels)
+
+### Todo
+
+- Apply data migration (`yarn database:migrate`)
+
+## 1.154.0 - 28.05.2022
+
+### Added
+
+- Added a vertical hover line to inspect data points in the line chart component
+
+### Changed
+
+- Improved the tooltips of the chart components (content and style)
+- Simplified the pricing page
+- Improved the rounding numbers in the twitter bot service
+- Removed the dependency `round-to`
+
+## 1.153.0 - 27.05.2022
+
+### Added
+
+- Extended the benchmarks of the markets overview by the current market condition (bear and bull market)
+- Extended the twitter bot service by benchmarks
+- Added value redaction for the impersonation mode in the API response as an interceptor
+
+### Changed
+
+- Changed the twitter bot service to rest on the weekend
+- Upgraded `prisma` from version `3.12.0` to `3.14.0`
+
+### Fixed
+
+- Fixed a styling issue in the benchmark component on mobile
+
+## 1.152.0 - 26.05.2022
+
+### Added
+
+- Added the _Ghostfolio_ trailer to the landing page
+- Extended the markets overview by benchmarks (current change to the all time high)
+
+## 1.151.0 - 24.05.2022
+
+### Added
+
+- Added support to set the base currency as an environment variable (`BASE_CURRENCY`)
+
+### Fixed
+
+- Fixed an issue with the missing conversion of countries in the symbol profile overrides
+
+## 1.150.0 - 21.05.2022
+
+### Changed
+
+- Skipped data enhancer (_Trackinsight_) if data is inaccurate
+
+### Fixed
+
+- Fixed an issue with the currency conversion in the account calculations
+- Fixed an issue with countries in the symbol profile overrides
+
+## 1.149.0 - 16.05.2022
+
+### Added
+
+- Added groups to the activities filter component
+- Added support for filtering by asset class on the allocations page
+
+## 1.148.0 - 14.05.2022
+
+### Added
+
+- Supported enter key press to submit the form of the create or edit transaction dialog
+- Added a _Report Data Glitch_ button to the position detail dialog
+
+### Fixed
+
+- Fixed the date format of the date picker and support manual changes
+- Fixed the state of the account delete button (disable if account contains activities)
+- Fixed an issue in the activities filter component (typing a search term)
+
+## 1.147.0 - 10.05.2022
+
+### Changed
+
+- Improved the allocations page with no filtering (include cash positions)
+
+## 1.146.3 - 08.05.2022
+
+### Added
+
+- Set up a queue for the data gathering jobs
+- Set up _Nx Cloud_
+
+### Changed
+
+- Migrated the asset profile data gathering to the queue design pattern
+- Improved the allocations page with no filtering
+- Harmonized the _No data available_ label in the portfolio proportion chart component
+- Improved the _FIRE_ calculator for the _Live Demo_
+- Simplified the about page
+- Upgraded `angular` from version `13.2.2` to `13.3.6`
+- Upgraded `Nx` from version `13.8.5` to `14.1.4`
+- Upgraded `storybook` from version `6.4.18` to `6.4.22`
+
+### Fixed
+
+- Eliminated the circular dependencies in the `@ghostfolio/common` library
+
+## 1.145.0 - 07.05.2022
+
+### Added
+
+- Added support for filtering by accounts on the allocations page
+- Added support for private equity
+- Extended the form to set the asset and asset sub class for (wealth) items
+
+### Changed
+
+- Refactored the filtering (activities table and allocations page)
+
+### Fixed
+
+- Fixed the tooltip update in the portfolio proportion chart component
+
+### Todo
+
+- Apply data migration (`yarn database:migrate`)
+
+## 1.144.0 - 30.04.2022
+
+### Added
+
+- Added support for commodities (via futures)
+- Added support for real estate
+
+### Changed
+
+- Improved the layout of the position detail dialog
+- Upgraded `yahoo-finance2` from version `2.3.1` to `2.3.2`
+
+### Fixed
+
+- Fixed the import validation for numbers equal 0
+- Fixed the color of the spinner in the activities filter component (dark mode)
+
+### Todo
+
+- Apply data migration (`yarn database:migrate`)
+
+## 1.143.0 - 26.04.2022
+
+### Changed
+
+- Improved the filtering by tags
+
+## 1.142.0 - 25.04.2022
+
+### Added
+
+- Added the tags to the create or edit transaction dialog
+- Added the tags to the position detail dialog
+
+### Changed
+
+- Changed the date to UTC in the data gathering service
+- Reused the value component in the users table of the admin control panel
+
+## 1.141.1 - 24.04.2022
+
+### Added
+
+- Added the database migration
+
+### Todo
+
+- Apply data migration (`yarn database:migrate`)
+
+## 1.141.0 - 24.04.2022
+
+### Added
+
+- Added a tagging system for activities
+
+### Changed
+
+- Extracted the activities table filter to a dedicated component
+- Changed the url of the _Get Started_ link to `https://ghostfol.io` on the public page
+- Simplified `@@id` using multiple fields with `@id` in the database schema of (`Access`, `Order`, `Subscription`)
+- Upgraded `prisma` from version `3.11.1` to `3.12.0`
+
+### Todo
+
+- Apply data migration (`yarn database:migrate`)
+
+## 1.140.2 - 22.04.2022
+
+### Added
+
+- Added support for sub-labels in the value component
+- Added a symbol profile overrides model for manual adjustments
+
+### Changed
+
+- Reused the value component in the _Ghostfolio in Numbers_ section of the about page
+- Persisted the savings rate in the _FIRE_ calculator
+- Upgraded `yahoo-finance2` from version `2.3.0` to `2.3.1`
+
+### Fixed
+
+- Fixed the calculation of the total value for sell and dividend activities in the create or edit transaction dialog
+
+### Todo
+
+- Apply data migration (`yarn database:migrate`)
+
+## 1.139.0 - 18.04.2022
+
+### Added
+
+- Added the total amount to the tooltip in the chart of the _FIRE_ calculator
+
+### Changed
+
+- Beautified the ETF names in the symbol profile
+
+### Fixed
+
+- Fixed an issue with changing the investment horizon in the chart of the _FIRE_ calculator
+- Fixed an issue with the end dates in the `.ics` file of the future activities (drafts) export
+- Fixed the data source of the _Fear & Greed Index_ (market mood)
+
+## 1.138.0 - 16.04.2022
+
+### Added
+
+- Added support to export a single future activity (draft) as an `.ics` file
+- Added the _Boringly Getting Rich_ guide to the resources section
+
+### Changed
+
+- Separated the deposit and savings in the chart of the _FIRE_ calculator
+
+## 1.137.0 - 15.04.2022
+
+### Added
+
+- Added support to export future activities (drafts) as an `.ics` file
+
+### Changed
+
+- Migrated the search functionality to `yahoo-finance2`
+
+### Fixed
+
+- Fixed an issue in the average price / investment calculation for sell activities
+
+## 1.136.0 - 13.04.2022
+
+### Changed
+
+- Changed the _Total_ label to _Total Assets_ in the portfolio summary tab on the home page
+
+### Fixed
+
+- Fixed an issue with the calculation of the projected total amount in the _FIRE_ calculator
+- Fixed an issue with the loading state of the _FIRE_ calculator
+
+## 1.135.0 - 10.04.2022
+
+### Added
+
+- Added a calculator to the _FIRE_ section
+- Added support for the cryptocurrency _Terra_ (`LUNA1-USD`)
+- Added support for the cryptocurrency _THORChain_ (`RUNE-USD`)
+
+## 1.134.0 - 09.04.2022
+
+### Changed
+
+- Switched to the new calculation engine
+- Improved the 4% rule in the _FIRE_ section
+- Changed the background of the header to a solid color
+
+## 1.133.0 - 07.04.2022
+
+### Changed
+
+- Improved the empty state of the portfolio proportion chart component
+
+### Fixed
+
+- Fixed an issue with dates in the value component
+
+## 1.132.1 - 06.04.2022
+
+### Fixed
+
+- Fixed an issue with percentages in the value component
+
+## 1.132.0 - 06.04.2022
+
+### Added
+
+- Added support for localization (date and number format) in user settings
+
+### Changed
+
+- Improved the label of the average price from _Ø Buy Price_ to _Average Unit Price_
+
+## 1.131.1 - 04.04.2022
+
+### Fixed
+
+- Fixed the missing API version in the _Stripe_ success callback url
+
+## 1.131.0 - 02.04.2022
+
+### Added
+
+- Added API versioning
+- Added more durations in the coupon system
+
+### Changed
+
+- Display the value in base currency in the accounts table on mobile
+- Display the value in base currency in the activities table on mobile
+- Renamed `orders` to `activities` in import and export functionality
+- Harmonized the algebraic sign of `currentGrossPerformancePercent` and `currentNetPerformancePercent` with `currentGrossPerformance` and `currentNetPerformance`
+- Improved the pricing page
+- Upgraded `prisma` from version `3.10.0` to `3.11.1`
+- Upgraded `yahoo-finance2` from version `2.2.0` to `2.3.0`
+
+## 1.130.0 - 30.03.2022
+
+### Added
+
+- Added a _FIRE_ (Financial Independence, Retire Early) section including the 4% rule
+- Added more durations in the coupon system
+
+### Fixed
+
+- Fixed an issue with the currency conversion (duplicate) in the account calculations
+
+## 1.129.0 - 26.03.2022
+
+### Added
+
+- Added the calculation for developed vs. emerging markets to the allocations page
+- Added a hover effect to the page tabs
+- Extended the feature overview page by _Bonds_ and _Emergency Fund_
+
+## 1.128.0 - 19.03.2022
+
+### Added
+
+- Added the attribute `defaultMarketPrice` to the scraper configuration to improve the support for bonds
+- Added a hover effect to the table style
+
+### Fixed
+
+- Fixed an issue with the user currency of the public page
+- Fixed an issue of the performance calculation with recent activities in the new calculation engine
+
+## 1.127.0 - 16.03.2022
+
+### Changed
+
+- Improved the error handling in the scraper configuration
+
+### Fixed
+
+- Fixed the support for multiple symbols of the data source `GHOSTFOLIO`
+
+## 1.126.0 - 14.03.2022
+
+### Added
+
+- Added support for bonds
+
+### Changed
+
+- Restructured the portfolio summary tab on the home page
+- Improved the tooltips in the portfolio proportion chart component by introducing multilines
+
+### Todo
+
+- Apply data migration (`yarn database:migrate`)
+
+## 1.125.0 - 12.03.2022
+
+### Added
+
+- Added support for an emergency fund
+- Added the contexts to the logger commands
+
+### Changed
+
+- Upgraded `Nx` from version `13.8.1` to `13.8.5`
+
+## 1.124.0 - 06.03.2022
+
+### Added
+
+- Added support for setting a duration in the coupon system
+
+### Changed
+
+- Upgraded `ngx-skeleton-loader` from version `2.9.1` to `5.0.0`
+- Upgraded `prisma` from version `3.9.1` to `3.10.0`
+- Upgraded `yahoo-finance2` from version `2.1.9` to `2.2.0`
+
+## 1.123.0 - 05.03.2022
+
+### Added
+
+- Included data provider errors in the API response
+
+### Changed
+
+- Removed the redundant attributes (`currency`, `dataSource`, `symbol`) of the activity model
+- Removed the prefix for symbols with the data source `GHOSTFOLIO`
+
+### Fixed
+
+- Improved the account calculations
+
+### Todo
+
+- Apply data migration (`yarn database:migrate`)
+
+## 1.122.0 - 01.03.2022
+
+### Added
+
+- Added support for click in the portfolio proportion chart component
+
+### Fixed
+
+- Fixed an issue with undefined currencies after creating an activity
+
+## 1.121.0 - 27.02.2022
+
+### Added
+
+- Added support for mutual funds
+- Added the url to the symbol profile model
+
+### Changed
+
+- Migrated from `yahoo-finance` to `yahoo-finance2`
+
+### Todo
+
+- Apply data migration (`yarn database:migrate`)
+
+## 1.120.0 - 25.02.2022
+
+### Changed
+
+- Distinguished the labels _Other_ and _Unknown_ in the portfolio proportion chart component
+- Improved the portfolio entry page
+
+### Fixed
+
+- Fixed the _Zen Mode_
+
+## 1.119.0 - 21.02.2022
+
+### Added
+
+- Added a trial for the subscription
+
+## 1.118.0 - 20.02.2022
+
+### Changed
+
+- Improved the calculation of the overall performance percentage in the new calculation engine
+- Displayed features in features overview page based on permissions
+- Extended the data points of historical data in the admin control panel
+
+## 1.117.0 - 19.02.2022
+
+### Changed
+
+- Moved the countries and sectors charts in the position detail dialog
+- Distinguished today's data point of historical data in the admin control panel
+- Restructured the server modules
+
+### Fixed
+
+- Fixed the allocations by account for non-unique account names
+- Added a fallback to the default account if the `accountId` is invalid in the import functionality for activities
+
+## 1.116.0 - 16.02.2022
+
+### Added
+
+- Added a service to tweet the current _Fear & Greed Index_ (market mood)
+
+### Changed
+
+- Improved the mobile layout of the position detail dialog (countries and sectors charts)
+
+### Fixed
+
+- Fixed the `maxItems` attribute of the portfolio proportion chart component
+- Fixed the time in market display of the portfolio summary tab on the home page
+
+## 1.115.0 - 13.02.2022
+
+### Added
+
+- Added a feature overview page
+- Added the asset and asset sub class to the position detail dialog
+- Added the countries and sectors to the position detail dialog
+
+### Changed
+
+- Upgraded `angular` from version `13.1.2` to `13.2.2`
+- 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
--- a/2
+++ b/2
@ -23,7 +23,7 @@ COPY ./angular.json angular.json
 COPY ./nx.json nx.json
 COPY ./replace.build.js replace.build.js
 COPY ./jest.preset.js jest.preset.js
-COPY ./jest.config.js jest.config.js
+COPY ./jest.config.ts jest.config.ts
 COPY ./tsconfig.base.json tsconfig.base.json
 COPY ./libs libs
 COPY ./apps apps
--- a/README.md
+++ b/README.md
@ -9,7 +9,7 @@

  <h1>Ghostfolio</h1>
  <p>
-    <strong>Open Source Wealth Management Software made for Humans</strong>
+    <strong>Open Source Wealth Management Software</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/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>
@ -24,38 +24,31 @@
  </p>
 </div>

-**Ghostfolio** is an open source wealth management software built with web technology. The application empowers busy people to keep track of their wealth like stocks, ETFs or cryptocurrencies and make solid, data-driven investment decisions.
+**Ghostfolio** is an open source wealth management software built with web technology. The application empowers busy people to keep track of stocks, ETFs or cryptocurrencies and make solid, data-driven investment decisions.

-<div align="center">
-  <img src="./apps/client/src/assets/images/screenshot.png" width="300">
+<div align="center" style="margin-top: 1rem; margin-bottom: 1rem;">
+  <a href="https://www.youtube.com/watch?v=yY6ObSQVJZk">
+    <img src="./apps/client/src/assets/images/video-preview.jpg" width="600"></a>
 </div>

 ## Ghostfolio Premium

 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 (self-hosting), please find further instructions in the section [Run with Docker](#run-with-docker-self-hosting).
+If you prefer to run Ghostfolio on your own infrastructure, please find further instructions in the [Self-hosting](#self-hosting) section.

 ## 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
-
+- 🙅 saying no to spreadsheets in 2022
 - 😎 still reading this list

 ## Features
@ -65,10 +58,15 @@ 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

+<div align="center" style="margin-top: 1rem; margin-bottom: 1rem;">
+  <img src="./apps/client/src/assets/images/screenshot.png" width="300">
+</div>
+
 ## Technology Stack

 Ghostfolio is a modern web application written in [TypeScript](https://www.typescriptlang.org) and organized as an [Nx](https://nx.dev) workspace.
@ -81,46 +79,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 (self-hosting)
+## Self-hosting

-### Prerequisites
+### Run with Docker Compose

- [Docker](https://www.docker.com/products/docker-desktop)
+#### Prerequisites

-### a. Run environment
+- Basic knowledge of Docker
+- Installation of [Docker](https://www.docker.com/products/docker-desktop)
+- Local copy of this Git repository (clone)
+
+#### a. Run environment

 Run the following command to start the Docker images from [Docker Hub](https://hub.docker.com/r/ghostfolio/ghostfolio):

 ```bash
-docker-compose -f docker/docker-compose.yml up
+docker-compose --env-file ./.env -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.yml exec ghostfolio yarn database:setup
+docker-compose --env-file ./.env -f docker/docker-compose.yml exec ghostfolio yarn database:setup
 ```

-### b. Build and run environment
+#### 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
+docker-compose --env-file ./.env -f docker/docker-compose.build.yml build
+docker-compose --env-file ./.env -f docker/docker-compose.build.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.yml exec ghostfolio yarn database:setup
+docker-compose --env-file ./.env -f docker/docker-compose.build.yml exec ghostfolio yarn database:setup
 ```

-### Fetch Historical Data
+#### Fetch Historical Data

 Open http://localhost:3333 in your browser and accomplish these steps:

@ -128,13 +130,15 @@ Open http://localhost:3333 in your browser and accomplish these steps:
 1. Go to the _Admin Control Panel_ and click _Gather All Data_ to fetch historical data
 1. Click _Sign out_ and check out the _Live Demo_

-### Migrate Database
+#### Upgrade Version

-With the following command you can keep your database schema in sync after a Ghostfolio version update:
+1. Increase the version of the `ghostfolio/ghostfolio` Docker image in `docker/docker-compose.yml`
+1. Run the following command to start the new Docker image: `docker-compose --env-file ./.env -f docker/docker-compose.yml up -d`
+1. Then, run the following command to keep your database schema in sync: `docker-compose --env-file ./.env -f docker/docker-compose.yml exec ghostfolio yarn database:migrate`

-```bash
-docker-compose -f docker/docker-compose-build-local.yml exec ghostfolio yarn database:migrate
-```
+### Run with _Unraid_ (Community)
+
+Please follow the instructions of the Ghostfolio [Unraid Community App](https://unraid.net/community/apps?q=ghostfolio).

 ## Development

@ -143,11 +147,12 @@ docker-compose -f docker/docker-compose-build-local.yml exec ghostfolio yarn dat
 - [Docker](https://www.docker.com/products/docker-desktop)
 - [Node.js](https://nodejs.org/en/download) (version 14+)
 - [Yarn](https://yarnpkg.com/en/docs/install)
+- A local copy of this Git repository (clone)

 ### Setup

 1. Run `yarn install`
-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 `docker-compose --env-file ./.env -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 the server and the client (see [_Development_](#Development))
 1. Create a new user via _Get Started_ (this first user will get the role `ADMIN`)
@ -169,16 +174,92 @@ Run `yarn start:client`

 Run `yarn start:storybook`

+### Migrate Database
+
+With the following command you can keep your database schema in sync:
+
+```bash
+yarn database:push
+```
+
 ## Testing

 Run `yarn test`

+## Public API
+
+### Import Activities
+
+#### Request
+
+`POST http://localhost:3333/api/v1/import`
+
+#### Authorization: Bearer Token
+
+Set the header as follows:
+
+```
+"Authorization": "Bearer eyJh..."
+```
+
+#### Body
+
+```
+{
+  "activities": [
+    {
+      "currency": "USD",
+      "dataSource": "YAHOO",
+      "date": "2021-09-15T00:00:00.000Z",
+      "fee": 19,
+      "quantity": 5,
+      "symbol": "MSFT"
+      "type": "BUY",
+      "unitPrice": 298.58
+    }
+  ]
+}
+```
+
+| Field      | Type                | Description                                        |
+| ---------- | ------------------- | -------------------------------------------------- |
+| accountId  | string (`optional`) | Id of the account                                  |
+| currency   | string              | `CHF` \| `EUR` \| `USD` etc.                       |
+| dataSource | string              | `MANUAL` (for type `ITEM`) \| `YAHOO`              |
+| date       | string              | Date in the format `ISO-8601`                      |
+| fee        | number              | Fee of the activity                                |
+| quantity   | number              | Quantity of the activity                           |
+| symbol     | string              | Symbol of the activity (suitable for `dataSource`) |
+| type       | string              | `BUY` \| `DIVIDEND` \| `ITEM` \| `SELL`            |
+| unitPrice  | number              | Price per unit of the activity                     |
+
+#### Response
+
+##### Success
+
+`201 Created`
+
+##### Error
+
+`400 Bad Request`
+
+```
+{
+  "error": "Bad Request",
+  "message": [
+    "activities.1 is a duplicate activity"
+  ]
+}
+```
+
 ## Contributing

 Ghostfolio is **100% free** and **open source**. We encourage and support an active and healthy community that accepts contributions from the public - including you.

 Not sure what to work on? We have got some ideas. Please join the Ghostfolio [Slack channel](https://join.slack.com/t/ghostfolio/shared_invite/zt-vsaan64h-F_I0fEo5M0P88lP9ibCxFg), tweet to [@ghostfolio\_](https://twitter.com/ghostfolio_) or send an e-mail to hi@ghostfol.io. We would love to hear from you.

+If you like to support this project, get **[Ghostfolio Premium](https://ghostfol.io/pricing)** or **[Buy me a coffee](https://www.buymeacoffee.com/ghostfolio)**.
+
 ## License

 © 2022 [Ghostfolio](https://ghostfol.io)
--- a/angular.json
+++ b/angular.json
@ -2,6 +2,7 @@
  "version": 1,
  "projects": {
    "api": {
+      "$schema": "../../node_modules/nx/schemas/project-schema.json",
      "root": "apps/api",
      "sourceRoot": "apps/api/src",
      "projectType": "application",
@ -9,7 +10,7 @@
      "schematics": {},
      "architect": {
        "build": {
-          "builder": "@nrwl/node:build",
+          "builder": "@nrwl/node:webpack",
          "options": {
            "outputPath": "dist/apps/api",
            "main": "apps/api/src/main.ts",
@ -33,7 +34,7 @@
          "outputs": ["{options.outputPath}"]
        },
        "serve": {
-          "builder": "@nrwl/node:execute",
+          "builder": "@nrwl/node:node",
          "options": {
            "buildTarget": "api:build"
          }
@ -47,7 +48,7 @@
        "test": {
          "builder": "@nrwl/jest:jest",
          "options": {
-            "jestConfig": "apps/api/jest.config.js",
+            "jestConfig": "apps/api/jest.config.ts",
            "passWithNoTests": true
          },
          "outputs": ["coverage/apps/api"]
@ -56,6 +57,7 @@
      "tags": []
    },
    "client": {
+      "$schema": "../../node_modules/nx/schemas/project-schema.json",
      "projectType": "application",
      "schematics": {
        "@schematics/angular:component": {
@ -180,7 +182,7 @@
        "test": {
          "builder": "@nrwl/jest:jest",
          "options": {
-            "jestConfig": "apps/client/jest.config.js",
+            "jestConfig": "apps/client/jest.config.ts",
            "passWithNoTests": true
          },
          "outputs": ["coverage/apps/client"]
@ -189,6 +191,7 @@
      "tags": []
    },
    "client-e2e": {
+      "$schema": "../../node_modules/nx/schemas/project-schema.json",
      "root": "apps/client-e2e",
      "sourceRoot": "apps/client-e2e/src",
      "projectType": "application",
@ -211,6 +214,7 @@
      "implicitDependencies": ["client"]
    },
    "common": {
+      "$schema": "../../node_modules/nx/schemas/project-schema.json",
      "root": "libs/common",
      "sourceRoot": "libs/common/src",
      "projectType": "library",
@ -225,7 +229,7 @@
          "builder": "@nrwl/jest:jest",
          "outputs": ["coverage/libs/common"],
          "options": {
-            "jestConfig": "libs/common/jest.config.js",
+            "jestConfig": "libs/common/jest.config.ts",
            "passWithNoTests": true
          }
        }
@ -233,6 +237,7 @@
      "tags": []
    },
    "ui": {
+      "$schema": "../../node_modules/nx/schemas/project-schema.json",
      "projectType": "library",
      "schematics": {
        "@schematics/angular:component": {
@ -247,7 +252,7 @@
          "builder": "@nrwl/jest:jest",
          "outputs": ["coverage/libs/ui"],
          "options": {
-            "jestConfig": "libs/ui/jest.config.js",
+            "jestConfig": "libs/ui/jest.config.ts",
            "passWithNoTests": true
          }
        },
@ -258,13 +263,12 @@
          }
        },
        "storybook": {
-          "builder": "@nrwl/storybook:storybook",
+          "builder": "@storybook/angular:start-storybook",
          "options": {
-            "uiFramework": "@storybook/angular",
            "port": 4400,
-            "config": {
-              "configFolder": "libs/ui/.storybook"
-            }
+            "configDir": "libs/ui/.storybook",
+            "browserTarget": "ui:build-storybook",
+            "compodoc": false
          },
          "configurations": {
            "ci": {
@ -273,14 +277,13 @@
          }
        },
        "build-storybook": {
-          "builder": "@nrwl/storybook:build",
+          "builder": "@storybook/angular:build-storybook",
          "outputs": ["{options.outputPath}"],
          "options": {
-            "uiFramework": "@storybook/angular",
-            "outputPath": "dist/storybook/ui",
-            "config": {
-              "configFolder": "libs/ui/.storybook"
-            }
+            "outputDir": "dist/storybook/ui",
+            "configDir": "libs/ui/.storybook",
+            "browserTarget": "ui:build-storybook",
+            "compodoc": false
          },
          "configurations": {
            "ci": {
@ -292,6 +295,7 @@
      "tags": []
    },
    "ui-e2e": {
+      "$schema": "../../node_modules/nx/schemas/project-schema.json",
      "root": "apps/ui-e2e",
      "sourceRoot": "apps/ui-e2e/src",
      "projectType": "application",
--- a/apps/api/jest.config.ts
+++ b/apps/api/jest.config.ts
@ -1,6 +1,6 @@
-module.exports = {
+export default {
  displayName: 'api',
-  preset: '../../jest.preset.js',
+
  globals: {
    'ts-jest': {
      tsconfig: '<rootDir>/tsconfig.spec.json'
@ -12,5 +12,6 @@ module.exports = {
  moduleFileExtensions: ['ts', 'js', 'html'],
  coverageDirectory: '../../coverage/apps/api',
  testTimeout: 10000,
-  testEnvironment: 'node'
+  testEnvironment: 'node',
+  preset: '../../jest.preset.js'
 };
--- a/apps/api/src/app/access/access.controller.ts
+++ b/apps/api/src/app/access/access.controller.ts
@ -78,8 +78,12 @@ export class AccessController {
  @Delete(':id')
  @UseGuards(AuthGuard('jwt'))
  public async deleteAccess(@Param('id') id: string): Promise<AccessModule> {
+    const access = await this.accessService.access({ id });
+
    if (
-      !hasPermission(this.request.user.permissions, permissions.deleteAccess)
+      !hasPermission(this.request.user.permissions, permissions.deleteAccess) ||
+      !access ||
+      access.userId !== this.request.user.id
    ) {
      throw new HttpException(
        getReasonPhrase(StatusCodes.FORBIDDEN),
@ -88,10 +92,7 @@ export class AccessController {
    }

    return this.accessService.deleteAccess({
-      id_userId: {
-        id,
-        userId: this.request.user.id
-      }
+      id
    });
  }
 }
--- a/apps/api/src/app/access/access.module.ts
+++ b/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 {}
--- a/apps/api/src/app/account/account.controller.ts
+++ b/apps/api/src/app/account/account.controller.ts
@ -1,4 +1,4 @@
-import { PortfolioServiceStrategy } from '@ghostfolio/api/app/portfolio/portfolio-service.strategy';
+import { PortfolioService } from '@ghostfolio/api/app/portfolio/portfolio.service';
 import { UserService } from '@ghostfolio/api/app/user/user.service';
 import {
  nullifyValuesInObject,
@ -35,7 +35,7 @@ export class AccountController {
  public constructor(
    private readonly accountService: AccountService,
    private readonly impersonationService: ImpersonationService,
-    private readonly portfolioServiceStrategy: PortfolioServiceStrategy,
+    private readonly portfolioService: PortfolioService,
    @Inject(REQUEST) private readonly request: RequestWithUser,
    private readonly userService: UserService
  ) {}
@ -91,9 +91,10 @@ export class AccountController {
        this.request.user.id
      );

-    let accountsWithAggregations = await this.portfolioServiceStrategy
-      .get()
-      .getAccountsWithAggregations(impersonationUserId || this.request.user.id);
+    let accountsWithAggregations =
+      await this.portfolioService.getAccountsWithAggregations(
+        impersonationUserId || this.request.user.id
+      );

    if (
      impersonationUserId ||
@ -101,16 +102,18 @@ export class AccountController {
    ) {
      accountsWithAggregations = {
        ...nullifyValuesInObject(accountsWithAggregations, [
-          'totalBalance',
-          'totalValue'
+          'totalBalanceInBaseCurrency',
+          'totalValueInBaseCurrency'
        ]),
        accounts: nullifyValuesInObjects(accountsWithAggregations.accounts, [
          'balance',
+          'balanceInBaseCurrency',
          'convertedBalance',
          'fee',
          'quantity',
          'unitPrice',
-          'value'
+          'value',
+          'valueInBaseCurrency'
        ])
      };
    }
--- a/apps/api/src/app/account/account.module.ts
+++ b/apps/api/src/app/account/account.module.ts
@ -13,6 +13,7 @@ import { AccountService } from './account.service';

@Module({
  controllers: [AccountController],
+  exports: [AccountService],
  imports: [
    ConfigurationModule,
    DataProviderModule,
--- a/apps/api/src/app/account/account.service.ts
+++ b/apps/api/src/app/account/account.service.ts
@ -1,7 +1,10 @@
 import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data.service';
 import { PrismaService } from '@ghostfolio/api/services/prisma.service';
+import { Filter } from '@ghostfolio/common/interfaces';
 import { Injectable } from '@nestjs/common';
 import { Account, Order, Platform, Prisma } from '@prisma/client';
+import Big from 'big.js';
+import { groupBy } from 'lodash';

 import { CashDetails } from './interfaces/cash-details.interface';

@ -101,25 +104,51 @@ export class AccountService {
    });
  }

-  public async getCashDetails(
-    aUserId: string,
-    aCurrency: string
-  ): Promise<CashDetails> {
-    let totalCashBalance = 0;
+  public async getCashDetails({
+    currency,
+    filters = [],
+    userId
+  }: {
+    currency: string;
+    filters?: Filter[];
+    userId: string;
+  }): Promise<CashDetails> {
+    let totalCashBalanceInBaseCurrency = new Big(0);

-    const accounts = await this.accounts({
-      where: { userId: aUserId }
+    const where: Prisma.AccountWhereInput = { userId };
+
+    const {
+      ACCOUNT: filtersByAccount,
+      ASSET_CLASS: filtersByAssetClass,
+      TAG: filtersByTag
+    } = groupBy(filters, (filter) => {
+      return filter.type;
    });

-    accounts.forEach((account) => {
-      totalCashBalance += this.exchangeRateDataService.toCurrency(
-        account.balance,
-        account.currency,
-        aCurrency
+    if (filtersByAccount?.length > 0) {
+      where.id = {
+        in: filtersByAccount.map(({ id }) => {
+          return id;
+        })
+      };
+    }
+
+    const accounts = await this.accounts({ where });
+
+    for (const account of accounts) {
+      totalCashBalanceInBaseCurrency = totalCashBalanceInBaseCurrency.plus(
+        this.exchangeRateDataService.toCurrency(
+          account.balance,
+          account.currency,
+          currency
+        )
      );
-    });
+    }

-    return { accounts, balance: totalCashBalance };
+    return {
+      accounts,
+      balanceInBaseCurrency: totalCashBalanceInBaseCurrency.toNumber()
+    };
  }

  public async updateAccount(
--- a/apps/api/src/app/account/interfaces/cash-details.interface.ts
+++ b/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;
 }
--- a/apps/api/src/app/admin/admin.controller.ts
+++ b/apps/api/src/app/admin/admin.controller.ts
@ -1,6 +1,10 @@
 import { DataGatheringService } from '@ghostfolio/api/services/data-gathering.service';
 import { MarketDataService } from '@ghostfolio/api/services/market-data.service';
 import { PropertyDto } from '@ghostfolio/api/services/property/property.dto';
+import {
+  GATHER_ASSET_PROFILE_PROCESS,
+  GATHER_ASSET_PROFILE_PROCESS_OPTIONS
+} from '@ghostfolio/common/config';
 import {
  AdminData,
  AdminMarketData,
@ -56,6 +60,24 @@ export class AdminController {
    return this.adminService.get();
  }

+  @Post('gather')
+  @UseGuards(AuthGuard('jwt'))
+  public async gather7Days(): Promise<void> {
+    if (
+      !hasPermission(
+        this.request.user.permissions,
+        permissions.accessAdminControl
+      )
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    this.dataGatheringService.gather7Days();
+  }
+
  @Post('gather/max')
  @UseGuards(AuthGuard('jwt'))
  public async gatherMax(): Promise<void> {
@ -71,10 +93,20 @@ export class AdminController {
      );
    }

-    await this.dataGatheringService.gatherProfileData();
-    this.dataGatheringService.gatherMax();
+    const uniqueAssets = await this.dataGatheringService.getUniqueAssets();

-    return;
+    for (const { dataSource, symbol } of uniqueAssets) {
+      await this.dataGatheringService.addJobToQueue(
+        GATHER_ASSET_PROFILE_PROCESS,
+        {
+          dataSource,
+          symbol
+        },
+        GATHER_ASSET_PROFILE_PROCESS_OPTIONS
+      );
+    }
+
+    this.dataGatheringService.gatherMax();
  }

  @Post('gather/profile-data')
@ -92,9 +124,18 @@ export class AdminController {
      );
    }

-    this.dataGatheringService.gatherProfileData();
+    const uniqueAssets = await this.dataGatheringService.getUniqueAssets();

-    return;
+    for (const { dataSource, symbol } of uniqueAssets) {
+      await this.dataGatheringService.addJobToQueue(
+        GATHER_ASSET_PROFILE_PROCESS,
+        {
+          dataSource,
+          symbol
+        },
+        GATHER_ASSET_PROFILE_PROCESS_OPTIONS
+      );
+    }
  }

  @Post('gather/profile-data/:dataSource/:symbol')
@ -115,9 +156,14 @@ export class AdminController {
      );
    }

-    this.dataGatheringService.gatherProfileData([{ dataSource, symbol }]);
-
-    return;
+    await this.dataGatheringService.addJobToQueue(
+      GATHER_ASSET_PROFILE_PROCESS,
+      {
+        dataSource,
+        symbol
+      },
+      GATHER_ASSET_PROFILE_PROCESS_OPTIONS
+    );
  }

  @Post('gather/:dataSource/:symbol')
--- a/apps/api/src/app/admin/admin.module.ts
+++ b/apps/api/src/app/admin/admin.module.ts
@ -11,6 +11,7 @@ import { Module } from '@nestjs/common';

 import { AdminController } from './admin.controller';
 import { AdminService } from './admin.service';
+import { QueueModule } from './queue/queue.module';

@Module({
  imports: [
@ -21,6 +22,7 @@ import { AdminService } from './admin.service';
    MarketDataModule,
    PrismaModule,
    PropertyModule,
+    QueueModule,
    SubscriptionModule,
    SymbolProfileModule
  ],
--- a/apps/api/src/app/admin/admin.service.ts
+++ b/apps/api/src/app/admin/admin.service.ts
@ -6,19 +6,22 @@ import { MarketDataService } from '@ghostfolio/api/services/market-data.service'
 import { PrismaService } from '@ghostfolio/api/services/prisma.service';
 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 { PROPERTY_CURRENCIES } from '@ghostfolio/common/config';
 import {
  AdminData,
  AdminMarketData,
  AdminMarketDataDetails,
-  AdminMarketDataItem
+  AdminMarketDataItem,
+  UniqueAsset
 } from '@ghostfolio/common/interfaces';
 import { Injectable } from '@nestjs/common';
-import { DataSource, Property } from '@prisma/client';
+import { Property } from '@prisma/client';
 import { differenceInDays } from 'date-fns';

@Injectable()
 export class AdminService {
+  private baseCurrency: string;
+
  public constructor(
    private readonly configurationService: ConfigurationService,
    private readonly dataGatheringService: DataGatheringService,
@ -28,40 +31,33 @@ export class AdminService {
    private readonly propertyService: PropertyService,
    private readonly subscriptionService: SubscriptionService,
    private readonly symbolProfileService: SymbolProfileService
-  ) {}
+  ) {
+    this.baseCurrency = this.configurationService.get('BASE_CURRENCY');
+  }

-  public async deleteProfileData({
-    dataSource,
-    symbol
-  }: {
-    dataSource: DataSource;
-    symbol: string;
-  }) {
+  public async deleteProfileData({ dataSource, symbol }: UniqueAsset) {
    await this.marketDataService.deleteMany({ dataSource, symbol });
    await this.symbolProfileService.delete({ dataSource, symbol });
  }

  public async get(): Promise<AdminData> {
    return {
-      dataGatheringProgress:
-        await this.dataGatheringService.getDataGatheringProgress(),
      exchangeRates: this.exchangeRateDataService
        .getCurrencies()
        .filter((currency) => {
-          return currency !== baseCurrency;
+          return currency !== this.baseCurrency;
        })
        .map((currency) => {
          return {
-            label1: baseCurrency,
+            label1: this.baseCurrency,
            label2: currency,
            value: this.exchangeRateDataService.toCurrency(
              1,
-              baseCurrency,
+              this.baseCurrency,
              currency
            )
          };
        }),
-      lastDataGathering: await this.getLastDataGathering(),
      settings: await this.propertyService.get(),
      transactionCount: await this.prismaService.order.count(),
      userCount: await this.prismaService.user.count(),
@ -137,10 +133,7 @@ export class AdminService {
  public async getMarketDataBySymbol({
    dataSource,
    symbol
-  }: {
-    dataSource: DataSource;
-    symbol: string;
-  }): Promise<AdminMarketDataDetails> {
+  }: UniqueAsset): Promise<AdminMarketDataDetails> {
    return {
      marketData: await this.marketDataService.marketDataItems({
        orderBy: {
@ -165,30 +158,11 @@ export class AdminService {

    if (key === PROPERTY_CURRENCIES) {
      await this.exchangeRateDataService.initialize();
-      await this.dataGatheringService.reset();
    }

    return response;
  }

-  private async getLastDataGathering() {
-    const lastDataGathering =
-      await this.dataGatheringService.getLastDataGathering();
-
-    if (lastDataGathering) {
-      return lastDataGathering;
-    }
-
-    const dataGatheringInProgress =
-      await this.dataGatheringService.getIsInProgress();
-
-    if (dataGatheringInProgress) {
-      return 'IN_PROGRESS';
-    }
-
-    return undefined;
-  }
-
  private async getUsersWithAnalytics(): Promise<AdminData['users']> {
    const usersWithAnalytics = await this.prismaService.user.findMany({
      orderBy: {
--- a/apps/api/src/app/admin/queue/queue.controller.ts
+++ b/apps/api/src/app/admin/queue/queue.controller.ts
@ -0,0 +1,87 @@
+import { AdminJobs } from '@ghostfolio/common/interfaces';
+import { hasPermission, permissions } from '@ghostfolio/common/permissions';
+import type { RequestWithUser } from '@ghostfolio/common/types';
+import {
+  Controller,
+  Delete,
+  Get,
+  HttpException,
+  Inject,
+  Param,
+  Query,
+  UseGuards
+} from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
+import { AuthGuard } from '@nestjs/passport';
+import { JobStatus } from 'bull';
+import { StatusCodes, getReasonPhrase } from 'http-status-codes';
+
+import { QueueService } from './queue.service';
+
+@Controller('admin/queue')
+export class QueueController {
+  public constructor(
+    private readonly queueService: QueueService,
+    @Inject(REQUEST) private readonly request: RequestWithUser
+  ) {}
+
+  @Delete('job')
+  @UseGuards(AuthGuard('jwt'))
+  public async deleteJobs(
+    @Query('status') filterByStatus?: string
+  ): Promise<void> {
+    if (
+      !hasPermission(
+        this.request.user.permissions,
+        permissions.accessAdminControl
+      )
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    const status = <JobStatus[]>filterByStatus?.split(',') ?? undefined;
+    return this.queueService.deleteJobs({ status });
+  }
+
+  @Get('job')
+  @UseGuards(AuthGuard('jwt'))
+  public async getJobs(
+    @Query('status') filterByStatus?: string
+  ): Promise<AdminJobs> {
+    if (
+      !hasPermission(
+        this.request.user.permissions,
+        permissions.accessAdminControl
+      )
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    const status = <JobStatus[]>filterByStatus?.split(',') ?? undefined;
+    return this.queueService.getJobs({ status });
+  }
+
+  @Delete('job/:id')
+  @UseGuards(AuthGuard('jwt'))
+  public async deleteJob(@Param('id') id: string): Promise<void> {
+    if (
+      !hasPermission(
+        this.request.user.permissions,
+        permissions.accessAdminControl
+      )
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    return this.queueService.deleteJob(id);
+  }
+}
--- a/apps/api/src/app/admin/queue/queue.module.ts
+++ b/apps/api/src/app/admin/queue/queue.module.ts
@ -0,0 +1,12 @@
+import { DataGatheringModule } from '@ghostfolio/api/services/data-gathering.module';
+import { Module } from '@nestjs/common';
+
+import { QueueController } from './queue.controller';
+import { QueueService } from './queue.service';
+
+@Module({
+  controllers: [QueueController],
+  imports: [DataGatheringModule],
+  providers: [QueueService]
+})
+export class QueueModule {}
--- a/apps/api/src/app/admin/queue/queue.service.ts
+++ b/apps/api/src/app/admin/queue/queue.service.ts
@ -0,0 +1,65 @@
+import {
+  DATA_GATHERING_QUEUE,
+  QUEUE_JOB_STATUS_LIST
+} from '@ghostfolio/common/config';
+import { AdminJobs } from '@ghostfolio/common/interfaces';
+import { InjectQueue } from '@nestjs/bull';
+import { Injectable, Logger } from '@nestjs/common';
+import { JobStatus, Queue } from 'bull';
+
+@Injectable()
+export class QueueService {
+  public constructor(
+    @InjectQueue(DATA_GATHERING_QUEUE)
+    private readonly dataGatheringQueue: Queue
+  ) {}
+
+  public async deleteJob(aId: string) {
+    return (await this.dataGatheringQueue.getJob(aId))?.remove();
+  }
+
+  public async deleteJobs({
+    status = QUEUE_JOB_STATUS_LIST
+  }: {
+    status?: JobStatus[];
+  }) {
+    const jobs = await this.dataGatheringQueue.getJobs(status);
+
+    for (const job of jobs) {
+      try {
+        await job.remove();
+      } catch (error) {
+        Logger.warn(error, 'QueueService');
+      }
+    }
+  }
+
+  public async getJobs({
+    limit = 1000,
+    status = QUEUE_JOB_STATUS_LIST
+  }: {
+    limit?: number;
+    status?: JobStatus[];
+  }): Promise<AdminJobs> {
+    const jobs = await this.dataGatheringQueue.getJobs(status);
+
+    const jobsWithState = await Promise.all(
+      jobs.slice(0, limit).map(async (job) => {
+        return {
+          attemptsMade: job.attemptsMade + 1,
+          data: job.data,
+          finishedOn: job.finishedOn,
+          id: job.id,
+          name: job.name,
+          stacktrace: job.stacktrace,
+          state: await job.getState(),
+          timestamp: job.timestamp
+        };
+      })
+    );
+
+    return {
+      jobs: jobsWithState
+    };
+  }
+}
--- a/apps/api/src/app/app.controller.ts
+++ b/apps/api/src/app/app.controller.ts
@ -1,26 +1,6 @@
-import { DataGatheringService } from '@ghostfolio/api/services/data-gathering.service';
 import { Controller } from '@nestjs/common';

-import { RedisCacheService } from './redis-cache/redis-cache.service';
-
@Controller()
 export class AppController {
-  public constructor(
-    private readonly dataGatheringService: DataGatheringService,
-    private readonly redisCacheService: RedisCacheService
-  ) {
-    this.initialize();
-  }
-
-  private async initialize() {
-    this.redisCacheService.reset();
-
-    const isDataGatheringInProgress =
-      await this.dataGatheringService.getIsInProgress();
-
-    if (isDataGatheringInProgress) {
-      // Prepare for automatical data gathering, if hung up in progress state
-      await this.dataGatheringService.reset();
-    }
-  }
+  public constructor() {}
 }
--- a/apps/api/src/app/app.module.ts
+++ b/apps/api/src/app/app.module.ts
@ -8,6 +8,8 @@ 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 { BullModule } from '@nestjs/bull';
 import { Module } from '@nestjs/common';
 import { ConfigModule } from '@nestjs/config';
 import { ScheduleModule } from '@nestjs/schedule';
@ -18,6 +20,7 @@ import { AccountModule } from './account/account.module';
 import { AdminModule } from './admin/admin.module';
 import { AppController } from './app.controller';
 import { AuthModule } from './auth/auth.module';
+import { BenchmarkModule } from './benchmark/benchmark.module';
 import { CacheModule } from './cache/cache.module';
 import { ExportModule } from './export/export.module';
 import { ImportModule } from './import/import.module';
@ -35,6 +38,14 @@ import { UserModule } from './user/user.module';
    AccountModule,
    AuthDeviceModule,
    AuthModule,
+    BenchmarkModule,
+    BullModule.forRoot({
+      redis: {
+        host: process.env.REDIS_HOST,
+        port: parseInt(process.env.REDIS_PORT, 10),
+        password: process.env.REDIS_PASSWORD
+      }
+    }),
    CacheModule,
    ConfigModule.forRoot(),
    ConfigurationModule,
@ -65,6 +76,7 @@ import { UserModule } from './user/user.module';
    }),
    SubscriptionModule,
    SymbolModule,
+    TwitterBotModule,
    UserModule
  ],
  controllers: [AppController],
--- a/apps/api/src/app/auth-device/auth-device.module.ts
+++ b/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 {}
--- a/apps/api/src/app/auth/auth.controller.ts
+++ b/apps/api/src/app/auth/auth.controller.ts
@ -9,7 +9,9 @@ import {
  Post,
  Req,
  Res,
-  UseGuards
+  UseGuards,
+  VERSION_NEUTRAL,
+  Version
 } from '@nestjs/common';
 import { AuthGuard } from '@nestjs/passport';
 import { StatusCodes, getReasonPhrase } from 'http-status-codes';
@ -51,6 +53,7 @@ export class AuthController {

  @Get('google/callback')
  @UseGuards(AuthGuard('google'))
+  @Version(VERSION_NEUTRAL)
  public googleLoginCallback(@Req() req, @Res() res) {
    // Handles the Google OAuth2 callback
    const jwt: string = req.user.jwt;
--- a/apps/api/src/app/auth/auth.module.ts
+++ b/apps/api/src/app/auth/auth.module.ts
@ -2,8 +2,8 @@ import { AuthDeviceService } from '@ghostfolio/api/app/auth-device/auth-device.s
 import { WebAuthService } from '@ghostfolio/api/app/auth/web-auth.service';
 import { SubscriptionModule } from '@ghostfolio/api/app/subscription/subscription.module';
 import { UserModule } from '@ghostfolio/api/app/user/user.module';
-import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
-import { PrismaService } from '@ghostfolio/api/services/prisma.service';
+import { ConfigurationModule } from '@ghostfolio/api/services/configuration.module';
+import { PrismaModule } from '@ghostfolio/api/services/prisma.module';
 import { Module } from '@nestjs/common';
 import { JwtModule } from '@nestjs/jwt';

@ -15,20 +15,20 @@ import { JwtStrategy } from './jwt.strategy';
@Module({
  controllers: [AuthController],
  imports: [
+    ConfigurationModule,
    JwtModule.register({
      secret: process.env.JWT_SECRET_KEY,
      signOptions: { expiresIn: '180 days' }
    }),
+    PrismaModule,
    SubscriptionModule,
    UserModule
  ],
  providers: [
    AuthDeviceService,
    AuthService,
-    ConfigurationService,
    GoogleStrategy,
    JwtStrategy,
-    PrismaService,
    WebAuthService
  ]
 })
--- a/apps/api/src/app/auth/google.strategy.ts
+++ b/apps/api/src/app/auth/google.strategy.ts
@ -42,7 +42,7 @@ export class GoogleStrategy extends PassportStrategy(Strategy, 'google') {

      done(null, user);
    } catch (error) {
-      Logger.error(error);
+      Logger.error(error, 'GoogleStrategy');
      done(error, false);
    }
  }
--- a/apps/api/src/app/auth/web-auth.service.ts
+++ b/apps/api/src/app/auth/web-auth.service.ts
@ -95,7 +95,7 @@ export class WebAuthService {
      };
      verification = await verifyRegistrationResponse(opts);
    } catch (error) {
-      Logger.error(error);
+      Logger.error(error, 'WebAuthService');
      throw new InternalServerErrorException(error.message);
    }

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

--- a/apps/api/src/app/benchmark/benchmark.controller.ts
+++ b/apps/api/src/app/benchmark/benchmark.controller.ts
@ -0,0 +1,32 @@
+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 { PropertyService } from '@ghostfolio/api/services/property/property.service';
+import { PROPERTY_BENCHMARKS } from '@ghostfolio/common/config';
+import { BenchmarkResponse, UniqueAsset } from '@ghostfolio/common/interfaces';
+import { Controller, Get, UseGuards, UseInterceptors } from '@nestjs/common';
+import { AuthGuard } from '@nestjs/passport';
+
+import { BenchmarkService } from './benchmark.service';
+
+@Controller('benchmark')
+export class BenchmarkController {
+  public constructor(
+    private readonly benchmarkService: BenchmarkService,
+    private readonly propertyService: PropertyService
+  ) {}
+
+  @Get()
+  @UseGuards(AuthGuard('jwt'))
+  @UseInterceptors(TransformDataSourceInRequestInterceptor)
+  @UseInterceptors(TransformDataSourceInResponseInterceptor)
+  public async getBenchmark(): Promise<BenchmarkResponse> {
+    const benchmarkAssets: UniqueAsset[] =
+      ((await this.propertyService.getByKey(
+        PROPERTY_BENCHMARKS
+      )) as UniqueAsset[]) ?? [];
+
+    return {
+      benchmarks: await this.benchmarkService.getBenchmarks(benchmarkAssets)
+    };
+  }
+}
--- a/apps/api/src/app/benchmark/benchmark.module.ts
+++ b/apps/api/src/app/benchmark/benchmark.module.ts
@ -0,0 +1,25 @@
+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 { MarketDataModule } from '@ghostfolio/api/services/market-data.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 { BenchmarkController } from './benchmark.controller';
+import { BenchmarkService } from './benchmark.service';
+
+@Module({
+  controllers: [BenchmarkController],
+  exports: [BenchmarkService],
+  imports: [
+    ConfigurationModule,
+    DataProviderModule,
+    MarketDataModule,
+    PropertyModule,
+    RedisCacheModule,
+    SymbolProfileModule
+  ],
+  providers: [BenchmarkService]
+})
+export class BenchmarkModule {}
--- a/apps/api/src/app/benchmark/benchmark.service.ts
+++ b/apps/api/src/app/benchmark/benchmark.service.ts
@ -0,0 +1,84 @@
+import { RedisCacheService } from '@ghostfolio/api/app/redis-cache/redis-cache.service';
+import { DataProviderService } from '@ghostfolio/api/services/data-provider/data-provider.service';
+import { MarketDataService } from '@ghostfolio/api/services/market-data.service';
+import { SymbolProfileService } from '@ghostfolio/api/services/symbol-profile.service';
+import { BenchmarkResponse, UniqueAsset } from '@ghostfolio/common/interfaces';
+import { Injectable } from '@nestjs/common';
+import Big from 'big.js';
+
+@Injectable()
+export class BenchmarkService {
+  private readonly CACHE_KEY_BENCHMARKS = 'BENCHMARKS';
+
+  public constructor(
+    private readonly dataProviderService: DataProviderService,
+    private readonly marketDataService: MarketDataService,
+    private readonly redisCacheService: RedisCacheService,
+    private readonly symbolProfileService: SymbolProfileService
+  ) {}
+
+  public async getBenchmarks(
+    benchmarkAssets: UniqueAsset[]
+  ): Promise<BenchmarkResponse['benchmarks']> {
+    let benchmarks: BenchmarkResponse['benchmarks'];
+
+    try {
+      benchmarks = JSON.parse(
+        await this.redisCacheService.get(this.CACHE_KEY_BENCHMARKS)
+      );
+
+      if (benchmarks) {
+        return benchmarks;
+      }
+    } catch {}
+
+    const promises: Promise<number>[] = [];
+
+    const [quotes, assetProfiles] = await Promise.all([
+      this.dataProviderService.getQuotes(benchmarkAssets),
+      this.symbolProfileService.getSymbolProfiles(benchmarkAssets)
+    ]);
+
+    for (const benchmarkAsset of benchmarkAssets) {
+      promises.push(this.marketDataService.getMax(benchmarkAsset));
+    }
+
+    const allTimeHighs = await Promise.all(promises);
+
+    benchmarks = allTimeHighs.map((allTimeHigh, index) => {
+      const { marketPrice } = quotes[benchmarkAssets[index].symbol];
+
+      const performancePercentFromAllTimeHigh = new Big(marketPrice)
+        .div(allTimeHigh)
+        .minus(1);
+
+      return {
+        marketCondition: this.getMarketCondition(
+          performancePercentFromAllTimeHigh
+        ),
+        name: assetProfiles.find(({ dataSource, symbol }) => {
+          return (
+            dataSource === benchmarkAssets[index].dataSource &&
+            symbol === benchmarkAssets[index].symbol
+          );
+        })?.name,
+        performances: {
+          allTimeHigh: {
+            performancePercent: performancePercentFromAllTimeHigh.toNumber()
+          }
+        }
+      };
+    });
+
+    await this.redisCacheService.set(
+      this.CACHE_KEY_BENCHMARKS,
+      JSON.stringify(benchmarks)
+    );
+
+    return benchmarks;
+  }
+
+  private getMarketCondition(aPerformanceInPercent: Big) {
+    return aPerformanceInPercent.lte(-0.2) ? 'BEAR_MARKET' : 'NEUTRAL_MARKET';
+  }
+}
--- a/apps/api/src/app/cache/cache.controller.ts
+++ b/apps/api/src/app/cache/cache.controller.ts
@ -1,25 +1,39 @@
-import { CacheService } from '@ghostfolio/api/app/cache/cache.service';
 import { RedisCacheService } from '@ghostfolio/api/app/redis-cache/redis-cache.service';
+import { hasPermission, permissions } from '@ghostfolio/common/permissions';
 import type { RequestWithUser } from '@ghostfolio/common/types';
-import { Controller, Inject, Post, UseGuards } from '@nestjs/common';
+import {
+  Controller,
+  HttpException,
+  Inject,
+  Post,
+  UseGuards
+} from '@nestjs/common';
 import { REQUEST } from '@nestjs/core';
 import { AuthGuard } from '@nestjs/passport';
+import { StatusCodes, getReasonPhrase } from 'http-status-codes';

@Controller('cache')
 export class CacheController {
  public constructor(
-    private readonly cacheService: CacheService,
    private readonly redisCacheService: RedisCacheService,
    @Inject(REQUEST) private readonly request: RequestWithUser
-  ) {
-    this.redisCacheService.reset();
-  }
+  ) {}

  @Post('flush')
  @UseGuards(AuthGuard('jwt'))
  public async flushCache(): Promise<void> {
-    this.redisCacheService.reset();
+    if (
+      !hasPermission(
+        this.request.user.permissions,
+        permissions.accessAdminControl
+      )
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }

-    return this.cacheService.flush();
+    return this.redisCacheService.reset();
  }
 }
--- a/apps/api/src/app/cache/cache.module.ts
+++ b/apps/api/src/app/cache/cache.module.ts
@ -1,30 +1,24 @@
-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({
+  controllers: [CacheController],
  imports: [
+    ConfigurationModule,
    DataGatheringModule,
    DataProviderModule,
    ExchangeRateDataModule,
+    PrismaModule,
    RedisCacheModule,
    SymbolProfileModule
-  ],
-  controllers: [CacheController],
-  providers: [
-    CacheService,
-    ConfigurationService,
-    DataGatheringService,
-    PrismaService
  ]
 })
 export class CacheModule {}
--- a/apps/api/src/app/cache/cache.service.ts
+++ b/apps/api/src/app/cache/cache.service.ts
@ -1,15 +0,0 @@
-import { DataGatheringService } from '@ghostfolio/api/services/data-gathering.service';
-import { Injectable } from '@nestjs/common';
-
-@Injectable()
-export class CacheService {
-  public constructor(
-    private readonly dataGaterhingService: DataGatheringService
-  ) {}
-
-  public async flush(): Promise<void> {
-    await this.dataGaterhingService.reset();
-
-    return;
-  }
-}
--- a/apps/api/src/app/export/export.controller.ts
+++ b/apps/api/src/app/export/export.controller.ts
@ -1,13 +1,6 @@
 import { Export } from '@ghostfolio/common/interfaces';
 import type { RequestWithUser } from '@ghostfolio/common/types';
-import {
-  Controller,
-  Get,
-  Headers,
-  Inject,
-  Query,
-  UseGuards
-} from '@nestjs/common';
+import { Controller, Get, Inject, Query, UseGuards } from '@nestjs/common';
 import { REQUEST } from '@nestjs/core';
 import { AuthGuard } from '@nestjs/passport';

--- a/apps/api/src/app/export/export.service.ts
+++ b/apps/api/src/app/export/export.service.ts
@ -14,12 +14,10 @@ export class ExportService {
    activityIds?: string[];
    userId: string;
  }): Promise<Export> {
-    let orders = await this.prismaService.order.findMany({
+    let activities = await this.prismaService.order.findMany({
      orderBy: { date: 'desc' },
      select: {
        accountId: true,
-        currency: true,
-        dataSource: true,
        date: true,
        fee: true,
        id: true,
@ -32,19 +30,19 @@ export class ExportService {
    });

    if (activityIds) {
-      orders = orders.filter((order) => {
-        return activityIds.includes(order.id);
+      activities = activities.filter((activity) => {
+        return activityIds.includes(activity.id);
      });
    }

    return {
      meta: { date: new Date().toISOString(), version: environment.version },
-      orders: orders.map(
+      activities: activities.map(
        ({
          accountId,
-          currency,
          date,
          fee,
+          id,
          quantity,
          SymbolProfile,
          type,
@ -52,14 +50,15 @@ export class ExportService {
        }) => {
          return {
            accountId,
-            currency,
-            date,
            fee,
+            id,
            quantity,
            type,
            unitPrice,
+            currency: SymbolProfile.currency,
            dataSource: SymbolProfile.dataSource,
-            symbol: SymbolProfile.symbol
+            date: date.toISOString(),
+            symbol: type === 'ITEM' ? SymbolProfile.name : SymbolProfile.symbol
          };
        }
      )
--- a/apps/api/src/app/import/import-data.dto.ts
+++ b/apps/api/src/app/import/import-data.dto.ts
@ -1,5 +1,4 @@
 import { CreateOrderDto } from '@ghostfolio/api/app/order/create-order.dto';
-import { Order } from '@prisma/client';
 import { Type } from 'class-transformer';
 import { IsArray, ValidateNested } from 'class-validator';

@ -7,5 +6,5 @@ export class ImportDataDto {
  @IsArray()
  @Type(() => CreateOrderDto)
  @ValidateNested({ each: true })
-  orders: Order[];
+  activities: CreateOrderDto[];
 }
--- a/apps/api/src/app/import/import.controller.ts
+++ b/apps/api/src/app/import/import.controller.ts
@ -36,11 +36,11 @@ export class ImportController {

    try {
      return await this.importService.import({
-        orders: importData.orders,
+        activities: importData.activities,
        userId: this.request.user.id
      });
    } catch (error) {
-      Logger.error(error);
+      Logger.error(error, ImportController);

      throw new HttpException(
        {
--- a/apps/api/src/app/import/import.module.ts
+++ b/apps/api/src/app/import/import.module.ts
@ -1,4 +1,5 @@
-import { CacheService } from '@ghostfolio/api/app/cache/cache.service';
+import { AccountModule } from '@ghostfolio/api/app/account/account.module';
+import { CacheModule } from '@ghostfolio/api/app/cache/cache.module';
 import { OrderModule } from '@ghostfolio/api/app/order/order.module';
 import { RedisCacheModule } from '@ghostfolio/api/app/redis-cache/redis-cache.module';
 import { ConfigurationModule } from '@ghostfolio/api/services/configuration.module';
@ -11,7 +12,10 @@ import { ImportController } from './import.controller';
 import { ImportService } from './import.service';

@Module({
+  controllers: [ImportController],
  imports: [
+    AccountModule,
+    CacheModule,
    ConfigurationModule,
    DataGatheringModule,
    DataProviderModule,
@ -19,7 +23,6 @@ import { ImportService } from './import.service';
    PrismaModule,
    RedisCacheModule
  ],
-  controllers: [ImportController],
-  providers: [CacheService, ImportService]
+  providers: [ImportService]
 })
 export class ImportModule {}
--- a/apps/api/src/app/import/import.service.ts
+++ b/apps/api/src/app/import/import.service.ts
@ -1,31 +1,44 @@
+import { AccountService } from '@ghostfolio/api/app/account/account.service';
+import { CreateOrderDto } from '@ghostfolio/api/app/order/create-order.dto';
 import { OrderService } from '@ghostfolio/api/app/order/order.service';
 import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
 import { DataProviderService } from '@ghostfolio/api/services/data-provider/data-provider.service';
 import { Injectable } from '@nestjs/common';
-import { Order } from '@prisma/client';
 import { isSameDay, parseISO } from 'date-fns';

@Injectable()
 export class ImportService {
  public constructor(
+    private readonly accountService: AccountService,
    private readonly configurationService: ConfigurationService,
    private readonly dataProviderService: DataProviderService,
    private readonly orderService: OrderService
  ) {}

  public async import({
-    orders,
+    activities,
    userId
  }: {
-    orders: Partial<Order>[];
+    activities: Partial<CreateOrderDto>[];
    userId: string;
  }): Promise<void> {
-    for (const order of orders) {
-      order.dataSource =
-        order.dataSource ?? this.dataProviderService.getPrimaryDataSource();
+    for (const activity of activities) {
+      if (!activity.dataSource) {
+        if (activity.type === 'ITEM') {
+          activity.dataSource = 'MANUAL';
+        } else {
+          activity.dataSource = this.dataProviderService.getPrimaryDataSource();
+        }
+      }
    }

-    await this.validateOrders({ orders, userId });
+    await this.validateActivities({ activities, userId });
+
+    const accountIds = (await this.accountService.getAccounts(userId)).map(
+      (account) => {
+        return account.id;
+      }
+    );

    for (const {
      accountId,
@ -37,21 +50,19 @@ export class ImportService {
      symbol,
      type,
      unitPrice
-    } of orders) {
+    } of activities) {
      await this.orderService.createOrder({
-        accountId,
-        currency,
-        dataSource,
        fee,
        quantity,
-        symbol,
        type,
        unitPrice,
        userId,
+        accountId: accountIds.includes(accountId) ? accountId : undefined,
        date: parseISO(<string>(<unknown>date)),
        SymbolProfile: {
          connectOrCreate: {
            create: {
+              currency,
              dataSource,
              symbol
            },
@ -68,24 +79,25 @@ export class ImportService {
    }
  }

-  private async validateOrders({
-    orders,
+  private async validateActivities({
+    activities,
    userId
  }: {
-    orders: Partial<Order>[];
+    activities: Partial<CreateOrderDto>[];
    userId: string;
  }) {
    if (
-      orders?.length > this.configurationService.get('MAX_ORDERS_TO_IMPORT')
+      activities?.length > this.configurationService.get('MAX_ORDERS_TO_IMPORT')
    ) {
      throw new Error(
-        `Too many transactions (${this.configurationService.get(
+        `Too many activities (${this.configurationService.get(
          'MAX_ORDERS_TO_IMPORT'
        )} at most)`
      );
    }

-    const existingOrders = await this.orderService.orders({
+    const existingActivities = await this.orderService.orders({
+      include: { SymbolProfile: true },
      orderBy: { date: 'desc' },
      where: { userId }
    });
@ -93,38 +105,40 @@ export class ImportService {
    for (const [
      index,
      { currency, dataSource, date, fee, quantity, symbol, type, unitPrice }
-    ] of orders.entries()) {
-      const duplicateOrder = existingOrders.find((order) => {
+    ] of activities.entries()) {
+      const duplicateActivity = existingActivities.find((activity) => {
        return (
-          order.currency === currency &&
-          order.dataSource === dataSource &&
-          isSameDay(order.date, parseISO(<string>(<unknown>date))) &&
-          order.fee === fee &&
-          order.quantity === quantity &&
-          order.symbol === symbol &&
-          order.type === type &&
-          order.unitPrice === unitPrice
+          activity.SymbolProfile.currency === currency &&
+          activity.SymbolProfile.dataSource === dataSource &&
+          isSameDay(activity.date, parseISO(<string>(<unknown>date))) &&
+          activity.fee === fee &&
+          activity.quantity === quantity &&
+          activity.SymbolProfile.symbol === symbol &&
+          activity.type === type &&
+          activity.unitPrice === unitPrice
        );
      });

-      if (duplicateOrder) {
-        throw new Error(`orders.${index} is a duplicate transaction`);
+      if (duplicateActivity) {
+        throw new Error(`activities.${index} is a duplicate activity`);
      }

-      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(
+            `activities.${index}.symbol ("${symbol}") is not valid for the specified data source ("${dataSource}")`
+          );
+        }

-      if (result[symbol].currency !== currency) {
-        throw new Error(
-          `orders.${index}.currency ("${currency}") does not match with "${result[symbol].currency}"`
-        );
+        if (quotes[symbol].currency !== currency) {
+          throw new Error(
+            `activities.${index}.currency ("${currency}") does not match with "${quotes[symbol].currency}"`
+          );
+        }
      }
    }
  }
--- a/apps/api/src/app/info/info.module.ts
+++ b/apps/api/src/app/info/info.module.ts
@ -1,12 +1,12 @@
 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 { TagModule } from '@ghostfolio/api/services/tag/tag.module';
 import { Module } from '@nestjs/common';
 import { JwtModule } from '@nestjs/jwt';

@ -14,7 +14,9 @@ import { InfoController } from './info.controller';
 import { InfoService } from './info.service';

@Module({
+  controllers: [InfoController],
  imports: [
+    ConfigurationModule,
    DataGatheringModule,
    DataProviderModule,
    ExchangeRateDataModule,
@ -22,16 +24,12 @@ import { InfoService } from './info.service';
      secret: process.env.JWT_SECRET_KEY,
      signOptions: { expiresIn: '30 days' }
    }),
+    PrismaModule,
    PropertyModule,
    RedisCacheModule,
-    SymbolProfileModule
+    SymbolProfileModule,
+    TagModule
  ],
-  controllers: [InfoController],
-  providers: [
-    ConfigurationService,
-    DataGatheringService,
-    InfoService,
-    PrismaService
-  ]
+  providers: [InfoService]
 })
 export class InfoModule {}
--- a/apps/api/src/app/info/info.service.ts
+++ b/apps/api/src/app/info/info.service.ts
@ -4,12 +4,14 @@ import { DataGatheringService } from '@ghostfolio/api/services/data-gathering.se
 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 { TagService } from '@ghostfolio/api/services/tag/tag.service';
 import {
  DEMO_USER_ID,
  PROPERTY_IS_READ_ONLY_MODE,
  PROPERTY_SLACK_COMMUNITY_USERS,
  PROPERTY_STRIPE_CONFIG,
-  PROPERTY_SYSTEM_MESSAGE
+  PROPERTY_SYSTEM_MESSAGE,
+  ghostfolioFearAndGreedIndexDataSource
 } from '@ghostfolio/common/config';
 import { encodeDataSource } from '@ghostfolio/common/helper';
 import { InfoItem } from '@ghostfolio/common/interfaces';
@ -18,7 +20,6 @@ import { Subscription } from '@ghostfolio/common/interfaces/subscription.interfa
 import { permissions } from '@ghostfolio/common/permissions';
 import { Injectable, Logger } from '@nestjs/common';
 import { JwtService } from '@nestjs/jwt';
-import { DataSource } from '@prisma/client';
 import * as bent from 'bent';
 import { subDays } from 'date-fns';

@ -33,7 +34,8 @@ export class InfoService {
    private readonly jwtService: JwtService,
    private readonly prismaService: PrismaService,
    private readonly propertyService: PropertyService,
-    private readonly redisCacheService: RedisCacheService
+    private readonly redisCacheService: RedisCacheService,
+    private readonly tagService: TagService
  ) {}

  public async get(): Promise<InfoItem> {
@ -52,7 +54,15 @@ export class InfoService {
    }

    if (this.configurationService.get('ENABLE_FEATURE_FEAR_AND_GREED_INDEX')) {
-      info.fearAndGreedDataSource = encodeDataSource(DataSource.RAKUTEN);
+      if (
+        this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION') === true
+      ) {
+        info.fearAndGreedDataSource = encodeDataSource(
+          ghostfolioFearAndGreedIndexDataSource
+        );
+      } else {
+        info.fearAndGreedDataSource = ghostfolioFearAndGreedIndexDataSource;
+      }
    }

    if (this.configurationService.get('ENABLE_FEATURE_IMPORT')) {
@ -93,11 +103,12 @@ export class InfoService {
      isReadOnlyMode,
      platforms,
      systemMessage,
+      baseCurrency: this.configurationService.get('BASE_CURRENCY'),
      currencies: this.exchangeRateDataService.getCurrencies(),
      demoAuthToken: this.getDemoAuthToken(),
-      lastDataGathering: await this.getLastDataGathering(),
      statistics: await this.getStatistics(),
-      subscriptions: await this.getSubscriptions()
+      subscriptions: await this.getSubscriptions(),
+      tags: await this.tagService.get()
    };
  }

@ -142,7 +153,7 @@ export class InfoService {
      const contributors = await get();
      return contributors?.length;
    } catch (error) {
-      Logger.error(error);
+      Logger.error(error, 'InfoService');

      return undefined;
    }
@ -163,7 +174,7 @@ export class InfoService {
      const { stargazers_count } = await get();
      return stargazers_count;
    } catch (error) {
-      Logger.error(error);
+      Logger.error(error, 'InfoService');

      return undefined;
    }
@ -203,13 +214,6 @@ export class InfoService {
    });
  }

-  private async getLastDataGathering() {
-    const lastDataGathering =
-      await this.dataGatheringService.getLastDataGathering();
-
-    return lastDataGathering ?? null;
-  }
-
  private async getStatistics() {
    if (!this.configurationService.get('ENABLE_FEATURE_STATISTICS')) {
      return undefined;
--- a/apps/api/src/app/order/create-order.dto.ts
+++ b/apps/api/src/app/order/create-order.dto.ts
@ -1,4 +1,4 @@
-import { DataSource, Type } from '@prisma/client';
+import { AssetClass, AssetSubClass, DataSource, Type } from '@prisma/client';
 import {
  IsEnum,
  IsISO8601,
@ -10,14 +10,22 @@ import {
 export class CreateOrderDto {
  @IsString()
  @IsOptional()
-  accountId: string;
+  accountId?: string;
+
+  @IsEnum(AssetClass, { each: true })
+  @IsOptional()
+  assetClass?: AssetClass;
+
+  @IsEnum(AssetSubClass, { each: true })
+  @IsOptional()
+  assetSubClass?: AssetSubClass;

  @IsString()
  currency: string;

  @IsEnum(DataSource, { each: true })
  @IsOptional()
-  dataSource: DataSource;
+  dataSource?: DataSource;

  @IsISO8601()
  date: string;
--- a/apps/api/src/app/order/order.controller.ts
+++ b/apps/api/src/app/order/order.controller.ts
@ -1,5 +1,6 @@
 import { UserService } from '@ghostfolio/api/app/user/user.service';
 import { nullifyValuesInObjects } from '@ghostfolio/api/helper/object.helper';
+import { RedactValuesInResponseInterceptor } from '@ghostfolio/api/interceptors/redact-values-in-response.interceptor';
 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';
@ -42,8 +43,12 @@ export class OrderController {
  @Delete(':id')
  @UseGuards(AuthGuard('jwt'))
  public async deleteOrder(@Param('id') id: string): Promise<OrderModel> {
+    const order = await this.orderService.order({ id });
+
    if (
-      !hasPermission(this.request.user.permissions, permissions.deleteOrder)
+      !hasPermission(this.request.user.permissions, permissions.deleteOrder) ||
+      !order ||
+      order.userId !== this.request.user.id
    ) {
      throw new HttpException(
        getReasonPhrase(StatusCodes.FORBIDDEN),
@ -52,15 +57,13 @@ export class OrderController {
    }

    return this.orderService.deleteOrder({
-      id_userId: {
-        id,
-        userId: this.request.user.id
-      }
+      id
    });
  }

  @Get()
  @UseGuards(AuthGuard('jwt'))
+  @UseInterceptors(RedactValuesInResponseInterceptor)
  @UseInterceptors(TransformDataSourceInResponseInterceptor)
  public async getAllOrders(
    @Headers('impersonation-id') impersonationId
@ -114,6 +117,7 @@ export class OrderController {
      SymbolProfile: {
        connectOrCreate: {
          create: {
+            currency: data.currency,
            dataSource: data.dataSource,
            symbol: data.symbol
          },
@ -134,23 +138,15 @@ export class OrderController {
  @UseGuards(AuthGuard('jwt'))
  @UseInterceptors(TransformDataSourceInRequestInterceptor)
  public async update(@Param('id') id: string, @Body() data: UpdateOrderDto) {
-    if (
-      !hasPermission(this.request.user.permissions, permissions.updateOrder)
-    ) {
-      throw new HttpException(
-        getReasonPhrase(StatusCodes.FORBIDDEN),
-        StatusCodes.FORBIDDEN
-      );
-    }
-
    const originalOrder = await this.orderService.order({
-      id_userId: {
-        id,
-        userId: this.request.user.id
-      }
+      id
    });

-    if (!originalOrder) {
+    if (
+      !hasPermission(this.request.user.permissions, permissions.updateOrder) ||
+      !originalOrder ||
+      originalOrder.userId !== this.request.user.id
+    ) {
      throw new HttpException(
        getReasonPhrase(StatusCodes.FORBIDDEN),
        StatusCodes.FORBIDDEN
@ -171,13 +167,23 @@ export class OrderController {
            id_userId: { id: accountId, userId: this.request.user.id }
          }
        },
+        SymbolProfile: {
+          connect: {
+            dataSource_symbol: {
+              dataSource: data.dataSource,
+              symbol: data.symbol
+            }
+          },
+          update: {
+            assetClass: data.assetClass,
+            assetSubClass: data.assetSubClass,
+            name: data.symbol
+          }
+        },
        User: { connect: { id: this.request.user.id } }
      },
      where: {
-        id_userId: {
-          id,
-          userId: this.request.user.id
-        }
+        id
      }
    });
  }
--- a/apps/api/src/app/order/order.module.ts
+++ b/apps/api/src/app/order/order.module.ts
@ -1,5 +1,5 @@
 import { AccountService } from '@ghostfolio/api/app/account/account.service';
-import { CacheService } from '@ghostfolio/api/app/cache/cache.service';
+import { CacheModule } from '@ghostfolio/api/app/cache/cache.module';
 import { RedisCacheModule } from '@ghostfolio/api/app/redis-cache/redis-cache.module';
 import { UserModule } from '@ghostfolio/api/app/user/user.module';
 import { ConfigurationModule } from '@ghostfolio/api/services/configuration.module';
@ -8,13 +8,17 @@ import { DataProviderModule } from '@ghostfolio/api/services/data-provider/data-
 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,
@ -22,10 +26,9 @@ import { OrderService } from './order.service';
    ImpersonationModule,
    PrismaModule,
    RedisCacheModule,
+    SymbolProfileModule,
    UserModule
  ],
-  controllers: [OrderController],
-  providers: [AccountService, CacheService, OrderService],
-  exports: [OrderService]
+  providers: [AccountService, OrderService]
 })
 export class OrderModule {}
--- a/apps/api/src/app/order/order.service.ts
+++ b/apps/api/src/app/order/order.service.ts
@ -1,13 +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 {
+  GATHER_ASSET_PROFILE_PROCESS,
+  GATHER_ASSET_PROFILE_PROCESS_OPTIONS
+} from '@ghostfolio/common/config';
+import { Filter } from '@ghostfolio/common/interfaces';
 import { OrderWithAccount } from '@ghostfolio/common/types';
 import { Injectable } from '@nestjs/common';
-import { DataSource, Order, Prisma, Type as TypeOfOrder } from '@prisma/client';
+import {
+  AssetClass,
+  AssetSubClass,
+  DataSource,
+  Order,
+  Prisma,
+  Type as TypeOfOrder
+} from '@prisma/client';
 import Big from 'big.js';
 import { endOfToday, isAfter } from 'date-fns';
+import { groupBy } from 'lodash';
+import { v4 as uuidv4 } from 'uuid';

 import { Activity } from './interfaces/activities.interface';

@ -15,10 +29,10 @@ import { Activity } from './interfaces/activities.interface';
 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 exchangeRateDataService: ExchangeRateDataService,
+    private readonly prismaService: PrismaService,
+    private readonly symbolProfileService: SymbolProfileService
  ) {}

  public async order(
@ -50,7 +64,15 @@ export class OrderService {
  }

  public async createOrder(
-    data: Prisma.OrderCreateInput & { accountId?: string; userId: string }
+    data: Prisma.OrderCreateInput & {
+      accountId?: string;
+      assetClass?: AssetClass;
+      assetSubClass?: AssetSubClass;
+      currency?: string;
+      dataSource?: DataSource;
+      symbol?: string;
+      userId: string;
+    }
  ): Promise<Order> {
    const defaultAccount = (
      await this.accountService.getAccounts(data.userId)
@ -58,7 +80,7 @@ export class OrderService {
      return account.isDefault === true;
    });

-    const Account = {
+    let Account = {
      connect: {
        id_userId: {
          userId: data.userId,
@ -67,29 +89,59 @@ export class OrderService {
      }
    };

-    const isDraft = isAfter(data.date as Date, endOfToday());
+    if (data.type === 'ITEM') {
+      const assetClass = data.assetClass;
+      const assetSubClass = data.assetSubClass;
+      const currency = data.SymbolProfile.connectOrCreate.create.currency;
+      const dataSource: DataSource = 'MANUAL';
+      const id = uuidv4();
+      const name = data.SymbolProfile.connectOrCreate.create.symbol;

-    // Convert the symbol to uppercase to avoid case-sensitive duplicates
-    const symbol = data.symbol.toUpperCase();
+      Account = undefined;
+      data.id = id;
+      data.SymbolProfile.connectOrCreate.create.assetClass = assetClass;
+      data.SymbolProfile.connectOrCreate.create.assetSubClass = assetSubClass;
+      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.addJobToQueue(
+      GATHER_ASSET_PROFILE_PROCESS,
+      {
+        dataSource: data.SymbolProfile.connectOrCreate.create.dataSource,
+        symbol: data.SymbolProfile.connectOrCreate.create.symbol
+      },
+      GATHER_ASSET_PROFILE_PROCESS_OPTIONS
+    );
+
+    const isDraft = isAfter(data.date as Date, endOfToday());

    if (!isDraft) {
      // Gather symbol data of order in the background, if not draft
      this.dataGatheringService.gatherSymbols([
        {
-          symbol,
-          dataSource: data.dataSource,
-          date: <Date>data.date
+          dataSource: data.SymbolProfile.connectOrCreate.create.dataSource,
+          date: <Date>data.date,
+          symbol: data.SymbolProfile.connectOrCreate.create.symbol
        }
      ]);
    }

-    this.dataGatheringService.gatherProfileData([
-      { symbol, dataSource: data.dataSource }
-    ]);
-
-    await this.cacheService.flush();
-
    delete data.accountId;
+    delete data.assetClass;
+    delete data.assetSubClass;
+    delete data.currency;
+    delete data.dataSource;
+    delete data.symbol;
    delete data.userId;

    const orderData: Prisma.OrderCreateInput = data;
@ -98,8 +150,7 @@ export class OrderService {
      data: {
        ...orderData,
        Account,
-        isDraft,
-        symbol
+        isDraft
      }
    });
  }
@ -107,17 +158,25 @@ 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 async getOrders({
+    filters,
    includeDrafts = false,
    types,
    userCurrency,
    userId
  }: {
+    filters?: Filter[];
    includeDrafts?: boolean;
    types?: TypeOfOrder[];
    userCurrency: string;
@ -125,10 +184,64 @@ export class OrderService {
  }): Promise<Activity[]> {
    const where: Prisma.OrderWhereInput = { userId };

+    const {
+      ACCOUNT: filtersByAccount,
+      ASSET_CLASS: filtersByAssetClass,
+      TAG: filtersByTag
+    } = groupBy(filters, (filter) => {
+      return filter.type;
+    });
+
+    if (filtersByAccount?.length > 0) {
+      where.accountId = {
+        in: filtersByAccount.map(({ id }) => {
+          return id;
+        })
+      };
+    }
+
    if (includeDrafts === false) {
      where.isDraft = false;
    }

+    if (filtersByAssetClass?.length > 0) {
+      where.SymbolProfile = {
+        OR: [
+          {
+            AND: [
+              {
+                OR: filtersByAssetClass.map(({ id }) => {
+                  return { assetClass: AssetClass[id] };
+                })
+              },
+              {
+                SymbolProfileOverrides: {
+                  is: null
+                }
+              }
+            ]
+          },
+          {
+            SymbolProfileOverrides: {
+              OR: filtersByAssetClass.map(({ id }) => {
+                return { assetClass: AssetClass[id] };
+              })
+            }
+          }
+        ]
+      };
+    }
+
+    if (filtersByTag?.length > 0) {
+      where.tags = {
+        some: {
+          OR: filtersByTag.map(({ id }) => {
+            return { id };
+          })
+        }
+      };
+    }
+
    if (types) {
      where.OR = types.map((type) => {
        return {
@ -150,7 +263,8 @@ export class OrderService {
            }
          },
          // eslint-disable-next-line @typescript-eslint/naming-convention
-          SymbolProfile: true
+          SymbolProfile: true,
+          tags: true
        },
        orderBy: { date: 'asc' }
      })
@ -162,38 +276,61 @@ export class OrderService {
        value,
        feeInBaseCurrency: this.exchangeRateDataService.toCurrency(
          order.fee,
-          order.currency,
+          order.SymbolProfile.currency,
          userCurrency
        ),
        valueInBaseCurrency: this.exchangeRateDataService.toCurrency(
          value,
-          order.currency,
+          order.SymbolProfile.currency,
          userCurrency
        )
      };
    });
  }

-  public async updateOrder(params: {
+  public async updateOrder({
+    data,
+    where
+  }: {
+    data: Prisma.OrderUpdateInput & {
+      assetClass?: AssetClass;
+      assetSubClass?: AssetSubClass;
+      currency?: string;
+      dataSource?: DataSource;
+      symbol?: string;
+    };
    where: Prisma.OrderWhereUniqueInput;
-    data: Prisma.OrderUpdateInput;
  }): Promise<Order> {
-    const { data, where } = params;
-
-    const isDraft = isAfter(data.date as Date, endOfToday());
-
-    if (!isDraft) {
-      // Gather symbol data of order in the background, if not draft
-      this.dataGatheringService.gatherSymbols([
-        {
-          dataSource: <DataSource>data.dataSource,
-          date: <Date>data.date,
-          symbol: <string>data.symbol
-        }
-      ]);
+    if (data.Account.connect.id_userId.id === null) {
+      delete data.Account;
    }

-    await this.cacheService.flush();
+    let isDraft = false;
+
+    if (data.type === 'ITEM') {
+      delete data.SymbolProfile.connect;
+    } else {
+      delete data.SymbolProfile.update;
+
+      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
+          }
+        ]);
+      }
+    }
+
+    delete data.assetClass;
+    delete data.assetSubClass;
+    delete data.currency;
+    delete data.dataSource;
+    delete data.symbol;

    return this.prismaService.order.update({
      data: {
--- a/apps/api/src/app/order/update-order.dto.ts
+++ b/apps/api/src/app/order/update-order.dto.ts
@ -1,9 +1,24 @@
-import { DataSource, Type } from '@prisma/client';
-import { IsISO8601, IsNumber, IsString } from 'class-validator';
+import { AssetClass, AssetSubClass, DataSource, Type } from '@prisma/client';
+import {
+  IsEnum,
+  IsISO8601,
+  IsNumber,
+  IsOptional,
+  IsString
+} from 'class-validator';

 export class UpdateOrderDto {
+  @IsOptional()
  @IsString()
-  accountId: string;
+  accountId?: string;
+
+  @IsEnum(AssetClass, { each: true })
+  @IsOptional()
+  assetClass?: AssetClass;
+
+  @IsEnum(AssetSubClass, { each: true })
+  @IsOptional()
+  assetSubClass?: AssetSubClass;

  @IsString()
  currency: string;
--- a/apps/api/src/app/portfolio/current-rate.service.mock.ts
+++ b/apps/api/src/app/portfolio/current-rate.service.mock.ts
@ -0,0 +1,75 @@
+import { parseDate, resetHours } from '@ghostfolio/common/helper';
+import { addDays, endOfDay, isBefore, isSameDay } from 'date-fns';
+
+import { GetValueObject } from './interfaces/get-value-object.interface';
+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 };
+
+    case 'NOVN.SW':
+      if (isSameDay(parseDate('2022-04-11'), date)) {
+        return { marketPrice: 87.8 };
+      }
+
+      return { marketPrice: 0 };
+
+    default:
+      return { marketPrice: 0 };
+  }
+}
+
+export const CurrentRateServiceMock = {
+  getValues: ({
+    dataGatheringItems,
+    dateQuery
+  }: GetValuesParams): Promise<GetValueObject[]> => {
+    const result: GetValueObject[] = [];
+    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,
+            marketPriceInBaseCurrency: mockGetValue(
+              dataGatheringItem.symbol,
+              date
+            ).marketPrice,
+            symbol: dataGatheringItem.symbol
+          });
+        }
+      }
+    } else {
+      for (const date of dateQuery.in) {
+        for (const dataGatheringItem of dataGatheringItems) {
+          result.push({
+            date,
+            marketPriceInBaseCurrency: mockGetValue(
+              dataGatheringItem.symbol,
+              date
+            ).marketPrice,
+            symbol: dataGatheringItem.symbol
+          });
+        }
+      }
+    }
+    return Promise.resolve(result);
+  }
+};
--- a/apps/api/src/app/portfolio/current-rate.service.spec.ts
+++ b/apps/api/src/app/portfolio/current-rate.service.spec.ts
@ -4,6 +4,7 @@ import { MarketDataService } from '@ghostfolio/api/services/market-data.service'
 import { DataSource, MarketData } from '@prisma/client';

 import { CurrentRateService } from './current-rate.service';
+import { GetValueObject } from './interfaces/get-value-object.interface';

 jest.mock('@ghostfolio/api/services/market-data.service', () => {
  return {
@ -73,7 +74,12 @@ describe('CurrentRateService', () => {

  beforeAll(async () => {
    dataProviderService = new DataProviderService(null, [], null);
-    exchangeRateDataService = new ExchangeRateDataService(null, null, null);
+    exchangeRateDataService = new ExchangeRateDataService(
+      null,
+      null,
+      null,
+      null
+    );
    marketDataService = new MarketDataService(null);

    await exchangeRateDataService.initialize();
@ -96,15 +102,15 @@ describe('CurrentRateService', () => {
        },
        userCurrency: 'CHF'
      })
-    ).toMatchObject([
+    ).toMatchObject<GetValueObject[]>([
      {
        date: undefined,
-        marketPrice: 1841.823902,
+        marketPriceInBaseCurrency: 1841.823902,
        symbol: 'AMZN'
      },
      {
        date: undefined,
-        marketPrice: 1847.839966,
+        marketPriceInBaseCurrency: 1847.839966,
        symbol: 'AMZN'
      }
    ]);
--- a/apps/api/src/app/portfolio/current-rate.service.ts
+++ b/apps/api/src/app/portfolio/current-rate.service.ts
@ -28,30 +28,25 @@ export class CurrentRateService {
      (!dateQuery.gte || isBefore(dateQuery.gte, new Date())) &&
      (!dateQuery.in || this.containsToday(dateQuery.in));

-    const promises: Promise<
-      {
-        date: Date;
-        marketPrice: number;
-        symbol: string;
-      }[]
-    >[] = [];
+    const promises: Promise<GetValueObject[]>[] = [];

    if (includeToday) {
      const today = resetHours(new Date());
      promises.push(
        this.dataProviderService
-          .get(dataGatheringItems)
+          .getQuotes(dataGatheringItems)
          .then((dataResultProvider) => {
-            const result = [];
+            const result: GetValueObject[] = [];
            for (const dataGatheringItem of dataGatheringItems) {
              result.push({
                date: today,
-                marketPrice: this.exchangeRateDataService.toCurrency(
-                  dataResultProvider?.[dataGatheringItem.symbol]?.marketPrice ??
-                    0,
-                  dataResultProvider?.[dataGatheringItem.symbol]?.currency,
-                  userCurrency
-                ),
+                marketPriceInBaseCurrency:
+                  this.exchangeRateDataService.toCurrency(
+                    dataResultProvider?.[dataGatheringItem.symbol]
+                      ?.marketPrice ?? 0,
+                    dataResultProvider?.[dataGatheringItem.symbol]?.currency,
+                    userCurrency
+                  ),
                symbol: dataGatheringItem.symbol
              });
            }
@ -74,11 +69,12 @@ export class CurrentRateService {
          return data.map((marketDataItem) => {
            return {
              date: marketDataItem.date,
-              marketPrice: this.exchangeRateDataService.toCurrency(
-                marketDataItem.marketPrice,
-                currencies[marketDataItem.symbol],
-                userCurrency
-              ),
+              marketPriceInBaseCurrency:
+                this.exchangeRateDataService.toCurrency(
+                  marketDataItem.marketPrice,
+                  currencies[marketDataItem.symbol],
+                  userCurrency
+                ),
              symbol: marketDataItem.symbol
            };
          });
--- a/apps/api/src/app/portfolio/interfaces/current-positions.interface.ts
+++ b/apps/api/src/app/portfolio/interfaces/current-positions.interface.ts
@ -1,8 +1,7 @@
-import { TimelinePosition } from '@ghostfolio/common/interfaces';
+import { ResponseError, TimelinePosition } from '@ghostfolio/common/interfaces';
 import Big from 'big.js';

-export interface CurrentPositions {
-  hasErrors: boolean;
+export interface CurrentPositions extends ResponseError {
  positions: TimelinePosition[];
  grossPerformance: Big;
  grossPerformancePercentage: Big;
--- a/apps/api/src/app/portfolio/interfaces/get-value-object.interface.ts
+++ b/apps/api/src/app/portfolio/interfaces/get-value-object.interface.ts
@ -1,5 +1,5 @@
 export interface GetValueObject {
  date: Date;
-  marketPrice: number;
+  marketPriceInBaseCurrency: number;
  symbol: string;
 }
--- a/apps/api/src/app/portfolio/interfaces/portfolio-position-detail.interface.ts
+++ b/apps/api/src/app/portfolio/interfaces/portfolio-position-detail.interface.ts
@ -1,11 +1,12 @@
+import {
+  EnhancedSymbolProfile,
+  HistoricalDataItem
+} from '@ghostfolio/common/interfaces';
 import { OrderWithAccount } from '@ghostfolio/common/types';
-import { AssetClass, AssetSubClass } from '@prisma/client';
+import { Tag } from '@prisma/client';

 export interface PortfolioPositionDetail {
-  assetClass?: AssetClass;
-  assetSubClass?: AssetSubClass;
  averagePrice: number;
-  currency: string;
  firstBuyDate: string;
  grossPerformance: number;
  grossPerformancePercent: number;
@ -14,12 +15,12 @@ export interface PortfolioPositionDetail {
  marketPrice: number;
  maxPrice: number;
  minPrice: number;
-  name: string;
  netPerformance: number;
  netPerformancePercent: number;
  orders: OrderWithAccount[];
  quantity: number;
-  symbol: string;
+  SymbolProfile: EnhancedSymbolProfile;
+  tags: Tag[];
  transactionCount: number;
  value: number;
 }
@ -29,10 +30,3 @@ export interface HistoricalDataContainer {
  isAllTimeLow: boolean;
  items: HistoricalDataItem[];
 }
-
-export interface HistoricalDataItem {
-  averagePrice?: number;
-  date: string;
-  grossPerformancePercent?: number;
-  value: number;
-}
--- a/apps/api/src/app/portfolio/portfolio-calculator-baln-buy-and-sell.spec.ts
+++ b/apps/api/src/app/portfolio/portfolio-calculator-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 { PortfolioCalculator } from './portfolio-calculator';
+
+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('PortfolioCalculator', () => {
+  let currentRateService: CurrentRateService;
+
+  beforeEach(() => {
+    currentRateService = new CurrentRateService(null, null, null);
+  });
+
+  describe('get current positions', () => {
+    it.only('with BALN.SW buy and sell', async () => {
+      const portfolioCalculator = new PortfolioCalculator({
+        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)
+          }
+        ]
+      });
+
+      portfolioCalculator.computeTransactionPoints();
+
+      const spy = jest
+        .spyOn(Date, 'now')
+        .mockImplementation(() => parseDate('2021-12-18').getTime());
+
+      const currentPositions = await portfolioCalculator.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')
+      });
+    });
+  });
+});
--- a/apps/api/src/app/portfolio/portfolio-calculator-baln-buy.spec.ts
+++ b/apps/api/src/app/portfolio/portfolio-calculator-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 { PortfolioCalculator } from './portfolio-calculator';
+
+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('PortfolioCalculator', () => {
+  let currentRateService: CurrentRateService;
+
+  beforeEach(() => {
+    currentRateService = new CurrentRateService(null, null, null);
+  });
+
+  describe('get current positions', () => {
+    it.only('with BALN.SW buy', async () => {
+      const portfolioCalculator = new PortfolioCalculator({
+        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)
+          }
+        ]
+      });
+
+      portfolioCalculator.computeTransactionPoints();
+
+      const spy = jest
+        .spyOn(Date, 'now')
+        .mockImplementation(() => parseDate('2021-12-18').getTime());
+
+      const currentPositions = await portfolioCalculator.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')
+      });
+    });
+  });
+});
--- a/apps/api/src/app/portfolio/portfolio-calculator-new.spec.ts
+++ b/apps/api/src/app/portfolio/portfolio-calculator-new.spec.ts
@ -1,73 +0,0 @@
-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);
-    });
-  });
-});
--- a/apps/api/src/app/portfolio/portfolio-calculator-new.ts
+++ b/apps/api/src/app/portfolio/portfolio-calculator-new.ts
@ -1,898 +0,0 @@
-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,
-  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 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 hasErrorsInSymbolMetrics = false;
-
-    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
-      });
-
-      hasErrorsInSymbolMetrics = hasErrorsInSymbolMetrics || 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
-      });
-    }
-    const overall = this.calculateOverallPerformance(positions, initialValues);
-
-    return {
-      ...overall,
-      positions,
-      hasErrors: hasErrorsInSymbolMetrics || overall.hasErrors
-    };
-  }
-
-  public getSymbolMetrics({
-    marketSymbolMap,
-    start,
-    symbol
-  }: {
-    marketSymbolMap: {
-      [date: string]: { [symbol: string]: Big };
-    };
-    start: Date;
-    symbol: string;
-  }) {
-    let orders: PortfolioOrderItem[] = this.orders.filter((order) => {
-      return order.symbol === symbol;
-    });
-
-    if (orders.length <= 0) {
-      return {
-        hasErrors: false,
-        initialValue: new Big(0),
-        netPerformance: new Big(0),
-        netPerformancePercentage: new Big(0),
-        grossPerformance: new Big(0),
-        grossPerformancePercentage: new Big(0)
-      };
-    }
-
-    const dateOfFirstTransaction = new Date(first(orders).date);
-    const endDate = new Date(Date.now());
-
-    const unitPriceAtStartDate =
-      marketSymbolMap[format(start, DATE_FORMAT)]?.[symbol];
-
-    const unitPriceAtEndDate =
-      marketSymbolMap[format(endDate, DATE_FORMAT)]?.[symbol];
-
-    if (
-      !unitPriceAtEndDate ||
-      (!unitPriceAtStartDate && isBefore(dateOfFirstTransaction, start))
-    ) {
-      return {
-        hasErrors: true,
-        initialValue: new Big(0),
-        netPerformance: new Big(0),
-        netPerformancePercentage: new Big(0),
-        grossPerformance: new Big(0),
-        grossPerformancePercentage: new Big(0)
-      };
-    }
-
-    let feesAtStartDate = new Big(0);
-    let fees = new Big(0);
-    let grossPerformance = new Big(0);
-    let grossPerformanceAtStartDate = new Big(0);
-    let grossPerformanceFromSells = new Big(0);
-    let initialValue: Big;
-    let lastAveragePrice = new Big(0);
-    let lastTransactionInvestment = new Big(0);
-    let lastValueOfInvestmentBeforeTransaction = new Big(0);
-    let timeWeightedGrossPerformancePercentage = new Big(1);
-    let timeWeightedNetPerformancePercentage = new Big(1);
-    let totalInvestment = new Big(0);
-    let totalUnits = new Big(0);
-
-    const holdingPeriodPerformances: {
-      grossReturn: Big;
-      netReturn: Big;
-      valueOfInvestment: Big;
-    }[] = [];
-
-    // Add a synthetic order at the start and the end date
-    orders.push({
-      symbol,
-      currency: null,
-      date: format(start, DATE_FORMAT),
-      dataSource: null,
-      fee: new Big(0),
-      itemType: 'start',
-      name: '',
-      quantity: new Big(0),
-      type: TypeOfOrder.BUY,
-      unitPrice: unitPriceAtStartDate ?? new Big(0)
-    });
-
-    orders.push({
-      symbol,
-      currency: null,
-      date: format(endDate, DATE_FORMAT),
-      dataSource: null,
-      fee: new Big(0),
-      itemType: 'end',
-      name: '',
-      quantity: new Big(0),
-      type: TypeOfOrder.BUY,
-      unitPrice: unitPriceAtEndDate ?? new Big(0)
-    });
-
-    // Sort orders so that the start and end placeholder order are at the right
-    // position
-    orders = sortBy(orders, (order) => {
-      let sortIndex = new Date(order.date);
-
-      if (order.itemType === 'start') {
-        sortIndex = addMilliseconds(sortIndex, -1);
-      }
-
-      if (order.itemType === 'end') {
-        sortIndex = addMilliseconds(sortIndex, 1);
-      }
-
-      return sortIndex.getTime();
-    });
-
-    const indexOfStartOrder = orders.findIndex((order) => {
-      return order.itemType === 'start';
-    });
-
-    for (let i = 0; i < orders.length; i += 1) {
-      const order = orders[i];
-
-      const valueOfInvestmentBeforeTransaction = totalUnits.mul(
-        order.unitPrice
-      );
-
-      const transactionInvestment = order.quantity
-        .mul(order.unitPrice)
-        .mul(this.getFactor(order.type));
-
-      if (
-        !initialValue &&
-        order.itemType !== 'start' &&
-        order.itemType !== 'end'
-      ) {
-        initialValue = transactionInvestment;
-      }
-
-      fees = fees.plus(order.fee);
-
-      totalUnits = totalUnits.plus(
-        order.quantity.mul(this.getFactor(order.type))
-      );
-
-      const valueOfInvestment = totalUnits.mul(order.unitPrice);
-
-      const grossPerformanceFromSell =
-        order.type === TypeOfOrder.SELL
-          ? order.unitPrice.minus(lastAveragePrice).mul(order.quantity)
-          : new Big(0);
-
-      grossPerformanceFromSells = grossPerformanceFromSells.plus(
-        grossPerformanceFromSell
-      );
-
-      totalInvestment = totalInvestment
-        .plus(transactionInvestment)
-        .plus(grossPerformanceFromSell);
-
-      lastAveragePrice = totalUnits.eq(0)
-        ? new Big(0)
-        : totalInvestment.div(totalUnits);
-
-      const newGrossPerformance = valueOfInvestment
-        .minus(totalInvestment)
-        .plus(grossPerformanceFromSells);
-
-      if (
-        i > indexOfStartOrder &&
-        !lastValueOfInvestmentBeforeTransaction
-          .plus(lastTransactionInvestment)
-          .eq(0)
-      ) {
-        const grossHoldingPeriodReturn = valueOfInvestmentBeforeTransaction
-          .minus(
-            lastValueOfInvestmentBeforeTransaction.plus(
-              lastTransactionInvestment
-            )
-          )
-          .div(
-            lastValueOfInvestmentBeforeTransaction.plus(
-              lastTransactionInvestment
-            )
-          );
-
-        timeWeightedGrossPerformancePercentage =
-          timeWeightedGrossPerformancePercentage.mul(
-            new Big(1).plus(grossHoldingPeriodReturn)
-          );
-
-        const netHoldingPeriodReturn = valueOfInvestmentBeforeTransaction
-          .minus(fees.minus(feesAtStartDate))
-          .minus(
-            lastValueOfInvestmentBeforeTransaction.plus(
-              lastTransactionInvestment
-            )
-          )
-          .div(
-            lastValueOfInvestmentBeforeTransaction.plus(
-              lastTransactionInvestment
-            )
-          );
-
-        timeWeightedNetPerformancePercentage =
-          timeWeightedNetPerformancePercentage.mul(
-            new Big(1).plus(netHoldingPeriodReturn)
-          );
-
-        holdingPeriodPerformances.push({
-          grossReturn: grossHoldingPeriodReturn,
-          netReturn: netHoldingPeriodReturn,
-          valueOfInvestment: lastValueOfInvestmentBeforeTransaction.plus(
-            lastTransactionInvestment
-          )
-        });
-      }
-
-      grossPerformance = newGrossPerformance;
-
-      lastTransactionInvestment = transactionInvestment;
-
-      lastValueOfInvestmentBeforeTransaction =
-        valueOfInvestmentBeforeTransaction;
-
-      if (order.itemType === 'start') {
-        feesAtStartDate = fees;
-        grossPerformanceAtStartDate = grossPerformance;
-      }
-    }
-
-    timeWeightedGrossPerformancePercentage =
-      timeWeightedGrossPerformancePercentage.minus(1);
-
-    timeWeightedNetPerformancePercentage =
-      timeWeightedNetPerformancePercentage.minus(1);
-
-    const totalGrossPerformance = grossPerformance.minus(
-      grossPerformanceAtStartDate
-    );
-
-    const totalNetPerformance = grossPerformance
-      .minus(grossPerformanceAtStartDate)
-      .minus(fees.minus(feesAtStartDate));
-
-    let valueOfInvestmentSum = new Big(0);
-
-    for (const holdingPeriodPerformance of holdingPeriodPerformances) {
-      valueOfInvestmentSum = valueOfInvestmentSum.plus(
-        holdingPeriodPerformance.valueOfInvestment
-      );
-    }
-
-    let totalWeightedGrossPerformance = new Big(0);
-    let totalWeightedNetPerformance = new Big(0);
-
-    // Weight the holding period returns according to their value of investment
-    for (const holdingPeriodPerformance of holdingPeriodPerformances) {
-      totalWeightedGrossPerformance = totalWeightedGrossPerformance.plus(
-        holdingPeriodPerformance.grossReturn
-          .mul(holdingPeriodPerformance.valueOfInvestment)
-          .div(valueOfInvestmentSum)
-      );
-
-      totalWeightedNetPerformance = totalWeightedNetPerformance.plus(
-        holdingPeriodPerformance.netReturn
-          .mul(holdingPeriodPerformance.valueOfInvestment)
-          .div(valueOfInvestmentSum)
-      );
-    }
-
-    return {
-      initialValue,
-      hasErrors: !initialValue || !unitPriceAtEndDate,
-      netPerformance: totalNetPerformance,
-      netPerformancePercentage: totalWeightedNetPerformance,
-      grossPerformance: totalGrossPerformance,
-      grossPerformancePercentage: totalWeightedGrossPerformance
-    };
-  }
-
-  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: { [p: string]: Big }
-  ) {
-    let hasErrors = false;
-    let currentValue = new Big(0);
-    let totalInvestment = new Big(0);
-    let grossPerformance = new Big(0);
-    let grossPerformancePercentage = new Big(0);
-    let netPerformance = new Big(0);
-    let netPerformancePercentage = new Big(0);
-    let completeInitialValue = 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 &&
-        initialValues[currentPosition.symbol]
-      ) {
-        const currentInitialValue = initialValues[currentPosition.symbol];
-        completeInitialValue = completeInitialValue.plus(currentInitialValue);
-        grossPerformancePercentage = grossPerformancePercentage.plus(
-          currentPosition.grossPerformancePercentage.mul(currentInitialValue)
-        );
-        netPerformancePercentage = netPerformancePercentage.plus(
-          currentPosition.netPerformancePercentage.mul(currentInitialValue)
-        );
-      } else if (!currentPosition.quantity.eq(0)) {
-        Logger.warn(
-          `Missing initial value for symbol ${currentPosition.symbol} at ${currentPosition.firstBuyDate}`
-        );
-        hasErrors = true;
-      }
-    }
-
-    if (!completeInitialValue.eq(0)) {
-      grossPerformancePercentage =
-        grossPerformancePercentage.div(completeInitialValue);
-      netPerformancePercentage =
-        netPerformancePercentage.div(completeInitialValue);
-    }
-
-    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 isNextItemActive(
-    timelineSpecification: TimelineSpecification[],
-    currentDate: Date,
-    i: number
-  ) {
-    return (
-      i + 1 < timelineSpecification.length &&
-      !isBefore(currentDate, parseDate(timelineSpecification[i + 1].start))
-    );
-  }
-}
--- a/apps/api/src/app/portfolio/portfolio-calculator-no-orders.spec.ts
+++ b/apps/api/src/app/portfolio/portfolio-calculator-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 { PortfolioCalculator } from './portfolio-calculator';
+
+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('PortfolioCalculator', () => {
+  let currentRateService: CurrentRateService;
+
+  beforeEach(() => {
+    currentRateService = new CurrentRateService(null, null, null);
+  });
+
+  describe('get current positions', () => {
+    it('with no orders', async () => {
+      const portfolioCalculator = new PortfolioCalculator({
+        currentRateService,
+        currency: 'CHF',
+        orders: []
+      });
+
+      portfolioCalculator.computeTransactionPoints();
+
+      const spy = jest
+        .spyOn(Date, 'now')
+        .mockImplementation(() => parseDate('2021-12-18').getTime());
+
+      const currentPositions = await portfolioCalculator.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)
+      });
+    });
+  });
+});
--- a/apps/api/src/app/portfolio/portfolio-calculator-novn-buy-and-sell-partially.spec.ts
+++ b/apps/api/src/app/portfolio/portfolio-calculator-novn-buy-and-sell-partially.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 { PortfolioCalculator } from './portfolio-calculator';
+
+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('PortfolioCalculator', () => {
+  let currentRateService: CurrentRateService;
+
+  beforeEach(() => {
+    currentRateService = new CurrentRateService(null, null, null);
+  });
+
+  describe('get current positions', () => {
+    it.only('with BALN.SW buy and sell', async () => {
+      const portfolioCalculator = new PortfolioCalculator({
+        currentRateService,
+        currency: 'CHF',
+        orders: [
+          {
+            currency: 'CHF',
+            date: '2022-03-07',
+            dataSource: 'YAHOO',
+            fee: new Big(1.3),
+            name: 'Novartis AG',
+            quantity: new Big(2),
+            symbol: 'NOVN.SW',
+            type: 'BUY',
+            unitPrice: new Big(75.8)
+          },
+          {
+            currency: 'CHF',
+            date: '2022-04-08',
+            dataSource: 'YAHOO',
+            fee: new Big(2.95),
+            name: 'Novartis AG',
+            quantity: new Big(1),
+            symbol: 'NOVN.SW',
+            type: 'SELL',
+            unitPrice: new Big(85.73)
+          }
+        ]
+      });
+
+      portfolioCalculator.computeTransactionPoints();
+
+      const spy = jest
+        .spyOn(Date, 'now')
+        .mockImplementation(() => parseDate('2022-04-11').getTime());
+
+      const currentPositions = await portfolioCalculator.getCurrentPositions(
+        parseDate('2022-03-07')
+      );
+
+      spy.mockRestore();
+
+      expect(currentPositions).toEqual({
+        currentValue: new Big('87.8'),
+        errors: [],
+        grossPerformance: new Big('21.93'),
+        grossPerformancePercentage: new Big('0.14465699208443271768'),
+        hasErrors: false,
+        netPerformance: new Big('17.68'),
+        netPerformancePercentage: new Big('0.11662269129287598945'),
+        positions: [
+          {
+            averagePrice: new Big('75.80'),
+            currency: 'CHF',
+            dataSource: 'YAHOO',
+            firstBuyDate: '2022-03-07',
+            grossPerformance: new Big('21.93'),
+            grossPerformancePercentage: new Big('0.14465699208443271768'),
+            investment: new Big('75.80'),
+            netPerformance: new Big('17.68'),
+            netPerformancePercentage: new Big('0.11662269129287598945'),
+            marketPrice: 87.8,
+            quantity: new Big('1'),
+            symbol: 'NOVN.SW',
+            transactionCount: 2
+          }
+        ],
+        totalInvestment: new Big('75.80')
+      });
+    });
+  });
+});
--- a/apps/api/src/app/portfolio/portfolio-calculator.spec.ts
+++ b/apps/api/src/app/portfolio/portfolio-calculator.spec.ts
--- a/apps/api/src/app/portfolio/portfolio-calculator.ts
+++ b/apps/api/src/app/portfolio/portfolio-calculator.ts
@ -1,15 +1,15 @@
 import { TimelineInfoInterface } from '@ghostfolio/api/app/portfolio/interfaces/timeline-info.interface';
 import { IDataGatheringItem } from '@ghostfolio/api/services/interfaces/interfaces';
 import { DATE_FORMAT, parseDate, resetHours } from '@ghostfolio/common/helper';
-import { TimelinePosition } from '@ghostfolio/common/interfaces';
+import { ResponseError, TimelinePosition } 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,
-  differenceInDays,
  endOfDay,
  format,
  isAfter,
@ -17,11 +17,12 @@ import {
  max,
  min
 } from 'date-fns';
-import { flatten, isNumber } from 'lodash';
+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 {
@ -32,22 +33,39 @@ import { TransactionPointSymbol } from './interfaces/transaction-point-symbol.in
 import { TransactionPoint } from './interfaces/transaction-point.interface';

 export class PortfolioCalculator {
+  private static readonly CALCULATE_PERCENTAGE_PERFORMANCE_WITH_MAX_INVESTMENT =
+    true;
+
+  private static readonly ENABLE_LOGGING = false;
+
+  private currency: string;
+  private currentRateService: CurrentRateService;
+  private orders: PortfolioOrder[];
  private transactionPoints: TransactionPoint[];

-  public constructor(
-    private currentRateService: CurrentRateService,
-    private currency: string
-  ) {}
+  public constructor({
+    currency,
+    currentRateService,
+    orders
+  }: {
+    currency: string;
+    currentRateService: CurrentRateService;
+    orders: PortfolioOrder[];
+  }) {
+    this.currency = currency;
+    this.currentRateService = currentRateService;
+    this.orders = orders;

-  public computeTransactionPoints(orders: PortfolioOrder[]) {
-    orders.sort((a, b) => a.date.localeCompare(b.date));
+    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 orders) {
+    for (const order of this.orders) {
      const currentDate = order.date;

      let currentTransactionPointItem: TransactionPointSymbol;
@ -59,17 +77,30 @@ export class PortfolioCalculator {
        const newQuantity = order.quantity
          .mul(factor)
          .plus(oldAccumulatedSymbol.quantity);
+
+        let investment = new Big(0);
+
+        if (newQuantity.gt(0)) {
+          if (order.type === 'BUY') {
+            investment = oldAccumulatedSymbol.investment.plus(
+              order.quantity.mul(unitPrice)
+            );
+          } else if (order.type === 'SELL') {
+            const averagePrice = oldAccumulatedSymbol.investment.div(
+              oldAccumulatedSymbol.quantity
+            );
+            investment = oldAccumulatedSymbol.investment.minus(
+              order.quantity.mul(averagePrice)
+            );
+          }
+        }
+
        currentTransactionPointItem = {
+          investment,
          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
@ -94,7 +125,7 @@ export class PortfolioCalculator {
        (transactionPointItem) => transactionPointItem.symbol !== order.symbol
      );
      newItems.push(currentTransactionPointItem);
-      newItems.sort((a, b) => a.symbol.localeCompare(b.symbol));
+      newItems.sort((a, b) => a.symbol?.localeCompare(b.symbol));
      if (lastDate !== currentDate || lastTransactionPoint === null) {
        lastTransactionPoint = {
          date: currentDate,
@ -140,7 +171,6 @@ export class PortfolioCalculator {
        hasErrors: false,
        grossPerformance: new Big(0),
        grossPerformancePercentage: new Big(0),
-        netAnnualizedPerformance: new Big(0),
        netPerformance: new Big(0),
        netPerformancePercentage: new Big(0),
        positions: [],
@ -195,120 +225,50 @@ export class PortfolioCalculator {
    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) {
+      if (marketSymbol.marketPriceInBaseCurrency) {
        marketSymbolMap[date][marketSymbol.symbol] = new Big(
-          marketSymbol.marketPrice
+          marketSymbol.marketPriceInBaseCurrency
        );
      }
    }

-    let hasErrors = false;
-    const startString = format(start, DATE_FORMAT);
-
-    const holdingPeriodReturns: { [symbol: string]: Big } = {};
-    const netHoldingPeriodReturns: { [symbol: string]: Big } = {};
-    const grossPerformance: { [symbol: string]: Big } = {};
-    const netPerformance: { [symbol: string]: Big } = {};
    const todayString = format(today, DATE_FORMAT);

    if (firstIndex > 0) {
      firstIndex--;
    }
-    const invalidSymbols = [];
-    const lastInvestments: { [symbol: string]: Big } = {};
-    const lastQuantities: { [symbol: string]: Big } = {};
-    const lastFees: { [symbol: string]: Big } = {};
    const initialValues: { [symbol: string]: Big } = {};

-    for (let i = firstIndex; i < this.transactionPoints.length; i++) {
-      const currentDate =
-        i === firstIndex ? startString : this.transactionPoints[i].date;
-      const nextDate =
-        i + 1 < this.transactionPoints.length
-          ? this.transactionPoints[i + 1].date
-          : todayString;
-
-      const items = this.transactionPoints[i].items;
-      for (const item of items) {
-        if (!marketSymbolMap[nextDate]?.[item.symbol]) {
-          invalidSymbols.push(item.symbol);
-          hasErrors = true;
-          Logger.warn(`Missing value for symbol ${item.symbol} at ${nextDate}`);
-          continue;
-        }
-        let lastInvestment: Big = new Big(0);
-        let lastQuantity: Big = item.quantity;
-        if (lastInvestments[item.symbol] && lastQuantities[item.symbol]) {
-          lastInvestment = item.investment.minus(lastInvestments[item.symbol]);
-          lastQuantity = lastQuantities[item.symbol];
-        }
-
-        const itemValue = marketSymbolMap[currentDate]?.[item.symbol];
-        let initialValue = itemValue?.mul(lastQuantity);
-        let investedValue = itemValue?.mul(item.quantity);
-        const isFirstOrderAndIsStartBeforeCurrentDate =
-          i === firstIndex &&
-          isBefore(parseDate(this.transactionPoints[i].date), start);
-        const lastFee: Big = lastFees[item.symbol] ?? new Big(0);
-        const fee = isFirstOrderAndIsStartBeforeCurrentDate
-          ? new Big(0)
-          : item.fee.minus(lastFee);
-        if (!isAfter(parseDate(currentDate), parseDate(item.firstBuyDate))) {
-          initialValue = item.investment;
-          investedValue = item.investment;
-        }
-        if (i === firstIndex || !initialValues[item.symbol]) {
-          initialValues[item.symbol] = initialValue;
-        }
-        if (!item.quantity.eq(0)) {
-          if (!initialValue) {
-            invalidSymbols.push(item.symbol);
-            hasErrors = true;
-            Logger.warn(
-              `Missing value for symbol ${item.symbol} at ${currentDate}`
-            );
-            continue;
-          }
-
-          const cashFlow = lastInvestment;
-          const endValue = marketSymbolMap[nextDate][item.symbol].mul(
-            item.quantity
-          );
-
-          const holdingPeriodReturn = endValue.div(initialValue.plus(cashFlow));
-          holdingPeriodReturns[item.symbol] = (
-            holdingPeriodReturns[item.symbol] ?? new Big(1)
-          ).mul(holdingPeriodReturn);
-          grossPerformance[item.symbol] = (
-            grossPerformance[item.symbol] ?? new Big(0)
-          ).plus(endValue.minus(investedValue));
-
-          const netHoldingPeriodReturn = endValue.div(
-            initialValue.plus(cashFlow).plus(fee)
-          );
-          netHoldingPeriodReturns[item.symbol] = (
-            netHoldingPeriodReturns[item.symbol] ?? new Big(1)
-          ).mul(netHoldingPeriodReturn);
-          netPerformance[item.symbol] = (
-            netPerformance[item.symbol] ?? new Big(0)
-          ).plus(endValue.minus(investedValue).minus(fee));
-        }
-        lastInvestments[item.symbol] = item.investment;
-        lastQuantities[item.symbol] = item.quantity;
-        lastFees[item.symbol] = item.fee;
-      }
-    }
-
    const positions: TimelinePosition[] = [];
+    let hasAnySymbolMetricsErrors = false;
+
+    const errors: ResponseError['errors'] = [];

    for (const item of lastTransactionPoint.items) {
      const marketValue = marketSymbolMap[todayString]?.[item.symbol];
-      const isValid = invalidSymbols.indexOf(item.symbol) === -1;
+
+      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)
@ -316,31 +276,33 @@ export class PortfolioCalculator {
        currency: item.currency,
        dataSource: item.dataSource,
        firstBuyDate: item.firstBuyDate,
-        grossPerformance: isValid
-          ? grossPerformance[item.symbol] ?? null
+        grossPerformance: !hasErrors ? grossPerformance ?? null : null,
+        grossPerformancePercentage: !hasErrors
+          ? grossPerformancePercentage ?? null
          : null,
-        grossPerformancePercentage:
-          isValid && holdingPeriodReturns[item.symbol]
-            ? holdingPeriodReturns[item.symbol].minus(1)
-            : null,
        investment: item.investment,
        marketPrice: marketValue?.toNumber() ?? null,
-        netPerformance: isValid ? netPerformance[item.symbol] ?? null : null,
-        netPerformancePercentage:
-          isValid && netHoldingPeriodReturns[item.symbol]
-            ? netHoldingPeriodReturns[item.symbol].minus(1)
-            : 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: hasErrors || overall.hasErrors
+      hasErrors: hasAnySymbolMetricsErrors || overall.hasErrors
    };
  }

@ -458,20 +420,16 @@ export class PortfolioCalculator {

  private calculateOverallPerformance(
    positions: TimelinePosition[],
-    initialValues: { [p: string]: Big }
+    initialValues: { [symbol: string]: Big }
  ) {
-    let hasErrors = false;
    let currentValue = new Big(0);
-    let totalInvestment = new Big(0);
    let grossPerformance = new Big(0);
    let grossPerformancePercentage = new Big(0);
+    let hasErrors = false;
    let netPerformance = new Big(0);
    let netPerformancePercentage = new Big(0);
-    let completeInitialValue = new Big(0);
-    let netAnnualizedPerformance = new Big(0);
-
-    // use Date.now() to use the mock for today
-    const today = new Date(Date.now());
+    let sumOfWeights = new Big(0);
+    let totalInvestment = new Big(0);

    for (const currentPosition of positions) {
      if (currentPosition.marketPrice) {
@ -481,52 +439,50 @@ export class PortfolioCalculator {
      } else {
        hasErrors = true;
      }
+
      totalInvestment = totalInvestment.plus(currentPosition.investment);
+
      if (currentPosition.grossPerformance) {
        grossPerformance = grossPerformance.plus(
          currentPosition.grossPerformance
        );
+
        netPerformance = netPerformance.plus(currentPosition.netPerformance);
      } else if (!currentPosition.quantity.eq(0)) {
        hasErrors = true;
      }

-      if (
-        currentPosition.grossPerformancePercentage &&
-        initialValues[currentPosition.symbol]
-      ) {
-        const currentInitialValue = initialValues[currentPosition.symbol];
-        completeInitialValue = completeInitialValue.plus(currentInitialValue);
+      if (currentPosition.grossPerformancePercentage) {
+        // Use the average from the initial value and the current investment as
+        // a weight
+        const weight = (initialValues[currentPosition.symbol] ?? new Big(0))
+          .plus(currentPosition.investment)
+          .div(2);
+
+        sumOfWeights = sumOfWeights.plus(weight);
+
        grossPerformancePercentage = grossPerformancePercentage.plus(
-          currentPosition.grossPerformancePercentage.mul(currentInitialValue)
-        );
-        netAnnualizedPerformance = netAnnualizedPerformance.plus(
-          this.getAnnualizedPerformancePercent({
-            daysInMarket: differenceInDays(
-              today,
-              parseDate(currentPosition.firstBuyDate)
-            ),
-            netPerformancePercent: currentPosition.netPerformancePercentage
-          }).mul(currentInitialValue)
+          currentPosition.grossPerformancePercentage.mul(weight)
        );
+
        netPerformancePercentage = netPerformancePercentage.plus(
-          currentPosition.netPerformancePercentage.mul(currentInitialValue)
+          currentPosition.netPerformancePercentage.mul(weight)
        );
      } else if (!currentPosition.quantity.eq(0)) {
        Logger.warn(
-          `Missing initial value for symbol ${currentPosition.symbol} at ${currentPosition.firstBuyDate}`
+          `Missing initial value for symbol ${currentPosition.symbol} at ${currentPosition.firstBuyDate}`,
+          'PortfolioCalculator'
        );
        hasErrors = true;
      }
    }

-    if (!completeInitialValue.eq(0)) {
-      grossPerformancePercentage =
-        grossPerformancePercentage.div(completeInitialValue);
-      netPerformancePercentage =
-        netPerformancePercentage.div(completeInitialValue);
-      netAnnualizedPerformance =
-        netAnnualizedPerformance.div(completeInitialValue);
+    if (sumOfWeights.gt(0)) {
+      grossPerformancePercentage = grossPerformancePercentage.div(sumOfWeights);
+      netPerformancePercentage = netPerformancePercentage.div(sumOfWeights);
+    } else {
+      grossPerformancePercentage = new Big(0);
+      netPerformancePercentage = new Big(0);
    }

    return {
@ -534,7 +490,6 @@ export class PortfolioCalculator {
      grossPerformance,
      grossPerformancePercentage,
      hasErrors,
-      netAnnualizedPerformance,
      netPerformance,
      netPerformancePercentage,
      totalInvestment
@ -581,7 +536,8 @@ export class PortfolioCalculator {
        } catch (error) {
          Logger.error(
            `Failed to fetch info for date ${startDate} with exception`,
-            error
+            error,
+            'PortfolioCalculator'
          );
          return null;
        }
@ -592,9 +548,9 @@ export class PortfolioCalculator {
        if (!marketSymbolMap[date]) {
          marketSymbolMap[date] = {};
        }
-        if (marketSymbol.marketPrice) {
+        if (marketSymbol.marketPriceInBaseCurrency) {
          marketSymbolMap[date][marketSymbol.symbol] = new Big(
-            marketSymbol.marketPrice
+            marketSymbol.marketPriceInBaseCurrency
          );
        }
      }
@ -687,6 +643,356 @@ export class PortfolioCalculator {
    }
  }

+  private getSymbolMetrics({
+    marketSymbolMap,
+    start,
+    symbol
+  }: {
+    marketSymbolMap: {
+      [date: string]: { [symbol: string]: Big };
+    };
+    start: Date;
+    symbol: string;
+  }) {
+    let orders: PortfolioOrderItem[] = this.orders.filter((order) => {
+      return order.symbol === symbol;
+    });
+
+    if (orders.length <= 0) {
+      return {
+        hasErrors: false,
+        initialValue: new Big(0),
+        netPerformance: new Big(0),
+        netPerformancePercentage: new Big(0),
+        grossPerformance: new Big(0),
+        grossPerformancePercentage: new Big(0)
+      };
+    }
+
+    const dateOfFirstTransaction = new Date(first(orders).date);
+    const endDate = new Date(Date.now());
+
+    const unitPriceAtStartDate =
+      marketSymbolMap[format(start, DATE_FORMAT)]?.[symbol];
+
+    const unitPriceAtEndDate =
+      marketSymbolMap[format(endDate, DATE_FORMAT)]?.[symbol];
+
+    if (
+      !unitPriceAtEndDate ||
+      (!unitPriceAtStartDate && isBefore(dateOfFirstTransaction, start))
+    ) {
+      return {
+        hasErrors: true,
+        initialValue: new Big(0),
+        netPerformance: new Big(0),
+        netPerformancePercentage: new Big(0),
+        grossPerformance: new Big(0),
+        grossPerformancePercentage: new Big(0)
+      };
+    }
+
+    let averagePriceAtEndDate = new Big(0);
+    let averagePriceAtStartDate = new Big(0);
+    let feesAtStartDate = new Big(0);
+    let fees = new Big(0);
+    let grossPerformance = new Big(0);
+    let grossPerformanceAtStartDate = new Big(0);
+    let grossPerformanceFromSells = new Big(0);
+    let initialValue: Big;
+    let investmentAtStartDate: Big;
+    let lastAveragePrice = new Big(0);
+    let lastTransactionInvestment = new Big(0);
+    let lastValueOfInvestmentBeforeTransaction = new Big(0);
+    let maxTotalInvestment = new Big(0);
+    let timeWeightedGrossPerformancePercentage = new Big(1);
+    let timeWeightedNetPerformancePercentage = new Big(1);
+    let totalInvestment = new Big(0);
+    let totalInvestmentWithGrossPerformanceFromSell = new Big(0);
+    let totalUnits = new Big(0);
+    let valueAtStartDate: Big;
+
+    // Add a synthetic order at the start and the end date
+    orders.push({
+      symbol,
+      currency: null,
+      date: format(start, DATE_FORMAT),
+      dataSource: null,
+      fee: new Big(0),
+      itemType: 'start',
+      name: '',
+      quantity: new Big(0),
+      type: TypeOfOrder.BUY,
+      unitPrice: unitPriceAtStartDate
+    });
+
+    orders.push({
+      symbol,
+      currency: null,
+      date: format(endDate, DATE_FORMAT),
+      dataSource: null,
+      fee: new Big(0),
+      itemType: 'end',
+      name: '',
+      quantity: new Big(0),
+      type: TypeOfOrder.BUY,
+      unitPrice: unitPriceAtEndDate
+    });
+
+    // Sort orders so that the start and end placeholder order are at the right
+    // position
+    orders = sortBy(orders, (order) => {
+      let sortIndex = new Date(order.date);
+
+      if (order.itemType === 'start') {
+        sortIndex = addMilliseconds(sortIndex, -1);
+      }
+
+      if (order.itemType === 'end') {
+        sortIndex = addMilliseconds(sortIndex, 1);
+      }
+
+      return sortIndex.getTime();
+    });
+
+    const indexOfStartOrder = orders.findIndex((order) => {
+      return order.itemType === 'start';
+    });
+
+    const indexOfEndOrder = orders.findIndex((order) => {
+      return order.itemType === 'end';
+    });
+
+    for (let i = 0; i < orders.length; i += 1) {
+      const order = orders[i];
+
+      if (order.itemType === 'start') {
+        // Take the unit price of the order as the market price if there are no
+        // orders of this symbol before the start date
+        order.unitPrice =
+          indexOfStartOrder === 0
+            ? orders[i + 1]?.unitPrice
+            : unitPriceAtStartDate;
+      }
+
+      // Calculate the average start price as soon as any units are held
+      if (
+        averagePriceAtStartDate.eq(0) &&
+        i >= indexOfStartOrder &&
+        totalUnits.gt(0)
+      ) {
+        averagePriceAtStartDate = totalInvestment.div(totalUnits);
+      }
+
+      const valueOfInvestmentBeforeTransaction = totalUnits.mul(
+        order.unitPrice
+      );
+
+      if (!investmentAtStartDate && i >= indexOfStartOrder) {
+        investmentAtStartDate = totalInvestment ?? new Big(0);
+        valueAtStartDate = valueOfInvestmentBeforeTransaction;
+      }
+
+      const transactionInvestment = order.quantity
+        .mul(order.unitPrice)
+        .mul(this.getFactor(order.type));
+
+      totalInvestment = totalInvestment.plus(transactionInvestment);
+
+      if (i >= indexOfStartOrder && totalInvestment.gt(maxTotalInvestment)) {
+        maxTotalInvestment = totalInvestment;
+      }
+
+      if (i === indexOfEndOrder && totalUnits.gt(0)) {
+        averagePriceAtEndDate = totalInvestment.div(totalUnits);
+      }
+
+      if (i >= indexOfStartOrder && !initialValue) {
+        if (
+          i === indexOfStartOrder &&
+          !valueOfInvestmentBeforeTransaction.eq(0)
+        ) {
+          initialValue = valueOfInvestmentBeforeTransaction;
+        } else if (transactionInvestment.gt(0)) {
+          initialValue = transactionInvestment;
+        }
+      }
+
+      fees = fees.plus(order.fee);
+
+      totalUnits = totalUnits.plus(
+        order.quantity.mul(this.getFactor(order.type))
+      );
+
+      const valueOfInvestment = totalUnits.mul(order.unitPrice);
+
+      const grossPerformanceFromSell =
+        order.type === TypeOfOrder.SELL
+          ? order.unitPrice.minus(lastAveragePrice).mul(order.quantity)
+          : new Big(0);
+
+      grossPerformanceFromSells = grossPerformanceFromSells.plus(
+        grossPerformanceFromSell
+      );
+
+      totalInvestmentWithGrossPerformanceFromSell =
+        totalInvestmentWithGrossPerformanceFromSell
+          .plus(transactionInvestment)
+          .plus(grossPerformanceFromSell);
+
+      lastAveragePrice = totalUnits.eq(0)
+        ? new Big(0)
+        : totalInvestmentWithGrossPerformanceFromSell.div(totalUnits);
+
+      const newGrossPerformance = valueOfInvestment
+        .minus(totalInvestmentWithGrossPerformanceFromSell)
+        .plus(grossPerformanceFromSells);
+
+      if (
+        i > indexOfStartOrder &&
+        !lastValueOfInvestmentBeforeTransaction
+          .plus(lastTransactionInvestment)
+          .eq(0)
+      ) {
+        const grossHoldingPeriodReturn = valueOfInvestmentBeforeTransaction
+          .minus(
+            lastValueOfInvestmentBeforeTransaction.plus(
+              lastTransactionInvestment
+            )
+          )
+          .div(
+            lastValueOfInvestmentBeforeTransaction.plus(
+              lastTransactionInvestment
+            )
+          );
+
+        timeWeightedGrossPerformancePercentage =
+          timeWeightedGrossPerformancePercentage.mul(
+            new Big(1).plus(grossHoldingPeriodReturn)
+          );
+
+        const netHoldingPeriodReturn = valueOfInvestmentBeforeTransaction
+          .minus(fees.minus(feesAtStartDate))
+          .minus(
+            lastValueOfInvestmentBeforeTransaction.plus(
+              lastTransactionInvestment
+            )
+          )
+          .div(
+            lastValueOfInvestmentBeforeTransaction.plus(
+              lastTransactionInvestment
+            )
+          );
+
+        timeWeightedNetPerformancePercentage =
+          timeWeightedNetPerformancePercentage.mul(
+            new Big(1).plus(netHoldingPeriodReturn)
+          );
+      }
+
+      grossPerformance = newGrossPerformance;
+
+      lastTransactionInvestment = transactionInvestment;
+
+      lastValueOfInvestmentBeforeTransaction =
+        valueOfInvestmentBeforeTransaction;
+
+      if (order.itemType === 'start') {
+        feesAtStartDate = fees;
+        grossPerformanceAtStartDate = grossPerformance;
+      }
+    }
+
+    timeWeightedGrossPerformancePercentage =
+      timeWeightedGrossPerformancePercentage.minus(1);
+
+    timeWeightedNetPerformancePercentage =
+      timeWeightedNetPerformancePercentage.minus(1);
+
+    const totalGrossPerformance = grossPerformance.minus(
+      grossPerformanceAtStartDate
+    );
+
+    const totalNetPerformance = grossPerformance
+      .minus(grossPerformanceAtStartDate)
+      .minus(fees.minus(feesAtStartDate));
+
+    const maxInvestmentBetweenStartAndEndDate = valueAtStartDate.plus(
+      maxTotalInvestment.minus(investmentAtStartDate)
+    );
+
+    const grossPerformancePercentage =
+      PortfolioCalculator.CALCULATE_PERCENTAGE_PERFORMANCE_WITH_MAX_INVESTMENT ||
+      averagePriceAtStartDate.eq(0) ||
+      averagePriceAtEndDate.eq(0) ||
+      orders[indexOfStartOrder].unitPrice.eq(0)
+        ? maxInvestmentBetweenStartAndEndDate.gt(0)
+          ? totalGrossPerformance.div(maxInvestmentBetweenStartAndEndDate)
+          : new Big(0)
+        : // This formula has the issue that buying more units with a price
+          // lower than the average buying price results in a positive
+          // performance even if the market price stays constant
+          unitPriceAtEndDate
+            .div(averagePriceAtEndDate)
+            .div(
+              orders[indexOfStartOrder].unitPrice.div(averagePriceAtStartDate)
+            )
+            .minus(1);
+
+    const feesPerUnit = totalUnits.gt(0)
+      ? fees.minus(feesAtStartDate).div(totalUnits)
+      : new Big(0);
+
+    const netPerformancePercentage =
+      PortfolioCalculator.CALCULATE_PERCENTAGE_PERFORMANCE_WITH_MAX_INVESTMENT ||
+      averagePriceAtStartDate.eq(0) ||
+      averagePriceAtEndDate.eq(0) ||
+      orders[indexOfStartOrder].unitPrice.eq(0)
+        ? maxInvestmentBetweenStartAndEndDate.gt(0)
+          ? totalNetPerformance.div(maxInvestmentBetweenStartAndEndDate)
+          : new Big(0)
+        : // This formula has the issue that buying more units with a price
+          // lower than the average buying price results in a positive
+          // performance even if the market price stays constant
+          unitPriceAtEndDate
+            .minus(feesPerUnit)
+            .div(averagePriceAtEndDate)
+            .div(
+              orders[indexOfStartOrder].unitPrice.div(averagePriceAtStartDate)
+            )
+            .minus(1);
+
+    if (PortfolioCalculator.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,
--- a/apps/api/src/app/portfolio/portfolio-service.strategy.ts
+++ b/apps/api/src/app/portfolio/portfolio-service.strategy.ts
@ -1,25 +0,0 @@
-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;
-  }
-}
--- a/apps/api/src/app/portfolio/portfolio.controller.ts
+++ b/apps/api/src/app/portfolio/portfolio.controller.ts
@ -4,22 +4,23 @@ import {
  hasNotDefinedValuesInObject,
  nullifyValuesInObject
 } from '@ghostfolio/api/helper/object.helper';
+import { RedactValuesInResponseInterceptor } from '@ghostfolio/api/interceptors/redact-values-in-response.interceptor';
 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 {
+  Filter,
  PortfolioChart,
  PortfolioDetails,
  PortfolioInvestments,
-  PortfolioPerformance,
+  PortfolioPerformanceResponse,
  PortfolioPublicDetails,
  PortfolioReport,
  PortfolioSummary
 } from '@ghostfolio/common/interfaces';
-import type { RequestWithUser } from '@ghostfolio/common/types';
+import type { DateRange, RequestWithUser } from '@ghostfolio/common/types';
 import {
  Controller,
  Get,
@ -33,22 +34,27 @@ import {
 } from '@nestjs/common';
 import { REQUEST } from '@nestjs/core';
 import { AuthGuard } from '@nestjs/passport';
+import { ViewMode } from '@prisma/client';
 import { StatusCodes, getReasonPhrase } from 'http-status-codes';

 import { PortfolioPositionDetail } from './interfaces/portfolio-position-detail.interface';
 import { PortfolioPositions } from './interfaces/portfolio-positions.interface';
-import { PortfolioServiceStrategy } from './portfolio-service.strategy';
+import { PortfolioService } from './portfolio.service';

@Controller('portfolio')
 export class PortfolioController {
+  private baseCurrency: string;
+
  public constructor(
    private readonly accessService: AccessService,
    private readonly configurationService: ConfigurationService,
    private readonly exchangeRateDataService: ExchangeRateDataService,
-    private readonly portfolioServiceStrategy: PortfolioServiceStrategy,
+    private readonly portfolioService: PortfolioService,
    @Inject(REQUEST) private readonly request: RequestWithUser,
    private readonly userService: UserService
-  ) {}
+  ) {
+    this.baseCurrency = this.configurationService.get('BASE_CURRENCY');
+  }

  @Get('chart')
  @UseGuards(AuthGuard('jwt'))
@ -56,9 +62,10 @@ export class PortfolioController {
    @Headers('impersonation-id') impersonationId: string,
    @Query('range') range
  ): Promise<PortfolioChart> {
-    const historicalDataContainer = await this.portfolioServiceStrategy
-      .get()
-      .getChart(impersonationId, range);
+    const historicalDataContainer = await this.portfolioService.getChart(
+      impersonationId,
+      range
+    );

    let chartData = historicalDataContainer.items;

@ -100,27 +107,49 @@ export class PortfolioController {

  @Get('details')
  @UseGuards(AuthGuard('jwt'))
+  @UseInterceptors(RedactValuesInResponseInterceptor)
  @UseInterceptors(TransformDataSourceInResponseInterceptor)
  public async getDetails(
    @Headers('impersonation-id') impersonationId: string,
-    @Query('range') range
+    @Query('accounts') filterByAccounts?: string,
+    @Query('assetClasses') filterByAssetClasses?: string,
+    @Query('range') range?: DateRange,
+    @Query('tags') filterByTags?: string
  ): Promise<PortfolioDetails & { hasError: boolean }> {
-    if (
-      this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION') &&
-      this.request.user.subscription.type === 'Basic'
-    ) {
-      throw new HttpException(
-        getReasonPhrase(StatusCodes.FORBIDDEN),
-        StatusCodes.FORBIDDEN
-      );
-    }
-
    let hasError = false;

+    const accountIds = filterByAccounts?.split(',') ?? [];
+    const assetClasses = filterByAssetClasses?.split(',') ?? [];
+    const tagIds = filterByTags?.split(',') ?? [];
+
+    const filters: Filter[] = [
+      ...accountIds.map((accountId) => {
+        return <Filter>{
+          id: accountId,
+          type: 'ACCOUNT'
+        };
+      }),
+      ...assetClasses.map((assetClass) => {
+        return <Filter>{
+          id: assetClass,
+          type: 'ASSET_CLASS'
+        };
+      }),
+      ...tagIds.map((tagId) => {
+        return <Filter>{
+          id: tagId,
+          type: 'TAG'
+        };
+      })
+    ];
+
    const { accounts, holdings, hasErrors } =
-      await this.portfolioServiceStrategy
-        .get()
-        .getDetails(impersonationId, this.request.user.id, range);
+      await this.portfolioService.getDetails(
+        impersonationId,
+        this.request.user.id,
+        range,
+        filters
+      );

    if (hasErrors || hasNotDefinedValuesInObject(holdings)) {
      hasError = true;
@ -161,7 +190,15 @@ export class PortfolioController {
      }
    }

-    return { accounts, hasError, holdings };
+    const isBasicUser =
+      this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION') &&
+      this.request.user.subscription.type === 'Basic';
+
+    return {
+      accounts,
+      hasError,
+      holdings: isBasicUser ? {} : holdings
+    };
  }

  @Get('investments')
@ -179,9 +216,9 @@ export class PortfolioController {
      );
    }

-    let investments = await this.portfolioServiceStrategy
-      .get()
-      .getInvestments(impersonationId);
+    let investments = await this.portfolioService.getInvestments(
+      impersonationId
+    );

    if (
      impersonationId ||
@ -203,16 +240,19 @@ export class PortfolioController {

  @Get('performance')
  @UseGuards(AuthGuard('jwt'))
+  @UseInterceptors(TransformDataSourceInResponseInterceptor)
  public async getPerformance(
    @Headers('impersonation-id') impersonationId: string,
    @Query('range') range
-  ): Promise<{ hasErrors: boolean; performance: PortfolioPerformance }> {
-    const performanceInformation = await this.portfolioServiceStrategy
-      .get()
-      .getPerformance(impersonationId, range);
+  ): Promise<PortfolioPerformanceResponse> {
+    const performanceInformation = await this.portfolioService.getPerformance(
+      impersonationId,
+      range
+    );

    if (
      impersonationId ||
+      this.request.user.Settings.viewMode === ViewMode.ZEN ||
      this.userService.isRestrictedView(this.request.user)
    ) {
      performanceInformation.performance = nullifyValuesInObject(
@ -231,9 +271,10 @@ export class PortfolioController {
    @Headers('impersonation-id') impersonationId: string,
    @Query('range') range
  ): Promise<PortfolioPositions> {
-    const result = await this.portfolioServiceStrategy
-      .get()
-      .getPositions(impersonationId, range);
+    const result = await this.portfolioService.getPositions(
+      impersonationId,
+      range
+    );

    if (
      impersonationId ||
@ -273,9 +314,12 @@ export class PortfolioController {
      hasDetails = user.subscription.type === 'Premium';
    }

-    const { holdings } = await this.portfolioServiceStrategy
-      .get()
-      .getDetails(access.userId, access.userId);
+    const { holdings } = await this.portfolioService.getDetails(
+      access.userId,
+      access.userId,
+      'max',
+      [{ id: 'EQUITY', type: 'ASSET_CLASS' }]
+    );

    const portfolioPublicDetails: PortfolioPublicDetails = {
      hasDetails,
@ -283,29 +327,28 @@ export class PortfolioController {
    };

    const totalValue = Object.values(holdings)
-      .filter((holding) => {
-        return holding.assetClass === 'EQUITY';
-      })
      .map((portfolioPosition) => {
        return this.exchangeRateDataService.toCurrency(
          portfolioPosition.quantity * portfolioPosition.marketPrice,
          portfolioPosition.currency,
-          this.request.user?.Settings?.currency ?? baseCurrency
+          this.request.user?.Settings?.currency ?? this.baseCurrency
        );
      })
      .reduce((a, b) => a + b, 0);

    for (const [symbol, portfolioPosition] of Object.entries(holdings)) {
-      if (portfolioPosition.assetClass === 'EQUITY') {
-        portfolioPublicDetails.holdings[symbol] = {
-          allocationCurrent: portfolioPosition.allocationCurrent,
-          countries: hasDetails ? portfolioPosition.countries : [],
-          currency: portfolioPosition.currency,
-          name: portfolioPosition.name,
-          sectors: hasDetails ? portfolioPosition.sectors : [],
-          value: portfolioPosition.value / totalValue
-        };
-      }
+      portfolioPublicDetails.holdings[symbol] = {
+        allocationCurrent: portfolioPosition.value / totalValue,
+        countries: hasDetails ? portfolioPosition.countries : [],
+        currency: portfolioPosition.currency,
+        markets: portfolioPosition.markets,
+        name: portfolioPosition.name,
+        netPerformancePercent: portfolioPosition.netPerformancePercent,
+        sectors: hasDetails ? portfolioPosition.sectors : [],
+        symbol: portfolioPosition.symbol,
+        url: portfolioPosition.url,
+        value: portfolioPosition.value / totalValue
+      };
    }

    return portfolioPublicDetails;
@ -316,9 +359,17 @@ export class PortfolioController {
  public async getSummary(
    @Headers('impersonation-id') impersonationId
  ): Promise<PortfolioSummary> {
-    let summary = await this.portfolioServiceStrategy
-      .get()
-      .getSummary(impersonationId);
+    if (
+      this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION') &&
+      this.request.user.subscription.type === 'Basic'
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    let summary = await this.portfolioService.getSummary(impersonationId);

    if (
      impersonationId ||
@ -331,7 +382,9 @@ export class PortfolioController {
        'currentNetPerformance',
        'currentValue',
        'dividend',
+        'emergencyFund',
        'fees',
+        'items',
        'netWorth',
        'totalBuy',
        'totalSell'
@ -343,15 +396,18 @@ export class PortfolioController {

  @Get('position/:dataSource/:symbol')
  @UseInterceptors(TransformDataSourceInRequestInterceptor)
+  @UseInterceptors(TransformDataSourceInResponseInterceptor)
  @UseGuards(AuthGuard('jwt'))
  public async getPosition(
    @Headers('impersonation-id') impersonationId: string,
    @Param('dataSource') dataSource,
    @Param('symbol') symbol
  ): Promise<PortfolioPositionDetail> {
-    let position = await this.portfolioServiceStrategy
-      .get()
-      .getPosition(dataSource, impersonationId, symbol);
+    let position = await this.portfolioService.getPosition(
+      dataSource,
+      impersonationId,
+      symbol
+    );

    if (position) {
      if (
@ -392,6 +448,6 @@ export class PortfolioController {
      );
    }

-    return await this.portfolioServiceStrategy.get().getReport(impersonationId);
+    return await this.portfolioService.getReport(impersonationId);
  }
 }
--- a/apps/api/src/app/portfolio/portfolio.module.ts
+++ b/apps/api/src/app/portfolio/portfolio.module.ts
@ -13,14 +13,13 @@ import { SymbolProfileModule } from '@ghostfolio/api/services/symbol-profile.mod
 import { Module } from '@nestjs/common';

 import { CurrentRateService } from './current-rate.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({
-  exports: [PortfolioServiceStrategy],
+  controllers: [PortfolioController],
+  exports: [PortfolioService],
  imports: [
    AccessModule,
    ConfigurationModule,
@ -34,13 +33,10 @@ import { RulesService } from './rules.service';
    SymbolProfileModule,
    UserModule
  ],
-  controllers: [PortfolioController],
  providers: [
    AccountService,
    CurrentRateService,
    PortfolioService,
-    PortfolioServiceNew,
-    PortfolioServiceStrategy,
    RulesService
  ]
 })
--- a/apps/api/src/app/portfolio/portfolio.service-new.ts
+++ b/apps/api/src/app/portfolio/portfolio.service-new.ts
--- a/apps/api/src/app/portfolio/portfolio.service.ts
+++ b/apps/api/src/app/portfolio/portfolio.service.ts
--- a/apps/api/src/app/redis-cache/redis-cache.module.ts
+++ b/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';
@ -13,13 +14,15 @@ import { RedisCacheService } from './redis-cache.service';
      useFactory: async (configurationService: ConfigurationService) => ({
        host: configurationService.get('REDIS_HOST'),
        max: configurationService.get('MAX_ITEM_IN_CACHE'),
+        password: configurationService.get('REDIS_PASSWORD'),
        port: configurationService.get('REDIS_PORT'),
        store: redisStore,
        ttl: configurationService.get('CACHE_TTL')
      })
-    })
+    }),
+    ConfigurationModule
  ],
-  providers: [ConfigurationService, RedisCacheService],
+  providers: [RedisCacheService],
  exports: [RedisCacheService]
 })
 export class RedisCacheModule {}
--- a/apps/api/src/app/subscription/subscription.controller.ts
+++ b/apps/api/src/app/subscription/subscription.controller.ts
@ -46,22 +46,25 @@ export class SubscriptionController {
      ((await this.propertyService.getByKey(PROPERTY_COUPONS)) as Coupon[]) ??
      [];

-    const isValid = coupons.some((coupon) => {
-      return coupon.code === couponCode;
+    const coupon = coupons.find((currentCoupon) => {
+      return currentCoupon.code === couponCode;
    });

-    if (!isValid) {
+    if (coupon === undefined) {
      throw new HttpException(
        getReasonPhrase(StatusCodes.BAD_REQUEST),
        StatusCodes.BAD_REQUEST
      );
    }

-    await this.subscriptionService.createSubscription(this.request.user.id);
+    await this.subscriptionService.createSubscription({
+      duration: coupon.duration,
+      userId: this.request.user.id
+    });

    // Destroy coupon
-    coupons = coupons.filter((coupon) => {
-      return coupon.code !== couponCode;
+    coupons = coupons.filter((currentCoupon) => {
+      return currentCoupon.code !== couponCode;
    });
    await this.propertyService.put({
      key: PROPERTY_COUPONS,
@ -69,7 +72,8 @@ export class SubscriptionController {
    });

    Logger.log(
-      `Subscription for user '${this.request.user.id}' has been created with coupon`
+      `Subscription for user '${this.request.user.id}' has been created with a coupon for ${coupon.duration}`,
+      'SubscriptionController'
    );

    return {
@ -84,7 +88,10 @@ export class SubscriptionController {
      req.query.checkoutSessionId
    );

-    Logger.log(`Subscription for user '${userId}' has been created via Stripe`);
+    Logger.log(
+      `Subscription for user '${userId}' has been created via Stripe`,
+      'SubscriptionController'
+    );

    res.redirect(`${this.configurationService.get('ROOT_URL')}/account`);
  }
@ -101,7 +108,7 @@ export class SubscriptionController {
        userId: this.request.user.id
      });
    } catch (error) {
-      Logger.error(error);
+      Logger.error(error, 'SubscriptionController');

      throw new HttpException(
        getReasonPhrase(StatusCodes.BAD_REQUEST),
--- a/apps/api/src/app/subscription/subscription.module.ts
+++ b/apps/api/src/app/subscription/subscription.module.ts
@ -1,5 +1,5 @@
-import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
-import { PrismaService } from '@ghostfolio/api/services/prisma.service';
+import { ConfigurationModule } from '@ghostfolio/api/services/configuration.module';
+import { PrismaModule } from '@ghostfolio/api/services/prisma.module';
 import { PropertyModule } from '@ghostfolio/api/services/property/property.module';
 import { Module } from '@nestjs/common';

@ -7,9 +7,9 @@ import { SubscriptionController } from './subscription.controller';
 import { SubscriptionService } from './subscription.service';

@Module({
-  imports: [PropertyModule],
  controllers: [SubscriptionController],
-  providers: [ConfigurationService, PrismaService, SubscriptionService],
-  exports: [SubscriptionService]
+  exports: [SubscriptionService],
+  imports: [ConfigurationModule, PrismaModule, PropertyModule],
+  providers: [SubscriptionService]
 })
 export class SubscriptionModule {}
--- a/apps/api/src/app/subscription/subscription.service.ts
+++ b/apps/api/src/app/subscription/subscription.service.ts
@ -2,8 +2,9 @@ import { ConfigurationService } from '@ghostfolio/api/services/configuration.ser
 import { PrismaService } from '@ghostfolio/api/services/prisma.service';
 import { SubscriptionType } from '@ghostfolio/common/types/subscription.type';
 import { Injectable, Logger } from '@nestjs/common';
-import { Subscription, User } from '@prisma/client';
-import { addDays, isBefore } from 'date-fns';
+import { Subscription } from '@prisma/client';
+import { addMilliseconds, isBefore } from 'date-fns';
+import ms, { StringValue } from 'ms';
 import Stripe from 'stripe';

@Injectable()
@ -44,7 +45,7 @@ export class SubscriptionService {
      payment_method_types: ['card'],
      success_url: `${this.configurationService.get(
        'ROOT_URL'
-      )}/api/subscription/stripe/callback?checkoutSessionId={CHECKOUT_SESSION_ID}`
+      )}/api/v1/subscription/stripe/callback?checkoutSessionId={CHECKOUT_SESSION_ID}`
    };

    if (couponId) {
@ -64,13 +65,19 @@ export class SubscriptionService {
    };
  }

-  public async createSubscription(aUserId: string) {
+  public async createSubscription({
+    duration = '1 year',
+    userId
+  }: {
+    duration?: StringValue;
+    userId: string;
+  }) {
    await this.prismaService.subscription.create({
      data: {
-        expiresAt: addDays(new Date(), 365),
+        expiresAt: addMilliseconds(new Date(), ms(duration)),
        User: {
          connect: {
-            id: aUserId
+            id: userId
          }
        }
      }
@ -83,7 +90,7 @@ export class SubscriptionService {
        aCheckoutSessionId
      );

-      await this.createSubscription(session.client_reference_id);
+      await this.createSubscription({ userId: session.client_reference_id });

      await this.stripe.customers.update(session.customer as string, {
        description: session.client_reference_id
@ -91,7 +98,7 @@ export class SubscriptionService {

      return session.client_reference_id;
    } catch (error) {
-      Logger.error(error);
+      Logger.error(error, 'SubscriptionService');
    }
  }

--- a/apps/api/src/app/symbol/interfaces/symbol-item.interface.ts
+++ b/apps/api/src/app/symbol/interfaces/symbol-item.interface.ts
@ -1,9 +1,7 @@
-import { HistoricalDataItem } from '@ghostfolio/api/app/portfolio/interfaces/portfolio-position-detail.interface';
-import { DataSource } from '@prisma/client';
+import { HistoricalDataItem, UniqueAsset } from '@ghostfolio/common/interfaces';

-export interface SymbolItem {
+export interface SymbolItem extends UniqueAsset {
  currency: string;
-  dataSource: DataSource;
  historicalData: HistoricalDataItem[];
  marketPrice: number;
 }
--- a/apps/api/src/app/symbol/symbol.module.ts
+++ b/apps/api/src/app/symbol/symbol.module.ts
@ -8,13 +8,14 @@ import { SymbolController } from './symbol.controller';
 import { SymbolService } from './symbol.service';

@Module({
+  controllers: [SymbolController],
+  exports: [SymbolService],
  imports: [
    ConfigurationModule,
    DataProviderModule,
    MarketDataModule,
    PrismaModule
  ],
-  controllers: [SymbolController],
  providers: [SymbolService]
 })
 export class SymbolModule {}
--- a/apps/api/src/app/symbol/symbol.service.ts
+++ b/apps/api/src/app/symbol/symbol.service.ts
@ -1,4 +1,3 @@
-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,
@ -6,6 +5,7 @@ import {
 } from '@ghostfolio/api/services/interfaces/interfaces';
 import { MarketDataService } from '@ghostfolio/api/services/market-data.service';
 import { DATE_FORMAT } from '@ghostfolio/common/helper';
+import { HistoricalDataItem } from '@ghostfolio/common/interfaces';
 import { Injectable, Logger } from '@nestjs/common';
 import { DataSource } from '@prisma/client';
 import { format, subDays } from 'date-fns';
@ -27,8 +27,10 @@ export class SymbolService {
    dataGatheringItem: IDataGatheringItem;
    includeHistoricalData?: number;
  }): Promise<SymbolItem> {
-    const response = await this.dataProviderService.get([dataGatheringItem]);
-    const { currency, marketPrice } = response[dataGatheringItem.symbol] ?? {};
+    const quotes = await this.dataProviderService.getQuotes([
+      dataGatheringItem
+    ]);
+    const { currency, marketPrice } = quotes[dataGatheringItem.symbol] ?? {};

    if (dataGatheringItem.dataSource && marketPrice) {
      let historicalData: HistoricalDataItem[] = [];
@ -53,7 +55,8 @@ export class SymbolService {
        currency,
        historicalData,
        marketPrice,
-        dataSource: dataGatheringItem.dataSource
+        dataSource: dataGatheringItem.dataSource,
+        symbol: dataGatheringItem.symbol
      };
    }

@ -93,7 +96,7 @@ export class SymbolService {
      results.items = items;
      return results;
    } catch (error) {
-      Logger.error(error);
+      Logger.error(error, 'SymbolService');

      throw error;
    }
--- a/apps/api/src/app/user/interfaces/access.interface.ts
+++ b/apps/api/src/app/user/interfaces/access.interface.ts
@ -1,4 +0,0 @@
-export interface Access {
-  alias?: string;
-  id: string;
-}
--- a/apps/api/src/app/user/interfaces/user-settings.interface.ts
+++ b/apps/api/src/app/user/interfaces/user-settings.interface.ts
@ -1,3 +1,5 @@
 export interface UserSettings {
+  emergencyFund?: number;
+  locale?: string;
  isRestrictedView?: boolean;
 }
--- a/apps/api/src/app/user/update-user-setting.dto.ts
+++ b/apps/api/src/app/user/update-user-setting.dto.ts
@ -1,11 +1,19 @@
-import { IsBoolean, IsOptional } from 'class-validator';
+import { IsBoolean, IsNumber, IsOptional, IsString } from 'class-validator';

 export class UpdateUserSettingDto {
-  @IsBoolean()
+  @IsNumber()
  @IsOptional()
-  isNewCalculationEngine?: boolean;
+  emergencyFund?: number;

  @IsBoolean()
  @IsOptional()
  isRestrictedView?: boolean;
+
+  @IsString()
+  @IsOptional()
+  locale?: string;
+
+  @IsNumber()
+  @IsOptional()
+  savingsRate?: number;
 }
--- a/apps/api/src/app/user/user.controller.ts
+++ b/apps/api/src/app/user/user.controller.ts
@ -2,17 +2,14 @@ import { ConfigurationService } from '@ghostfolio/api/services/configuration.ser
 import { PropertyService } from '@ghostfolio/api/services/property/property.service';
 import { PROPERTY_IS_READ_ONLY_MODE } from '@ghostfolio/common/config';
 import { User } from '@ghostfolio/common/interfaces';
-import {
-  hasPermission,
-  hasRole,
-  permissions
-} from '@ghostfolio/common/permissions';
+import { hasPermission, permissions } from '@ghostfolio/common/permissions';
 import type { RequestWithUser } from '@ghostfolio/common/types';
 import {
  Body,
  Controller,
  Delete,
  Get,
+  Headers,
  HttpException,
  Inject,
  Param,
@ -23,7 +20,6 @@ import {
 import { REQUEST } from '@nestjs/core';
 import { JwtService } from '@nestjs/jwt';
 import { AuthGuard } from '@nestjs/passport';
-import { Provider, Role } from '@prisma/client';
 import { User as UserModel } from '@prisma/client';
 import { StatusCodes, getReasonPhrase } from 'http-status-codes';

@ -38,7 +34,7 @@ import { UserService } from './user.service';
 export class UserController {
  public constructor(
    private readonly configurationService: ConfigurationService,
-    private jwtService: JwtService,
+    private readonly jwtService: JwtService,
    private readonly propertyService: PropertyService,
    @Inject(REQUEST) private readonly request: RequestWithUser,
    private readonly userService: UserService
@ -64,8 +60,13 @@ export class UserController {

  @Get()
  @UseGuards(AuthGuard('jwt'))
-  public async getUser(@Param('id') id: string): Promise<User> {
-    return this.userService.getUser(this.request.user);
+  public async getUser(
+    @Headers('accept-language') acceptLanguage: string
+  ): Promise<User> {
+    return this.userService.getUser(
+      this.request.user,
+      acceptLanguage?.split(',')?.[0]
+    );
  }

  @Post()
@ -119,7 +120,7 @@ export class UserController {
    };

    for (const key in userSettings) {
-      if (userSettings[key] === false) {
+      if (userSettings[key] === false || userSettings[key] === null) {
        delete userSettings[key];
      }
    }
--- a/apps/api/src/app/user/user.module.ts
+++ b/apps/api/src/app/user/user.module.ts
@ -1,7 +1,8 @@
 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 { TagModule } from '@ghostfolio/api/services/tag/tag.module';
 import { Module } from '@nestjs/common';
 import { JwtModule } from '@nestjs/jwt';

@ -9,16 +10,19 @@ 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
+    SubscriptionModule,
+    TagModule
  ],
-  controllers: [UserController],
-  providers: [ConfigurationService, PrismaService, UserService],
-  exports: [UserService]
+  providers: [UserService]
 })
 export class UserModule {}
--- a/apps/api/src/app/user/user.service.ts
+++ b/apps/api/src/app/user/user.service.ts
@ -2,20 +2,17 @@ import { SubscriptionService } from '@ghostfolio/api/app/subscription/subscripti
 import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
 import { PrismaService } from '@ghostfolio/api/services/prisma.service';
 import { PropertyService } from '@ghostfolio/api/services/property/property.service';
-import {
-  PROPERTY_IS_READ_ONLY_MODE,
-  baseCurrency,
-  locale
-} from '@ghostfolio/common/config';
+import { TagService } from '@ghostfolio/api/services/tag/tag.service';
+import { PROPERTY_IS_READ_ONLY_MODE, locale } from '@ghostfolio/common/config';
 import { User as IUser, UserWithSettings } from '@ghostfolio/common/interfaces';
 import {
  getPermissions,
  hasRole,
  permissions
 } from '@ghostfolio/common/permissions';
-import { SubscriptionType } from '@ghostfolio/common/types/subscription.type';
 import { Injectable } from '@nestjs/common';
-import { Prisma, Provider, Role, User, ViewMode } from '@prisma/client';
+import { Prisma, Role, User, ViewMode } from '@prisma/client';
+import { sortBy } from 'lodash';

 import { UserSettingsParams } from './interfaces/user-settings-params.interface';
 import { UserSettings } from './interfaces/user-settings.interface';
@ -26,21 +23,29 @@ const crypto = require('crypto');
 export class UserService {
  public static DEFAULT_CURRENCY = 'USD';

+  private baseCurrency: string;
+
  public constructor(
    private readonly configurationService: ConfigurationService,
    private readonly prismaService: PrismaService,
    private readonly propertyService: PropertyService,
-    private readonly subscriptionService: SubscriptionService
-  ) {}
+    private readonly subscriptionService: SubscriptionService,
+    private readonly tagService: TagService
+  ) {
+    this.baseCurrency = this.configurationService.get('BASE_CURRENCY');
+  }

-  public async getUser({
-    Account,
-    alias,
-    id,
-    permissions,
-    Settings,
-    subscription
-  }: UserWithSettings): Promise<IUser> {
+  public async getUser(
+    {
+      Account,
+      alias,
+      id,
+      permissions,
+      Settings,
+      subscription
+    }: UserWithSettings,
+    aLocale = locale
+  ): Promise<IUser> {
    const access = await this.prismaService.access.findMany({
      include: {
        User: true
@ -48,12 +53,21 @@ export class UserService {
      orderBy: { User: { alias: 'asc' } },
      where: { GranteeUser: { id } }
    });
+    let tags = await this.tagService.getByUser(id);
+
+    if (
+      this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION') &&
+      subscription.type === 'Basic'
+    ) {
+      tags = [];
+    }

    return {
      alias,
      id,
      permissions,
      subscription,
+      tags,
      access: access.map((accessItem) => {
        return {
          alias: accessItem.User.alias,
@ -63,8 +77,8 @@ export class UserService {
      accounts: Account,
      settings: {
        ...(<UserSettings>Settings.settings),
-        locale,
        baseCurrency: Settings?.currency ?? UserService.DEFAULT_CURRENCY,
+        locale: (<UserSettings>Settings.settings)?.locale ?? aLocale,
        viewMode: Settings?.viewMode ?? ViewMode.DEFAULT
      }
    };
@ -89,19 +103,69 @@ export class UserService {
  public async user(
    userWhereUniqueInput: Prisma.UserWhereUniqueInput
  ): Promise<UserWithSettings | null> {
-    const userFromDatabase = await this.prismaService.user.findUnique({
+    const {
+      accessToken,
+      Account,
+      alias,
+      authChallenge,
+      createdAt,
+      id,
+      provider,
+      role,
+      Settings,
+      Subscription,
+      thirdPartyId,
+      updatedAt
+    } = await this.prismaService.user.findUnique({
      include: { Account: true, Settings: true, Subscription: true },
      where: userWhereUniqueInput
    });

-    const user: UserWithSettings = userFromDatabase;
+    const user: UserWithSettings = {
+      accessToken,
+      Account,
+      alias,
+      authChallenge,
+      createdAt,
+      id,
+      provider,
+      role,
+      Settings,
+      thirdPartyId,
+      updatedAt
+    };

-    let currentPermissions = getPermissions(userFromDatabase.role);
+    if (user?.Settings) {
+      if (!user.Settings.currency) {
+        // Set default currency if needed
+        user.Settings.currency = UserService.DEFAULT_CURRENCY;
+      }
+    } else if (user) {
+      // Set default settings if needed
+      user.Settings = {
+        currency: UserService.DEFAULT_CURRENCY,
+        settings: null,
+        updatedAt: new Date(),
+        userId: user?.id,
+        viewMode: ViewMode.DEFAULT
+      };
+    }
+
+    if (this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION')) {
+      user.subscription =
+        this.subscriptionService.getSubscription(Subscription);
+    }
+
+    let currentPermissions = getPermissions(user.role);

    if (this.configurationService.get('ENABLE_FEATURE_FEAR_AND_GREED_INDEX')) {
      currentPermissions.push(permissions.accessFearAndGreedIndex);
    }

+    if (user.subscription?.type === 'Premium') {
+      currentPermissions.push(permissions.reportDataGlitch);
+    }
+
    if (this.configurationService.get('ENABLE_FEATURE_READ_ONLY_MODE')) {
      if (hasRole(user, Role.ADMIN)) {
        currentPermissions.push(permissions.toggleReadOnlyMode);
@ -122,36 +186,10 @@ export class UserService {
      }
    }

-    user.permissions = currentPermissions;
-
-    if (userFromDatabase?.Settings) {
-      if (!userFromDatabase.Settings.currency) {
-        // Set default currency if needed
-        userFromDatabase.Settings.currency = UserService.DEFAULT_CURRENCY;
-      }
-    } else if (userFromDatabase) {
-      // Set default settings if needed
-      userFromDatabase.Settings = {
-        currency: UserService.DEFAULT_CURRENCY,
-        settings: null,
-        updatedAt: new Date(),
-        userId: userFromDatabase?.id,
-        viewMode: ViewMode.DEFAULT
-      };
-    }
-
-    if (this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION')) {
-      user.subscription = this.subscriptionService.getSubscription(
-        userFromDatabase?.Subscription
-      );
-
-      if (user.subscription.type === SubscriptionType.Basic) {
-        user.permissions = user.permissions.filter((permission) => {
-          return permission !== permissions.updateViewMode;
-        });
-        user.Settings.viewMode = ViewMode.ZEN;
-      }
-    }
+    user.Account = sortBy(user.Account, (account) => {
+      return account.name;
+    });
+    user.permissions = currentPermissions.sort();

    return user;
  }
@ -190,14 +228,14 @@ export class UserService {
        ...data,
        Account: {
          create: {
-            currency: baseCurrency,
+            currency: this.baseCurrency,
            isDefault: true,
            name: 'Default Account'
          }
        },
        Settings: {
          create: {
-            currency: baseCurrency
+            currency: this.baseCurrency
          }
        }
      }
--- a/apps/api/src/assets/.gitkeep
+++ b/apps/api/src/assets/.gitkeep
--- a/apps/api/src/assets/countries/developed-markets.json
+++ b/apps/api/src/assets/countries/developed-markets.json
@ -0,0 +1,26 @@
+[
+  "AT",
+  "AU",
+  "BE",
+  "CA",
+  "CH",
+  "DE",
+  "DK",
+  "ES",
+  "FI",
+  "FR",
+  "GB",
+  "HK",
+  "IE",
+  "IL",
+  "IT",
+  "JP",
+  "LU",
+  "NL",
+  "NO",
+  "NZ",
+  "PT",
+  "SE",
+  "SG",
+  "US"
+]
--- a/apps/api/src/assets/countries/emerging-markets.json
+++ b/apps/api/src/assets/countries/emerging-markets.json
@ -0,0 +1,28 @@
+[
+  "AE",
+  "BR",
+  "CL",
+  "CN",
+  "CO",
+  "CY",
+  "CZ",
+  "EG",
+  "GR",
+  "HK",
+  "HU",
+  "ID",
+  "IN",
+  "KR",
+  "KW",
+  "MX",
+  "MY",
+  "PE",
+  "PH",
+  "PL",
+  "QA",
+  "SA",
+  "TH",
+  "TR",
+  "TW",
+  "ZA"
+]
--- a/apps/api/src/assets/cryptocurrencies/cryptocurrencies.json
+++ b/apps/api/src/assets/cryptocurrencies/cryptocurrencies.json
--- a/apps/api/src/assets/cryptocurrencies/custom.json
+++ b/apps/api/src/assets/cryptocurrencies/custom.json
@ -0,0 +1,4 @@
+{
+  "LUNA1": "Terra",
+  "UNI1": "Uniswap"
+}
--- a/apps/api/src/interceptors/redact-values-in-response.interceptor.ts
+++ b/apps/api/src/interceptors/redact-values-in-response.interceptor.ts
@ -0,0 +1,50 @@
+import { Activity } from '@ghostfolio/api/app/order/interfaces/activities.interface';
+import {
+  CallHandler,
+  ExecutionContext,
+  Injectable,
+  NestInterceptor
+} from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+
+@Injectable()
+export class RedactValuesInResponseInterceptor<T>
+  implements NestInterceptor<T, any>
+{
+  public constructor() {}
+
+  public intercept(
+    context: ExecutionContext,
+    next: CallHandler<T>
+  ): Observable<any> {
+    return next.handle().pipe(
+      map((data: any) => {
+        const request = context.switchToHttp().getRequest();
+        const hasImpersonationId = !!request.headers?.['impersonation-id'];
+
+        if (hasImpersonationId) {
+          if (data.accounts) {
+            for (const accountId of Object.keys(data.accounts)) {
+              if (data.accounts[accountId]?.balance !== undefined) {
+                data.accounts[accountId].balance = null;
+              }
+            }
+          }
+
+          if (data.activities) {
+            data.activities = data.activities.map((activity: Activity) => {
+              if (activity.Account?.balance !== undefined) {
+                activity.Account.balance = null;
+              }
+
+              return activity;
+            });
+          }
+        }
+
+        return data;
+      })
+    );
+  }
+}
--- a/apps/api/src/interceptors/transform-data-source-in-response.interceptor.ts
+++ b/apps/api/src/interceptors/transform-data-source-in-response.interceptor.ts
@ -32,7 +32,6 @@ export class TransformDataSourceInResponseInterceptor<T>
              activity.SymbolProfile.dataSource = encodeDataSource(
                activity.SymbolProfile.dataSource
              );
-              activity.dataSource = encodeDataSource(activity.dataSource);
              return activity;
            });
          }
@ -41,6 +40,14 @@ export class TransformDataSourceInResponseInterceptor<T>
            data.dataSource = encodeDataSource(data.dataSource);
          }

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

        return data;
--- a/apps/api/src/main.ts
+++ b/apps/api/src/main.ts
@ -1,4 +1,4 @@
-import { Logger, ValidationPipe } from '@nestjs/common';
+import { Logger, ValidationPipe, VersioningType } from '@nestjs/common';
 import { NestFactory } from '@nestjs/core';

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

+  const host = process.env.HOST || '0.0.0.0';
  const port = process.env.PORT || 3333;
-  await app.listen(port, () => {
+  await app.listen(port, host, () => {
    logLogo();
-    Logger.log(`Listening at http://localhost:${port}`);
+    Logger.log(`Listening at http://${host}:${port}`);
    Logger.log('');
  });
 }
--- a/apps/api/src/models/rules/account-cluster-risk/initial-investment.ts
+++ b/apps/api/src/models/rules/account-cluster-risk/initial-investment.ts
@ -1,10 +1,10 @@
 import { RuleSettings } from '@ghostfolio/api/models/interfaces/rule-settings.interface';
 import { UserSettings } from '@ghostfolio/api/models/interfaces/user-settings.interface';
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data.service';
 import {
  PortfolioDetails,
  PortfolioPosition
 } from '@ghostfolio/common/interfaces';
-import { ExchangeRateDataService } from 'apps/api/src/services/exchange-rate-data.service';

 import { Rule } from '../../rule';

--- a/apps/api/src/models/rules/account-cluster-risk/single-account.ts
+++ b/apps/api/src/models/rules/account-cluster-risk/single-account.ts
@ -1,7 +1,7 @@
 import { RuleSettings } from '@ghostfolio/api/models/interfaces/rule-settings.interface';
 import { UserSettings } from '@ghostfolio/api/models/interfaces/user-settings.interface';
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data.service';
 import { PortfolioDetails } from '@ghostfolio/common/interfaces';
-import { ExchangeRateDataService } from 'apps/api/src/services/exchange-rate-data.service';

 import { Rule } from '../../rule';

--- a/apps/api/src/models/rules/currency-cluster-risk/base-currency-initial-investment.ts
+++ b/apps/api/src/models/rules/currency-cluster-risk/base-currency-initial-investment.ts
@ -1,7 +1,7 @@
 import { CurrentPositions } from '@ghostfolio/api/app/portfolio/interfaces/current-positions.interface';
 import { RuleSettings } from '@ghostfolio/api/models/interfaces/rule-settings.interface';
 import { UserSettings } from '@ghostfolio/api/models/interfaces/user-settings.interface';
-import { ExchangeRateDataService } from 'apps/api/src/services/exchange-rate-data.service';
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data.service';

 import { Rule } from '../../rule';

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

 import { Rule } from '../../rule';

--- a/apps/api/src/models/rules/currency-cluster-risk/initial-investment.ts
+++ b/apps/api/src/models/rules/currency-cluster-risk/initial-investment.ts
@ -1,7 +1,7 @@
 import { CurrentPositions } from '@ghostfolio/api/app/portfolio/interfaces/current-positions.interface';
 import { RuleSettings } from '@ghostfolio/api/models/interfaces/rule-settings.interface';
 import { UserSettings } from '@ghostfolio/api/models/interfaces/user-settings.interface';
-import { ExchangeRateDataService } from 'apps/api/src/services/exchange-rate-data.service';
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data.service';

 import { Rule } from '../../rule';

--- a/apps/api/src/models/rules/fees/fee-ratio-initial-investment.ts
+++ b/apps/api/src/models/rules/fees/fee-ratio-initial-investment.ts
@ -1,6 +1,6 @@
 import { RuleSettings } from '@ghostfolio/api/models/interfaces/rule-settings.interface';
 import { UserSettings } from '@ghostfolio/api/models/interfaces/user-settings.interface';
-import { ExchangeRateDataService } from 'apps/api/src/services/exchange-rate-data.service';
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data.service';

 import { Rule } from '../../rule';

--- a/apps/api/src/services/configuration.service.ts
+++ b/apps/api/src/services/configuration.service.ts
@ -12,9 +12,10 @@ export class ConfigurationService {
    this.environmentConfiguration = cleanEnv(process.env, {
      ACCESS_TOKEN_SALT: str(),
      ALPHA_VANTAGE_API_KEY: str({ default: '' }),
+      BASE_CURRENCY: str({ default: 'USD' }),
      CACHE_TTL: num({ default: 1 }),
      DATA_SOURCE_PRIMARY: str({ default: DataSource.YAHOO }),
-      DATA_SOURCES: json({ default: JSON.stringify([DataSource.YAHOO]) }),
+      DATA_SOURCES: json({ default: [DataSource.YAHOO] }),
      ENABLE_FEATURE_BLOG: bool({ default: false }),
      ENABLE_FEATURE_CUSTOM_SYMBOLS: bool({ default: false }),
      ENABLE_FEATURE_FEAR_AND_GREED_INDEX: bool({ default: false }),
@ -24,21 +25,28 @@ export class ConfigurationService {
      ENABLE_FEATURE_STATISTICS: bool({ default: false }),
      ENABLE_FEATURE_SUBSCRIPTION: bool({ default: false }),
      ENABLE_FEATURE_SYSTEM_MESSAGE: bool({ default: false }),
+      EOD_HISTORICAL_DATA_API_KEY: str({ default: '' }),
      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: '' }),
+      HOST: host({ default: '0.0.0.0' }),
      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' }),
+      REDIS_HOST: host({ default: 'localhost' }),
+      REDIS_PASSWORD: str({ default: '' }),
      REDIS_PORT: port({ default: 6379 }),
      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' })
    });
  }
--- a/apps/api/src/services/cron.service.ts
+++ b/apps/api/src/services/cron.service.ts
@ -1,18 +1,24 @@
+import {
+  GATHER_ASSET_PROFILE_PROCESS,
+  GATHER_ASSET_PROFILE_PROCESS_OPTIONS
+} from '@ghostfolio/common/config';
 import { Injectable } from '@nestjs/common';
 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)
-  public async runEveryMinute() {
+  @Cron(CronExpression.EVERY_HOUR)
+  public async runEveryHour() {
    await this.dataGatheringService.gather7Days();
  }

@ -21,8 +27,24 @@ 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();
+    const uniqueAssets = await this.dataGatheringService.getUniqueAssets();
+
+    for (const { dataSource, symbol } of uniqueAssets) {
+      await this.dataGatheringService.addJobToQueue(
+        GATHER_ASSET_PROFILE_PROCESS,
+        {
+          dataSource,
+          symbol
+        },
+        GATHER_ASSET_PROFILE_PROCESS_OPTIONS
+      );
+    }
  }
 }
--- a/apps/api/src/services/cryptocurrency/cryptocurrency.service.ts
+++ b/apps/api/src/services/cryptocurrency/cryptocurrency.service.ts
@ -1,8 +1,7 @@
 import { Injectable } from '@nestjs/common';

-const cryptocurrencies = require('cryptocurrencies');
-
-const customCryptocurrencies = require('./custom-cryptocurrencies.json');
+const cryptocurrencies = require('../../assets/cryptocurrencies/cryptocurrencies.json');
+const customCryptocurrencies = require('../../assets/cryptocurrencies/custom.json');

@Injectable()
 export class CryptocurrencyService {
@ -18,7 +17,7 @@ export class CryptocurrencyService {
  private getCryptocurrencies() {
    if (!this.combinedCryptocurrencies) {
      this.combinedCryptocurrencies = [
-        ...cryptocurrencies.symbols(),
+        ...Object.keys(cryptocurrencies),
        ...Object.keys(customCryptocurrencies)
      ];
    }
--- a/apps/api/src/services/cryptocurrency/custom-cryptocurrencies.json
+++ b/apps/api/src/services/cryptocurrency/custom-cryptocurrencies.json
@ -1,12 +0,0 @@
-{
-  "1INCH": "1inch",
-  "ALGO": "Algorand",
-  "ATOM": "Cosmos",
-  "AVAX": "Avalanche",
-  "DOT": "Polkadot",
-  "MATIC": "Polygon",
-  "MINA": "Mina Protocol",
-  "SHIB": "Shiba Inu",
-  "SOL": "Solana",
-  "UNI3": "Uniswap"
-}
--- a/apps/api/src/services/data-gathering.module.ts
+++ b/apps/api/src/services/data-gathering.module.ts
@ -3,21 +3,34 @@ import { DataGatheringService } from '@ghostfolio/api/services/data-gathering.se
 import { DataEnhancerModule } from '@ghostfolio/api/services/data-provider/data-enhancer/data-enhancer.module';
 import { DataProviderModule } from '@ghostfolio/api/services/data-provider/data-provider.module';
 import { PrismaModule } from '@ghostfolio/api/services/prisma.module';
+import { DATA_GATHERING_QUEUE } from '@ghostfolio/common/config';
+import { BullModule } from '@nestjs/bull';
 import { Module } from '@nestjs/common';
+import ms from 'ms';

+import { DataGatheringProcessor } from './data-gathering.processor';
 import { ExchangeRateDataModule } from './exchange-rate-data.module';
+import { MarketDataModule } from './market-data.module';
 import { SymbolProfileModule } from './symbol-profile.module';

@Module({
  imports: [
+    BullModule.registerQueue({
+      limiter: {
+        duration: ms('5 seconds'),
+        max: 1
+      },
+      name: DATA_GATHERING_QUEUE
+    }),
    ConfigurationModule,
    DataEnhancerModule,
    DataProviderModule,
    ExchangeRateDataModule,
+    MarketDataModule,
    PrismaModule,
    SymbolProfileModule
  ],
-  providers: [DataGatheringService],
-  exports: [DataEnhancerModule, DataGatheringService]
+  providers: [DataGatheringProcessor, DataGatheringService],
+  exports: [BullModule, DataEnhancerModule, DataGatheringService]
 })
 export class DataGatheringModule {}
--- a/apps/api/src/services/data-gathering.processor.ts
+++ b/apps/api/src/services/data-gathering.processor.ts
@ -0,0 +1,128 @@
+import {
+  DATA_GATHERING_QUEUE,
+  GATHER_ASSET_PROFILE_PROCESS,
+  GATHER_HISTORICAL_MARKET_DATA_PROCESS
+} from '@ghostfolio/common/config';
+import { DATE_FORMAT } from '@ghostfolio/common/helper';
+import { UniqueAsset } from '@ghostfolio/common/interfaces';
+import { Process, Processor } from '@nestjs/bull';
+import { Injectable, Logger } from '@nestjs/common';
+import { Job } from 'bull';
+import {
+  format,
+  getDate,
+  getMonth,
+  getYear,
+  isBefore,
+  parseISO
+} from 'date-fns';
+
+import { DataGatheringService } from './data-gathering.service';
+import { DataProviderService } from './data-provider/data-provider.service';
+import { IDataGatheringItem } from './interfaces/interfaces';
+import { PrismaService } from './prisma.service';
+
+@Injectable()
+@Processor(DATA_GATHERING_QUEUE)
+export class DataGatheringProcessor {
+  public constructor(
+    private readonly dataGatheringService: DataGatheringService,
+    private readonly dataProviderService: DataProviderService,
+    private readonly prismaService: PrismaService
+  ) {}
+
+  @Process(GATHER_ASSET_PROFILE_PROCESS)
+  public async gatherAssetProfile(job: Job<UniqueAsset>) {
+    try {
+      await this.dataGatheringService.gatherAssetProfiles([job.data]);
+    } catch (error) {
+      Logger.error(
+        error,
+        `DataGatheringProcessor (${GATHER_ASSET_PROFILE_PROCESS})`
+      );
+
+      throw new Error(error);
+    }
+  }
+
+  @Process(GATHER_HISTORICAL_MARKET_DATA_PROCESS)
+  public async gatherHistoricalMarketData(job: Job<IDataGatheringItem>) {
+    try {
+      const { dataSource, date, symbol } = job.data;
+
+      const historicalData = await this.dataProviderService.getHistoricalRaw(
+        [{ dataSource, symbol }],
+        parseISO(<string>(<unknown>date)),
+        new Date()
+      );
+
+      let currentDate = parseISO(<string>(<unknown>date));
+      let lastMarketPrice: number;
+
+      while (
+        isBefore(
+          currentDate,
+          new Date(
+            Date.UTC(
+              getYear(new Date()),
+              getMonth(new Date()),
+              getDate(new Date()),
+              0
+            )
+          )
+        )
+      ) {
+        if (
+          historicalData[symbol]?.[format(currentDate, DATE_FORMAT)]
+            ?.marketPrice
+        ) {
+          lastMarketPrice =
+            historicalData[symbol]?.[format(currentDate, DATE_FORMAT)]
+              ?.marketPrice;
+        }
+
+        if (lastMarketPrice) {
+          try {
+            await this.prismaService.marketData.create({
+              data: {
+                dataSource,
+                symbol,
+                date: new Date(
+                  Date.UTC(
+                    getYear(currentDate),
+                    getMonth(currentDate),
+                    getDate(currentDate),
+                    0
+                  )
+                ),
+                marketPrice: lastMarketPrice
+              }
+            });
+          } catch {}
+        }
+
+        // Count month one up for iteration
+        currentDate = new Date(
+          Date.UTC(
+            getYear(currentDate),
+            getMonth(currentDate),
+            getDate(currentDate) + 1,
+            0
+          )
+        );
+      }
+
+      Logger.log(
+        `Historical market data gathering has been completed for ${symbol} (${dataSource}).`,
+        `DataGatheringProcessor (${GATHER_HISTORICAL_MARKET_DATA_PROCESS})`
+      );
+    } catch (error) {
+      Logger.error(
+        error,
+        `DataGatheringProcessor (${GATHER_HISTORICAL_MARKET_DATA_PROCESS})`
+      );
+
+      throw new Error(error);
+    }
+  }
+}
--- a/apps/api/src/services/data-gathering.service.ts
+++ b/apps/api/src/services/data-gathering.service.ts
@ -1,181 +1,72 @@
 import { SymbolProfileService } from '@ghostfolio/api/services/symbol-profile.service';
 import {
-  PROPERTY_LAST_DATA_GATHERING,
-  PROPERTY_LOCKED_DATA_GATHERING
+  DATA_GATHERING_QUEUE,
+  GATHER_HISTORICAL_MARKET_DATA_PROCESS,
+  GATHER_HISTORICAL_MARKET_DATA_PROCESS_OPTIONS,
+  QUEUE_JOB_STATUS_LIST
 } from '@ghostfolio/common/config';
 import { DATE_FORMAT, resetHours } from '@ghostfolio/common/helper';
+import { UniqueAsset } from '@ghostfolio/common/interfaces';
+import { InjectQueue } from '@nestjs/bull';
 import { Inject, Injectable, Logger } from '@nestjs/common';
 import { DataSource } from '@prisma/client';
-import {
-  differenceInHours,
-  format,
-  getDate,
-  getMonth,
-  getYear,
-  isBefore,
-  subDays
-} from 'date-fns';
+import { JobOptions, Queue } from 'bull';
+import { format, subDays } from 'date-fns';

 import { DataProviderService } from './data-provider/data-provider.service';
 import { DataEnhancerInterface } from './data-provider/interfaces/data-enhancer.interface';
 import { ExchangeRateDataService } from './exchange-rate-data.service';
 import { IDataGatheringItem } from './interfaces/interfaces';
+import { MarketDataService } from './market-data.service';
 import { PrismaService } from './prisma.service';

@Injectable()
 export class DataGatheringService {
-  private dataGatheringProgress: number;
-
  public constructor(
    @Inject('DataEnhancers')
    private readonly dataEnhancers: DataEnhancerInterface[],
+    @InjectQueue(DATA_GATHERING_QUEUE)
+    private readonly dataGatheringQueue: Queue,
    private readonly dataProviderService: DataProviderService,
    private readonly exchangeRateDataService: ExchangeRateDataService,
+    private readonly marketDataService: MarketDataService,
    private readonly prismaService: PrismaService,
    private readonly symbolProfileService: SymbolProfileService
  ) {}

-  public async gather7Days() {
-    const isDataGatheringNeeded = await this.isDataGatheringNeeded();
+  public async addJobToQueue(name: string, data: any, options?: JobOptions) {
+    const hasJob = await this.hasJob(name, data);

-    if (isDataGatheringNeeded) {
-      Logger.log('7d data gathering has been started.');
-      console.time('data-gathering-7d');
-
-      await this.prismaService.property.create({
-        data: {
-          key: PROPERTY_LOCKED_DATA_GATHERING,
-          value: new Date().toISOString()
-        }
-      });
-
-      const symbols = await this.getSymbols7D();
-
-      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('7d data gathering has been completed.');
-      console.timeEnd('data-gathering-7d');
+    if (hasJob) {
+      Logger.log(
+        `Job ${name} with data ${JSON.stringify(data)} already exists.`,
+        'DataGatheringService'
+      );
+    } else {
+      return this.dataGatheringQueue.add(name, data, options);
    }
  }

+  public async gather7Days() {
+    const dataGatheringItems = await this.getSymbols7D();
+    await this.gatherSymbols(dataGatheringItems);
+  }
+
  public async gatherMax() {
-    const isDataGatheringLocked = await this.prismaService.property.findUnique({
-      where: { key: PROPERTY_LOCKED_DATA_GATHERING }
-    });
-
-    if (!isDataGatheringLocked) {
-      Logger.log('Max data gathering has been started.');
-      console.time('data-gathering-max');
-
-      await this.prismaService.property.create({
-        data: {
-          key: PROPERTY_LOCKED_DATA_GATHERING,
-          value: new Date().toISOString()
-        }
-      });
-
-      const symbols = await this.getSymbolsMax();
-
-      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('Max data gathering has been completed.');
-      console.timeEnd('data-gathering-max');
-    }
+    const dataGatheringItems = await this.getSymbolsMax();
+    await this.gatherSymbols(dataGatheringItems);
  }

-  public async gatherSymbol({
-    dataSource,
-    symbol
-  }: {
-    dataSource: DataSource;
-    symbol: string;
-  }) {
-    const isDataGatheringLocked = await this.prismaService.property.findUnique({
-      where: { key: PROPERTY_LOCKED_DATA_GATHERING }
-    });
+  public async gatherSymbol({ dataSource, symbol }: UniqueAsset) {
+    await this.marketDataService.deleteMany({ dataSource, symbol });

-    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
-          );
-        }
+    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');
-    }
+    });
+    await this.gatherSymbols(symbols);
  }

  public async gatherSymbolForDate({
@ -210,42 +101,48 @@ export class DataGatheringService {
        });
      }
    } catch (error) {
-      Logger.error(error);
+      Logger.error(error, 'DataGatheringService');
    } finally {
      return undefined;
    }
  }

-  public async gatherProfileData(aDataGatheringItems?: IDataGatheringItem[]) {
-    Logger.log('Profile data gathering has been started.');
-    console.time('data-gathering-profile');
+  public async gatherAssetProfiles(aUniqueAssets?: UniqueAsset[]) {
+    let uniqueAssets = aUniqueAssets?.filter((dataGatheringItem) => {
+      return dataGatheringItem.dataSource !== 'MANUAL';
+    });

-    let dataGatheringItems = aDataGatheringItems;
-
-    if (!dataGatheringItems) {
-      dataGatheringItems = await this.getSymbolsProfileData();
+    if (!uniqueAssets) {
+      uniqueAssets = await this.getUniqueAssets();
    }

-    const currentData = await this.dataProviderService.get(dataGatheringItems);
-    const symbolProfiles = await this.symbolProfileService.getSymbolProfiles(
-      dataGatheringItems.map(({ symbol }) => {
-        return symbol;
-      })
+    const assetProfiles = await this.dataProviderService.getAssetProfiles(
+      uniqueAssets
    );
+    const symbolProfiles =
+      await this.symbolProfileService.getSymbolProfilesBySymbols(
+        uniqueAssets.map(({ symbol }) => {
+          return symbol;
+        })
+      );

-    for (const [symbol, response] of Object.entries(currentData)) {
+    for (const [symbol, assetProfile] of Object.entries(assetProfiles)) {
      const symbolMapping = symbolProfiles.find((symbolProfile) => {
        return symbolProfile.symbol === symbol;
      })?.symbolMapping;

      for (const dataEnhancer of this.dataEnhancers) {
        try {
-          currentData[symbol] = await dataEnhancer.enhance({
-            response,
+          assetProfiles[symbol] = await dataEnhancer.enhance({
+            response: assetProfile,
            symbol: symbolMapping?.[dataEnhancer.getName()] ?? symbol
          });
        } catch (error) {
-          Logger.error(`Failed to enhance data for symbol ${symbol}`, error);
+          Logger.error(
+            `Failed to enhance data for symbol ${symbol} by ${dataEnhancer.getName()}`,
+            error,
+            'DataGatheringService'
+          );
        }
      }

@ -256,8 +153,9 @@ export class DataGatheringService {
        currency,
        dataSource,
        name,
-        sectors
-      } = currentData[symbol];
+        sectors,
+        url
+      } = assetProfiles[symbol];

      try {
        await this.prismaService.symbolProfile.upsert({
@ -269,7 +167,8 @@ export class DataGatheringService {
            dataSource,
            name,
            sectors,
-            symbol
+            symbol,
+            url
          },
          update: {
            assetClass,
@ -277,7 +176,8 @@ export class DataGatheringService {
            countries,
            currency,
            name,
-            sectors
+            sectors,
+            url
          },
          where: {
            dataSource_symbol: {
@ -287,132 +187,40 @@ export class DataGatheringService {
          }
        });
      } catch (error) {
-        Logger.error(`${symbol}: ${error?.meta?.cause}`);
+        Logger.error(
+          `${symbol}: ${error?.meta?.cause}`,
+          error,
+          'DataGatheringService'
+        );
      }
    }

-    Logger.log('Profile data gathering has been completed.');
-    console.timeEnd('data-gathering-profile');
+    Logger.log(
+      `Asset profile data gathering has been completed for ${uniqueAssets
+        .map(({ dataSource, symbol }) => {
+          return `${symbol} (${dataSource})`;
+        })
+        .join(',')}.`,
+      'DataGatheringService'
+    );
  }

  public async gatherSymbols(aSymbolsWithStartDate: IDataGatheringItem[]) {
-    let hasError = false;
-    let symbolCounter = 0;
-
    for (const { dataSource, date, symbol } of aSymbolsWithStartDate) {
-      this.dataGatheringProgress = symbolCounter / aSymbolsWithStartDate.length;
+      if (dataSource === 'MANUAL') {
+        continue;
+      }

-      try {
-        const historicalData = await this.dataProviderService.getHistoricalRaw(
-          [{ dataSource, symbol }],
+      await this.addJobToQueue(
+        GATHER_HISTORICAL_MARKET_DATA_PROCESS,
+        {
+          dataSource,
          date,
-          new Date()
-        );
-
-        let currentDate = date;
-        let lastMarketPrice: number;
-
-        while (
-          isBefore(
-            currentDate,
-            new Date(
-              Date.UTC(
-                getYear(new Date()),
-                getMonth(new Date()),
-                getDate(new Date()),
-                0
-              )
-            )
-          )
-        ) {
-          if (
-            historicalData[symbol]?.[format(currentDate, DATE_FORMAT)]
-              ?.marketPrice
-          ) {
-            lastMarketPrice =
-              historicalData[symbol]?.[format(currentDate, DATE_FORMAT)]
-                ?.marketPrice;
-          }
-
-          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} at ${format(
-                currentDate,
-                DATE_FORMAT
-              )}.`
-            );
-          }
-
-          // Count month one up for iteration
-          currentDate = new Date(
-            Date.UTC(
-              getYear(currentDate),
-              getMonth(currentDate),
-              getDate(currentDate) + 1,
-              0
-            )
-          );
-        }
-      } catch (error) {
-        hasError = true;
-        Logger.error(error);
-      }
-
-      if (symbolCounter > 0 && symbolCounter % 100 === 0) {
-        Logger.log(
-          `Data gathering progress: ${(
-            this.dataGatheringProgress * 100
-          ).toFixed(2)}%`
-        );
-      }
-
-      symbolCounter += 1;
+          symbol
+        },
+        GATHER_HISTORICAL_MARKET_DATA_PROCESS_OPTIONS
+      );
    }
-
-    await this.exchangeRateDataService.initialize();
-
-    if (hasError) {
-      throw '';
-    }
-  }
-
-  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: PROPERTY_LOCKED_DATA_GATHERING }
-    });
-  }
-
-  public async getLastDataGathering() {
-    const lastDataGathering = await this.prismaService.property.findUnique({
-      where: { key: PROPERTY_LAST_DATA_GATHERING }
-    });
-
-    if (lastDataGathering?.value) {
-      return new Date(lastDataGathering.value);
-    }
-
-    return undefined;
  }

  public async getSymbolsMax(): Promise<IDataGatheringItem[]> {
@ -445,6 +253,11 @@ export class DataGatheringService {
          },
          scraperConfiguration: true,
          symbol: true
+        },
+        where: {
+          dataSource: {
+            not: 'MANUAL'
+          }
        }
      })
    ).map((symbolProfile) => {
@ -457,17 +270,25 @@ export class DataGatheringService {
    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 }
-        ]
-      }
+  public async getUniqueAssets(): Promise<UniqueAsset[]> {
+    const symbolProfiles = await this.prismaService.symbolProfile.findMany({
+      orderBy: [{ symbol: 'asc' }]
    });
+
+    return symbolProfiles
+      .filter(({ dataSource }) => {
+        return (
+          dataSource !== DataSource.GHOSTFOLIO &&
+          dataSource !== DataSource.MANUAL &&
+          dataSource !== DataSource.RAKUTEN
+        );
+      })
+      .map(({ dataSource, symbol }) => {
+        return {
+          dataSource,
+          symbol
+        };
+      });
  }

  private async getSymbols7D(): Promise<IDataGatheringItem[]> {
@ -479,6 +300,11 @@ export class DataGatheringService {
        dataSource: true,
        scraperConfiguration: true,
        symbol: true
+      },
+      where: {
+        dataSource: {
+          not: 'MANUAL'
+        }
      }
    });

@ -488,6 +314,7 @@ export class DataGatheringService {
      await this.prismaService.marketData.groupBy({
        _count: true,
        by: ['symbol'],
+        orderBy: [{ symbol: 'asc' }],
        where: {
          date: { gt: startDate }
        }
@ -527,30 +354,17 @@ export class DataGatheringService {
    return [...currencyPairsToGather, ...symbolProfilesToGather];
  }

-  private async getSymbolsProfileData(): Promise<IDataGatheringItem[]> {
-    const distinctOrders = await this.prismaService.order.findMany({
-      distinct: ['symbol'],
-      orderBy: [{ symbol: 'asc' }],
-      select: { dataSource: true, symbol: true }
-    });
+  private async hasJob(name: string, data: any) {
+    const jobs = await this.dataGatheringQueue.getJobs(
+      QUEUE_JOB_STATUS_LIST.filter((status) => {
+        return status !== 'completed';
+      })
+    );

-    return distinctOrders.filter((distinctOrder) => {
+    return jobs.some((job) => {
      return (
-        distinctOrder.dataSource !== DataSource.GHOSTFOLIO &&
-        distinctOrder.dataSource !== DataSource.RAKUTEN
+        job.name === name && JSON.stringify(job.data) === JSON.stringify(data)
      );
    });
  }
-
-  private async isDataGatheringNeeded() {
-    const lastDataGathering = await this.getLastDataGathering();
-
-    const isDataGatheringLocked = await this.prismaService.property.findUnique({
-      where: { key: PROPERTY_LOCKED_DATA_GATHERING }
-    });
-
-    const diffInHours = differenceInHours(new Date(), lastDataGathering);
-
-    return (diffInHours >= 1 || !lastDataGathering) && !isDataGatheringLocked;
-  }
 }
--- a/apps/api/src/services/data-provider/alpha-vantage/alpha-vantage.service.ts
+++ b/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 { format, isAfter, isBefore, parse } from 'date-fns';
+
 import { IAlphaVantageHistoricalResponse } from './interfaces/interfaces';

@Injectable()
@ -29,25 +29,23 @@ export class AlphaVantageService implements DataProviderInterface {
    return !!this.configurationService.get('ALPHA_VANTAGE_API_KEY');
  }

-  public async get(
-    aSymbols: string[]
-  ): Promise<{ [symbol: string]: IDataProviderResponse }> {
-    return {};
+  public async getAssetProfile(
+    aSymbol: string
+  ): Promise<Partial<SymbolProfile>> {
+    return {
+      dataSource: this.getName()
+    };
  }

  public async getHistorical(
-    aSymbols: string[],
+    aSymbol: string,
    aGranularity: Granularity = 'day',
    from: Date,
    to: Date
  ): Promise<{
    [symbol: string]: { [date: string]: IDataProviderHistoricalResponse };
  }> {
-    if (aSymbols.length <= 0) {
-      return {};
-    }
-
-    const symbol = aSymbols[0];
+    const symbol = aSymbol;

    try {
      const historicalData: {
@ -78,9 +76,12 @@ export class AlphaVantageService implements DataProviderInterface {

      return response;
    } catch (error) {
-      Logger.error(error, symbol);
-
-      return {};
+      throw new Error(
+        `Could not get historical market data for ${aSymbol} (${this.getName()}) from ${format(
+          from,
+          DATE_FORMAT
+        )} to ${format(to, DATE_FORMAT)}: [${error.name}] ${error.message}`
+      );
    }
  }

@ -88,6 +89,12 @@ export class AlphaVantageService implements DataProviderInterface {
    return DataSource.ALPHA_VANTAGE;
  }

+  public async getQuotes(
+    aSymbols: string[]
+  ): Promise<{ [symbol: string]: IDataProviderResponse }> {
+    return {};
+  }
+
  public async search(aQuery: string): Promise<{ items: LookupItem[] }> {
    const result = await this.alphaVantage.data.search(aQuery);

--- a/apps/api/src/services/data-provider/data-enhancer/trackinsight/trackinsight.service.ts
+++ b/apps/api/src/services/data-provider/data-enhancer/trackinsight/trackinsight.service.ts
@ -1,5 +1,7 @@
 import { DataEnhancerInterface } from '@ghostfolio/api/services/data-provider/interfaces/data-enhancer.interface';
-import { IDataProviderResponse } from '@ghostfolio/api/services/interfaces/interfaces';
+import { Country } from '@ghostfolio/common/interfaces/country.interface';
+import { Sector } from '@ghostfolio/common/interfaces/sector.interface';
+import { SymbolProfile } from '@prisma/client';
 import bent from 'bent';

 const getJSON = bent('json');
@ -21,16 +23,16 @@ 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')
    ) {
      return response;
    }

-    const holdings = await getJSON(
+    const result = await getJSON(
      `${TrackinsightDataEnhancerService.baseUrl}/${symbol}.json`
    ).catch(() => {
      return getJSON(
@ -40,9 +42,17 @@ export class TrackinsightDataEnhancerService implements DataEnhancerInterface {
      );
    });

-    if (!response.countries || response.countries.length === 0) {
+    if (result.weight < 0.95) {
+      // Skip if data is inaccurate
+      return response;
+    }
+
+    if (
+      !response.countries ||
+      (response.countries as unknown as Country[]).length === 0
+    ) {
      response.countries = [];
-      for (const [name, value] of Object.entries<any>(holdings.countries)) {
+      for (const [name, value] of Object.entries<any>(result.countries)) {
        let countryCode: string;

        for (const [key, country] of Object.entries<any>(
@ -65,9 +75,12 @@ 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)) {
+      for (const [name, value] of Object.entries<any>(result.sectors)) {
        response.sectors.push({
          name: TrackinsightDataEnhancerService.sectorsMapping[name] ?? name,
          weight: value.weight
--- a/Show More
+++ b/Show More
				`@ -0,0 +1 @@`
				`custom: ['https://www.buymeacoffee.com/ghostfolio']`