Release 1.135.0 (#823)

* Add fire calculator

* Update changelog

.env

@@ -5,12 +5,12 @@ REDIS_HOST=localhost
 REDIS_PORT=6379
 
 # POSTGRES
+POSTGRES_DB=ghostfolio-db
 POSTGRES_USER=user
 POSTGRES_PASSWORD=password
-POSTGRES_DB=ghostfolio-db
 
 ACCESS_TOKEN_SALT=GHOSTFOLIO
 ALPHA_VANTAGE_API_KEY=
-DATABASE_URL=postgresql://user:password@localhost:5432/ghostfolio-db?sslmode=prefer
+DATABASE_URL=postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@localhost:5432/${POSTGRES_DB}?sslmode=prefer
 JWT_SECRET_KEY=123456
 PORT=3333

.eslintrc.json

@@ -44,7 +44,7 @@
           }
         ],
         "@typescript-eslint/member-ordering": "error",
-        "@typescript-eslint/naming-convention": "error",
+        "@typescript-eslint/naming-convention": "off",
         "@typescript-eslint/no-empty-function": "off",
         "@typescript-eslint/no-empty-interface": "error",
         "@typescript-eslint/no-inferrable-types": [

.gitignore

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

.prettierignore

@@ -1 +1,2 @@
 /dist
+/test/import

.storybook/main.js

@@ -0,0 +1,11 @@
+module.exports = {
+  stories: [],
+  addons: ['@storybook/addon-essentials']
+  // uncomment the property below if you want to apply some webpack config globally
+  // webpackFinal: async (config, { configType }) => {
+  //   // Make whatever fine-grained changes you need that should apply to all storybook configs
+
+  //   // Return the altered config
+  //   return config;
+  // },
+};

.storybook/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../tsconfig.base.json",
+  "exclude": [
+    "../**/*.spec.js",
+    "../**/*.spec.ts",
+    "../**/*.spec.tsx",
+    "../**/*.spec.jsx"
+  ],
+  "include": ["../**/*"]
+}

.travis.yml

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

.vscode/launch.json

@@ -26,7 +26,8 @@
       "skipFiles": [
         "${workspaceFolder}/node_modules/**/*.js",
         "<node_internals>/**/*.js"
-      ]
+      ],
+      "console": "integratedTerminal"
     }
   ]
 }

Dockerfile

@@ -0,0 +1,52 @@
+FROM node:14-alpine as builder
+
+# Build application and add additional files
+
+WORKDIR /ghostfolio
+
+# Only add basic files without the application itself to avoid rebuilding
+# layers when files (package.json etc.) have not changed
+COPY ./CHANGELOG.md CHANGELOG.md
+COPY ./LICENSE LICENSE
+COPY ./package.json package.json
+COPY ./yarn.lock yarn.lock
+COPY ./prisma/schema.prisma prisma/schema.prisma
+
+RUN apk add --no-cache python3 g++ make openssl
+RUN yarn install
+
+# See https://github.com/nrwl/nx/issues/6586 for further details
+COPY ./decorate-angular-cli.js decorate-angular-cli.js
+RUN node decorate-angular-cli.js
+
+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 ./tsconfig.base.json tsconfig.base.json
+COPY ./libs libs
+COPY ./apps apps
+
+RUN yarn build:all
+
+# Prepare the dist image with additional node_modules
+WORKDIR /ghostfolio/dist/apps/api
+# package.json was generated by the build process, however the original
+# yarn.lock needs to be used to ensure the same versions
+COPY ./yarn.lock /ghostfolio/dist/apps/api/yarn.lock
+
+RUN yarn
+COPY prisma /ghostfolio/dist/apps/api/prisma
+
+# Overwrite the generated package.json with the original one to ensure having
+# all the scripts
+COPY package.json /ghostfolio/dist/apps/api
+RUN yarn database:generate-typings
+
+# Image to run, copy everything needed from builder
+FROM node:14-alpine
+COPY --from=builder /ghostfolio/dist/apps /ghostfolio/apps
+WORKDIR /ghostfolio/apps/api
+EXPOSE 3333
+CMD [ "node", "main" ]

README.md

@@ -1,95 +1,253 @@
 <div align="center">
+  <a href="https://ghostfol.io">
+    <img
+      alt="Ghostfolio Logo"
+      src="https://avatars.githubusercontent.com/u/82473144?s=200"
+      width="100"
+    />
+  </a>
+
   <h1>Ghostfolio</h1>
   <p>
-    <strong>Open Source Portfolio Tracker</strong>
+    <strong>Open Source Wealth Management Software made for Humans</strong>
   </p>
   <p>
-    <a href="https://ghostfol.io"><strong>Live Demo</strong></a>
+    <a href="https://ghostfol.io"><strong>Live Demo</strong></a> | <a href="https://ghostfol.io/pricing"><strong>Ghostfolio Premium</strong></a> | <a href="https://ghostfol.io/blog"><strong>Blog</strong></a> | <a href="https://join.slack.com/t/ghostfolio/shared_invite/zt-vsaan64h-F_I0fEo5M0P88lP9ibCxFg"><strong>Slack</strong></a> | <a href="https://twitter.com/ghostfolio_"><strong>Twitter</strong></a>
   </p>
   <p>
+    <a href="#contributing">
+      <img src="https://img.shields.io/badge/contributions-welcome-orange.svg"/></a>
+    <a href="https://travis-ci.com/github/ghostfolio/ghostfolio" rel="nofollow">
+      <img src="https://travis-ci.com/ghostfolio/ghostfolio.svg?branch=main" alt="Build Status"/></a>
     <a href="https://www.gnu.org/licenses/agpl-3.0" rel="nofollow">
-      <img src="https://img.shields.io/badge/License-AGPL%20v3-blue.svg" alt="License: AGPL v3">
-    </a>
+      <img src="https://img.shields.io/badge/License-AGPL%20v3-blue.svg" alt="License: AGPL v3"/></a>
   </p>
 </div>
 
-**Ghostfolio** is an open source portfolio tracker. The software empowers busy folks to have a sharp look of their financial assets and to make solid, data-driven investment decisions by evaluating automated static portfolio analysis rules.
+**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.
+
+<div align="center">
+  <img src="./apps/client/src/assets/images/screenshot.png" width="300">
+</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).
 
 ## Why Ghostfolio?
 
 Ghostfolio is for you if you are...
 
 - 💼 trading stocks, ETFs or cryptocurrencies on multiple platforms
-
 - 🏦 pursuing a buy & hold strategy
-
 - 🎯 interested in getting insights of your portfolio composition
-
 - 👻 valuing privacy and data ownership
-
 - 🧘 into minimalism
-
 - 🧺 caring about diversifying your financial resources
-
 - 🆓 interested in financial independence
-
 - 🙅 saying no to spreadsheets in 2021
-
 - 😎 still reading this list
 
 ## Features
 
 - ✅ Create, update and delete transactions
-- ✅ Portfolio performance (`Today`, `YTD`, `1Y`, `5Y`, `Max`)
+- ✅ Multi account management
+- ✅ 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
 
-## Technology
+## Technology Stack
 
 Ghostfolio is a modern web application written in [TypeScript](https://www.typescriptlang.org) and organized as an [Nx](https://nx.dev) workspace.
 
-### Frontend
-
-The frontend is built with [Angular](https://angular.io).
-
 ### Backend
 
-The backend is based on [NestJS](https://nestjs.com) using [PostgreSQL](https://www.postgresql.org) as a database and [Redis](https://redis.io) for caching.
+The backend is based on [NestJS](https://nestjs.com) using [PostgreSQL](https://www.postgresql.org) as a database together with [Prisma](https://www.prisma.io) and [Redis](https://redis.io) for caching.
 
-## Getting Started
+### Frontend
+
+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)
 
 ### Prerequisites
 
-- [Node.js](https://nodejs.org/en/download)
-- [Yarn](https://yarnpkg.com/en/docs/install)
 - [Docker](https://www.docker.com/products/docker-desktop)
+- A local copy of this Git repository (clone)
+
+### a. Run environment
+
+Run the following command to start the Docker images from [Docker Hub](https://hub.docker.com/r/ghostfolio/ghostfolio):
+
+```bash
+docker-compose -f docker/docker-compose.yml up -d
+```
+
+#### 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
+```
+
+### b. Build and run environment
+
+Run the following commands to build and start the Docker images:
+
+```bash
+docker-compose -f docker/docker-compose.build.yml build
+docker-compose -f docker/docker-compose.build.yml up -d
+```
+
+#### Setup Database
+
+Run the following command to setup the database once Ghostfolio is running:
+
+```bash
+docker-compose -f docker/docker-compose.build.yml exec ghostfolio yarn database:setup
+```
+
+### Fetch Historical Data
+
+Open http://localhost:3333 in your browser and accomplish these steps:
+
+1. Create a new user via _Get Started_ (this first user will get the role `ADMIN`)
+1. Go to the _Admin Control Panel_ and click _Gather All Data_ to fetch historical data
+1. Click _Sign out_ and check out the _Live Demo_
+
+### Upgrade Version
+
+1. Increase the version of the `ghostfolio/ghostfolio` Docker image in `docker/docker-compose.yml`
+1. Run the following command to start the new Docker image: `docker-compose -f docker/docker-compose.yml up -d`
+1. Then, run the following command to keep your database schema in sync: `docker-compose -f docker/docker-compose.yml exec ghostfolio yarn database:migrate`
+
+## Development
+
+### Prerequisites
+
+- [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`
-2. Run `cd docker`
-3. Run `docker compose build`
-4. Run `docker compose up -d` to start [PostgreSQL](https://www.postgresql.org) and [Redis](https://redis.io)
-5. Run `yarn setup:database` to initialize the database schema and populate your database with (example) data
-6. Start server and client (see _Development_)
-7. Login as _Admin_ with the following _Security Token_: `ae76872ae8f3419c6d6f64bf51888ecbcc703927a342d815fafe486acdb938da07d0cf44fca211a0be74a423238f535362d390a41e81e633a9ce668a6e31cdf9`
+1. Run `docker-compose -f docker/docker-compose.dev.yml up -d` to start [PostgreSQL](https://www.postgresql.org) and [Redis](https://redis.io)
+1. Run `yarn database:setup` to initialize the database schema and populate your database with (example) data
+1. Start the server and the client (see [_Development_](#Development))
+1. Create a new user via _Get Started_ (this first user will get the role `ADMIN`)
+1. Go to the _Admin Control Panel_ and click _Gather All Data_ to fetch historical data
+1. Click _Sign out_ and check out the _Live Demo_
 
-## Development
+### Start Server
 
-### Start server
+<ol type="a">
+  <li>Debug: Run <code>yarn watch:server</code> and click "Launch Program" in <a href="https://code.visualstudio.com">Visual Studio Code</a></li>
+  <li>Serve: Run <code>yarn start:server</code></li>
+</ol>
 
-- Debug: Run `yarn watch:server` and click "Launch Program" in _Visual Studio Code_
-- Serve: Run `yarn start:server`
+### Start Client
 
-### Start client
+Run `yarn start:client`
 
-- Run `yarn start:client`
+### Start _Storybook_
+
+Run `yarn start:storybook`
+
+### Migrate Database
+
+With the following command you can keep your database schema in sync:
+
+```bash
+yarn database:push
+```
 
 ## Testing
 
 Run `yarn test`
 
+## Public API (experimental)
+
+### Import Activities
+
+#### Request
+
+`POST http://localhost:3333/api/v1/import`
+
+#### Authorization: Bearer Token
+
+Set the header as follows:
+
+```
+"Authorization": "Bearer eyJh..."
+```
+
+#### Body
+
+```
+{
+  "activities": [
+    {
+      "currency": "USD",
+      "dataSource": "YAHOO",
+      "date": "2021-09-15T00:00:00.000Z",
+      "fee": 19,
+      "quantity": 5,
+      "symbol": "MSFT"
+      "type": "BUY",
+      "unitPrice": 298.58
+    }
+  ]
+}
+```
+
+| Field      | Type                | Description                                        |
+| ---------- | ------------------- | -------------------------------------------------- |
+| accountId  | string (`optional`) | Id of the account                                  |
+| currency   | string              | `CHF` \| `EUR` \| `USD` etc.                       |
+| dataSource | string              | `MANUAL` (for type `ITEM`) \| `YAHOO`              |
+| date       | string              | Date in the format `ISO-8601`                      |
+| fee        | number              | Fee of the activity                                |
+| quantity   | number              | Quantity of the activity                           |
+| symbol     | string              | Symbol of the activity (suitable for `dataSource`) |
+| type       | string              | `BUY` \| `DIVIDEND` \| `ITEM` \| `SELL`            |
+| unitPrice  | number              | Price per unit of the activity                     |
+
+#### Response
+
+##### Success
+
+`201 Created`
+
+##### Error
+
+`400 Bad Request`
+
+```
+{
+  "error": "Bad Request",
+  "message": [
+    "activities.1 is a duplicate activity"
+  ]
+}
+```
+
+## Contributing
+
+Ghostfolio is **100% free** and **open source**. We encourage and support an active and healthy community that accepts contributions from the public - including you.
+
+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.
+
 ## License
 
+© 2022 [Ghostfolio](https://ghostfol.io)
+
 Licensed under the [AGPLv3 License](https://www.gnu.org/licenses/agpl-3.0.html).

angular.json

@@ -1,19 +1,5 @@
 {
   "version": 1,
-  "cli": {
-    "defaultCollection": "@nrwl/nest"
-  },
-  "defaultProject": "api",
-  "schematics": {
-    "@nrwl/angular:application": {
-      "unitTestRunner": "jest",
-      "e2eTestRunner": "cypress"
-    },
-    "@nrwl/angular:library": {
-      "unitTestRunner": "jest"
-    },
-    "@nrwl/nest": {}
-  },
   "projects": {
     "api": {
       "root": "apps/api",
@@ -23,7 +9,7 @@
       "schematics": {},
       "architect": {
         "build": {
-          "builder": "@nrwl/node:build",
+          "builder": "@nrwl/node:webpack",
           "options": {
             "outputPath": "dist/apps/api",
             "main": "apps/api/src/main.ts",
@@ -32,6 +18,7 @@
           },
           "configurations": {
             "production": {
+              "generatePackageJson": true,
               "optimization": true,
               "extractLicenses": true,
               "inspect": false,
@@ -46,7 +33,7 @@
           "outputs": ["{options.outputPath}"]
         },
         "serve": {
-          "builder": "@nrwl/node:execute",
+          "builder": "@nrwl/node:node",
           "options": {
             "buildTarget": "api:build"
           }
@@ -65,7 +52,8 @@
           },
           "outputs": ["coverage/apps/api"]
         }
-      }
+      },
+      "tags": []
     },
     "client": {
       "projectType": "application",
@@ -86,7 +74,6 @@
             "main": "apps/client/src/main.ts",
             "polyfills": "apps/client/src/polyfills.ts",
             "tsConfig": "apps/client/tsconfig.app.json",
-            "aot": true,
             "assets": [
               "apps/client/src/assets",
               {
@@ -97,11 +84,16 @@
               {
                 "glob": "CHANGELOG.md",
                 "input": "",
-                "output": "./"
+                "output": "./assets"
               },
               {
                 "glob": "LICENSE",
                 "input": "",
+                "output": "./assets"
+              },
+              {
+                "glob": "robots.txt",
+                "input": "apps/client/src/assets",
                 "output": "./"
               },
               {
@@ -121,7 +113,13 @@
               }
             ],
             "styles": ["apps/client/src/styles.scss"],
-            "scripts": ["node_modules/marked/lib/marked.js"]
+            "scripts": ["node_modules/marked/lib/marked.js"],
+            "vendorChunk": true,
+            "extractLicenses": false,
+            "buildOptimizer": false,
+            "sourceMap": true,
+            "optimization": false,
+            "namedChunks": true
           },
           "configurations": {
             "production": {
@@ -152,7 +150,8 @@
               ]
             }
           },
-          "outputs": ["{options.outputPath}"]
+          "outputs": ["{options.outputPath}"],
+          "defaultConfiguration": ""
         },
         "serve": {
           "builder": "@angular-devkit/build-angular:dev-server",
@@ -186,7 +185,8 @@
           },
           "outputs": ["coverage/apps/client"]
         }
-      }
+      },
+      "tags": []
     },
     "client-e2e": {
       "root": "apps/client-e2e",
@@ -206,28 +206,120 @@
             }
           }
         }
-      }
+      },
+      "tags": [],
+      "implicitDependencies": ["client"]
     },
-    "helper": {
-      "root": "libs/helper",
-      "sourceRoot": "libs/helper/src",
+    "common": {
+      "root": "libs/common",
+      "sourceRoot": "libs/common/src",
       "projectType": "library",
       "architect": {
         "lint": {
           "builder": "@nrwl/linter:eslint",
           "options": {
-            "lintFilePatterns": ["libs/helper/**/*.ts"]
+            "lintFilePatterns": ["libs/common/**/*.ts"]
           }
         },
         "test": {
           "builder": "@nrwl/jest:jest",
-          "outputs": ["coverage/libs/helper"],
+          "outputs": ["coverage/libs/common"],
           "options": {
-            "jestConfig": "libs/helper/jest.config.js",
+            "jestConfig": "libs/common/jest.config.js",
             "passWithNoTests": true
           }
         }
-      }
+      },
+      "tags": []
+    },
+    "ui": {
+      "projectType": "library",
+      "schematics": {
+        "@schematics/angular:component": {
+          "style": "scss"
+        }
+      },
+      "root": "libs/ui",
+      "sourceRoot": "libs/ui/src",
+      "prefix": "gf",
+      "architect": {
+        "test": {
+          "builder": "@nrwl/jest:jest",
+          "outputs": ["coverage/libs/ui"],
+          "options": {
+            "jestConfig": "libs/ui/jest.config.js",
+            "passWithNoTests": true
+          }
+        },
+        "lint": {
+          "builder": "@nrwl/linter:eslint",
+          "options": {
+            "lintFilePatterns": ["libs/ui/src/**/*.ts", "libs/ui/src/**/*.html"]
+          }
+        },
+        "storybook": {
+          "builder": "@nrwl/storybook:storybook",
+          "options": {
+            "uiFramework": "@storybook/angular",
+            "port": 4400,
+            "config": {
+              "configFolder": "libs/ui/.storybook"
+            },
+            "projectBuildConfig": "ui:build-storybook"
+          },
+          "configurations": {
+            "ci": {
+              "quiet": true
+            }
+          }
+        },
+        "build-storybook": {
+          "builder": "@nrwl/storybook:build",
+          "outputs": ["{options.outputPath}"],
+          "options": {
+            "uiFramework": "@storybook/angular",
+            "outputPath": "dist/storybook/ui",
+            "config": {
+              "configFolder": "libs/ui/.storybook"
+            },
+            "projectBuildConfig": "ui:build-storybook"
+          },
+          "configurations": {
+            "ci": {
+              "quiet": true
+            }
+          }
+        }
+      },
+      "tags": []
+    },
+    "ui-e2e": {
+      "root": "apps/ui-e2e",
+      "sourceRoot": "apps/ui-e2e/src",
+      "projectType": "application",
+      "architect": {
+        "e2e": {
+          "builder": "@nrwl/cypress:cypress",
+          "options": {
+            "cypressConfig": "apps/ui-e2e/cypress.json",
+            "devServerTarget": "ui:storybook",
+            "tsConfig": "apps/ui-e2e/tsconfig.json"
+          },
+          "configurations": {
+            "ci": {
+              "devServerTarget": "ui:storybook:ci"
+            }
+          }
+        },
+        "lint": {
+          "builder": "@nrwl/linter:eslint",
+          "options": {
+            "lintFilePatterns": ["apps/ui-e2e/**/*.{js,ts}"]
+          }
+        }
+      },
+      "tags": [],
+      "implicitDependencies": ["ui"]
     }
   }
 }

apps/api/jest.config.js

@@ -11,5 +11,6 @@ module.exports = {
   },
   moduleFileExtensions: ['ts', 'js', 'html'],
   coverageDirectory: '../../coverage/apps/api',
-  testTimeout: 10000
+  testTimeout: 10000,
+  testEnvironment: 'node'
 };

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

@@ -1,10 +1,25 @@
-import { Controller, Get, Inject, UseGuards } from '@nestjs/common';
+import { Access } from '@ghostfolio/common/interfaces';
+import { hasPermission, permissions } from '@ghostfolio/common/permissions';
+import type { RequestWithUser } from '@ghostfolio/common/types';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpException,
+  Inject,
+  Param,
+  Post,
+  UseGuards
+} from '@nestjs/common';
 import { REQUEST } from '@nestjs/core';
 import { AuthGuard } from '@nestjs/passport';
-import { RequestWithUser } from 'apps/api/src/app/interfaces/request-with-user.type';
+import { Access as AccessModel } from '@prisma/client';
+import { StatusCodes, getReasonPhrase } from 'http-status-codes';
 
+import { AccessModule } from './access.module';
 import { AccessService } from './access.service';
-import { Access } from './interfaces/access.interface';
+import { CreateAccessDto } from './create-access.dto';
 
 @Controller('access')
 export class AccessController {
@@ -20,13 +35,63 @@ export class AccessController {
       include: {
         GranteeUser: true
       },
+      orderBy: { granteeUserId: 'asc' },
       where: { userId: this.request.user.id }
     });
 
     return accessesWithGranteeUser.map((access) => {
+      if (access.GranteeUser) {
+        return {
+          granteeAlias: access.GranteeUser?.alias,
+          id: access.id,
+          type: 'RESTRICTED_VIEW'
+        };
+      }
+
       return {
-        granteeAlias: access.GranteeUser.alias
+        granteeAlias: 'Public',
+        id: access.id,
+        type: 'PUBLIC'
       };
     });
   }
+
+  @Post()
+  @UseGuards(AuthGuard('jwt'))
+  public async createAccess(
+    @Body() data: CreateAccessDto
+  ): Promise<AccessModel> {
+    if (
+      !hasPermission(this.request.user.permissions, permissions.createAccess)
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    return this.accessService.createAccess({
+      User: { connect: { id: this.request.user.id } }
+    });
+  }
+
+  @Delete(':id')
+  @UseGuards(AuthGuard('jwt'))
+  public async deleteAccess(@Param('id') id: string): Promise<AccessModule> {
+    if (
+      !hasPermission(this.request.user.permissions, permissions.deleteAccess)
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    return this.accessService.deleteAccess({
+      id_userId: {
+        id,
+        userId: this.request.user.id
+      }
+    });
+  }
 }

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

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

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

@@ -1,12 +1,22 @@
+import { PrismaService } from '@ghostfolio/api/services/prisma.service';
+import { AccessWithGranteeUser } from '@ghostfolio/common/types';
 import { Injectable } from '@nestjs/common';
-import { Prisma } from '@prisma/client';
-
-import { PrismaService } from '../../services/prisma.service';
-import { AccessWithGranteeUser } from './interfaces/access-with-grantee-user.type';
+import { Access, Prisma } from '@prisma/client';
 
 @Injectable()
 export class AccessService {
-  public constructor(private prisma: PrismaService) {}
+  public constructor(private readonly prismaService: PrismaService) {}
+
+  public async access(
+    accessWhereInput: Prisma.AccessWhereInput
+  ): Promise<AccessWithGranteeUser | null> {
+    return this.prismaService.access.findFirst({
+      include: {
+        GranteeUser: true
+      },
+      where: accessWhereInput
+    });
+  }
 
   public async accesses(params: {
     include?: Prisma.AccessInclude;
@@ -14,11 +24,11 @@ export class AccessService {
     take?: number;
     cursor?: Prisma.AccessWhereUniqueInput;
     where?: Prisma.AccessWhereInput;
-    orderBy?: Prisma.AccessOrderByInput;
+    orderBy?: Prisma.AccessOrderByWithRelationInput;
   }): Promise<AccessWithGranteeUser[]> {
     const { include, skip, take, cursor, where, orderBy } = params;
 
-    return this.prisma.access.findMany({
+    return this.prismaService.access.findMany({
       cursor,
       include,
       orderBy,
@@ -27,4 +37,18 @@ export class AccessService {
       where
     });
   }
+
+  public async createAccess(data: Prisma.AccessCreateInput): Promise<Access> {
+    return this.prismaService.access.create({
+      data
+    });
+  }
+
+  public async deleteAccess(
+    where: Prisma.AccessWhereUniqueInput
+  ): Promise<Access> {
+    return this.prismaService.access.delete({
+      where
+    });
+  }
 }

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

@@ -0,0 +1 @@
+export class CreateAccessDto {}

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

@@ -0,0 +1,244 @@
+import { PortfolioService } from '@ghostfolio/api/app/portfolio/portfolio.service';
+import { UserService } from '@ghostfolio/api/app/user/user.service';
+import {
+  nullifyValuesInObject,
+  nullifyValuesInObjects
+} from '@ghostfolio/api/helper/object.helper';
+import { ImpersonationService } from '@ghostfolio/api/services/impersonation.service';
+import { Accounts } from '@ghostfolio/common/interfaces';
+import { hasPermission, permissions } from '@ghostfolio/common/permissions';
+import type { RequestWithUser } from '@ghostfolio/common/types';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Headers,
+  HttpException,
+  Inject,
+  Param,
+  Post,
+  Put,
+  UseGuards
+} from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
+import { AuthGuard } from '@nestjs/passport';
+import { Account as AccountModel } from '@prisma/client';
+import { StatusCodes, getReasonPhrase } from 'http-status-codes';
+
+import { AccountService } from './account.service';
+import { CreateAccountDto } from './create-account.dto';
+import { UpdateAccountDto } from './update-account.dto';
+
+@Controller('account')
+export class AccountController {
+  public constructor(
+    private readonly accountService: AccountService,
+    private readonly impersonationService: ImpersonationService,
+    private readonly portfolioService: PortfolioService,
+    @Inject(REQUEST) private readonly request: RequestWithUser,
+    private readonly userService: UserService
+  ) {}
+
+  @Delete(':id')
+  @UseGuards(AuthGuard('jwt'))
+  public async deleteAccount(@Param('id') id: string): Promise<AccountModel> {
+    if (
+      !hasPermission(this.request.user.permissions, permissions.deleteAccount)
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    const account = await this.accountService.accountWithOrders(
+      {
+        id_userId: {
+          id,
+          userId: this.request.user.id
+        }
+      },
+      { Order: true }
+    );
+
+    if (account?.isDefault || account?.Order.length > 0) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    return this.accountService.deleteAccount(
+      {
+        id_userId: {
+          id,
+          userId: this.request.user.id
+        }
+      },
+      this.request.user.id
+    );
+  }
+
+  @Get()
+  @UseGuards(AuthGuard('jwt'))
+  public async getAllAccounts(
+    @Headers('impersonation-id') impersonationId
+  ): Promise<Accounts> {
+    const impersonationUserId =
+      await this.impersonationService.validateImpersonationId(
+        impersonationId,
+        this.request.user.id
+      );
+
+    let accountsWithAggregations =
+      await this.portfolioService.getAccountsWithAggregations(
+        impersonationUserId || this.request.user.id
+      );
+
+    if (
+      impersonationUserId ||
+      this.userService.isRestrictedView(this.request.user)
+    ) {
+      accountsWithAggregations = {
+        ...nullifyValuesInObject(accountsWithAggregations, [
+          'totalBalanceInBaseCurrency',
+          'totalValueInBaseCurrency'
+        ]),
+        accounts: nullifyValuesInObjects(accountsWithAggregations.accounts, [
+          'balance',
+          'balanceInBaseCurrency',
+          'convertedBalance',
+          'fee',
+          'quantity',
+          'unitPrice',
+          'value',
+          'valueInBaseCurrency'
+        ])
+      };
+    }
+
+    return accountsWithAggregations;
+  }
+
+  @Get(':id')
+  @UseGuards(AuthGuard('jwt'))
+  public async getAccountById(@Param('id') id: string): Promise<AccountModel> {
+    return this.accountService.account({
+      id_userId: {
+        id,
+        userId: this.request.user.id
+      }
+    });
+  }
+
+  @Post()
+  @UseGuards(AuthGuard('jwt'))
+  public async createAccount(
+    @Body() data: CreateAccountDto
+  ): Promise<AccountModel> {
+    if (
+      !hasPermission(this.request.user.permissions, permissions.createAccount)
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    if (data.platformId) {
+      const platformId = data.platformId;
+      delete data.platformId;
+
+      return this.accountService.createAccount(
+        {
+          ...data,
+          Platform: { connect: { id: platformId } },
+          User: { connect: { id: this.request.user.id } }
+        },
+        this.request.user.id
+      );
+    } else {
+      delete data.platformId;
+
+      return this.accountService.createAccount(
+        {
+          ...data,
+          User: { connect: { id: this.request.user.id } }
+        },
+        this.request.user.id
+      );
+    }
+  }
+
+  @Put(':id')
+  @UseGuards(AuthGuard('jwt'))
+  public async update(@Param('id') id: string, @Body() data: UpdateAccountDto) {
+    if (
+      !hasPermission(this.request.user.permissions, permissions.updateAccount)
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    const originalAccount = await this.accountService.account({
+      id_userId: {
+        id,
+        userId: this.request.user.id
+      }
+    });
+
+    if (!originalAccount) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    if (data.platformId) {
+      const platformId = data.platformId;
+      delete data.platformId;
+
+      return this.accountService.updateAccount(
+        {
+          data: {
+            ...data,
+            Platform: { connect: { id: platformId } },
+            User: { connect: { id: this.request.user.id } }
+          },
+          where: {
+            id_userId: {
+              id,
+              userId: this.request.user.id
+            }
+          }
+        },
+        this.request.user.id
+      );
+    } else {
+      // platformId is null, remove it
+      delete data.platformId;
+
+      return this.accountService.updateAccount(
+        {
+          data: {
+            ...data,
+            Platform: originalAccount.platformId
+              ? { disconnect: true }
+              : undefined,
+            User: { connect: { id: this.request.user.id } }
+          },
+          where: {
+            id_userId: {
+              id,
+              userId: this.request.user.id
+            }
+          }
+        },
+        this.request.user.id
+      );
+    }
+  }
+}

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

@@ -0,0 +1,29 @@
+import { PortfolioModule } from '@ghostfolio/api/app/portfolio/portfolio.module';
+import { RedisCacheModule } from '@ghostfolio/api/app/redis-cache/redis-cache.module';
+import { UserModule } from '@ghostfolio/api/app/user/user.module';
+import { ConfigurationModule } from '@ghostfolio/api/services/configuration.module';
+import { DataProviderModule } from '@ghostfolio/api/services/data-provider/data-provider.module';
+import { ExchangeRateDataModule } from '@ghostfolio/api/services/exchange-rate-data.module';
+import { ImpersonationModule } from '@ghostfolio/api/services/impersonation.module';
+import { PrismaModule } from '@ghostfolio/api/services/prisma.module';
+import { Module } from '@nestjs/common';
+
+import { AccountController } from './account.controller';
+import { AccountService } from './account.service';
+
+@Module({
+  controllers: [AccountController],
+  exports: [AccountService],
+  imports: [
+    ConfigurationModule,
+    DataProviderModule,
+    ExchangeRateDataModule,
+    ImpersonationModule,
+    PortfolioModule,
+    PrismaModule,
+    RedisCacheModule,
+    UserModule
+  ],
+  providers: [AccountService]
+})
+export class AccountModule {}

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

@@ -0,0 +1,144 @@
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data.service';
+import { PrismaService } from '@ghostfolio/api/services/prisma.service';
+import { Injectable } from '@nestjs/common';
+import { Account, Order, Platform, Prisma } from '@prisma/client';
+import Big from 'big.js';
+
+import { CashDetails } from './interfaces/cash-details.interface';
+
+@Injectable()
+export class AccountService {
+  public constructor(
+    private readonly exchangeRateDataService: ExchangeRateDataService,
+    private readonly prismaService: PrismaService
+  ) {}
+
+  public async account(
+    accountWhereUniqueInput: Prisma.AccountWhereUniqueInput
+  ): Promise<Account | null> {
+    return this.prismaService.account.findUnique({
+      where: accountWhereUniqueInput
+    });
+  }
+
+  public async accountWithOrders(
+    accountWhereUniqueInput: Prisma.AccountWhereUniqueInput,
+    accountInclude: Prisma.AccountInclude
+  ): Promise<
+    Account & {
+      Order?: Order[];
+    }
+  > {
+    return this.prismaService.account.findUnique({
+      include: accountInclude,
+      where: accountWhereUniqueInput
+    });
+  }
+
+  public async accounts(params: {
+    include?: Prisma.AccountInclude;
+    skip?: number;
+    take?: number;
+    cursor?: Prisma.AccountWhereUniqueInput;
+    where?: Prisma.AccountWhereInput;
+    orderBy?: Prisma.AccountOrderByWithRelationInput;
+  }): Promise<
+    (Account & {
+      Order?: Order[];
+      Platform?: Platform;
+    })[]
+  > {
+    const { include, skip, take, cursor, where, orderBy } = params;
+
+    return this.prismaService.account.findMany({
+      cursor,
+      include,
+      orderBy,
+      skip,
+      take,
+      where
+    });
+  }
+
+  public async createAccount(
+    data: Prisma.AccountCreateInput,
+    aUserId: string
+  ): Promise<Account> {
+    return this.prismaService.account.create({
+      data
+    });
+  }
+
+  public async deleteAccount(
+    where: Prisma.AccountWhereUniqueInput,
+    aUserId: string
+  ): Promise<Account> {
+    return this.prismaService.account.delete({
+      where
+    });
+  }
+
+  public async getAccounts(aUserId: string) {
+    const accounts = await this.accounts({
+      include: { Order: true, Platform: true },
+      orderBy: { name: 'asc' },
+      where: { userId: aUserId }
+    });
+
+    return accounts.map((account) => {
+      let transactionCount = 0;
+
+      for (const order of account.Order) {
+        if (!order.isDraft) {
+          transactionCount += 1;
+        }
+      }
+
+      const result = { ...account, transactionCount };
+
+      delete result.Order;
+
+      return result;
+    });
+  }
+
+  public async getCashDetails(
+    aUserId: string,
+    aCurrency: string
+  ): Promise<CashDetails> {
+    let totalCashBalanceInBaseCurrency = new Big(0);
+
+    const accounts = await this.accounts({
+      where: { userId: aUserId }
+    });
+
+    for (const account of accounts) {
+      totalCashBalanceInBaseCurrency = totalCashBalanceInBaseCurrency.plus(
+        this.exchangeRateDataService.toCurrency(
+          account.balance,
+          account.currency,
+          aCurrency
+        )
+      );
+    }
+
+    return {
+      accounts,
+      balanceInBaseCurrency: totalCashBalanceInBaseCurrency.toNumber()
+    };
+  }
+
+  public async updateAccount(
+    params: {
+      where: Prisma.AccountWhereUniqueInput;
+      data: Prisma.AccountUpdateInput;
+    },
+    aUserId: string
+  ): Promise<Account> {
+    const { data, where } = params;
+    return this.prismaService.account.update({
+      data,
+      where
+    });
+  }
+}

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

@@ -0,0 +1,20 @@
+import { AccountType } from '@prisma/client';
+import { IsNumber, IsString, ValidateIf } from 'class-validator';
+
+export class CreateAccountDto {
+  @IsString()
+  accountType: AccountType;
+
+  @IsNumber()
+  balance: number;
+
+  @IsString()
+  currency: string;
+
+  @IsString()
+  name: string;
+
+  @IsString()
+  @ValidateIf((object, value) => value !== null)
+  platformId: string | null;
+}

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

@@ -0,0 +1,6 @@
+import { Account } from '@prisma/client';
+
+export interface CashDetails {
+  accounts: Account[];
+  balanceInBaseCurrency: number;
+}

apps/api/src/app/account/update-account.dto.ts

@@ -0,0 +1,23 @@
+import { AccountType } from '@prisma/client';
+import { IsNumber, IsString, ValidateIf } from 'class-validator';
+
+export class UpdateAccountDto {
+  @IsString()
+  accountType: AccountType;
+
+  @IsNumber()
+  balance: number;
+
+  @IsString()
+  currency: string;
+
+  @IsString()
+  id: string;
+
+  @IsString()
+  name: string;
+
+  @IsString()
+  @ValidateIf((object, value) => value !== null)
+  platformId: string | null;
+}

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

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

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

@@ -1,29 +1,31 @@
+import { SubscriptionModule } from '@ghostfolio/api/app/subscription/subscription.module';
+import { ConfigurationModule } from '@ghostfolio/api/services/configuration.module';
+import { DataGatheringModule } from '@ghostfolio/api/services/data-gathering.module';
+import { DataProviderModule } from '@ghostfolio/api/services/data-provider/data-provider.module';
+import { ExchangeRateDataModule } from '@ghostfolio/api/services/exchange-rate-data.module';
+import { MarketDataModule } from '@ghostfolio/api/services/market-data.module';
+import { PrismaModule } from '@ghostfolio/api/services/prisma.module';
+import { PropertyModule } from '@ghostfolio/api/services/property/property.module';
+import { SymbolProfileModule } from '@ghostfolio/api/services/symbol-profile.module';
 import { Module } from '@nestjs/common';
 
-import { ConfigurationService } from '../../services/configuration.service';
-import { DataGatheringService } from '../../services/data-gathering.service';
-import { DataProviderService } from '../../services/data-provider.service';
-import { AlphaVantageService } from '../../services/data-provider/alpha-vantage/alpha-vantage.service';
-import { RakutenRapidApiService } from '../../services/data-provider/rakuten-rapid-api/rakuten-rapid-api.service';
-import { YahooFinanceService } from '../../services/data-provider/yahoo-finance/yahoo-finance.service';
-import { ExchangeRateDataService } from '../../services/exchange-rate-data.service';
-import { PrismaService } from '../../services/prisma.service';
 import { AdminController } from './admin.controller';
 import { AdminService } from './admin.service';
 
 @Module({
-  imports: [],
+  imports: [
+    ConfigurationModule,
+    DataGatheringModule,
+    DataProviderModule,
+    ExchangeRateDataModule,
+    MarketDataModule,
+    PrismaModule,
+    PropertyModule,
+    SubscriptionModule,
+    SymbolProfileModule
+  ],
   controllers: [AdminController],
-  providers: [
-    AdminService,
-    AlphaVantageService,
-    ConfigurationService,
-    DataGatheringService,
-    DataProviderService,
-    ExchangeRateDataService,
-    PrismaService,
-    RakutenRapidApiService,
-    YahooFinanceService
-  ]
+  providers: [AdminService],
+  exports: [AdminService]
 })
 export class AdminModule {}

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

@@ -1,95 +1,188 @@
+import { SubscriptionService } from '@ghostfolio/api/app/subscription/subscription.service';
+import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
+import { DataGatheringService } from '@ghostfolio/api/services/data-gathering.service';
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data.service';
+import { MarketDataService } from '@ghostfolio/api/services/market-data.service';
+import { PrismaService } from '@ghostfolio/api/services/prisma.service';
+import { PropertyService } from '@ghostfolio/api/services/property/property.service';
+import { SymbolProfileService } from '@ghostfolio/api/services/symbol-profile.service';
+import { PROPERTY_CURRENCIES, baseCurrency } from '@ghostfolio/common/config';
+import {
+  AdminData,
+  AdminMarketData,
+  AdminMarketDataDetails,
+  AdminMarketDataItem,
+  UniqueAsset
+} from '@ghostfolio/common/interfaces';
 import { Injectable } from '@nestjs/common';
-import { Currency } from '@prisma/client';
-
-import { ExchangeRateDataService } from '../../services/exchange-rate-data.service';
-import { PrismaService } from '../../services/prisma.service';
-import { AdminData } from './interfaces/admin-data.interface';
+import { DataSource, Property } from '@prisma/client';
+import { differenceInDays } from 'date-fns';
 
 @Injectable()
 export class AdminService {
   public constructor(
-    private exchangeRateDataService: ExchangeRateDataService,
-    private prisma: PrismaService
+    private readonly configurationService: ConfigurationService,
+    private readonly dataGatheringService: DataGatheringService,
+    private readonly exchangeRateDataService: ExchangeRateDataService,
+    private readonly marketDataService: MarketDataService,
+    private readonly prismaService: PrismaService,
+    private readonly propertyService: PropertyService,
+    private readonly subscriptionService: SubscriptionService,
+    private readonly symbolProfileService: SymbolProfileService
   ) {}
 
+  public async deleteProfileData({ dataSource, symbol }: UniqueAsset) {
+    await this.marketDataService.deleteMany({ dataSource, symbol });
+    await this.symbolProfileService.delete({ dataSource, symbol });
+  }
+
   public async get(): Promise<AdminData> {
     return {
-      exchangeRates: [
-        {
-          label1: Currency.EUR,
-          label2: Currency.CHF,
-          value: await this.exchangeRateDataService.toCurrency(
-            1,
-            Currency.EUR,
-            Currency.CHF
-          )
-        },
-        {
-          label1: Currency.GBP,
-          label2: Currency.CHF,
-          value: await this.exchangeRateDataService.toCurrency(
-            1,
-            Currency.GBP,
-            Currency.CHF
-          )
-        },
-        {
-          label1: Currency.USD,
-          label2: Currency.CHF,
-          value: await this.exchangeRateDataService.toCurrency(
-            1,
-            Currency.USD,
-            Currency.CHF
-          )
-        },
-        {
-          label1: Currency.USD,
-          label2: Currency.EUR,
-          value: await this.exchangeRateDataService.toCurrency(
-            1,
-            Currency.USD,
-            Currency.EUR
-          )
-        },
-        {
-          label1: Currency.USD,
-          label2: Currency.GBP,
-          value: await this.exchangeRateDataService.toCurrency(
-            1,
-            Currency.USD,
-            Currency.GBP
-          )
-        }
-      ],
+      dataGatheringProgress:
+        await this.dataGatheringService.getDataGatheringProgress(),
+      exchangeRates: this.exchangeRateDataService
+        .getCurrencies()
+        .filter((currency) => {
+          return currency !== baseCurrency;
+        })
+        .map((currency) => {
+          return {
+            label1: baseCurrency,
+            label2: currency,
+            value: this.exchangeRateDataService.toCurrency(
+              1,
+              baseCurrency,
+              currency
+            )
+          };
+        }),
       lastDataGathering: await this.getLastDataGathering(),
-      transactionCount: await this.prisma.order.count(),
-      userCount: await this.prisma.user.count(),
+      settings: await this.propertyService.get(),
+      transactionCount: await this.prismaService.order.count(),
+      userCount: await this.prismaService.user.count(),
       users: await this.getUsersWithAnalytics()
     };
   }
 
-  private async getLastDataGathering() {
-    const lastDataGathering = await this.prisma.property.findUnique({
-      where: { key: 'LAST_DATA_GATHERING' }
+  public async getMarketData(): Promise<AdminMarketData> {
+    const marketData = await this.prismaService.marketData.groupBy({
+      _count: true,
+      by: ['dataSource', 'symbol']
     });
 
-    if (lastDataGathering?.value) {
-      return new Date(lastDataGathering.value);
+    const currencyPairsToGather: AdminMarketDataItem[] =
+      this.exchangeRateDataService
+        .getCurrencyPairs()
+        .map(({ dataSource, symbol }) => {
+          const marketDataItemCount =
+            marketData.find((marketDataItem) => {
+              return (
+                marketDataItem.dataSource === dataSource &&
+                marketDataItem.symbol === symbol
+              );
+            })?._count ?? 0;
+
+          return {
+            dataSource,
+            marketDataItemCount,
+            symbol
+          };
+        });
+
+    const symbolProfilesToGather: AdminMarketDataItem[] = (
+      await this.prismaService.symbolProfile.findMany({
+        orderBy: [{ symbol: 'asc' }],
+        select: {
+          _count: {
+            select: { Order: true }
+          },
+          dataSource: true,
+          Order: {
+            orderBy: [{ date: 'asc' }],
+            select: { date: true },
+            take: 1
+          },
+          scraperConfiguration: true,
+          symbol: true
+        }
+      })
+    ).map((symbolProfile) => {
+      const marketDataItemCount =
+        marketData.find((marketDataItem) => {
+          return (
+            marketDataItem.dataSource === symbolProfile.dataSource &&
+            marketDataItem.symbol === symbolProfile.symbol
+          );
+        })?._count ?? 0;
+
+      return {
+        marketDataItemCount,
+        activityCount: symbolProfile._count.Order,
+        dataSource: symbolProfile.dataSource,
+        date: symbolProfile.Order?.[0]?.date,
+        symbol: symbolProfile.symbol
+      };
+    });
+
+    return {
+      marketData: [...currencyPairsToGather, ...symbolProfilesToGather]
+    };
+  }
+
+  public async getMarketDataBySymbol({
+    dataSource,
+    symbol
+  }: UniqueAsset): Promise<AdminMarketDataDetails> {
+    return {
+      marketData: await this.marketDataService.marketDataItems({
+        orderBy: {
+          date: 'asc'
+        },
+        where: {
+          dataSource,
+          symbol
+        }
+      })
+    };
+  }
+
+  public async putSetting(key: string, value: string) {
+    let response: Property;
+
+    if (value === '') {
+      response = await this.propertyService.delete({ key });
+    } else {
+      response = await this.propertyService.put({ key, value });
     }
 
-    const dataGatheringInProgress = await this.prisma.property.findUnique({
-      where: { key: 'LOCKED_DATA_GATHERING' }
-    });
+    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 null;
+    return undefined;
   }
 
-  private async getUsersWithAnalytics() {
-    return await this.prisma.user.findMany({
+  private async getUsersWithAnalytics(): Promise<AdminData['users']> {
+    const usersWithAnalytics = await this.prismaService.user.findMany({
       orderBy: {
         Analytics: {
           updatedAt: 'desc'
@@ -97,7 +190,7 @@ export class AdminService {
       },
       select: {
         _count: {
-          select: { Order: true }
+          select: { Account: true, Order: true }
         },
         alias: true,
         Analytics: {
@@ -107,9 +200,40 @@ export class AdminService {
           }
         },
         createdAt: true,
-        id: true
+        id: true,
+        Subscription: true
       },
-      take: 20
+      take: 30,
+      where: {
+        NOT: {
+          Analytics: null
+        }
+      }
     });
+
+    return usersWithAnalytics.map(
+      ({ _count, alias, Analytics, createdAt, id, Subscription }) => {
+        const daysSinceRegistration =
+          differenceInDays(new Date(), createdAt) + 1;
+        const engagement = Analytics.activityCount / daysSinceRegistration;
+
+        const subscription = this.configurationService.get(
+          'ENABLE_FEATURE_SUBSCRIPTION'
+        )
+          ? this.subscriptionService.getSubscription(Subscription)
+          : undefined;
+
+        return {
+          alias,
+          createdAt,
+          engagement,
+          id,
+          subscription,
+          accountCount: _count.Account || 0,
+          lastActivity: Analytics.updatedAt,
+          transactionCount: _count.Order || 0
+        };
+      }
+    );
   }
 }

apps/api/src/app/admin/interfaces/admin-data.interface.ts

@@ -1,15 +0,0 @@
-export interface AdminData {
-  exchangeRates: { label1: string; label2: string; value: number }[];
-  lastDataGathering: Date | 'IN_PROGRESS';
-  transactionCount: number;
-  userCount: number;
-  users: {
-    alias: string;
-    createdAt: Date;
-    Analytics: {
-      activityCount: number;
-      updatedAt: Date;
-    };
-    id: string;
-  }[];
-}

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

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

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

@@ -1,12 +1,12 @@
+import { DataGatheringService } from '@ghostfolio/api/services/data-gathering.service';
 import { Controller } from '@nestjs/common';
 
-import { PrismaService } from '../services/prisma.service';
 import { RedisCacheService } from './redis-cache/redis-cache.service';
 
 @Controller()
 export class AppController {
   public constructor(
-    private prisma: PrismaService,
+    private readonly dataGatheringService: DataGatheringService,
     private readonly redisCacheService: RedisCacheService
   ) {
     this.initialize();
@@ -15,17 +15,12 @@ export class AppController {
   private async initialize() {
     this.redisCacheService.reset();
 
-    const isDataGatheringLocked = await this.prisma.property.findUnique({
-      where: { key: 'LOCKED_DATA_GATHERING' }
-    });
+    const isDataGatheringInProgress =
+      await this.dataGatheringService.getIsInProgress();
 
-    if (!isDataGatheringLocked) {
-      // Prepare for automatical data gather if not locked
-      await this.prisma.property.deleteMany({
-        where: {
-          OR: [{ key: 'LAST_DATA_GATHERING' }, { key: 'LOCKED_DATA_GATHERING' }]
-        }
-      });
+    if (isDataGatheringInProgress) {
+      // Prepare for automatical data gathering, if hung up in progress state
+      await this.dataGatheringService.reset();
     }
   }
 }

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

@@ -1,29 +1,31 @@
 import { join } from 'path';
 
+import { AuthDeviceModule } from '@ghostfolio/api/app/auth-device/auth-device.module';
+import { RedisCacheModule } from '@ghostfolio/api/app/redis-cache/redis-cache.module';
+import { ConfigurationModule } from '@ghostfolio/api/services/configuration.module';
+import { CronService } from '@ghostfolio/api/services/cron.service';
+import { DataGatheringModule } from '@ghostfolio/api/services/data-gathering.module';
+import { DataProviderModule } from '@ghostfolio/api/services/data-provider/data-provider.module';
+import { ExchangeRateDataModule } from '@ghostfolio/api/services/exchange-rate-data.module';
+import { PrismaModule } from '@ghostfolio/api/services/prisma.module';
+import { TwitterBotModule } from '@ghostfolio/api/services/twitter-bot/twitter-bot.module';
 import { Module } from '@nestjs/common';
 import { ConfigModule } from '@nestjs/config';
 import { ScheduleModule } from '@nestjs/schedule';
 import { ServeStaticModule } from '@nestjs/serve-static';
 
-import { ConfigurationService } from '../services/configuration.service';
-import { CronService } from '../services/cron.service';
-import { DataGatheringService } from '../services/data-gathering.service';
-import { DataProviderService } from '../services/data-provider.service';
-import { AlphaVantageService } from '../services/data-provider/alpha-vantage/alpha-vantage.service';
-import { RakutenRapidApiService } from '../services/data-provider/rakuten-rapid-api/rakuten-rapid-api.service';
-import { YahooFinanceService } from '../services/data-provider/yahoo-finance/yahoo-finance.service';
-import { ExchangeRateDataService } from '../services/exchange-rate-data.service';
-import { PrismaService } from '../services/prisma.service';
 import { AccessModule } from './access/access.module';
+import { AccountModule } from './account/account.module';
 import { AdminModule } from './admin/admin.module';
 import { AppController } from './app.controller';
 import { AuthModule } from './auth/auth.module';
 import { CacheModule } from './cache/cache.module';
-import { ExperimentalModule } from './experimental/experimental.module';
+import { ExportModule } from './export/export.module';
+import { ImportModule } from './import/import.module';
 import { InfoModule } from './info/info.module';
 import { OrderModule } from './order/order.module';
 import { PortfolioModule } from './portfolio/portfolio.module';
-import { RedisCacheModule } from './redis-cache/redis-cache.module';
+import { SubscriptionModule } from './subscription/subscription.module';
 import { SymbolModule } from './symbol/symbol.module';
 import { UserModule } from './user/user.module';
 
@@ -31,13 +33,21 @@ import { UserModule } from './user/user.module';
   imports: [
     AdminModule,
     AccessModule,
+    AccountModule,
+    AuthDeviceModule,
     AuthModule,
     CacheModule,
     ConfigModule.forRoot(),
-    ExperimentalModule,
+    ConfigurationModule,
+    DataGatheringModule,
+    DataProviderModule,
+    ExchangeRateDataModule,
+    ExportModule,
+    ImportModule,
     InfoModule,
     OrderModule,
     PortfolioModule,
+    PrismaModule,
     RedisCacheModule,
     ScheduleModule.forRoot(),
     ServeStaticModule.forRoot({
@@ -54,20 +64,12 @@ import { UserModule } from './user/user.module';
       rootPath: join(__dirname, '..', 'client'),
       exclude: ['/api*']
     }),
+    SubscriptionModule,
     SymbolModule,
+    TwitterBotModule,
     UserModule
   ],
   controllers: [AppController],
-  providers: [
-    AlphaVantageService,
-    ConfigurationService,
-    CronService,
-    DataGatheringService,
-    DataProviderService,
-    ExchangeRateDataService,
-    PrismaService,
-    RakutenRapidApiService,
-    YahooFinanceService
-  ]
+  providers: [CronService]
 })
 export class AppModule {}

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

@@ -0,0 +1,40 @@
+import { AuthDeviceService } from '@ghostfolio/api/app/auth-device/auth-device.service';
+import { hasPermission, permissions } from '@ghostfolio/common/permissions';
+import type { RequestWithUser } from '@ghostfolio/common/types';
+import {
+  Controller,
+  Delete,
+  HttpException,
+  Inject,
+  Param,
+  UseGuards
+} from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
+import { AuthGuard } from '@nestjs/passport';
+import { StatusCodes, getReasonPhrase } from 'http-status-codes';
+
+@Controller('auth-device')
+export class AuthDeviceController {
+  public constructor(
+    private readonly authDeviceService: AuthDeviceService,
+    @Inject(REQUEST) private readonly request: RequestWithUser
+  ) {}
+
+  @Delete(':id')
+  @UseGuards(AuthGuard('jwt'))
+  public async deleteAuthDevice(@Param('id') id: string): Promise<void> {
+    if (
+      !hasPermission(
+        this.request.user.permissions,
+        permissions.deleteAuthDevice
+      )
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    await this.authDeviceService.deleteAuthDevice({ id });
+  }
+}

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

@@ -0,0 +1,4 @@
+export interface AuthDeviceDto {
+  createdAt: string;
+  id: string;
+}

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

@@ -0,0 +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 { 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]
+})
+export class AuthDeviceModule {}

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

@@ -0,0 +1,65 @@
+import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
+import { PrismaService } from '@ghostfolio/api/services/prisma.service';
+import { Injectable } from '@nestjs/common';
+import { AuthDevice, Prisma } from '@prisma/client';
+
+@Injectable()
+export class AuthDeviceService {
+  public constructor(
+    private readonly configurationService: ConfigurationService,
+    private readonly prismaService: PrismaService
+  ) {}
+
+  public async authDevice(
+    where: Prisma.AuthDeviceWhereUniqueInput
+  ): Promise<AuthDevice | null> {
+    return this.prismaService.authDevice.findUnique({
+      where
+    });
+  }
+
+  public async authDevices(params: {
+    skip?: number;
+    take?: number;
+    cursor?: Prisma.AuthDeviceWhereUniqueInput;
+    where?: Prisma.AuthDeviceWhereInput;
+    orderBy?: Prisma.AuthDeviceOrderByWithRelationInput;
+  }): Promise<AuthDevice[]> {
+    const { skip, take, cursor, where, orderBy } = params;
+    return this.prismaService.authDevice.findMany({
+      skip,
+      take,
+      cursor,
+      where,
+      orderBy
+    });
+  }
+
+  public async createAuthDevice(
+    data: Prisma.AuthDeviceCreateInput
+  ): Promise<AuthDevice> {
+    return this.prismaService.authDevice.create({
+      data
+    });
+  }
+
+  public async updateAuthDevice(params: {
+    data: Prisma.AuthDeviceUpdateInput;
+    where: Prisma.AuthDeviceWhereUniqueInput;
+  }): Promise<AuthDevice> {
+    const { data, where } = params;
+
+    return this.prismaService.authDevice.update({
+      data,
+      where
+    });
+  }
+
+  public async deleteAuthDevice(
+    where: Prisma.AuthDeviceWhereUniqueInput
+  ): Promise<AuthDevice> {
+    return this.prismaService.authDevice.delete({
+      where
+    });
+  }
+}

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

@@ -1,23 +1,33 @@
+import { WebAuthService } from '@ghostfolio/api/app/auth/web-auth.service';
+import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
 import {
+  Body,
   Controller,
   Get,
   HttpException,
   Param,
+  Post,
   Req,
   Res,
-  UseGuards
+  UseGuards,
+  VERSION_NEUTRAL,
+  Version
 } from '@nestjs/common';
 import { AuthGuard } from '@nestjs/passport';
 import { StatusCodes, getReasonPhrase } from 'http-status-codes';
 
-import { ConfigurationService } from '../../services/configuration.service';
 import { AuthService } from './auth.service';
+import {
+  AssertionCredentialJSON,
+  AttestationCredentialJSON
+} from './interfaces/simplewebauthn';
 
 @Controller('auth')
 export class AuthController {
   public constructor(
     private readonly authService: AuthService,
-    private readonly configurationService: ConfigurationService
+    private readonly configurationService: ConfigurationService,
+    private readonly webAuthService: WebAuthService
   ) {}
 
   @Get('anonymous/:accessToken')
@@ -43,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;
@@ -53,4 +64,44 @@ export class AuthController {
       res.redirect(`${this.configurationService.get('ROOT_URL')}/auth`);
     }
   }
+
+  @Get('webauthn/generate-registration-options')
+  @UseGuards(AuthGuard('jwt'))
+  public async generateRegistrationOptions() {
+    return this.webAuthService.generateRegistrationOptions();
+  }
+
+  @Post('webauthn/verify-attestation')
+  @UseGuards(AuthGuard('jwt'))
+  public async verifyAttestation(
+    @Body() body: { deviceName: string; credential: AttestationCredentialJSON }
+  ) {
+    return this.webAuthService.verifyAttestation(
+      body.deviceName,
+      body.credential
+    );
+  }
+
+  @Post('webauthn/generate-assertion-options')
+  public async generateAssertionOptions(@Body() body: { deviceId: string }) {
+    return this.webAuthService.generateAssertionOptions(body.deviceId);
+  }
+
+  @Post('webauthn/verify-assertion')
+  public async verifyAssertion(
+    @Body() body: { deviceId: string; credential: AssertionCredentialJSON }
+  ) {
+    try {
+      const authToken = await this.webAuthService.verifyAssertion(
+        body.deviceId,
+        body.credential
+      );
+      return { authToken };
+    } catch {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+  }
 }

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

@@ -1,9 +1,12 @@
+import { AuthDeviceService } from '@ghostfolio/api/app/auth-device/auth-device.service';
+import { WebAuthService } from '@ghostfolio/api/app/auth/web-auth.service';
+import { SubscriptionModule } from '@ghostfolio/api/app/subscription/subscription.module';
+import { UserModule } from '@ghostfolio/api/app/user/user.module';
+import { ConfigurationModule } from '@ghostfolio/api/services/configuration.module';
+import { PrismaModule } from '@ghostfolio/api/services/prisma.module';
 import { Module } from '@nestjs/common';
 import { JwtModule } from '@nestjs/jwt';
 
-import { ConfigurationService } from '../../services/configuration.service';
-import { PrismaService } from '../../services/prisma.service';
-import { UserService } from '../user/user.service';
 import { AuthController } from './auth.controller';
 import { AuthService } from './auth.service';
 import { GoogleStrategy } from './google.strategy';
@@ -12,18 +15,21 @@ 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,
-    UserService
+    WebAuthService
   ]
 })
 export class AuthModule {}

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

@@ -1,8 +1,8 @@
+import { UserService } from '@ghostfolio/api/app/user/user.service';
+import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
 import { Injectable, InternalServerErrorException } from '@nestjs/common';
 import { JwtService } from '@nestjs/jwt';
 
-import { ConfigurationService } from '../../services/configuration.service';
-import { UserService } from '../user/user.service';
 import { ValidateOAuthLoginParams } from './interfaces/interfaces';
 
 @Injectable()

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

@@ -1,9 +1,9 @@
-import { Injectable } from '@nestjs/common';
+import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
+import { Injectable, Logger } from '@nestjs/common';
 import { PassportStrategy } from '@nestjs/passport';
 import { Provider } from '@prisma/client';
 import { Strategy } from 'passport-google-oauth20';
 
-import { ConfigurationService } from '../../services/configuration.service';
 import { AuthService } from './auth.service';
 
 @Injectable()
@@ -41,9 +41,9 @@ export class GoogleStrategy extends PassportStrategy(Strategy, 'google') {
       };
 
       done(null, user);
-    } catch (err) {
-      console.error(err);
-      done(err, false);
+    } catch (error) {
+      Logger.error(error, 'GoogleStrategy');
+      done(error, false);
     }
   }
 }

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

@@ -1,5 +1,10 @@
+import { AuthDeviceDto } from '@ghostfolio/api/app/auth-device/auth-device.dto';
 import { Provider } from '@prisma/client';
 
+export interface AuthDeviceDialogParams {
+  authDevice: AuthDeviceDto;
+}
+
 export interface ValidateOAuthLoginParams {
   provider: Provider;
   thirdPartyId: string;

apps/api/src/app/auth/interfaces/simplewebauthn.ts

@@ -0,0 +1,226 @@
+export interface AuthenticatorAssertionResponse extends AuthenticatorResponse {
+  readonly authenticatorData: ArrayBuffer;
+  readonly signature: ArrayBuffer;
+  readonly userHandle: ArrayBuffer | null;
+}
+export interface AuthenticatorAttestationResponse
+  extends AuthenticatorResponse {
+  readonly attestationObject: ArrayBuffer;
+}
+export interface AuthenticationExtensionsClientInputs {
+  appid?: string;
+  appidExclude?: string;
+  credProps?: boolean;
+  uvm?: boolean;
+}
+export interface AuthenticationExtensionsClientOutputs {
+  appid?: boolean;
+  credProps?: CredentialPropertiesOutput;
+  uvm?: UvmEntries;
+}
+export interface AuthenticatorSelectionCriteria {
+  authenticatorAttachment?: AuthenticatorAttachment;
+  requireResidentKey?: boolean;
+  residentKey?: ResidentKeyRequirement;
+  userVerification?: UserVerificationRequirement;
+}
+export interface PublicKeyCredential extends Credential {
+  readonly rawId: ArrayBuffer;
+  readonly response: AuthenticatorResponse;
+  getClientExtensionResults(): AuthenticationExtensionsClientOutputs;
+}
+export interface PublicKeyCredentialCreationOptions {
+  attestation?: AttestationConveyancePreference;
+  authenticatorSelection?: AuthenticatorSelectionCriteria;
+  challenge: BufferSource;
+  excludeCredentials?: PublicKeyCredentialDescriptor[];
+  extensions?: AuthenticationExtensionsClientInputs;
+  pubKeyCredParams: PublicKeyCredentialParameters[];
+  rp: PublicKeyCredentialRpEntity;
+  timeout?: number;
+  user: PublicKeyCredentialUserEntity;
+}
+export interface PublicKeyCredentialDescriptor {
+  id: BufferSource;
+  transports?: AuthenticatorTransport[];
+  type: PublicKeyCredentialType;
+}
+export interface PublicKeyCredentialParameters {
+  alg: COSEAlgorithmIdentifier;
+  type: PublicKeyCredentialType;
+}
+export interface PublicKeyCredentialRequestOptions {
+  allowCredentials?: PublicKeyCredentialDescriptor[];
+  challenge: BufferSource;
+  extensions?: AuthenticationExtensionsClientInputs;
+  rpId?: string;
+  timeout?: number;
+  userVerification?: UserVerificationRequirement;
+}
+export interface PublicKeyCredentialUserEntity
+  extends PublicKeyCredentialEntity {
+  displayName: string;
+  id: BufferSource;
+}
+export interface AuthenticatorResponse {
+  readonly clientDataJSON: ArrayBuffer;
+}
+export interface CredentialPropertiesOutput {
+  rk?: boolean;
+}
+export interface Credential {
+  readonly id: string;
+  readonly type: string;
+}
+export interface PublicKeyCredentialRpEntity extends PublicKeyCredentialEntity {
+  id?: string;
+}
+export interface PublicKeyCredentialEntity {
+  name: string;
+}
+export declare type AttestationConveyancePreference =
+  | 'direct'
+  | 'enterprise'
+  | 'indirect'
+  | 'none';
+export declare type AuthenticatorTransport = 'ble' | 'internal' | 'nfc' | 'usb';
+export declare type COSEAlgorithmIdentifier = number;
+export declare type UserVerificationRequirement =
+  | 'discouraged'
+  | 'preferred'
+  | 'required';
+export declare type UvmEntries = UvmEntry[];
+export declare type AuthenticatorAttachment = 'cross-platform' | 'platform';
+export declare type ResidentKeyRequirement =
+  | 'discouraged'
+  | 'preferred'
+  | 'required';
+export declare type BufferSource = ArrayBufferView | ArrayBuffer;
+export declare type PublicKeyCredentialType = 'public-key';
+export declare type UvmEntry = number[];
+
+export interface PublicKeyCredentialCreationOptionsJSON
+  extends Omit<
+    PublicKeyCredentialCreationOptions,
+    'challenge' | 'user' | 'excludeCredentials'
+  > {
+  user: PublicKeyCredentialUserEntityJSON;
+  challenge: Base64URLString;
+  excludeCredentials: PublicKeyCredentialDescriptorJSON[];
+  extensions?: AuthenticationExtensionsClientInputs;
+}
+/**
+ * A variant of PublicKeyCredentialRequestOptions suitable for JSON transmission to the browser to
+ * (eventually) get passed into navigator.credentials.get(...) in the browser.
+ */
+export interface PublicKeyCredentialRequestOptionsJSON
+  extends Omit<
+    PublicKeyCredentialRequestOptions,
+    'challenge' | 'allowCredentials'
+  > {
+  challenge: Base64URLString;
+  allowCredentials?: PublicKeyCredentialDescriptorJSON[];
+  extensions?: AuthenticationExtensionsClientInputs;
+}
+export interface PublicKeyCredentialDescriptorJSON
+  extends Omit<PublicKeyCredentialDescriptor, 'id'> {
+  id: Base64URLString;
+}
+export interface PublicKeyCredentialUserEntityJSON
+  extends Omit<PublicKeyCredentialUserEntity, 'id'> {
+  id: string;
+}
+/**
+ * The value returned from navigator.credentials.create()
+ */
+export interface AttestationCredential extends PublicKeyCredential {
+  response: AuthenticatorAttestationResponseFuture;
+}
+/**
+ * A slightly-modified AttestationCredential to simplify working with ArrayBuffers that
+ * are Base64URL-encoded in the browser so that they can be sent as JSON to the server.
+ */
+export interface AttestationCredentialJSON
+  extends Omit<
+    AttestationCredential,
+    'response' | 'rawId' | 'getClientExtensionResults'
+  > {
+  rawId: Base64URLString;
+  response: AuthenticatorAttestationResponseJSON;
+  clientExtensionResults: AuthenticationExtensionsClientOutputs;
+  transports?: AuthenticatorTransport[];
+}
+/**
+ * The value returned from navigator.credentials.get()
+ */
+export interface AssertionCredential extends PublicKeyCredential {
+  response: AuthenticatorAssertionResponse;
+}
+/**
+ * A slightly-modified AssertionCredential to simplify working with ArrayBuffers that
+ * are Base64URL-encoded in the browser so that they can be sent as JSON to the server.
+ */
+export interface AssertionCredentialJSON
+  extends Omit<
+    AssertionCredential,
+    'response' | 'rawId' | 'getClientExtensionResults'
+  > {
+  rawId: Base64URLString;
+  response: AuthenticatorAssertionResponseJSON;
+  clientExtensionResults: AuthenticationExtensionsClientOutputs;
+}
+/**
+ * A slightly-modified AuthenticatorAttestationResponse to simplify working with ArrayBuffers that
+ * are Base64URL-encoded in the browser so that they can be sent as JSON to the server.
+ */
+export interface AuthenticatorAttestationResponseJSON
+  extends Omit<
+    AuthenticatorAttestationResponseFuture,
+    'clientDataJSON' | 'attestationObject'
+  > {
+  clientDataJSON: Base64URLString;
+  attestationObject: Base64URLString;
+}
+/**
+ * A slightly-modified AuthenticatorAssertionResponse to simplify working with ArrayBuffers that
+ * are Base64URL-encoded in the browser so that they can be sent as JSON to the server.
+ */
+export interface AuthenticatorAssertionResponseJSON
+  extends Omit<
+    AuthenticatorAssertionResponse,
+    'authenticatorData' | 'clientDataJSON' | 'signature' | 'userHandle'
+  > {
+  authenticatorData: Base64URLString;
+  clientDataJSON: Base64URLString;
+  signature: Base64URLString;
+  userHandle?: string;
+}
+/**
+ * A WebAuthn-compatible device and the information needed to verify assertions by it
+ */
+export declare type AuthenticatorDevice = {
+  credentialPublicKey: Buffer;
+  credentialID: Buffer;
+  counter: number;
+  transports?: AuthenticatorTransport[];
+};
+/**
+ * An attempt to communicate that this isn't just any string, but a Base64URL-encoded string
+ */
+export declare type Base64URLString = string;
+/**
+ * AuthenticatorAttestationResponse in TypeScript's DOM lib is outdated (up through v3.9.7).
+ * Maintain an augmented version here so we can implement additional properties as the WebAuthn
+ * spec evolves.
+ *
+ * See https://www.w3.org/TR/webauthn-2/#iface-authenticatorattestationresponse
+ *
+ * Properties marked optional are not supported in all browsers.
+ */
+export interface AuthenticatorAttestationResponseFuture
+  extends AuthenticatorAttestationResponse {
+  getTransports?: () => AuthenticatorTransport[];
+  getAuthenticatorData?: () => ArrayBuffer;
+  getPublicKey?: () => ArrayBuffer;
+  getPublicKeyAlgorithm?: () => COSEAlgorithmIdentifier[];
+}

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

@@ -1,16 +1,15 @@
+import { UserService } from '@ghostfolio/api/app/user/user.service';
+import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
+import { PrismaService } from '@ghostfolio/api/services/prisma.service';
 import { Injectable, UnauthorizedException } from '@nestjs/common';
 import { PassportStrategy } from '@nestjs/passport';
 import { ExtractJwt, Strategy } from 'passport-jwt';
 
-import { ConfigurationService } from '../../services/configuration.service';
-import { PrismaService } from '../../services/prisma.service';
-import { UserService } from '../user/user.service';
-
 @Injectable()
 export class JwtStrategy extends PassportStrategy(Strategy, 'jwt') {
   public constructor(
     readonly configurationService: ConfigurationService,
-    private prisma: PrismaService,
+    private readonly prismaService: PrismaService,
     private readonly userService: UserService
   ) {
     super({
@@ -24,7 +23,7 @@ export class JwtStrategy extends PassportStrategy(Strategy, 'jwt') {
       const user = await this.userService.user({ id });
 
       if (user) {
-        await this.prisma.analytics.upsert({
+        await this.prismaService.analytics.upsert({
           create: { User: { connect: { id: user.id } } },
           update: { activityCount: { increment: 1 }, updatedAt: new Date() },
           where: { userId: user.id }

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

@@ -0,0 +1,217 @@
+import { AuthDeviceDto } from '@ghostfolio/api/app/auth-device/auth-device.dto';
+import { AuthDeviceService } from '@ghostfolio/api/app/auth-device/auth-device.service';
+import { UserService } from '@ghostfolio/api/app/user/user.service';
+import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
+import type { RequestWithUser } from '@ghostfolio/common/types';
+import {
+  Inject,
+  Injectable,
+  InternalServerErrorException,
+  Logger
+} from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
+import { JwtService } from '@nestjs/jwt';
+import {
+  GenerateAuthenticationOptionsOpts,
+  GenerateRegistrationOptionsOpts,
+  VerifiedAuthenticationResponse,
+  VerifiedRegistrationResponse,
+  VerifyAuthenticationResponseOpts,
+  VerifyRegistrationResponseOpts,
+  generateAuthenticationOptions,
+  generateRegistrationOptions,
+  verifyAuthenticationResponse,
+  verifyRegistrationResponse
+} from '@simplewebauthn/server';
+
+import {
+  AssertionCredentialJSON,
+  AttestationCredentialJSON
+} from './interfaces/simplewebauthn';
+
+@Injectable()
+export class WebAuthService {
+  public constructor(
+    private readonly configurationService: ConfigurationService,
+    private readonly deviceService: AuthDeviceService,
+    private readonly jwtService: JwtService,
+    private readonly userService: UserService,
+    @Inject(REQUEST) private readonly request: RequestWithUser
+  ) {}
+
+  get rpID() {
+    return this.configurationService.get('WEB_AUTH_RP_ID');
+  }
+
+  get expectedOrigin() {
+    return this.configurationService.get('ROOT_URL');
+  }
+
+  public async generateRegistrationOptions() {
+    const user = this.request.user;
+
+    const opts: GenerateRegistrationOptionsOpts = {
+      rpName: 'Ghostfolio',
+      rpID: this.rpID,
+      userID: user.id,
+      userName: user.alias,
+      timeout: 60000,
+      attestationType: 'indirect',
+      authenticatorSelection: {
+        authenticatorAttachment: 'platform',
+        requireResidentKey: false,
+        userVerification: 'required'
+      }
+    };
+
+    const options = generateRegistrationOptions(opts);
+
+    await this.userService.updateUser({
+      data: {
+        authChallenge: options.challenge
+      },
+      where: {
+        id: user.id
+      }
+    });
+
+    return options;
+  }
+
+  public async verifyAttestation(
+    deviceName: string,
+    credential: AttestationCredentialJSON
+  ): Promise<AuthDeviceDto> {
+    const user = this.request.user;
+    const expectedChallenge = user.authChallenge;
+
+    let verification: VerifiedRegistrationResponse;
+    try {
+      const opts: VerifyRegistrationResponseOpts = {
+        credential,
+        expectedChallenge,
+        expectedOrigin: this.expectedOrigin,
+        expectedRPID: this.rpID
+      };
+      verification = await verifyRegistrationResponse(opts);
+    } catch (error) {
+      Logger.error(error, 'WebAuthService');
+      throw new InternalServerErrorException(error.message);
+    }
+
+    const { registrationInfo, verified } = verification;
+
+    const devices = await this.deviceService.authDevices({
+      where: { userId: user.id }
+    });
+    if (registrationInfo && verified) {
+      const { counter, credentialID, credentialPublicKey } = registrationInfo;
+
+      let existingDevice = devices.find(
+        (device) => device.credentialId === credentialID
+      );
+
+      if (!existingDevice) {
+        /**
+         * Add the returned device to the user's list of devices
+         */
+        existingDevice = await this.deviceService.createAuthDevice({
+          counter,
+          credentialPublicKey,
+          credentialId: credentialID,
+          User: { connect: { id: user.id } }
+        });
+      }
+
+      return {
+        createdAt: existingDevice.createdAt.toISOString(),
+        id: existingDevice.id
+      };
+    }
+
+    throw new InternalServerErrorException('An unknown error occurred');
+  }
+
+  public async generateAssertionOptions(deviceId: string) {
+    const device = await this.deviceService.authDevice({ id: deviceId });
+
+    if (!device) {
+      throw new Error('Device not found');
+    }
+
+    const opts: GenerateAuthenticationOptionsOpts = {
+      allowCredentials: [
+        {
+          id: device.credentialId,
+          transports: ['internal'],
+          type: 'public-key'
+        }
+      ],
+      rpID: this.rpID,
+      timeout: 60000,
+      userVerification: 'preferred'
+    };
+
+    const options = generateAuthenticationOptions(opts);
+
+    await this.userService.updateUser({
+      data: {
+        authChallenge: options.challenge
+      },
+      where: {
+        id: device.userId
+      }
+    });
+
+    return options;
+  }
+
+  public async verifyAssertion(
+    deviceId: string,
+    credential: AssertionCredentialJSON
+  ) {
+    const device = await this.deviceService.authDevice({ id: deviceId });
+
+    if (!device) {
+      throw new Error('Device not found');
+    }
+
+    const user = await this.userService.user({ id: device.userId });
+
+    let verification: VerifiedAuthenticationResponse;
+    try {
+      const opts: VerifyAuthenticationResponseOpts = {
+        credential,
+        authenticator: {
+          credentialID: device.credentialId,
+          credentialPublicKey: device.credentialPublicKey,
+          counter: device.counter
+        },
+        expectedChallenge: `${user.authChallenge}`,
+        expectedOrigin: this.expectedOrigin,
+        expectedRPID: this.rpID
+      };
+      verification = verifyAuthenticationResponse(opts);
+    } catch (error) {
+      Logger.error(error, 'WebAuthService');
+      throw new InternalServerErrorException({ error: error.message });
+    }
+
+    const { verified, authenticationInfo } = verification;
+
+    if (verified) {
+      device.counter = authenticationInfo.newCounter;
+
+      await this.deviceService.updateAuthDevice({
+        data: device,
+        where: { id: device.id }
+      });
+
+      return this.jwtService.sign({
+        id: user.id
+      });
+    }
+
+    throw new Error();
+  }
+}

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

@@ -1,10 +1,9 @@
-import { Controller, Inject, Param, Post, UseGuards } from '@nestjs/common';
+import { CacheService } from '@ghostfolio/api/app/cache/cache.service';
+import { RedisCacheService } from '@ghostfolio/api/app/redis-cache/redis-cache.service';
+import type { RequestWithUser } from '@ghostfolio/common/types';
+import { Controller, Inject, Post, UseGuards } from '@nestjs/common';
 import { REQUEST } from '@nestjs/core';
 import { AuthGuard } from '@nestjs/passport';
-import { RequestWithUser } from 'apps/api/src/app/interfaces/request-with-user.type';
-
-import { RedisCacheService } from '../redis-cache/redis-cache.service';
-import { CacheService } from './cache.service';
 
 @Controller('cache')
 export class CacheController {
@@ -21,6 +20,6 @@ export class CacheController {
   public async flushCache(): Promise<void> {
     this.redisCacheService.reset();
 
-    return this.cacheService.flush(this.request.user.id);
+    return this.cacheService.flush();
   }
 }

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

@@ -1,13 +1,27 @@
+import { CacheService } from '@ghostfolio/api/app/cache/cache.service';
+import { RedisCacheModule } from '@ghostfolio/api/app/redis-cache/redis-cache.module';
+import { ConfigurationModule } from '@ghostfolio/api/services/configuration.module';
+import { DataGatheringModule } from '@ghostfolio/api/services/data-gathering.module';
+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 { SymbolProfileModule } from '@ghostfolio/api/services/symbol-profile.module';
 import { Module } from '@nestjs/common';
 
-import { PrismaService } from '../../services/prisma.service';
-import { RedisCacheModule } from '../redis-cache/redis-cache.module';
 import { CacheController } from './cache.controller';
-import { CacheService } from './cache.service';
 
 @Module({
-  imports: [RedisCacheModule],
+  exports: [CacheService],
   controllers: [CacheController],
-  providers: [CacheService, PrismaService]
+  imports: [
+    ConfigurationModule,
+    DataGatheringModule,
+    DataProviderModule,
+    ExchangeRateDataModule,
+    PrismaModule,
+    RedisCacheModule,
+    SymbolProfileModule
+  ],
+  providers: [CacheService]
 })
 export class CacheModule {}

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

@@ -1,18 +1,14 @@
+import { DataGatheringService } from '@ghostfolio/api/services/data-gathering.service';
 import { Injectable } from '@nestjs/common';
-import { Prisma, User } from '@prisma/client';
-
-import { PrismaService } from '../../services/prisma.service';
 
 @Injectable()
 export class CacheService {
-  public constructor(private prisma: PrismaService) {}
+  public constructor(
+    private readonly dataGaterhingService: DataGatheringService
+  ) {}
 
-  public async flush(aUserId: string): Promise<void> {
-    await this.prisma.property.deleteMany({
-      where: {
-        OR: [{ key: 'LAST_DATA_GATHERING' }, { key: 'LOCKED_DATA_GATHERING' }]
-      }
-    });
+  public async flush(): Promise<void> {
+    await this.dataGaterhingService.reset();
 
     return;
   }

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

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

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

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

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

@@ -1,29 +0,0 @@
-import { Module } from '@nestjs/common';
-
-import { ConfigurationService } from '../../services/configuration.service';
-import { DataProviderService } from '../../services/data-provider.service';
-import { AlphaVantageService } from '../../services/data-provider/alpha-vantage/alpha-vantage.service';
-import { RakutenRapidApiService } from '../../services/data-provider/rakuten-rapid-api/rakuten-rapid-api.service';
-import { YahooFinanceService } from '../../services/data-provider/yahoo-finance/yahoo-finance.service';
-import { ExchangeRateDataService } from '../../services/exchange-rate-data.service';
-import { PrismaService } from '../../services/prisma.service';
-import { RulesService } from '../../services/rules.service';
-import { ExperimentalController } from './experimental.controller';
-import { ExperimentalService } from './experimental.service';
-
-@Module({
-  imports: [],
-  controllers: [ExperimentalController],
-  providers: [
-    AlphaVantageService,
-    ConfigurationService,
-    DataProviderService,
-    ExchangeRateDataService,
-    ExperimentalService,
-    PrismaService,
-    RakutenRapidApiService,
-    RulesService,
-    YahooFinanceService
-  ]
-})
-export class ExperimentalModule {}

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

@@ -1,62 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { Currency, Type } from '@prisma/client';
-import { parseISO } from 'date-fns';
-
-import { Portfolio } from '../../models/portfolio';
-import { DataProviderService } from '../../services/data-provider.service';
-import { ExchangeRateDataService } from '../../services/exchange-rate-data.service';
-import { PrismaService } from '../../services/prisma.service';
-import { RulesService } from '../../services/rules.service';
-import { OrderWithPlatform } from '../order/interfaces/order-with-platform.type';
-import { CreateOrderDto } from './create-order.dto';
-import { Data } from './interfaces/data.interface';
-
-@Injectable()
-export class ExperimentalService {
-  public constructor(
-    private readonly dataProviderService: DataProviderService,
-    private readonly exchangeRateDataService: ExchangeRateDataService,
-    private prisma: PrismaService,
-    private readonly rulesService: RulesService
-  ) {}
-
-  public async getBenchmark(aSymbol: string) {
-    return this.prisma.marketData.findMany({
-      orderBy: { date: 'asc' },
-      select: { date: true, marketPrice: true },
-      where: { symbol: aSymbol }
-    });
-  }
-
-  public async getValue(
-    aOrders: CreateOrderDto[],
-    aDate: Date,
-    aBaseCurrency: Currency
-  ): Promise<Data> {
-    const ordersWithPlatform: OrderWithPlatform[] = aOrders.map((order) => {
-      return {
-        ...order,
-        createdAt: new Date(),
-        date: parseISO(order.date),
-        fee: 0,
-        id: undefined,
-        platformId: undefined,
-        type: Type.BUY,
-        updatedAt: undefined,
-        userId: undefined
-      };
-    });
-
-    const portfolio = new Portfolio(
-      this.dataProviderService,
-      this.exchangeRateDataService,
-      this.rulesService
-    );
-    await portfolio.setOrders(ordersWithPlatform);
-
-    return {
-      currency: aBaseCurrency,
-      value: portfolio.getValue(aDate)
-    };
-  }
-}

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

@@ -1,6 +0,0 @@
-import { Currency } from '@prisma/client';
-
-export interface Data {
-  currency: Currency;
-  value: number;
-}

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

@@ -0,0 +1,26 @@
+import { Export } from '@ghostfolio/common/interfaces';
+import type { RequestWithUser } from '@ghostfolio/common/types';
+import { Controller, Get, Inject, Query, UseGuards } from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
+import { AuthGuard } from '@nestjs/passport';
+
+import { ExportService } from './export.service';
+
+@Controller('export')
+export class ExportController {
+  public constructor(
+    private readonly exportService: ExportService,
+    @Inject(REQUEST) private readonly request: RequestWithUser
+  ) {}
+
+  @Get()
+  @UseGuards(AuthGuard('jwt'))
+  public async export(
+    @Query('activityIds') activityIds?: string[]
+  ): Promise<Export> {
+    return this.exportService.export({
+      activityIds,
+      userId: this.request.user.id
+    });
+  }
+}

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

@@ -0,0 +1,22 @@
+import { RedisCacheModule } from '@ghostfolio/api/app/redis-cache/redis-cache.module';
+import { ConfigurationModule } from '@ghostfolio/api/services/configuration.module';
+import { DataGatheringModule } from '@ghostfolio/api/services/data-gathering.module';
+import { DataProviderModule } from '@ghostfolio/api/services/data-provider/data-provider.module';
+import { PrismaModule } from '@ghostfolio/api/services/prisma.module';
+import { Module } from '@nestjs/common';
+
+import { ExportController } from './export.controller';
+import { ExportService } from './export.service';
+
+@Module({
+  imports: [
+    ConfigurationModule,
+    DataGatheringModule,
+    DataProviderModule,
+    PrismaModule,
+    RedisCacheModule
+  ],
+  controllers: [ExportController],
+  providers: [ExportService]
+})
+export class ExportModule {}

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

@@ -0,0 +1,65 @@
+import { environment } from '@ghostfolio/api/environments/environment';
+import { PrismaService } from '@ghostfolio/api/services/prisma.service';
+import { Export } from '@ghostfolio/common/interfaces';
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class ExportService {
+  public constructor(private readonly prismaService: PrismaService) {}
+
+  public async export({
+    activityIds,
+    userId
+  }: {
+    activityIds?: string[];
+    userId: string;
+  }): Promise<Export> {
+    let activities = await this.prismaService.order.findMany({
+      orderBy: { date: 'desc' },
+      select: {
+        accountId: true,
+        date: true,
+        fee: true,
+        id: true,
+        quantity: true,
+        SymbolProfile: true,
+        type: true,
+        unitPrice: true
+      },
+      where: { userId }
+    });
+
+    if (activityIds) {
+      activities = activities.filter((activity) => {
+        return activityIds.includes(activity.id);
+      });
+    }
+
+    return {
+      meta: { date: new Date().toISOString(), version: environment.version },
+      activities: activities.map(
+        ({
+          accountId,
+          date,
+          fee,
+          quantity,
+          SymbolProfile,
+          type,
+          unitPrice
+        }) => {
+          return {
+            accountId,
+            date,
+            fee,
+            quantity,
+            type,
+            unitPrice,
+            currency: SymbolProfile.currency,
+            dataSource: SymbolProfile.dataSource,
+            symbol: type === 'ITEM' ? SymbolProfile.name : SymbolProfile.symbol
+          };
+        }
+      )
+    };
+  }
+}

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

@@ -0,0 +1,10 @@
+import { CreateOrderDto } from '@ghostfolio/api/app/order/create-order.dto';
+import { Type } from 'class-transformer';
+import { IsArray, ValidateNested } from 'class-validator';
+
+export class ImportDataDto {
+  @IsArray()
+  @Type(() => CreateOrderDto)
+  @ValidateNested({ each: true })
+  activities: CreateOrderDto[];
+}

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

@@ -0,0 +1,54 @@
+import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
+import type { RequestWithUser } from '@ghostfolio/common/types';
+import {
+  Body,
+  Controller,
+  HttpException,
+  Inject,
+  Logger,
+  Post,
+  UseGuards
+} from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
+import { AuthGuard } from '@nestjs/passport';
+import { StatusCodes, getReasonPhrase } from 'http-status-codes';
+
+import { ImportDataDto } from './import-data.dto';
+import { ImportService } from './import.service';
+
+@Controller('import')
+export class ImportController {
+  public constructor(
+    private readonly configurationService: ConfigurationService,
+    private readonly importService: ImportService,
+    @Inject(REQUEST) private readonly request: RequestWithUser
+  ) {}
+
+  @Post()
+  @UseGuards(AuthGuard('jwt'))
+  public async import(@Body() importData: ImportDataDto): Promise<void> {
+    if (!this.configurationService.get('ENABLE_FEATURE_IMPORT')) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    try {
+      return await this.importService.import({
+        activities: importData.activities,
+        userId: this.request.user.id
+      });
+    } catch (error) {
+      Logger.error(error, ImportController);
+
+      throw new HttpException(
+        {
+          error: getReasonPhrase(StatusCodes.BAD_REQUEST),
+          message: [error.message]
+        },
+        StatusCodes.BAD_REQUEST
+      );
+    }
+  }
+}

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

@@ -0,0 +1,28 @@
+import { AccountModule } from '@ghostfolio/api/app/account/account.module';
+import { CacheModule } from '@ghostfolio/api/app/cache/cache.module';
+import { OrderModule } from '@ghostfolio/api/app/order/order.module';
+import { RedisCacheModule } from '@ghostfolio/api/app/redis-cache/redis-cache.module';
+import { ConfigurationModule } from '@ghostfolio/api/services/configuration.module';
+import { DataGatheringModule } from '@ghostfolio/api/services/data-gathering.module';
+import { DataProviderModule } from '@ghostfolio/api/services/data-provider/data-provider.module';
+import { PrismaModule } from '@ghostfolio/api/services/prisma.module';
+import { Module } from '@nestjs/common';
+
+import { ImportController } from './import.controller';
+import { ImportService } from './import.service';
+
+@Module({
+  controllers: [ImportController],
+  imports: [
+    AccountModule,
+    CacheModule,
+    ConfigurationModule,
+    DataGatheringModule,
+    DataProviderModule,
+    OrderModule,
+    PrismaModule,
+    RedisCacheModule
+  ],
+  providers: [ImportService]
+})
+export class ImportModule {}

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

@@ -0,0 +1,145 @@
+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 { 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({
+    activities,
+    userId
+  }: {
+    activities: Partial<CreateOrderDto>[];
+    userId: string;
+  }): Promise<void> {
+    for (const activity of activities) {
+      if (!activity.dataSource) {
+        if (activity.type === 'ITEM') {
+          activity.dataSource = 'MANUAL';
+        } else {
+          activity.dataSource = this.dataProviderService.getPrimaryDataSource();
+        }
+      }
+    }
+
+    await this.validateActivities({ activities, userId });
+
+    const accountIds = (await this.accountService.getAccounts(userId)).map(
+      (account) => {
+        return account.id;
+      }
+    );
+
+    for (const {
+      accountId,
+      currency,
+      dataSource,
+      date,
+      fee,
+      quantity,
+      symbol,
+      type,
+      unitPrice
+    } of activities) {
+      await this.orderService.createOrder({
+        fee,
+        quantity,
+        type,
+        unitPrice,
+        userId,
+        accountId: accountIds.includes(accountId) ? accountId : undefined,
+        date: parseISO(<string>(<unknown>date)),
+        SymbolProfile: {
+          connectOrCreate: {
+            create: {
+              currency,
+              dataSource,
+              symbol
+            },
+            where: {
+              dataSource_symbol: {
+                dataSource,
+                symbol
+              }
+            }
+          }
+        },
+        User: { connect: { id: userId } }
+      });
+    }
+  }
+
+  private async validateActivities({
+    activities,
+    userId
+  }: {
+    activities: Partial<CreateOrderDto>[];
+    userId: string;
+  }) {
+    if (
+      activities?.length > this.configurationService.get('MAX_ORDERS_TO_IMPORT')
+    ) {
+      throw new Error(
+        `Too many activities (${this.configurationService.get(
+          'MAX_ORDERS_TO_IMPORT'
+        )} at most)`
+      );
+    }
+
+    const existingActivities = await this.orderService.orders({
+      include: { SymbolProfile: true },
+      orderBy: { date: 'desc' },
+      where: { userId }
+    });
+
+    for (const [
+      index,
+      { currency, dataSource, date, fee, quantity, symbol, type, unitPrice }
+    ] of activities.entries()) {
+      const duplicateActivity = existingActivities.find((activity) => {
+        return (
+          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 (duplicateActivity) {
+        throw new Error(`activities.${index} is a duplicate activity`);
+      }
+
+      if (dataSource !== 'MANUAL') {
+        const quotes = await this.dataProviderService.getQuotes([
+          { dataSource, symbol }
+        ]);
+
+        if (quotes[symbol] === undefined) {
+          throw new Error(
+            `activities.${index}.symbol ("${symbol}") is not valid for the specified data source ("${dataSource}")`
+          );
+        }
+
+        if (quotes[symbol].currency !== currency) {
+          throw new Error(
+            `activities.${index}.currency ("${currency}") does not match with "${quotes[symbol].currency}"`
+          );
+        }
+      }
+    }
+  }
+}

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

@@ -1,7 +1,7 @@
+import { InfoItem } from '@ghostfolio/common/interfaces';
 import { Controller, Get } from '@nestjs/common';
 
 import { InfoService } from './info.service';
-import { InfoItem } from './interfaces/info-item.interface';
 
 @Controller('info')
 export class InfoController {

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

@@ -1,19 +1,33 @@
+import { RedisCacheModule } from '@ghostfolio/api/app/redis-cache/redis-cache.module';
+import { ConfigurationModule } from '@ghostfolio/api/services/configuration.module';
+import { DataGatheringModule } from '@ghostfolio/api/services/data-gathering.module';
+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 { PropertyModule } from '@ghostfolio/api/services/property/property.module';
+import { SymbolProfileModule } from '@ghostfolio/api/services/symbol-profile.module';
 import { Module } from '@nestjs/common';
 import { JwtModule } from '@nestjs/jwt';
 
-import { ConfigurationService } from '../../services/configuration.service';
-import { PrismaService } from '../../services/prisma.service';
 import { InfoController } from './info.controller';
 import { InfoService } from './info.service';
 
 @Module({
+  controllers: [InfoController],
   imports: [
+    ConfigurationModule,
+    DataGatheringModule,
+    DataProviderModule,
+    ExchangeRateDataModule,
     JwtModule.register({
       secret: process.env.JWT_SECRET_KEY,
       signOptions: { expiresIn: '30 days' }
-    })
+    }),
+    PrismaModule,
+    PropertyModule,
+    RedisCacheModule,
+    SymbolProfileModule
   ],
-  controllers: [InfoController],
-  providers: [ConfigurationService, InfoService, PrismaService]
+  providers: [InfoService]
 })
 export class InfoModule {}

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

@@ -1,54 +1,271 @@
-import { permissions } from '@ghostfolio/helper';
-import { Injectable } from '@nestjs/common';
+import { RedisCacheService } from '@ghostfolio/api/app/redis-cache/redis-cache.service';
+import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
+import { DataGatheringService } from '@ghostfolio/api/services/data-gathering.service';
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data.service';
+import { PrismaService } from '@ghostfolio/api/services/prisma.service';
+import { PropertyService } from '@ghostfolio/api/services/property/property.service';
+import {
+  DEMO_USER_ID,
+  PROPERTY_IS_READ_ONLY_MODE,
+  PROPERTY_SLACK_COMMUNITY_USERS,
+  PROPERTY_STRIPE_CONFIG,
+  PROPERTY_SYSTEM_MESSAGE,
+  ghostfolioFearAndGreedIndexDataSource
+} from '@ghostfolio/common/config';
+import { encodeDataSource } from '@ghostfolio/common/helper';
+import { InfoItem } from '@ghostfolio/common/interfaces';
+import { Statistics } from '@ghostfolio/common/interfaces/statistics.interface';
+import { Subscription } from '@ghostfolio/common/interfaces/subscription.interface';
+import { permissions } from '@ghostfolio/common/permissions';
+import { Injectable, Logger } from '@nestjs/common';
 import { JwtService } from '@nestjs/jwt';
-import { Currency } from '@prisma/client';
-
-import { ConfigurationService } from '../../services/configuration.service';
-import { PrismaService } from '../../services/prisma.service';
-import { InfoItem } from './interfaces/info-item.interface';
+import * as bent from 'bent';
+import { subDays } from 'date-fns';
 
 @Injectable()
 export class InfoService {
-  private static DEMO_USER_ID = '9b112b4d-3b7d-4bad-9bdd-3b0f7b4dac2f';
+  private static CACHE_KEY_STATISTICS = 'STATISTICS';
 
   public constructor(
     private readonly configurationService: ConfigurationService,
-    private jwtService: JwtService,
-    private prisma: PrismaService
+    private readonly exchangeRateDataService: ExchangeRateDataService,
+    private readonly dataGatheringService: DataGatheringService,
+    private readonly jwtService: JwtService,
+    private readonly prismaService: PrismaService,
+    private readonly propertyService: PropertyService,
+    private readonly redisCacheService: RedisCacheService
   ) {}
 
   public async get(): Promise<InfoItem> {
-    const platforms = await this.prisma.platform.findMany({
+    const info: Partial<InfoItem> = {};
+    let isReadOnlyMode: boolean;
+    const platforms = await this.prismaService.platform.findMany({
       orderBy: { name: 'asc' },
       select: { id: true, name: true }
     });
+    let systemMessage: string;
 
     const globalPermissions: string[] = [];
 
+    if (this.configurationService.get('ENABLE_FEATURE_BLOG')) {
+      globalPermissions.push(permissions.enableBlog);
+    }
+
+    if (this.configurationService.get('ENABLE_FEATURE_FEAR_AND_GREED_INDEX')) {
+      info.fearAndGreedDataSource = encodeDataSource(
+        ghostfolioFearAndGreedIndexDataSource
+      );
+    }
+
+    if (this.configurationService.get('ENABLE_FEATURE_IMPORT')) {
+      globalPermissions.push(permissions.enableImport);
+    }
+
+    if (this.configurationService.get('ENABLE_FEATURE_READ_ONLY_MODE')) {
+      isReadOnlyMode = (await this.propertyService.getByKey(
+        PROPERTY_IS_READ_ONLY_MODE
+      )) as boolean;
+    }
+
     if (this.configurationService.get('ENABLE_FEATURE_SOCIAL_LOGIN')) {
-      globalPermissions.push(permissions.useSocialLogin);
+      globalPermissions.push(permissions.enableSocialLogin);
+    }
+
+    if (this.configurationService.get('ENABLE_FEATURE_STATISTICS')) {
+      globalPermissions.push(permissions.enableStatistics);
+    }
+
+    if (this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION')) {
+      globalPermissions.push(permissions.enableSubscription);
+
+      info.stripePublicKey = this.configurationService.get('STRIPE_PUBLIC_KEY');
+    }
+
+    if (this.configurationService.get('ENABLE_FEATURE_SYSTEM_MESSAGE')) {
+      globalPermissions.push(permissions.enableSystemMessage);
+
+      systemMessage = (await this.propertyService.getByKey(
+        PROPERTY_SYSTEM_MESSAGE
+      )) as string;
     }
 
     return {
+      ...info,
       globalPermissions,
+      isReadOnlyMode,
       platforms,
-      currencies: Object.values(Currency),
+      systemMessage,
+      currencies: this.exchangeRateDataService.getCurrencies(),
       demoAuthToken: this.getDemoAuthToken(),
-      lastDataGathering: await this.getLastDataGathering()
+      lastDataGathering: await this.getLastDataGathering(),
+      statistics: await this.getStatistics(),
+      subscriptions: await this.getSubscriptions()
     };
   }
 
+  private async countActiveUsers(aDays: number) {
+    return await this.prismaService.user.count({
+      orderBy: {
+        Analytics: {
+          updatedAt: 'desc'
+        }
+      },
+      where: {
+        AND: [
+          {
+            NOT: {
+              Analytics: null
+            }
+          },
+          {
+            Analytics: {
+              updatedAt: {
+                gt: subDays(new Date(), aDays)
+              }
+            }
+          }
+        ]
+      }
+    });
+  }
+
+  private async countGitHubContributors(): Promise<number> {
+    try {
+      const get = bent(
+        `https://api.github.com/repos/ghostfolio/ghostfolio/contributors`,
+        'GET',
+        'json',
+        200,
+        {
+          'User-Agent': 'request'
+        }
+      );
+
+      const contributors = await get();
+      return contributors?.length;
+    } catch (error) {
+      Logger.error(error, 'InfoService');
+
+      return undefined;
+    }
+  }
+
+  private async countGitHubStargazers(): Promise<number> {
+    try {
+      const get = bent(
+        `https://api.github.com/repos/ghostfolio/ghostfolio`,
+        'GET',
+        'json',
+        200,
+        {
+          'User-Agent': 'request'
+        }
+      );
+
+      const { stargazers_count } = await get();
+      return stargazers_count;
+    } catch (error) {
+      Logger.error(error, 'InfoService');
+
+      return undefined;
+    }
+  }
+
+  private async countNewUsers(aDays: number) {
+    return await this.prismaService.user.count({
+      orderBy: {
+        createdAt: 'desc'
+      },
+      where: {
+        AND: [
+          {
+            NOT: {
+              Analytics: null
+            }
+          },
+          {
+            createdAt: {
+              gt: subDays(new Date(), aDays)
+            }
+          }
+        ]
+      }
+    });
+  }
+
+  private async countSlackCommunityUsers() {
+    return (await this.propertyService.getByKey(
+      PROPERTY_SLACK_COMMUNITY_USERS
+    )) as string;
+  }
+
   private getDemoAuthToken() {
     return this.jwtService.sign({
-      id: InfoService.DEMO_USER_ID
+      id: DEMO_USER_ID
     });
   }
 
   private async getLastDataGathering() {
-    const lastDataGathering = await this.prisma.property.findUnique({
-      where: { key: 'LAST_DATA_GATHERING' }
+    const lastDataGathering =
+      await this.dataGatheringService.getLastDataGathering();
+
+    return lastDataGathering ?? null;
+  }
+
+  private async getStatistics() {
+    if (!this.configurationService.get('ENABLE_FEATURE_STATISTICS')) {
+      return undefined;
+    }
+
+    let statistics: Statistics;
+
+    try {
+      statistics = JSON.parse(
+        await this.redisCacheService.get(InfoService.CACHE_KEY_STATISTICS)
+      );
+
+      if (statistics) {
+        return statistics;
+      }
+    } catch {}
+
+    const activeUsers1d = await this.countActiveUsers(1);
+    const activeUsers30d = await this.countActiveUsers(30);
+    const newUsers30d = await this.countNewUsers(30);
+    const gitHubContributors = await this.countGitHubContributors();
+    const gitHubStargazers = await this.countGitHubStargazers();
+    const slackCommunityUsers = await this.countSlackCommunityUsers();
+
+    statistics = {
+      activeUsers1d,
+      activeUsers30d,
+      gitHubContributors,
+      gitHubStargazers,
+      newUsers30d,
+      slackCommunityUsers
+    };
+
+    await this.redisCacheService.set(
+      InfoService.CACHE_KEY_STATISTICS,
+      JSON.stringify(statistics)
+    );
+
+    return statistics;
+  }
+
+  private async getSubscriptions(): Promise<Subscription[]> {
+    if (!this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION')) {
+      return undefined;
+    }
+
+    const stripeConfig = await this.prismaService.property.findUnique({
+      where: { key: PROPERTY_STRIPE_CONFIG }
     });
 
-    return lastDataGathering?.value ? new Date(lastDataGathering.value) : null;
+    if (stripeConfig) {
+      return [JSON.parse(stripeConfig.value)];
+    }
+
+    return [];
   }
 }

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

@@ -1,13 +0,0 @@
-import { Currency } from '@prisma/client';
-
-export interface InfoItem {
-  currencies: Currency[];
-  demoAuthToken: string;
-  globalPermissions: string[];
-  lastDataGathering?: Date;
-  message?: {
-    text: string;
-    type: string;
-  };
-  platforms: { id: string; name: string }[];
-}

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

@@ -1,3 +0,0 @@
-import { Settings, User } from '@prisma/client';
-
-export type UserWithSettings = User & { Settings: Settings };

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

@@ -1,9 +1,23 @@
-import { Currency, Type } from '@prisma/client';
-import { IsISO8601, IsNumber, IsString, ValidateIf } from 'class-validator';
+import { DataSource, Type } from '@prisma/client';
+import {
+  IsEnum,
+  IsISO8601,
+  IsNumber,
+  IsOptional,
+  IsString
+} from 'class-validator';
 
 export class CreateOrderDto {
   @IsString()
-  currency: Currency;
+  @IsOptional()
+  accountId: string;
+
+  @IsString()
+  currency: string;
+
+  @IsEnum(DataSource, { each: true })
+  @IsOptional()
+  dataSource: DataSource;
 
   @IsISO8601()
   date: string;
@@ -11,17 +25,13 @@ export class CreateOrderDto {
   @IsNumber()
   fee: number;
 
-  @IsString()
-  @ValidateIf((object, value) => value !== null)
-  platformId: string | null;
-
   @IsNumber()
   quantity: number;
 
   @IsString()
   symbol: string;
 
-  @IsString()
+  @IsEnum(Type, { each: true })
   type: Type;
 
   @IsNumber()

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

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

apps/api/src/app/order/interfaces/order-with-platform.type.ts

@@ -1,3 +0,0 @@
-import { Order, Platform } from '@prisma/client';
-
-export type OrderWithPlatform = Order & { Platform?: Platform };

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

@@ -1,3 +1,10 @@
+import { UserService } from '@ghostfolio/api/app/user/user.service';
+import { nullifyValuesInObjects } from '@ghostfolio/api/helper/object.helper';
+import { TransformDataSourceInRequestInterceptor } from '@ghostfolio/api/interceptors/transform-data-source-in-request.interceptor';
+import { TransformDataSourceInResponseInterceptor } from '@ghostfolio/api/interceptors/transform-data-source-in-response.interceptor';
+import { ImpersonationService } from '@ghostfolio/api/services/impersonation.service';
+import { hasPermission, permissions } from '@ghostfolio/common/permissions';
+import type { RequestWithUser } from '@ghostfolio/common/types';
 import {
   Body,
   Controller,
@@ -9,19 +16,17 @@ import {
   Param,
   Post,
   Put,
-  UseGuards
+  UseGuards,
+  UseInterceptors
 } from '@nestjs/common';
 import { REQUEST } from '@nestjs/core';
 import { AuthGuard } from '@nestjs/passport';
 import { Order as OrderModel } from '@prisma/client';
-import { RequestWithUser } from 'apps/api/src/app/interfaces/request-with-user.type';
 import { parseISO } from 'date-fns';
 import { StatusCodes, getReasonPhrase } from 'http-status-codes';
-import { getPermissions, hasPermission, permissions } from 'libs/helper/src';
 
-import { nullifyValuesInObjects } from '../../helper/object.helper';
-import { ImpersonationService } from '../../services/impersonation.service';
 import { CreateOrderDto } from './create-order.dto';
+import { Activities } from './interfaces/activities.interface';
 import { OrderService } from './order.service';
 import { UpdateOrderDto } from './update-order.dto';
 
@@ -30,17 +35,15 @@ export class OrderController {
   public constructor(
     private readonly impersonationService: ImpersonationService,
     private readonly orderService: OrderService,
-    @Inject(REQUEST) private readonly request: RequestWithUser
+    @Inject(REQUEST) private readonly request: RequestWithUser,
+    private readonly userService: UserService
   ) {}
 
   @Delete(':id')
   @UseGuards(AuthGuard('jwt'))
   public async deleteOrder(@Param('id') id: string): Promise<OrderModel> {
     if (
-      !hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.deleteOrder
-      )
+      !hasPermission(this.request.user.permissions, permissions.deleteOrder)
     ) {
       throw new HttpException(
         getReasonPhrase(StatusCodes.FORBIDDEN),
@@ -48,52 +51,7 @@ export class OrderController {
       );
     }
 
-    return this.orderService.deleteOrder(
-      {
-        id_userId: {
-          id,
-          userId: this.request.user.id
-        }
-      },
-      this.request.user.id
-    );
-  }
-
-  @Get()
-  @UseGuards(AuthGuard('jwt'))
-  public async getAllOrders(
-    @Headers('impersonation-id') impersonationId
-  ): Promise<OrderModel[]> {
-    const impersonationUserId = await this.impersonationService.validateImpersonationId(
-      impersonationId,
-      this.request.user.id
-    );
-
-    let orders = await this.orderService.orders({
-      include: {
-        Platform: true
-      },
-      orderBy: { date: 'desc' },
-      where: { userId: impersonationUserId || this.request.user.id }
-    });
-
-    if (
-      impersonationUserId &&
-      !hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.readForeignPortfolio
-      )
-    ) {
-      orders = nullifyValuesInObjects(orders, ['fee', 'quantity', 'unitPrice']);
-    }
-
-    return orders;
-  }
-
-  @Get(':id')
-  @UseGuards(AuthGuard('jwt'))
-  public async getOrderById(@Param('id') id: string): Promise<OrderModel> {
-    return this.orderService.order({
+    return this.orderService.deleteOrder({
       id_userId: {
         id,
         userId: this.request.user.id
@@ -101,14 +59,48 @@ export class OrderController {
     });
   }
 
+  @Get()
+  @UseGuards(AuthGuard('jwt'))
+  @UseInterceptors(TransformDataSourceInResponseInterceptor)
+  public async getAllOrders(
+    @Headers('impersonation-id') impersonationId
+  ): Promise<Activities> {
+    const impersonationUserId =
+      await this.impersonationService.validateImpersonationId(
+        impersonationId,
+        this.request.user.id
+      );
+    const userCurrency = this.request.user.Settings.currency;
+
+    let activities = await this.orderService.getOrders({
+      userCurrency,
+      includeDrafts: true,
+      userId: impersonationUserId || this.request.user.id
+    });
+
+    if (
+      impersonationUserId ||
+      this.userService.isRestrictedView(this.request.user)
+    ) {
+      activities = nullifyValuesInObjects(activities, [
+        'fee',
+        'feeInBaseCurrency',
+        'quantity',
+        'unitPrice',
+        'value',
+        'valueInBaseCurrency'
+      ]);
+    }
+
+    return { activities };
+  }
+
   @Post()
   @UseGuards(AuthGuard('jwt'))
+  @UseInterceptors(TransformDataSourceInRequestInterceptor)
   public async createOrder(@Body() data: CreateOrderDto): Promise<OrderModel> {
     if (
-      !hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.createOrder
-      )
+      !hasPermission(this.request.user.permissions, permissions.createOrder)
     ) {
       throw new HttpException(
         getReasonPhrase(StatusCodes.FORBIDDEN),
@@ -116,43 +108,35 @@ export class OrderController {
       );
     }
 
-    const date = parseISO(data.date);
-
-    if (data.platformId) {
-      const platformId = data.platformId;
-      delete data.platformId;
-
-      return this.orderService.createOrder(
-        {
-          ...data,
-          date,
-          Platform: { connect: { id: platformId } },
-          User: { connect: { id: this.request.user.id } }
-        },
-        this.request.user.id
-      );
-    } else {
-      delete data.platformId;
-
-      return this.orderService.createOrder(
-        {
-          ...data,
-          date,
-          User: { connect: { id: this.request.user.id } }
-        },
-        this.request.user.id
-      );
-    }
+    return this.orderService.createOrder({
+      ...data,
+      date: parseISO(data.date),
+      SymbolProfile: {
+        connectOrCreate: {
+          create: {
+            currency: data.currency,
+            dataSource: data.dataSource,
+            symbol: data.symbol
+          },
+          where: {
+            dataSource_symbol: {
+              dataSource: data.dataSource,
+              symbol: data.symbol
+            }
+          }
+        }
+      },
+      User: { connect: { id: this.request.user.id } },
+      userId: this.request.user.id
+    });
   }
 
   @Put(':id')
   @UseGuards(AuthGuard('jwt'))
+  @UseInterceptors(TransformDataSourceInRequestInterceptor)
   public async update(@Param('id') id: string, @Body() data: UpdateOrderDto) {
     if (
-      !hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.updateOrder
-      )
+      !hasPermission(this.request.user.permissions, permissions.updateOrder)
     ) {
       throw new HttpException(
         getReasonPhrase(StatusCodes.FORBIDDEN),
@@ -167,52 +151,43 @@ export class OrderController {
       }
     });
 
-    const date = parseISO(data.date);
-
-    if (data.platformId) {
-      const platformId = data.platformId;
-      delete data.platformId;
-
-      return this.orderService.updateOrder(
-        {
-          data: {
-            ...data,
-            date,
-            Platform: { connect: { id: platformId } },
-            User: { connect: { id: this.request.user.id } }
-          },
-          where: {
-            id_userId: {
-              id,
-              userId: this.request.user.id
-            }
-          }
-        },
-        this.request.user.id
-      );
-    } else {
-      // platformId is null, remove it
-      delete data.platformId;
-
-      return this.orderService.updateOrder(
-        {
-          data: {
-            ...data,
-            date,
-            Platform: originalOrder.platformId
-              ? { disconnect: true }
-              : undefined,
-            User: { connect: { id: this.request.user.id } }
-          },
-          where: {
-            id_userId: {
-              id,
-              userId: this.request.user.id
-            }
-          }
-        },
-        this.request.user.id
+    if (!originalOrder) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
       );
     }
+
+    const date = parseISO(data.date);
+
+    const accountId = data.accountId;
+    delete data.accountId;
+
+    return this.orderService.updateOrder({
+      data: {
+        ...data,
+        date,
+        Account: {
+          connect: {
+            id_userId: { id: accountId, userId: this.request.user.id }
+          }
+        },
+        SymbolProfile: {
+          connect: {
+            dataSource_symbol: {
+              dataSource: data.dataSource,
+              symbol: data.symbol
+            }
+          }
+        },
+        User: { connect: { id: this.request.user.id } }
+      },
+      where: {
+        id_userId: {
+          id,
+          userId: this.request.user.id
+        }
+      }
+    });
   }
 }

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

@@ -1,32 +1,34 @@
+import { AccountService } from '@ghostfolio/api/app/account/account.service';
+import { CacheModule } from '@ghostfolio/api/app/cache/cache.module';
+import { RedisCacheModule } from '@ghostfolio/api/app/redis-cache/redis-cache.module';
+import { UserModule } from '@ghostfolio/api/app/user/user.module';
+import { ConfigurationModule } from '@ghostfolio/api/services/configuration.module';
+import { DataGatheringModule } from '@ghostfolio/api/services/data-gathering.module';
+import { DataProviderModule } from '@ghostfolio/api/services/data-provider/data-provider.module';
+import { ExchangeRateDataModule } from '@ghostfolio/api/services/exchange-rate-data.module';
+import { ImpersonationModule } from '@ghostfolio/api/services/impersonation.module';
+import { PrismaModule } from '@ghostfolio/api/services/prisma.module';
+import { SymbolProfileModule } from '@ghostfolio/api/services/symbol-profile.module';
 import { Module } from '@nestjs/common';
 
-import { ConfigurationService } from '../../services/configuration.service';
-import { DataGatheringService } from '../../services/data-gathering.service';
-import { DataProviderService } from '../../services/data-provider.service';
-import { AlphaVantageService } from '../../services/data-provider/alpha-vantage/alpha-vantage.service';
-import { RakutenRapidApiService } from '../../services/data-provider/rakuten-rapid-api/rakuten-rapid-api.service';
-import { YahooFinanceService } from '../../services/data-provider/yahoo-finance/yahoo-finance.service';
-import { ImpersonationService } from '../../services/impersonation.service';
-import { PrismaService } from '../../services/prisma.service';
-import { CacheService } from '../cache/cache.service';
-import { RedisCacheModule } from '../redis-cache/redis-cache.module';
 import { OrderController } from './order.controller';
 import { OrderService } from './order.service';
 
 @Module({
-  imports: [RedisCacheModule],
   controllers: [OrderController],
-  providers: [
-    AlphaVantageService,
-    CacheService,
-    ConfigurationService,
-    DataGatheringService,
-    DataProviderService,
-    ImpersonationService,
-    OrderService,
-    PrismaService,
-    RakutenRapidApiService,
-    YahooFinanceService
-  ]
+  exports: [OrderService],
+  imports: [
+    CacheModule,
+    ConfigurationModule,
+    DataGatheringModule,
+    DataProviderModule,
+    ExchangeRateDataModule,
+    ImpersonationModule,
+    PrismaModule,
+    RedisCacheModule,
+    SymbolProfileModule,
+    UserModule
+  ],
+  providers: [AccountService, OrderService]
 })
 export class OrderModule {}

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

@@ -1,25 +1,33 @@
+import { AccountService } from '@ghostfolio/api/app/account/account.service';
+import { CacheService } from '@ghostfolio/api/app/cache/cache.service';
+import { DataGatheringService } from '@ghostfolio/api/services/data-gathering.service';
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data.service';
+import { PrismaService } from '@ghostfolio/api/services/prisma.service';
+import { SymbolProfileService } from '@ghostfolio/api/services/symbol-profile.service';
+import { OrderWithAccount } from '@ghostfolio/common/types';
 import { Injectable } from '@nestjs/common';
-import { Order, Prisma } from '@prisma/client';
+import { DataSource, Order, Prisma, Type as TypeOfOrder } from '@prisma/client';
+import Big from 'big.js';
+import { endOfToday, isAfter } from 'date-fns';
+import { v4 as uuidv4 } from 'uuid';
 
-import { DataGatheringService } from '../../services/data-gathering.service';
-import { PrismaService } from '../../services/prisma.service';
-import { CacheService } from '../cache/cache.service';
-import { RedisCacheService } from '../redis-cache/redis-cache.service';
-import { OrderWithPlatform } from './interfaces/order-with-platform.type';
+import { Activity } from './interfaces/activities.interface';
 
 @Injectable()
 export class OrderService {
   public constructor(
+    private readonly accountService: AccountService,
     private readonly cacheService: CacheService,
+    private readonly exchangeRateDataService: ExchangeRateDataService,
     private readonly dataGatheringService: DataGatheringService,
-    private readonly redisCacheService: RedisCacheService,
-    private prisma: PrismaService
+    private readonly prismaService: PrismaService,
+    private readonly symbolProfileService: SymbolProfileService
   ) {}
 
   public async order(
     orderWhereUniqueInput: Prisma.OrderWhereUniqueInput
   ): Promise<Order | null> {
-    return this.prisma.order.findUnique({
+    return this.prismaService.order.findUnique({
       where: orderWhereUniqueInput
     });
   }
@@ -30,11 +38,11 @@ export class OrderService {
     take?: number;
     cursor?: Prisma.OrderWhereUniqueInput;
     where?: Prisma.OrderWhereInput;
-    orderBy?: Prisma.OrderOrderByInput;
-  }): Promise<OrderWithPlatform[]> {
+    orderBy?: Prisma.OrderOrderByWithRelationInput;
+  }): Promise<OrderWithAccount[]> {
     const { include, skip, take, cursor, where, orderBy } = params;
 
-    return this.prisma.order.findMany({
+    return this.prismaService.order.findMany({
       cursor,
       include,
       orderBy,
@@ -45,60 +53,212 @@ export class OrderService {
   }
 
   public async createOrder(
-    data: Prisma.OrderCreateInput,
-    aUserId: string
+    data: Prisma.OrderCreateInput & {
+      accountId?: string;
+      currency?: string;
+      dataSource?: DataSource;
+      symbol?: string;
+      userId: string;
+    }
   ): Promise<Order> {
-    this.redisCacheService.remove(`${aUserId}.portfolio`);
+    const defaultAccount = (
+      await this.accountService.getAccounts(data.userId)
+    ).find((account) => {
+      return account.isDefault === true;
+    });
 
-    // Gather symbol data of order in the background
-    this.dataGatheringService.gatherSymbols([
+    let Account = {
+      connect: {
+        id_userId: {
+          userId: data.userId,
+          id: data.accountId ?? defaultAccount?.id
+        }
+      }
+    };
+
+    if (data.type === 'ITEM') {
+      const currency = data.SymbolProfile.connectOrCreate.create.currency;
+      const dataSource: DataSource = 'MANUAL';
+      const id = uuidv4();
+      const name = data.SymbolProfile.connectOrCreate.create.symbol;
+
+      Account = undefined;
+      data.id = id;
+      data.SymbolProfile.connectOrCreate.create.currency = currency;
+      data.SymbolProfile.connectOrCreate.create.dataSource = dataSource;
+      data.SymbolProfile.connectOrCreate.create.name = name;
+      data.SymbolProfile.connectOrCreate.create.symbol = id;
+      data.SymbolProfile.connectOrCreate.where.dataSource_symbol = {
+        dataSource,
+        symbol: id
+      };
+    } else {
+      data.SymbolProfile.connectOrCreate.create.symbol =
+        data.SymbolProfile.connectOrCreate.create.symbol.toUpperCase();
+    }
+
+    await this.dataGatheringService.gatherProfileData([
       {
-        date: <Date>data.date,
-        symbol: data.symbol
+        dataSource: data.SymbolProfile.connectOrCreate.create.dataSource,
+        symbol: data.SymbolProfile.connectOrCreate.create.symbol
       }
     ]);
 
-    await this.cacheService.flush(aUserId);
+    const isDraft = isAfter(data.date as Date, endOfToday());
 
-    return this.prisma.order.create({
-      data
+    if (!isDraft) {
+      // Gather symbol data of order in the background, if not draft
+      this.dataGatheringService.gatherSymbols([
+        {
+          dataSource: data.SymbolProfile.connectOrCreate.create.dataSource,
+          date: <Date>data.date,
+          symbol: data.SymbolProfile.connectOrCreate.create.symbol
+        }
+      ]);
+    }
+
+    await this.cacheService.flush();
+
+    delete data.accountId;
+    delete data.currency;
+    delete data.dataSource;
+    delete data.symbol;
+    delete data.userId;
+
+    const orderData: Prisma.OrderCreateInput = data;
+
+    return this.prismaService.order.create({
+      data: {
+        ...orderData,
+        Account,
+        isDraft
+      }
     });
   }
 
   public async deleteOrder(
-    where: Prisma.OrderWhereUniqueInput,
-    aUserId: string
+    where: Prisma.OrderWhereUniqueInput
   ): Promise<Order> {
-    this.redisCacheService.remove(`${aUserId}.portfolio`);
-
-    return this.prisma.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({
+    includeDrafts = false,
+    types,
+    userCurrency,
+    userId
+  }: {
+    includeDrafts?: boolean;
+    types?: TypeOfOrder[];
+    userCurrency: string;
+    userId: string;
+  }): Promise<Activity[]> {
+    const where: Prisma.OrderWhereInput = { userId };
+
+    if (includeDrafts === false) {
+      where.isDraft = false;
+    }
+
+    if (types) {
+      where.OR = types.map((type) => {
+        return {
+          type: {
+            equals: type
+          }
+        };
+      });
+    }
+
+    return (
+      await this.orders({
+        where,
+        include: {
+          // eslint-disable-next-line @typescript-eslint/naming-convention
+          Account: {
+            include: {
+              Platform: true
+            }
+          },
+          // eslint-disable-next-line @typescript-eslint/naming-convention
+          SymbolProfile: true
+        },
+        orderBy: { date: 'asc' }
+      })
+    ).map((order) => {
+      const value = new Big(order.quantity).mul(order.unitPrice).toNumber();
+
+      return {
+        ...order,
+        value,
+        feeInBaseCurrency: this.exchangeRateDataService.toCurrency(
+          order.fee,
+          order.SymbolProfile.currency,
+          userCurrency
+        ),
+        valueInBaseCurrency: this.exchangeRateDataService.toCurrency(
+          value,
+          order.SymbolProfile.currency,
+          userCurrency
+        )
+      };
+    });
   }
 
-  public async updateOrder(
-    params: {
-      where: Prisma.OrderWhereUniqueInput;
-      data: Prisma.OrderUpdateInput;
-    },
-    aUserId: string
-  ): Promise<Order> {
-    const { data, where } = params;
+  public async updateOrder({
+    data,
+    where
+  }: {
+    data: Prisma.OrderUpdateInput & {
+      currency?: string;
+      dataSource?: DataSource;
+      symbol?: string;
+    };
+    where: Prisma.OrderWhereUniqueInput;
+  }): Promise<Order> {
+    if (data.Account.connect.id_userId.id === null) {
+      delete data.Account;
+    }
 
-    this.redisCacheService.remove(`${aUserId}.portfolio`);
+    let isDraft = false;
 
-    // Gather symbol data of order in the background
-    this.dataGatheringService.gatherSymbols([
-      {
-        date: <Date>data.date,
-        symbol: <string>data.symbol
+    if (data.type === 'ITEM') {
+      const name = data.SymbolProfile.connect.dataSource_symbol.symbol;
+
+      data.SymbolProfile = { update: { name } };
+    } else {
+      isDraft = isAfter(data.date as Date, endOfToday());
+
+      if (!isDraft) {
+        // Gather symbol data of order in the background, if not draft
+        this.dataGatheringService.gatherSymbols([
+          {
+            dataSource: data.SymbolProfile.connect.dataSource_symbol.dataSource,
+            date: <Date>data.date,
+            symbol: data.SymbolProfile.connect.dataSource_symbol.symbol
+          }
+        ]);
       }
-    ]);
+    }
 
-    await this.cacheService.flush(aUserId);
+    await this.cacheService.flush();
 
-    return this.prisma.order.update({
-      data,
+    delete data.currency;
+    delete data.dataSource;
+    delete data.symbol;
+
+    return this.prismaService.order.update({
+      data: {
+        ...data,
+        isDraft
+      },
       where
     });
   }

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

@@ -1,9 +1,16 @@
-import { Currency, Type } from '@prisma/client';
-import { IsISO8601, IsNumber, IsString, ValidateIf } from 'class-validator';
+import { DataSource, Type } from '@prisma/client';
+import { IsISO8601, IsNumber, IsOptional, IsString } from 'class-validator';
 
 export class UpdateOrderDto {
+  @IsOptional()
   @IsString()
-  currency: Currency;
+  accountId: string;
+
+  @IsString()
+  currency: string;
+
+  @IsString()
+  dataSource: DataSource;
 
   @IsISO8601()
   date: string;
@@ -11,10 +18,6 @@ export class UpdateOrderDto {
   @IsNumber()
   fee: number;
 
-  @IsString()
-  @ValidateIf((object, value) => value !== null)
-  platformId: string | null;
-
   @IsString()
   id: string;
 

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

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

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

@@ -0,0 +1,112 @@
+import { DataProviderService } from '@ghostfolio/api/services/data-provider/data-provider.service';
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data.service';
+import { MarketDataService } from '@ghostfolio/api/services/market-data.service';
+import { DataSource, MarketData } from '@prisma/client';
+
+import { CurrentRateService } from './current-rate.service';
+
+jest.mock('@ghostfolio/api/services/market-data.service', () => {
+  return {
+    MarketDataService: jest.fn().mockImplementation(() => {
+      return {
+        get: (date: Date, symbol: string) => {
+          return Promise.resolve<MarketData>({
+            date,
+            symbol,
+            createdAt: date,
+            dataSource: DataSource.YAHOO,
+            id: 'aefcbe3a-ee10-4c4f-9f2d-8ffad7b05584',
+            marketPrice: 1847.839966
+          });
+        },
+        getRange: ({
+          dateRangeEnd,
+          dateRangeStart,
+          symbols
+        }: {
+          dateRangeEnd: Date;
+          dateRangeStart: Date;
+          symbols: string[];
+        }) => {
+          return Promise.resolve<MarketData[]>([
+            {
+              createdAt: dateRangeStart,
+              dataSource: DataSource.YAHOO,
+              date: dateRangeStart,
+              id: '8fa48fde-f397-4b0d-adbc-fb940e830e6d',
+              marketPrice: 1841.823902,
+              symbol: symbols[0]
+            },
+            {
+              createdAt: dateRangeEnd,
+              dataSource: DataSource.YAHOO,
+              date: dateRangeEnd,
+              id: '082d6893-df27-4c91-8a5d-092e84315b56',
+              marketPrice: 1847.839966,
+              symbol: symbols[0]
+            }
+          ]);
+        }
+      };
+    })
+  };
+});
+
+jest.mock('@ghostfolio/api/services/exchange-rate-data.service', () => {
+  return {
+    ExchangeRateDataService: jest.fn().mockImplementation(() => {
+      return {
+        initialize: () => Promise.resolve(),
+        toCurrency: (value: number) => {
+          return 1 * value;
+        }
+      };
+    })
+  };
+});
+
+describe('CurrentRateService', () => {
+  let currentRateService: CurrentRateService;
+  let dataProviderService: DataProviderService;
+  let exchangeRateDataService: ExchangeRateDataService;
+  let marketDataService: MarketDataService;
+
+  beforeAll(async () => {
+    dataProviderService = new DataProviderService(null, [], null);
+    exchangeRateDataService = new ExchangeRateDataService(null, null, null);
+    marketDataService = new MarketDataService(null);
+
+    await exchangeRateDataService.initialize();
+
+    currentRateService = new CurrentRateService(
+      dataProviderService,
+      exchangeRateDataService,
+      marketDataService
+    );
+  });
+
+  it('getValues', async () => {
+    expect(
+      await currentRateService.getValues({
+        currencies: { AMZN: 'USD' },
+        dataGatheringItems: [{ dataSource: DataSource.YAHOO, symbol: 'AMZN' }],
+        dateQuery: {
+          lt: new Date(Date.UTC(2020, 0, 2, 0, 0, 0)),
+          gte: new Date(Date.UTC(2020, 0, 1, 0, 0, 0))
+        },
+        userCurrency: 'CHF'
+      })
+    ).toMatchObject([
+      {
+        date: undefined,
+        marketPrice: 1841.823902,
+        symbol: 'AMZN'
+      },
+      {
+        date: undefined,
+        marketPrice: 1847.839966,
+        symbol: 'AMZN'
+      }
+    ]);
+  });
+});

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

@@ -0,0 +1,99 @@
+import { DataProviderService } from '@ghostfolio/api/services/data-provider/data-provider.service';
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data.service';
+import { MarketDataService } from '@ghostfolio/api/services/market-data.service';
+import { resetHours } from '@ghostfolio/common/helper';
+import { Injectable } from '@nestjs/common';
+import { isBefore, isToday } from 'date-fns';
+import { flatten } from 'lodash';
+
+import { GetValueObject } from './interfaces/get-value-object.interface';
+import { GetValuesParams } from './interfaces/get-values-params.interface';
+
+@Injectable()
+export class CurrentRateService {
+  public constructor(
+    private readonly dataProviderService: DataProviderService,
+    private readonly exchangeRateDataService: ExchangeRateDataService,
+    private readonly marketDataService: MarketDataService
+  ) {}
+
+  public async getValues({
+    currencies,
+    dataGatheringItems,
+    dateQuery,
+    userCurrency
+  }: GetValuesParams): Promise<GetValueObject[]> {
+    const includeToday =
+      (!dateQuery.lt || isBefore(new Date(), dateQuery.lt)) &&
+      (!dateQuery.gte || isBefore(dateQuery.gte, new Date())) &&
+      (!dateQuery.in || this.containsToday(dateQuery.in));
+
+    const promises: Promise<
+      {
+        date: Date;
+        marketPrice: number;
+        symbol: string;
+      }[]
+    >[] = [];
+
+    if (includeToday) {
+      const today = resetHours(new Date());
+      promises.push(
+        this.dataProviderService
+          .getQuotes(dataGatheringItems)
+          .then((dataResultProvider) => {
+            const result = [];
+            for (const dataGatheringItem of dataGatheringItems) {
+              result.push({
+                date: today,
+                marketPrice: this.exchangeRateDataService.toCurrency(
+                  dataResultProvider?.[dataGatheringItem.symbol]?.marketPrice ??
+                    0,
+                  dataResultProvider?.[dataGatheringItem.symbol]?.currency,
+                  userCurrency
+                ),
+                symbol: dataGatheringItem.symbol
+              });
+            }
+            return result;
+          })
+      );
+    }
+
+    const symbols = dataGatheringItems.map((dataGatheringItem) => {
+      return dataGatheringItem.symbol;
+    });
+
+    promises.push(
+      this.marketDataService
+        .getRange({
+          dateQuery,
+          symbols
+        })
+        .then((data) => {
+          return data.map((marketDataItem) => {
+            return {
+              date: marketDataItem.date,
+              marketPrice: this.exchangeRateDataService.toCurrency(
+                marketDataItem.marketPrice,
+                currencies[marketDataItem.symbol],
+                userCurrency
+              ),
+              symbol: marketDataItem.symbol
+            };
+          });
+        })
+    );
+
+    return flatten(await Promise.all(promises));
+  }
+
+  private containsToday(dates: Date[]): boolean {
+    for (const date of dates) {
+      if (isToday(date)) {
+        return true;
+      }
+    }
+    return false;
+  }
+}

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

@@ -0,0 +1,13 @@
+import { ResponseError, TimelinePosition } from '@ghostfolio/common/interfaces';
+import Big from 'big.js';
+
+export interface CurrentPositions extends ResponseError {
+  positions: TimelinePosition[];
+  grossPerformance: Big;
+  grossPerformancePercentage: Big;
+  netAnnualizedPerformance?: Big;
+  netPerformance: Big;
+  netPerformancePercentage: Big;
+  currentValue: Big;
+  totalInvestment: Big;
+}

apps/api/src/app/portfolio/interfaces/date-query.interface.ts

@@ -0,0 +1,5 @@
+export interface DateQuery {
+  gte?: Date;
+  in?: Date[];
+  lt?: Date;
+}

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

@@ -0,0 +1,5 @@
+export interface GetValueObject {
+  date: Date;
+  marketPrice: number;
+  symbol: string;
+}

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

@@ -0,0 +1,10 @@
+import { IDataGatheringItem } from '@ghostfolio/api/services/interfaces/interfaces';
+
+import { DateQuery } from './date-query.interface';
+
+export interface GetValuesParams {
+  currencies: { [symbol: string]: string };
+  dataGatheringItems: IDataGatheringItem[];
+  dateQuery: DateQuery;
+  userCurrency: string;
+}

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

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

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

@@ -1,19 +0,0 @@
-import { Currency } from '@prisma/client';
-
-export interface PortfolioItem {
-  date: string;
-  grossPerformancePercent: number;
-  investment: number;
-  positions: { [symbol: string]: Position };
-  value: number;
-}
-
-export interface Position {
-  averagePrice: number;
-  currency: Currency;
-  firstBuyDate: string;
-  investment: number;
-  investmentInOriginalCurrency?: number;
-  marketPrice?: number;
-  quantity: number;
-}

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

@@ -0,0 +1,14 @@
+import { DataSource, Type as TypeOfOrder } from '@prisma/client';
+import Big from 'big.js';
+
+export interface PortfolioOrder {
+  currency: string;
+  date: string;
+  dataSource: DataSource;
+  fee: Big;
+  name: string;
+  quantity: Big;
+  symbol: string;
+  type: TypeOfOrder;
+  unitPrice: Big;
+}

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

@@ -1,6 +1,8 @@
+import { EnhancedSymbolProfile } from '@ghostfolio/api/services/interfaces/symbol-profile.interface';
+import { OrderWithAccount } from '@ghostfolio/common/types';
+
 export interface PortfolioPositionDetail {
   averagePrice: number;
-  currency: string;
   firstBuyDate: string;
   grossPerformance: number;
   grossPerformancePercent: number;
@@ -9,8 +11,19 @@ export interface PortfolioPositionDetail {
   marketPrice: number;
   maxPrice: number;
   minPrice: number;
+  netPerformance: number;
+  netPerformancePercent: number;
+  orders: OrderWithAccount[];
   quantity: number;
-  symbol: string;
+  SymbolProfile: EnhancedSymbolProfile;
+  transactionCount: number;
+  value: number;
+}
+
+export interface HistoricalDataContainer {
+  isAllTimeHigh: boolean;
+  isAllTimeLow: boolean;
+  items: HistoricalDataItem[];
 }
 
 export interface HistoricalDataItem {

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

@@ -1,25 +0,0 @@
-import { Currency } from '@prisma/client';
-
-export interface PortfolioPosition {
-  currency: Currency;
-  exchange?: string;
-  grossPerformance: number;
-  grossPerformancePercent: number;
-  industry?: string;
-  investment: number;
-  isMarketOpen: boolean;
-  marketChange?: number;
-  marketChangePercent?: number;
-  marketPrice: number;
-  name: string;
-  platforms: {
-    [name: string]: { current: number; original: number };
-  };
-  quantity: number;
-  sector?: string;
-  shareCurrent: number;
-  shareInvestment: number;
-  symbol: string;
-  type?: string;
-  url?: string;
-}

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

@@ -0,0 +1,5 @@
+import { Position } from '@ghostfolio/common/interfaces';
+
+export interface PortfolioPositions {
+  positions: Position[];
+}

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

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

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

@@ -0,0 +1,9 @@
+import Big from 'big.js';
+
+export interface TimelinePeriod {
+  date: string;
+  grossPerformance: Big;
+  investment: Big;
+  netPerformance: Big;
+  value: Big;
+}

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

@@ -0,0 +1,6 @@
+export type Accuracy = 'day' | 'month' | 'year';
+
+export interface TimelineSpecification {
+  accuracy: Accuracy;
+  start: string;
+}

apps/api/src/app/portfolio/interfaces/transaction-point-symbol.interface.ts

@@ -0,0 +1,13 @@
+import { DataSource } from '@prisma/client';
+import Big from 'big.js';
+
+export interface TransactionPointSymbol {
+  currency: string;
+  dataSource: DataSource;
+  fee: Big;
+  firstBuyDate: string;
+  investment: Big;
+  quantity: Big;
+  symbol: string;
+  transactionCount: number;
+}

apps/api/src/app/portfolio/interfaces/transaction-point.interface.ts

@@ -0,0 +1,6 @@
+import { TransactionPointSymbol } from './transaction-point-symbol.interface';
+
+export interface TransactionPoint {
+  date: string;
+  items: TransactionPointSymbol[];
+}

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')
+      });
+    });
+  });
+});

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')
+      });
+    });
+  });
+});

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)
+      });
+    });
+  });
+});

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

@@ -0,0 +1,73 @@
+import Big from 'big.js';
+
+import { CurrentRateService } from './current-rate.service';
+import { PortfolioCalculator } from './portfolio-calculator';
+
+describe('PortfolioCalculator', () => {
+  let currentRateService: CurrentRateService;
+
+  beforeEach(() => {
+    currentRateService = new CurrentRateService(null, null, null);
+  });
+
+  describe('annualized performance percentage', () => {
+    const portfolioCalculator = new PortfolioCalculator({
+      currentRateService,
+      currency: 'USD',
+      orders: []
+    });
+
+    it('Get annualized performance', async () => {
+      expect(
+        portfolioCalculator
+          .getAnnualizedPerformancePercent({
+            daysInMarket: NaN, // differenceInDays of date-fns returns NaN for the same day
+            netPerformancePercent: new Big(0)
+          })
+          .toNumber()
+      ).toEqual(0);
+
+      expect(
+        portfolioCalculator
+          .getAnnualizedPerformancePercent({
+            daysInMarket: 0,
+            netPerformancePercent: new Big(0)
+          })
+          .toNumber()
+      ).toEqual(0);
+
+      /**
+       * Source: https://www.readyratios.com/reference/analysis/annualized_rate.html
+       */
+      expect(
+        portfolioCalculator
+          .getAnnualizedPerformancePercent({
+            daysInMarket: 65, // < 1 year
+            netPerformancePercent: new Big(0.1025)
+          })
+          .toNumber()
+      ).toBeCloseTo(0.729705);
+
+      expect(
+        portfolioCalculator
+          .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(
+        portfolioCalculator
+          .getAnnualizedPerformancePercent({
+            daysInMarket: 575, // > 1 year
+            netPerformancePercent: new Big(0.2374)
+          })
+          .toNumber()
+      ).toBeCloseTo(0.145);
+    });
+  });
+});

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

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

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

@@ -1,3 +1,25 @@
+import { AccessService } from '@ghostfolio/api/app/access/access.service';
+import { UserService } from '@ghostfolio/api/app/user/user.service';
+import {
+  hasNotDefinedValuesInObject,
+  nullifyValuesInObject
+} from '@ghostfolio/api/helper/object.helper';
+import { TransformDataSourceInRequestInterceptor } from '@ghostfolio/api/interceptors/transform-data-source-in-request.interceptor';
+import { TransformDataSourceInResponseInterceptor } from '@ghostfolio/api/interceptors/transform-data-source-in-response.interceptor';
+import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data.service';
+import { baseCurrency } from '@ghostfolio/common/config';
+import { parseDate } from '@ghostfolio/common/helper';
+import {
+  PortfolioChart,
+  PortfolioDetails,
+  PortfolioInvestments,
+  PortfolioPerformanceResponse,
+  PortfolioPublicDetails,
+  PortfolioReport,
+  PortfolioSummary
+} from '@ghostfolio/common/interfaces';
+import type { RequestWithUser } from '@ghostfolio/common/types';
 import {
   Controller,
   Get,
@@ -6,107 +28,53 @@ import {
   Inject,
   Param,
   Query,
-  Res,
-  UseGuards
+  UseGuards,
+  UseInterceptors
 } from '@nestjs/common';
 import { REQUEST } from '@nestjs/core';
 import { AuthGuard } from '@nestjs/passport';
-import { Response } from 'express';
+import { ViewMode } from '@prisma/client';
 import { StatusCodes, getReasonPhrase } from 'http-status-codes';
-import { getPermissions, hasPermission, permissions } from 'libs/helper/src';
 
-import {
-  hasNotDefinedValuesInObject,
-  nullifyValuesInObject
-} from '../../helper/object.helper';
-import { ExchangeRateDataService } from '../../services/exchange-rate-data.service';
-import { ImpersonationService } from '../../services/impersonation.service';
-import { RequestWithUser } from '../interfaces/request-with-user.type';
-import { PortfolioItem } from './interfaces/portfolio-item.interface';
-import { PortfolioOverview } from './interfaces/portfolio-overview.interface';
-import { PortfolioPerformance } from './interfaces/portfolio-performance.interface';
-import {
-  HistoricalDataItem,
-  PortfolioPositionDetail
-} from './interfaces/portfolio-position-detail.interface';
-import { PortfolioPosition } from './interfaces/portfolio-position.interface';
-import { PortfolioReport } from './interfaces/portfolio-report.interface';
+import { PortfolioPositionDetail } from './interfaces/portfolio-position-detail.interface';
+import { PortfolioPositions } from './interfaces/portfolio-positions.interface';
 import { PortfolioService } from './portfolio.service';
 
 @Controller('portfolio')
 export class PortfolioController {
   public constructor(
+    private readonly accessService: AccessService,
+    private readonly configurationService: ConfigurationService,
     private readonly exchangeRateDataService: ExchangeRateDataService,
-    private readonly impersonationService: ImpersonationService,
-    private portfolioService: PortfolioService,
-    @Inject(REQUEST) private readonly request: RequestWithUser
+    private readonly portfolioService: PortfolioService,
+    @Inject(REQUEST) private readonly request: RequestWithUser,
+    private readonly userService: UserService
   ) {}
 
-  @Get()
-  @UseGuards(AuthGuard('jwt'))
-  public async findAll(
-    @Headers('impersonation-id') impersonationId
-  ): Promise<PortfolioItem[]> {
-    let portfolio = await this.portfolioService.findAll(impersonationId);
-
-    if (
-      impersonationId &&
-      !hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.readForeignPortfolio
-      )
-    ) {
-      portfolio = portfolio.map((portfolioItem) => {
-        Object.keys(portfolioItem.positions).forEach((symbol) => {
-          portfolioItem.positions[symbol].investment =
-            portfolioItem.positions[symbol].investment > 0 ? 1 : 0;
-          portfolioItem.positions[symbol].investmentInOriginalCurrency =
-            portfolioItem.positions[symbol].investmentInOriginalCurrency > 0
-              ? 1
-              : 0;
-          portfolioItem.positions[symbol].quantity =
-            portfolioItem.positions[symbol].quantity > 0 ? 1 : 0;
-        });
-
-        portfolioItem.investment = null;
-
-        return portfolioItem;
-      });
-    }
-
-    return portfolio;
-  }
-
   @Get('chart')
   @UseGuards(AuthGuard('jwt'))
   public async getChart(
-    @Headers('impersonation-id') impersonationId,
-    @Query('range') range,
-    @Res() res: Response
-  ): Promise<HistoricalDataItem[]> {
-    let chartData = await this.portfolioService.getChart(
+    @Headers('impersonation-id') impersonationId: string,
+    @Query('range') range
+  ): Promise<PortfolioChart> {
+    const historicalDataContainer = await this.portfolioService.getChart(
       impersonationId,
       range
     );
 
-    let hasNullValue = false;
+    let chartData = historicalDataContainer.items;
+
+    let hasError = false;
 
     chartData.forEach((chartDataItem) => {
       if (hasNotDefinedValuesInObject(chartDataItem)) {
-        hasNullValue = true;
+        hasError = true;
       }
     });
 
-    if (hasNullValue) {
-      res.status(StatusCodes.ACCEPTED);
-    }
-
     if (
-      impersonationId &&
-      !hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.readForeignPortfolio
-      )
+      impersonationId ||
+      this.userService.isRestrictedView(this.request.user)
     ) {
       let maxValue = 0;
 
@@ -124,53 +92,45 @@ export class PortfolioController {
       });
     }
 
-    return <any>res.json(chartData);
+    return {
+      hasError,
+      chart: chartData,
+      isAllTimeHigh: historicalDataContainer.isAllTimeHigh,
+      isAllTimeLow: historicalDataContainer.isAllTimeLow
+    };
   }
 
   @Get('details')
   @UseGuards(AuthGuard('jwt'))
+  @UseInterceptors(TransformDataSourceInResponseInterceptor)
   public async getDetails(
-    @Headers('impersonation-id') impersonationId,
-    @Query('range') range,
-    @Res() res: Response
-  ): Promise<{ [symbol: string]: PortfolioPosition }> {
-    let details: { [symbol: string]: PortfolioPosition } = {};
+    @Headers('impersonation-id') impersonationId: string,
+    @Query('range') range
+  ): Promise<PortfolioDetails & { hasError: boolean }> {
+    let hasError = false;
 
-    const impersonationUserId = await this.impersonationService.validateImpersonationId(
-      impersonationId,
-      this.request.user.id
-    );
+    const { accounts, holdings, hasErrors } =
+      await this.portfolioService.getDetails(
+        impersonationId,
+        this.request.user.id,
+        range
+      );
 
-    const portfolio = await this.portfolioService.createPortfolio(
-      impersonationUserId || this.request.user.id
-    );
-
-    try {
-      details = await portfolio.getDetails(range);
-    } catch (error) {
-      console.error(error);
-
-      res.status(StatusCodes.ACCEPTED);
-    }
-
-    if (hasNotDefinedValuesInObject(details)) {
-      res.status(StatusCodes.ACCEPTED);
+    if (hasErrors || hasNotDefinedValuesInObject(holdings)) {
+      hasError = true;
     }
 
     if (
-      impersonationId &&
-      !hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.readForeignPortfolio
-      )
+      impersonationId ||
+      this.userService.isRestrictedView(this.request.user)
     ) {
-      const totalInvestment = Object.values(details)
+      const totalInvestment = Object.values(holdings)
         .map((portfolioPosition) => {
           return portfolioPosition.investment;
         })
         .reduce((a, b) => a + b, 0);
 
-      const totalValue = Object.values(details)
+      const totalValue = Object.values(holdings)
         .map((portfolioPosition) => {
           return this.exchangeRateDataService.toCurrency(
             portfolioPosition.quantity * portfolioPosition.marketPrice,
@@ -180,110 +140,249 @@ export class PortfolioController {
         })
         .reduce((a, b) => a + b, 0);
 
-      for (const [symbol, portfolioPosition] of Object.entries(details)) {
+      for (const [symbol, portfolioPosition] of Object.entries(holdings)) {
         portfolioPosition.grossPerformance = null;
         portfolioPosition.investment =
           portfolioPosition.investment / totalInvestment;
-
-        for (const [platform, { current, original }] of Object.entries(
-          portfolioPosition.platforms
-        )) {
-          portfolioPosition.platforms[platform].current = current / totalValue;
-          portfolioPosition.platforms[platform].original =
-            original / totalInvestment;
-        }
-
+        portfolioPosition.netPerformance = null;
         portfolioPosition.quantity = null;
+        portfolioPosition.value = portfolioPosition.value / totalValue;
+      }
+
+      for (const [name, { current, original }] of Object.entries(accounts)) {
+        accounts[name].current = current / totalValue;
+        accounts[name].original = original / totalInvestment;
       }
     }
 
-    return <any>res.json(details);
+    const isBasicUser =
+      this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION') &&
+      this.request.user.subscription.type === 'Basic';
+
+    return { accounts, hasError, holdings: isBasicUser ? {} : holdings };
   }
 
-  @Get('overview')
+  @Get('investments')
   @UseGuards(AuthGuard('jwt'))
-  public async getOverview(
-    @Headers('impersonation-id') impersonationId
-  ): Promise<PortfolioOverview> {
-    let overview = await this.portfolioService.getOverview(impersonationId);
+  public async getInvestments(
+    @Headers('impersonation-id') impersonationId: string
+  ): Promise<PortfolioInvestments> {
+    if (
+      this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION') &&
+      this.request.user.subscription.type === 'Basic'
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    let investments = await this.portfolioService.getInvestments(
+      impersonationId
+    );
 
     if (
-      impersonationId &&
-      !hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.readForeignPortfolio
-      )
+      impersonationId ||
+      this.userService.isRestrictedView(this.request.user)
     ) {
-      overview = nullifyValuesInObject(overview, [
+      const maxInvestment = investments.reduce(
+        (investment, item) => Math.max(investment, item.investment),
+        1
+      );
+
+      investments = investments.map((item) => ({
+        date: item.date,
+        investment: item.investment / maxInvestment
+      }));
+    }
+
+    return { firstOrderDate: parseDate(investments[0]?.date), investments };
+  }
+
+  @Get('performance')
+  @UseGuards(AuthGuard('jwt'))
+  @UseInterceptors(TransformDataSourceInResponseInterceptor)
+  public async getPerformance(
+    @Headers('impersonation-id') impersonationId: string,
+    @Query('range') range
+  ): Promise<PortfolioPerformanceResponse> {
+    const performanceInformation = await this.portfolioService.getPerformance(
+      impersonationId,
+      range
+    );
+
+    if (
+      impersonationId ||
+      this.request.user.Settings.viewMode === ViewMode.ZEN ||
+      this.userService.isRestrictedView(this.request.user)
+    ) {
+      performanceInformation.performance = nullifyValuesInObject(
+        performanceInformation.performance,
+        ['currentGrossPerformance', 'currentValue']
+      );
+    }
+
+    return performanceInformation;
+  }
+
+  @Get('positions')
+  @UseGuards(AuthGuard('jwt'))
+  @UseInterceptors(TransformDataSourceInResponseInterceptor)
+  public async getPositions(
+    @Headers('impersonation-id') impersonationId: string,
+    @Query('range') range
+  ): Promise<PortfolioPositions> {
+    const result = await this.portfolioService.getPositions(
+      impersonationId,
+      range
+    );
+
+    if (
+      impersonationId ||
+      this.userService.isRestrictedView(this.request.user)
+    ) {
+      result.positions = result.positions.map((position) => {
+        return nullifyValuesInObject(position, [
+          'grossPerformance',
+          'investment',
+          'netPerformance',
+          'quantity'
+        ]);
+      });
+    }
+
+    return result;
+  }
+
+  @Get('public/:accessId')
+  public async getPublic(
+    @Param('accessId') accessId
+  ): Promise<PortfolioPublicDetails> {
+    const access = await this.accessService.access({ id: accessId });
+    const user = await this.userService.user({
+      id: access.userId
+    });
+
+    if (!access) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.NOT_FOUND),
+        StatusCodes.NOT_FOUND
+      );
+    }
+
+    let hasDetails = true;
+    if (this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION')) {
+      hasDetails = user.subscription.type === 'Premium';
+    }
+
+    const { holdings } = await this.portfolioService.getDetails(
+      access.userId,
+      access.userId
+    );
+
+    const portfolioPublicDetails: PortfolioPublicDetails = {
+      hasDetails,
+      holdings: {}
+    };
+
+    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
+        );
+      })
+      .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,
+          markets: portfolioPosition.markets,
+          name: portfolioPosition.name,
+          sectors: hasDetails ? portfolioPosition.sectors : [],
+          value: portfolioPosition.value / totalValue
+        };
+      }
+    }
+
+    return portfolioPublicDetails;
+  }
+
+  @Get('summary')
+  @UseGuards(AuthGuard('jwt'))
+  public async getSummary(
+    @Headers('impersonation-id') impersonationId
+  ): Promise<PortfolioSummary> {
+    if (
+      this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION') &&
+      this.request.user.subscription.type === 'Basic'
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    let summary = await this.portfolioService.getSummary(impersonationId);
+
+    if (
+      impersonationId ||
+      this.userService.isRestrictedView(this.request.user)
+    ) {
+      summary = nullifyValuesInObject(summary, [
+        'cash',
         'committedFunds',
+        'currentGrossPerformance',
+        'currentNetPerformance',
+        'currentValue',
+        'dividend',
+        'emergencyFund',
         'fees',
+        'items',
+        'netWorth',
         'totalBuy',
         'totalSell'
       ]);
     }
 
-    return overview;
+    return summary;
   }
 
-  @Get('performance')
-  @UseGuards(AuthGuard('jwt'))
-  public async getPerformance(
-    @Headers('impersonation-id') impersonationId,
-    @Query('range') range,
-    @Res() res: Response
-  ): Promise<PortfolioPerformance> {
-    const impersonationUserId = await this.impersonationService.validateImpersonationId(
-      impersonationId,
-      this.request.user.id
-    );
-
-    const portfolio = await this.portfolioService.createPortfolio(
-      impersonationUserId || this.request.user.id
-    );
-
-    let performance = await portfolio.getPerformance(range);
-
-    if (hasNotDefinedValuesInObject(performance)) {
-      res.status(StatusCodes.ACCEPTED);
-    }
-
-    if (
-      impersonationId &&
-      !hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.readForeignPortfolio
-      )
-    ) {
-      performance = nullifyValuesInObject(performance, [
-        'currentGrossPerformance',
-        'currentNetPerformance',
-        'currentValue'
-      ]);
-    }
-
-    return <any>res.json(performance);
-  }
-
-  @Get('position/:symbol')
+  @Get('position/:dataSource/:symbol')
+  @UseInterceptors(TransformDataSourceInRequestInterceptor)
+  @UseInterceptors(TransformDataSourceInResponseInterceptor)
   @UseGuards(AuthGuard('jwt'))
   public async getPosition(
-    @Headers('impersonation-id') impersonationId,
+    @Headers('impersonation-id') impersonationId: string,
+    @Param('dataSource') dataSource,
     @Param('symbol') symbol
   ): Promise<PortfolioPositionDetail> {
     let position = await this.portfolioService.getPosition(
+      dataSource,
       impersonationId,
       symbol
     );
 
     if (position) {
       if (
-        impersonationId &&
-        !hasPermission(
-          getPermissions(this.request.user.role),
-          permissions.readForeignPortfolio
-        )
+        impersonationId ||
+        this.userService.isRestrictedView(this.request.user)
       ) {
-        position = nullifyValuesInObject(position, ['grossPerformance']);
+        position = nullifyValuesInObject(position, [
+          'grossPerformance',
+          'investment',
+          'netPerformance',
+          'orders',
+          'quantity',
+          'value'
+        ]);
       }
 
       return position;
@@ -298,29 +397,18 @@ export class PortfolioController {
   @Get('report')
   @UseGuards(AuthGuard('jwt'))
   public async getReport(
-    @Headers('impersonation-id') impersonationId
+    @Headers('impersonation-id') impersonationId: string
   ): Promise<PortfolioReport> {
-    const impersonationUserId = await this.impersonationService.validateImpersonationId(
-      impersonationId,
-      this.request.user.id
-    );
-
-    const portfolio = await this.portfolioService.createPortfolio(
-      impersonationUserId || this.request.user.id
-    );
-
-    let report = await portfolio.getReport();
-
     if (
-      impersonationId &&
-      !hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.readForeignPortfolio
-      )
+      this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION') &&
+      this.request.user.subscription.type === 'Basic'
     ) {
-      // TODO: Filter out absolute numbers
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
     }
 
-    return report;
+    return await this.portfolioService.getReport(impersonationId);
   }
 }

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

@@ -1,40 +1,43 @@
+import { AccessModule } from '@ghostfolio/api/app/access/access.module';
+import { AccountService } from '@ghostfolio/api/app/account/account.service';
+import { OrderModule } from '@ghostfolio/api/app/order/order.module';
+import { UserModule } from '@ghostfolio/api/app/user/user.module';
+import { ConfigurationModule } from '@ghostfolio/api/services/configuration.module';
+import { DataGatheringModule } from '@ghostfolio/api/services/data-gathering.module';
+import { DataProviderModule } from '@ghostfolio/api/services/data-provider/data-provider.module';
+import { ExchangeRateDataModule } from '@ghostfolio/api/services/exchange-rate-data.module';
+import { ImpersonationModule } from '@ghostfolio/api/services/impersonation.module';
+import { MarketDataModule } from '@ghostfolio/api/services/market-data.module';
+import { PrismaModule } from '@ghostfolio/api/services/prisma.module';
+import { SymbolProfileModule } from '@ghostfolio/api/services/symbol-profile.module';
 import { Module } from '@nestjs/common';
 
-import { ConfigurationService } from '../../services/configuration.service';
-import { DataGatheringService } from '../../services/data-gathering.service';
-import { DataProviderService } from '../../services/data-provider.service';
-import { AlphaVantageService } from '../../services/data-provider/alpha-vantage/alpha-vantage.service';
-import { RakutenRapidApiService } from '../../services/data-provider/rakuten-rapid-api/rakuten-rapid-api.service';
-import { YahooFinanceService } from '../../services/data-provider/yahoo-finance/yahoo-finance.service';
-import { ExchangeRateDataService } from '../../services/exchange-rate-data.service';
-import { ImpersonationService } from '../../services/impersonation.service';
-import { PrismaService } from '../../services/prisma.service';
-import { RulesService } from '../../services/rules.service';
-import { CacheService } from '../cache/cache.service';
-import { OrderService } from '../order/order.service';
-import { RedisCacheModule } from '../redis-cache/redis-cache.module';
-import { UserService } from '../user/user.service';
+import { CurrentRateService } from './current-rate.service';
 import { PortfolioController } from './portfolio.controller';
 import { PortfolioService } from './portfolio.service';
+import { RulesService } from './rules.service';
 
 @Module({
-  imports: [RedisCacheModule],
   controllers: [PortfolioController],
+  exports: [PortfolioService],
+  imports: [
+    AccessModule,
+    ConfigurationModule,
+    DataGatheringModule,
+    DataProviderModule,
+    ExchangeRateDataModule,
+    ImpersonationModule,
+    MarketDataModule,
+    OrderModule,
+    PrismaModule,
+    SymbolProfileModule,
+    UserModule
+  ],
   providers: [
-    AlphaVantageService,
-    CacheService,
-    ConfigurationService,
-    DataGatheringService,
-    DataProviderService,
-    ExchangeRateDataService,
-    ImpersonationService,
-    OrderService,
+    AccountService,
+    CurrentRateService,
     PortfolioService,
-    PrismaService,
-    RakutenRapidApiService,
-    RulesService,
-    UserService,
-    YahooFinanceService
+    RulesService
   ]
 })
 export class PortfolioModule {}

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

@@ -0,0 +1,22 @@
+import { RuleSettings } from '@ghostfolio/api/models/interfaces/rule-settings.interface';
+import { Rule } from '@ghostfolio/api/models/rule';
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class RulesService {
+  public constructor() {}
+
+  public async evaluate<T extends RuleSettings>(
+    aRules: Rule<T>[],
+    aUserSettings: { baseCurrency: string }
+  ) {
+    return aRules
+      .filter((rule) => {
+        return rule.getSettings(aUserSettings)?.isActive;
+      })
+      .map((rule) => {
+        const evaluationResult = rule.evaluate(rule.getSettings(aUserSettings));
+        return { ...evaluationResult, name: rule.getName() };
+      });
+  }
+}

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

@@ -1,8 +1,9 @@
+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';
 import * as redisStore from 'cache-manager-redis-store';
 
-import { ConfigurationService } from '../../services/configuration.service';
 import { RedisCacheService } from './redis-cache.service';
 
 @Module({
@@ -17,9 +18,10 @@ import { RedisCacheService } from './redis-cache.service';
         store: redisStore,
         ttl: configurationService.get('CACHE_TTL')
       })
-    })
+    }),
+    ConfigurationModule
   ],
-  providers: [ConfigurationService, RedisCacheService],
+  providers: [RedisCacheService],
   exports: [RedisCacheService]
 })
 export class RedisCacheModule {}

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

@@ -1,8 +1,7 @@
+import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
 import { CACHE_MANAGER, Inject, Injectable } from '@nestjs/common';
 import { Cache } from 'cache-manager';
 
-import { ConfigurationService } from '../../services/configuration.service';
-
 @Injectable()
 export class RedisCacheService {
   public constructor(
@@ -22,9 +21,9 @@ export class RedisCacheService {
     await this.cache.reset();
   }
 
-  public async set(key: string, value: string) {
+  public async set(key: string, value: string, ttlInSeconds?: number) {
     await this.cache.set(key, value, {
-      ttl: this.configurationService.get('CACHE_TTL')
+      ttl: ttlInSeconds ?? this.configurationService.get('CACHE_TTL')
     });
   }
 }

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

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

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

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