Release 2.41.0 (#2888)

* Increase timeout to load historical data

* Update changelog

.env

@@ -1,16 +0,0 @@
-COMPOSE_PROJECT_NAME=ghostfolio-development
-
-# CACHE
-REDIS_HOST=localhost
-REDIS_PORT=6379
-
-# POSTGRES
-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
-JWT_SECRET_KEY=123456
-PORT=3333

.env.example

@@ -0,0 +1,15 @@
+COMPOSE_PROJECT_NAME=ghostfolio-development
+
+# CACHE
+REDIS_HOST=localhost
+REDIS_PORT=6379
+REDIS_PASSWORD=<INSERT_REDIS_PASSWORD>
+
+# POSTGRES
+POSTGRES_DB=ghostfolio-db
+POSTGRES_USER=user
+POSTGRES_PASSWORD=<INSERT_POSTGRES_PASSWORD>
+
+ACCESS_TOKEN_SALT=<INSERT_RANDOM_STRING>
+DATABASE_URL=postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@localhost:5432/${POSTGRES_DB}?connect_timeout=300&sslmode=prefer
+JWT_SECRET_KEY=<INSERT_RANDOM_STRING>

.eslintrc.json

@@ -1,12 +1,12 @@
 {
   "root": true,
   "ignorePatterns": ["**/*"],
-  "plugins": ["@nrwl/nx"],
+  "plugins": ["@nx"],
   "overrides": [
     {
       "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
       "rules": {
-        "@nrwl/nx/enforce-module-boundaries": [
+        "@nx/enforce-module-boundaries": [
           "error",
           {
             "enforceBuildableLibDependency": true,
@@ -23,12 +23,12 @@
     },
     {
       "files": ["*.ts", "*.tsx"],
-      "extends": ["plugin:@nrwl/nx/typescript"],
+      "extends": ["plugin:@nx/typescript"],
       "rules": {}
     },
     {
       "files": ["*.js", "*.jsx"],
-      "extends": ["plugin:@nrwl/nx/javascript"],
+      "extends": ["plugin:@nx/javascript"],
       "rules": {}
     },
     {
@@ -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": [
@@ -113,5 +113,6 @@
         "radix": "error"
       }
     }
-  ]
+  ],
+  "extends": [null, "plugin:storybook/recommended"]
 }

.github/FUNDING.yml

@@ -0,0 +1 @@
+custom: ['https://www.buymeacoffee.com/ghostfolio']

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,53 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: '[BUG]'
+labels: ''
+assignees: ''
+---
+
+**Important Notice**
+
+The issue tracker is **ONLY** used for reporting bugs. New features should be discussed in our [Slack](https://join.slack.com/t/ghostfolio/shared_invite/zt-vsaan64h-F_I0fEo5M0P88lP9ibCxFg) community or in [Discussions](https://github.com/ghostfolio/ghostfolio/discussions).
+
+Incomplete or non-reproducible issues may be closed, but we are here to help! If you encounter difficulties reproducing the bug or need assistance, please reach out to our community channels mentioned above.
+
+Thank you for your understanding and cooperation!
+
+**Bug Description**
+
+<!-- A clear and concise description of what the bug is. -->
+
+**To Reproduce**
+
+<!-- Steps to reproduce the behavior -->
+
+1.
+2.
+3.
+
+**Expected behavior**
+
+<!-- A clear and concise description of what you expected to happen. -->
+
+**Screenshots**
+
+<!-- If applicable, add screenshots to help explain your problem. -->
+
+**Logs**
+
+<!-- If applicable, add logs to help explain your problem. -->
+
+**Environment**
+
+<!-- Please complete the following information -->
+
+- Ghostfolio Version X.Y.Z
+- Cloud or Self-hosted
+- Experimental Features enabled or disabled
+- Browser
+- OS
+
+**Additional context**
+
+<!-- Add any other context about the problem here. -->

.github/workflows/build-code.yml

@@ -0,0 +1,39 @@
+name: Build code
+
+on:
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node_version:
+          - 18
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Use Node.js ${{ matrix.node_version }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node_version }}
+          cache: 'yarn'
+
+      - name: Install dependencies
+        run: yarn install --frozen-lockfile
+
+      - name: Check formatting
+        run: yarn format:check
+
+      - name: Execute tests
+        run: yarn test
+
+      - name: Build application
+        run: yarn build:production

.github/workflows/docker-image.yml

@@ -0,0 +1,50 @@
+name: Docker image CD
+
+on:
+  push:
+    tags:
+      - '*.*.*'
+  pull_request:
+    branches:
+      - 'main'
+
+jobs:
+  build_and_push:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Docker metadata
+        id: meta
+        uses: docker/metadata-action@v4
+        with:
+          images: ghostfolio/ghostfolio
+          tags: |
+            type=semver,pattern={{major}}
+            type=semver,pattern={{version}}
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v2
+
+      - name: Login to DockerHub
+        if: github.event_name != 'pull_request'
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKER_HUB_USERNAME }}
+          password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
+
+      - name: Build and push
+        uses: docker/build-push-action@v3
+        with:
+          context: .
+          platforms: linux/amd64,linux/arm/v7,linux/arm64
+          push: ${{ github.event_name != 'pull_request' }}
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.output.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max

.gitignore

@@ -5,6 +5,7 @@
 /tmp
 
 # dependencies
+/.yarn
 /node_modules
 
 # IDEs and editors
@@ -23,15 +24,19 @@
 !.vscode/settings.json
 
 # misc
+/.angular/cache
+.env
+.env.prod
+.nx/cache
 /.sass-cache
 /connect.lock
 /coverage
 /dist
 /libpeerconnection.log
 npm-debug.log
-yarn-error.log
 testem.log
 /typings
+yarn-error.log
 
 # System Files
 .DS_Store

.nvmrc

@@ -0,0 +1 @@
+v18

.prettierignore

@@ -1 +1,3 @@
+/.nx/cache
 /dist
+/test/import

.prettierrc

@@ -1,5 +1,15 @@
 {
+  "attributeGroups": [
+    "$ANGULAR_ELEMENT_REF",
+    "$ANGULAR_STRUCTURAL_DIRECTIVE",
+    "$DEFAULT",
+    "$ANGULAR_INPUT",
+    "$ANGULAR_TWO_WAY_BINDING",
+    "$ANGULAR_OUTPUT"
+  ],
+  "attributeSort": "ASC",
   "endOfLine": "auto",
+  "plugins": ["prettier-plugin-organize-attributes"],
   "printWidth": 80,
   "singleQuote": true,
   "tabWidth": 2,

.travis.yml

@@ -1,9 +0,0 @@
-language: node_js
-git:
-  depth: false
-node_js:
-  - 14
-before_script:
-  - yarn
-script:
-  - yarn format:check

.vscode/launch.json

@@ -2,31 +2,33 @@
   "version": "0.2.0",
   "configurations": [
     {
-      "name": "Debug Jest File",
-      "type": "node",
-      "request": "launch",
-      "program": "${workspaceFolder}/node_modules/@angular/cli/bin/ng",
       "args": [
         "test",
         "--codeCoverage=false",
-        "--testFile=${workspaceFolder}/apps/api/src/models/portfolio.spec.ts"
+        "--testFile=${workspaceFolder}/apps/api/src/app/portfolio/portfolio-calculator-novn-buy-and-sell.spec.ts"
       ],
+      "console": "internalConsole",
       "cwd": "${workspaceFolder}",
-      "console": "internalConsole"
+      "name": "Debug Jest",
+      "program": "${workspaceFolder}/node_modules/@nrwl/cli/bin/nx",
+      "request": "launch",
+      "type": "node"
     },
     {
-      "envFile": "${workspaceFolder}/.env",
-      "type": "node",
-      "request": "launch",
-      "name": "Launch Program",
-      "program": "${workspaceFolder}/apps/api/src/main.ts",
-      "runtimeArgs": ["--nolazy", "-r", "ts-node/register"],
-      "outFiles": ["${workspaceFolder}/dist/apps/api/**/*.js"],
       "autoAttachChildProcesses": true,
+      "console": "integratedTerminal",
+      "cwd": "${workspaceFolder}/apps/api",
+      "envFile": "${workspaceFolder}/.env",
+      "name": "Debug API",
+      "outFiles": ["${workspaceFolder}/dist/apps/api/**/*.js"],
+      "program": "${workspaceFolder}/apps/api/src/main.ts",
+      "request": "launch",
+      "runtimeArgs": ["--nolazy", "-r", "ts-node/register"],
       "skipFiles": [
         "${workspaceFolder}/node_modules/**/*.js",
         "<node_internals>/**/*.js"
-      ]
+      ],
+      "type": "node"
     }
   ]
 }

DEVELOPMENT.md

@@ -0,0 +1,55 @@
+# Ghostfolio Development Guide
+
+## Experimental Features
+
+New functionality can be enabled using a feature flag switch from the user settings.
+
+### Backend
+
+Remove permission in `UserService` using `without()`
+
+### Frontend
+
+Use `*ngIf="user?.settings?.isExperimentalFeatures"` in HTML template
+
+## Git
+
+### Rebase
+
+`git rebase -i --autosquash main`
+
+## Dependencies
+
+### Angular
+
+#### Upgrade (minor versions)
+
+1. Run `npx npm-check-updates --upgrade --target "minor" --filter "/@angular.*/"`
+
+### Nx
+
+#### Upgrade
+
+1. Run `yarn nx migrate latest`
+1. Make sure `package.json` changes make sense and then run `yarn install`
+1. Run `yarn nx migrate --run-migrations` (Run `YARN_NODE_LINKER="node-modules" NX_MIGRATE_SKIP_INSTALL=1 yarn nx migrate --run-migrations` due to https://github.com/nrwl/nx/issues/16338)
+
+### Prisma
+
+#### Access database via GUI
+
+Run `yarn database:gui`
+
+https://www.prisma.io/studio
+
+#### Synchronize schema with database for prototyping
+
+Run `yarn database:push`
+
+https://www.prisma.io/docs/concepts/components/prisma-migrate/db-push
+
+#### Create schema migration
+
+Run `yarn prisma migrate dev --name added_job_title`
+
+https://www.prisma.io/docs/concepts/components/prisma-migrate#getting-started-with-prisma-migrate

Dockerfile

@@ -0,0 +1,61 @@
+FROM --platform=$BUILDPLATFORM node:18-slim 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 ./.yarnrc .yarnrc
+COPY ./prisma/schema.prisma prisma/schema.prisma
+
+RUN apt update && apt install -y \
+    git \
+    g++ \
+    make \
+    openssl \
+    python3 \
+    && rm -rf /var/lib/apt/lists/*
+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 ./nx.json nx.json
+COPY ./replace.build.js replace.build.js
+COPY ./jest.preset.js jest.preset.js
+COPY ./jest.config.ts jest.config.ts
+COPY ./tsconfig.base.json tsconfig.base.json
+COPY ./libs libs
+COPY ./apps apps
+
+RUN yarn build:production
+
+# 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:18-slim
+RUN apt update && apt install -y \
+    openssl \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY --from=builder /ghostfolio/dist/apps /ghostfolio/apps
+WORKDIR /ghostfolio/apps/api
+EXPOSE ${PORT:-3333}
+CMD [ "yarn", "start:production" ]

README.md

@@ -1,52 +1,67 @@
 <div align="center">
-  <h1>Ghostfolio</h1>
-  <p>
-    <strong>Open Source Portfolio Tracker</strong>
-  </p>
-  <p>
-    <a href="https://ghostfol.io"><strong>Live Demo</strong></a>
-  </p>
-  <p>
-    <a href="https://travis-ci.org/github/ghostfolio/ghostfolio" rel="nofollow">
-      <img src="https://travis-ci.org/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>
-  </p>
+
+[<img src="https://avatars.githubusercontent.com/u/82473144?s=200" width="100" alt="Ghostfolio logo">](https://ghostfol.io)
+
+# Ghostfolio
+
+**Open Source Wealth Management Software**
+
+[**Ghostfol.io**](https://ghostfol.io) | [**Live Demo**](https://ghostfol.io/en/demo) | [**Ghostfolio Premium**](https://ghostfol.io/en/pricing) | [**FAQ**](https://ghostfol.io/en/faq) |
+[**Blog**](https://ghostfol.io/en/blog) | [**Slack**](https://join.slack.com/t/ghostfolio/shared_invite/zt-vsaan64h-F_I0fEo5M0P88lP9ibCxFg) | [**Twitter**](https://twitter.com/ghostfolio_)
+
+[![Shield: Buy me a coffee](https://img.shields.io/badge/Buy%20me%20a%20coffee-Support-yellow?logo=buymeacoffee)](https://www.buymeacoffee.com/ghostfolio)
+[![Shield: Contributions Welcome](https://img.shields.io/badge/Contributions-Welcome-orange.svg)](#contributing)
+[![Shield: License: AGPL v3](https://img.shields.io/badge/License-AGPL%20v3-blue.svg)](https://www.gnu.org/licenses/agpl-3.0)
+
+New: [Ghostfolio 2.0](https://ghostfol.io/en/blog/2023/09/ghostfolio-2)
+
 </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 stocks, ETFs or cryptocurrencies and make solid, data-driven investment decisions. The software is designed for personal use in continuous operation.
+
+<div align="center">
+
+[<img src="./apps/client/src/assets/images/video-preview.jpg" width="600" alt="Preview image of the Ghostfolio video trailer">](https://www.youtube.com/watch?v=yY6ObSQVJZk)
+
+</div>
+
+## Ghostfolio Premium
+
+Our official **[Ghostfolio Premium](https://ghostfol.io/en/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. Revenue is used to cover the costs of the hosting infrastructure and to fund ongoing development.
+
+If you prefer to run Ghostfolio on your own infrastructure, please find further instructions in the [Self-hosting](#self-hosting) section.
 
 ## Why Ghostfolio?
 
 Ghostfolio is for you if you are...
 
 - 💼 trading stocks, ETFs or cryptocurrencies on multiple platforms
-
 - 🏦 pursuing a buy & hold strategy
-
 - 🎯 interested in getting insights of your portfolio composition
-
 - 👻 valuing privacy and data ownership
-
 - 🧘 into minimalism
-
 - 🧺 caring about diversifying your financial resources
-
 - 🆓 interested in financial independence
-
-- 🙅 saying no to spreadsheets in 2021
-
+- 🙅 saying no to spreadsheets
 - 😎 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
+- ✅ Progressive Web App (PWA) with a mobile-first design
+
+<div align="center">
+
+<img src="./apps/client/src/assets/images/screenshot.png" width="300" alt="Image of a phone showing the Ghostfolio app open">
+
+</div>
 
 ## Technology Stack
 
@@ -54,51 +69,219 @@ Ghostfolio is a modern web application written in [TypeScript](https://www.types
 
 ### 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.
 
 ### Frontend
 
-The frontend is built with [Angular](https://angular.io).
+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).
 
-## Getting Started
+## Self-hosting
+
+We provide official container images hosted on [Docker Hub](https://hub.docker.com/r/ghostfolio/ghostfolio) for `linux/amd64`, `linux/arm/v7` and `linux/arm64`.
+
+<div align="center">
+
+[<img src="./apps/client/src/assets/images/button-buy-me-a-coffee.png" width="150" alt="Buy me a coffee button"/>](https://www.buymeacoffee.com/ghostfolio)
+
+</div>
+
+### Supported Environment Variables
+
+| Name                     | Default Value | Description                                                                                                                         |
+| ------------------------ | ------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
+| `ACCESS_TOKEN_SALT`      |               | A random string used as salt for access tokens                                                                                      |
+| `API_KEY_COINGECKO_DEMO` |               | The _CoinGecko_ Demo API key                                                                                                        |
+| `API_KEY_COINGECKO_PRO`  |               | The _CoinGecko_ Pro API                                                                                                             |
+| `DATABASE_URL`           |               | The database connection URL, e.g. `postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@localhost:5432/${POSTGRES_DB}?sslmode=prefer` |
+| `HOST`                   | `0.0.0.0`     | The host where the Ghostfolio application will run on                                                                               |
+| `JWT_SECRET_KEY`         |               | A random string used for _JSON Web Tokens_ (JWT)                                                                                    |
+| `PORT`                   | `3333`        | The port where the Ghostfolio application will run on                                                                               |
+| `POSTGRES_DB`            |               | The name of the _PostgreSQL_ database                                                                                               |
+| `POSTGRES_PASSWORD`      |               | The password of the _PostgreSQL_ database                                                                                           |
+| `POSTGRES_USER`          |               | The user of the _PostgreSQL_ database                                                                                               |
+| `REDIS_HOST`             |               | The host where _Redis_ is running                                                                                                   |
+| `REDIS_PASSWORD`         |               | The password of _Redis_                                                                                                             |
+| `REDIS_PORT`             |               | The port where _Redis_ is running                                                                                                   |
+| `REQUEST_TIMEOUT`        | `2000`        | The timeout of network requests to data providers in milliseconds                                                                   |
+
+### Run with Docker Compose
+
+#### Prerequisites
+
+- Basic knowledge of Docker
+- Installation of [Docker](https://www.docker.com/products/docker-desktop)
+- Create a local copy of this Git repository (clone)
+- Copy the file `.env.example` to `.env` and populate it with your data (`cp .env.example .env`)
+
+#### 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 --env-file ./.env -f docker/docker-compose.yml up -d
+```
+
+#### b. Build and run environment
+
+Run the following commands to build and start the Docker images:
+
+```bash
+docker compose --env-file ./.env -f docker/docker-compose.build.yml build
+docker compose --env-file ./.env -f docker/docker-compose.build.yml up -d
+```
+
+#### Setup
+
+1. Open http://localhost:3333 in your browser
+1. Create a new user via _Get Started_ (this first user will get the role `ADMIN`)
+
+#### 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 --env-file ./.env -f docker/docker-compose.yml up -d`  
+   At each start, the container will automatically apply the database schema migrations if needed.
+
+### Home Server Systems (Community)
+
+Ghostfolio is available for various home server systems, including [Runtipi](https://www.runtipi.io/docs/apps-available), [TrueCharts](https://truecharts.org/charts/stable/ghostfolio), [Umbrel](https://apps.umbrel.com/app/ghostfolio), and [Unraid](https://unraid.net/community/apps?q=ghostfolio).
+
+## Development
 
 ### Prerequisites
 
-- [Node.js](https://nodejs.org/en/download) (version 14+)
-- [Yarn](https://yarnpkg.com/en/docs/install)
 - [Docker](https://www.docker.com/products/docker-desktop)
+- [Node.js](https://nodejs.org/en/download) (version 18+)
+- [Yarn](https://yarnpkg.com/en/docs/install)
+- Create a local copy of this Git repository (clone)
+- Copy the file `.env.example` to `.env` and populate it with your data (`cp .env.example .env`)
 
 ### Setup
 
 1. Run `yarn install`
-1. Run `cd docker`
-1. Run `docker compose up -d` to start [PostgreSQL](https://www.postgresql.org) and [Redis](https://redis.io)
-1. Run `cd -` to go back to the project root directory
-1. Run `yarn setup:database` to initialize the database schema and populate your database with (example) data
-1. Start server and client (see [_Development_](#Development))
-1. Login as _Admin_ with the following _Security Token_: `ae76872ae8f3419c6d6f64bf51888ecbcc703927a342d815fafe486acdb938da07d0cf44fca211a0be74a423238f535362d390a41e81e633a9ce668a6e31cdf9`
-1. Go to the _Admin Control Panel_ and press _Gather All Data_ to fetch historical data
-1. Press _Sign out_ and check out the _Live Demo_
+1. Run `docker compose --env-file ./.env -f docker/docker-compose.dev.yml up -d` to start [PostgreSQL](https://www.postgresql.org) and [Redis](https://redis.io)
+1. Run `yarn database:setup` to initialize the database schema
+1. Run `git config core.hooksPath ./git-hooks/` to setup git hooks
+1. Start the server and the client (see [_Development_](#Development))
+1. Open http://localhost:4200/en in your browser
+1. Create a new user via _Get Started_ (this first user will get the role `ADMIN`)
 
-## Development
+### Start Server
 
-Please make sure you have completed the instructions from [_Setup_](#Setup)
+#### Debug
 
-### Start server
+Run `yarn watch:server` and click _Debug API_ in [Visual Studio Code](https://code.visualstudio.com)
 
-- Debug: Run `yarn watch:server` and click "Launch Program" in _Visual Studio Code_
-- Serve: Run `yarn start:server`
+#### Serve
 
-### Start client
+Run `yarn start:server`
 
-- Run `yarn start:client`
+### Start Client
+
+Run `yarn start:client` and open http://localhost:4200/en in your browser
+
+### 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
+
+### Authorization: Bearer Token
+
+Set the header for each request as follows:
+
+```
+"Authorization": "Bearer eyJh..."
+```
+
+You can get the _Bearer Token_ via `POST http://localhost:3333/api/v1/auth/anonymous` (Body: `{ accessToken: <INSERT_SECURITY_TOKEN_OF_ACCOUNT> }`)
+
+Deprecated: `GET http://localhost:3333/api/v1/auth/anonymous/<INSERT_SECURITY_TOKEN_OF_ACCOUNT>` or `curl -s http://localhost:3333/api/v1/auth/anonymous/<INSERT_SECURITY_TOKEN_OF_ACCOUNT>`.
+
+### Import Activities
+
+#### Request
+
+`POST http://localhost:3333/api/v1/import`
+
+#### 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                                                             |
+| comment    | string (`optional`) | Comment of the activity                                                       |
+| currency   | string              | `CHF` \| `EUR` \| `USD` etc.                                                  |
+| dataSource | string              | `COINGECKO` \| `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` \| `FEE` \| `INTEREST` \| `ITEM` \| `LIABILITY` \| `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"
+  ]
+}
+```
+
+## Community Projects
+
+Discover a variety of community projects for Ghostfolio: https://github.com/topics/ghostfolio
+
+Are you building your own project? Add the `ghostfolio` topic to your _GitHub_ repository to get listed as well. [Learn more →](https://docs.github.com/en/articles/classifying-your-repository-with-topics)
+
+## 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](https://join.slack.com/t/ghostfolio/shared_invite/zt-vsaan64h-F_I0fEo5M0P88lP9ibCxFg) channel or post to [@ghostfolio\_](https://twitter.com/ghostfolio_) on _X_. We would love to hear from you.
+
+If you like to support this project, get [**Ghostfolio Premium**](https://ghostfol.io/en/pricing) or [**Buy me a coffee**](https://www.buymeacoffee.com/ghostfolio).
+
 ## License
 
-© 2021 [Ghostfolio](https://ghostfol.io)
+© 2021 - 2024 [Ghostfolio](https://ghostfol.io)
 
 Licensed under the [AGPLv3 License](https://www.gnu.org/licenses/agpl-3.0.html).

angular.json

@@ -1,233 +0,0 @@
-{
-  "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",
-      "sourceRoot": "apps/api/src",
-      "projectType": "application",
-      "prefix": "api",
-      "schematics": {},
-      "architect": {
-        "build": {
-          "builder": "@nrwl/node:build",
-          "options": {
-            "outputPath": "dist/apps/api",
-            "main": "apps/api/src/main.ts",
-            "tsConfig": "apps/api/tsconfig.app.json",
-            "assets": ["apps/api/src/assets"]
-          },
-          "configurations": {
-            "production": {
-              "optimization": true,
-              "extractLicenses": true,
-              "inspect": false,
-              "fileReplacements": [
-                {
-                  "replace": "apps/api/src/environments/environment.ts",
-                  "with": "apps/api/src/environments/environment.prod.ts"
-                }
-              ]
-            }
-          },
-          "outputs": ["{options.outputPath}"]
-        },
-        "serve": {
-          "builder": "@nrwl/node:execute",
-          "options": {
-            "buildTarget": "api:build"
-          }
-        },
-        "lint": {
-          "builder": "@nrwl/linter:eslint",
-          "options": {
-            "lintFilePatterns": ["apps/api/**/*.ts"]
-          }
-        },
-        "test": {
-          "builder": "@nrwl/jest:jest",
-          "options": {
-            "jestConfig": "apps/api/jest.config.js",
-            "passWithNoTests": true
-          },
-          "outputs": ["coverage/apps/api"]
-        }
-      }
-    },
-    "client": {
-      "projectType": "application",
-      "schematics": {
-        "@schematics/angular:component": {
-          "style": "scss"
-        }
-      },
-      "root": "apps/client",
-      "sourceRoot": "apps/client/src",
-      "prefix": "gf",
-      "architect": {
-        "build": {
-          "builder": "@angular-devkit/build-angular:browser",
-          "options": {
-            "outputPath": "dist/apps/client",
-            "index": "apps/client/src/index.html",
-            "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",
-              {
-                "glob": "assetlinks.json",
-                "input": "apps/client/src/assets",
-                "output": "./.well-known"
-              },
-              {
-                "glob": "CHANGELOG.md",
-                "input": "",
-                "output": "./"
-              },
-              {
-                "glob": "LICENSE",
-                "input": "",
-                "output": "./"
-              },
-              {
-                "glob": "sitemap.xml",
-                "input": "apps/client/src/assets",
-                "output": "./"
-              },
-              {
-                "glob": "**/*",
-                "input": "node_modules/ionicons/dist/ionicons",
-                "output": "./ionicons"
-              },
-              {
-                "glob": "**/*.js",
-                "input": "node_modules/ionicons/dist/",
-                "output": "./"
-              }
-            ],
-            "styles": ["apps/client/src/styles.scss"],
-            "scripts": ["node_modules/marked/lib/marked.js"]
-          },
-          "configurations": {
-            "production": {
-              "fileReplacements": [
-                {
-                  "replace": "apps/client/src/environments/environment.ts",
-                  "with": "apps/client/src/environments/environment.prod.ts"
-                }
-              ],
-              "optimization": true,
-              "outputHashing": "all",
-              "sourceMap": false,
-              "namedChunks": false,
-              "extractLicenses": true,
-              "vendorChunk": false,
-              "buildOptimizer": true,
-              "budgets": [
-                {
-                  "type": "initial",
-                  "maximumWarning": "2mb",
-                  "maximumError": "5mb"
-                },
-                {
-                  "type": "anyComponentStyle",
-                  "maximumWarning": "6kb",
-                  "maximumError": "10kb"
-                }
-              ]
-            }
-          },
-          "outputs": ["{options.outputPath}"]
-        },
-        "serve": {
-          "builder": "@angular-devkit/build-angular:dev-server",
-          "options": {
-            "browserTarget": "client:build",
-            "proxyConfig": "apps/client/proxy.conf.json"
-          },
-          "configurations": {
-            "production": {
-              "browserTarget": "client:build:production"
-            }
-          }
-        },
-        "extract-i18n": {
-          "builder": "@angular-devkit/build-angular:extract-i18n",
-          "options": {
-            "browserTarget": "client:build"
-          }
-        },
-        "lint": {
-          "builder": "@nrwl/linter:eslint",
-          "options": {
-            "lintFilePatterns": ["apps/client/**/*.ts"]
-          }
-        },
-        "test": {
-          "builder": "@nrwl/jest:jest",
-          "options": {
-            "jestConfig": "apps/client/jest.config.js",
-            "passWithNoTests": true
-          },
-          "outputs": ["coverage/apps/client"]
-        }
-      }
-    },
-    "client-e2e": {
-      "root": "apps/client-e2e",
-      "sourceRoot": "apps/client-e2e/src",
-      "projectType": "application",
-      "architect": {
-        "e2e": {
-          "builder": "@nrwl/cypress:cypress",
-          "options": {
-            "cypressConfig": "apps/client-e2e/cypress.json",
-            "tsConfig": "apps/client-e2e/tsconfig.e2e.json",
-            "devServerTarget": "client:serve"
-          },
-          "configurations": {
-            "production": {
-              "devServerTarget": "client:serve:production"
-            }
-          }
-        }
-      }
-    },
-    "helper": {
-      "root": "libs/helper",
-      "sourceRoot": "libs/helper/src",
-      "projectType": "library",
-      "architect": {
-        "lint": {
-          "builder": "@nrwl/linter:eslint",
-          "options": {
-            "lintFilePatterns": ["libs/helper/**/*.ts"]
-          }
-        },
-        "test": {
-          "builder": "@nrwl/jest:jest",
-          "outputs": ["coverage/libs/helper"],
-          "options": {
-            "jestConfig": "libs/helper/jest.config.js",
-            "passWithNoTests": true
-          }
-        }
-      }
-    }
-  }
-}

apps/api/jest.config.js

@@ -1,15 +0,0 @@
-module.exports = {
-  displayName: 'api',
-  preset: '../../jest.preset.js',
-  globals: {
-    'ts-jest': {
-      tsconfig: '<rootDir>/tsconfig.spec.json'
-    }
-  },
-  transform: {
-    '^.+\\.[tj]s$': 'ts-jest'
-  },
-  moduleFileExtensions: ['ts', 'js', 'html'],
-  coverageDirectory: '../../coverage/apps/api',
-  testTimeout: 10000
-};

apps/api/jest.config.ts

@@ -0,0 +1,19 @@
+/* eslint-disable */
+export default {
+  displayName: 'api',
+
+  globals: {},
+  transform: {
+    '^.+\\.[tj]s$': [
+      'ts-jest',
+      {
+        tsconfig: '<rootDir>/tsconfig.spec.json'
+      }
+    ]
+  },
+  moduleFileExtensions: ['ts', 'js', 'html'],
+  coverageDirectory: '../../coverage/apps/api',
+  testTimeout: 10000,
+  testEnvironment: 'node',
+  preset: '../../jest.preset.js'
+};

apps/api/project.json

@@ -0,0 +1,57 @@
+{
+  "name": "api",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "apps/api/src",
+  "projectType": "application",
+  "prefix": "api",
+  "generators": {},
+  "targets": {
+    "build": {
+      "executor": "@nx/webpack:webpack",
+      "options": {
+        "outputPath": "dist/apps/api",
+        "main": "apps/api/src/main.ts",
+        "tsConfig": "apps/api/tsconfig.app.json",
+        "assets": ["apps/api/src/assets"],
+        "target": "node",
+        "compiler": "tsc",
+        "webpackConfig": "apps/api/webpack.config.js"
+      },
+      "configurations": {
+        "production": {
+          "generatePackageJson": true,
+          "optimization": true,
+          "extractLicenses": true,
+          "inspect": false,
+          "fileReplacements": [
+            {
+              "replace": "apps/api/src/environments/environment.ts",
+              "with": "apps/api/src/environments/environment.prod.ts"
+            }
+          ]
+        }
+      },
+      "outputs": ["{options.outputPath}"]
+    },
+    "serve": {
+      "executor": "@nx/js:node",
+      "options": {
+        "buildTarget": "api:build"
+      }
+    },
+    "lint": {
+      "executor": "@nx/eslint:lint",
+      "options": {
+        "lintFilePatterns": ["apps/api/**/*.ts"]
+      }
+    },
+    "test": {
+      "executor": "@nx/jest:jest",
+      "options": {
+        "jestConfig": "apps/api/jest.config.ts"
+      },
+      "outputs": ["{workspaceRoot}/coverage/apps/api"]
+    }
+  },
+  "tags": []
+}

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

@@ -1,32 +1,113 @@
-import { RequestWithUser } from '@ghostfolio/api/app/interfaces/request-with-user.type';
-import { Controller, Get, Inject, UseGuards } from '@nestjs/common';
+import { HasPermission } from '@ghostfolio/api/decorators/has-permission.decorator';
+import { HasPermissionGuard } from '@ghostfolio/api/guards/has-permission.guard';
+import { ConfigurationService } from '@ghostfolio/api/services/configuration/configuration.service';
+import { Access } from '@ghostfolio/common/interfaces';
+import { 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 { Access as AccessModel } from '@prisma/client';
+import { StatusCodes, getReasonPhrase } from 'http-status-codes';
 
 import { AccessService } from './access.service';
-import { Access } from './interfaces/access.interface';
+import { CreateAccessDto } from './create-access.dto';
 
 @Controller('access')
 export class AccessController {
   public constructor(
     private readonly accessService: AccessService,
+    private readonly configurationService: ConfigurationService,
     @Inject(REQUEST) private readonly request: RequestWithUser
   ) {}
 
   @Get()
-  @UseGuards(AuthGuard('jwt'))
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
   public async getAllAccesses(): Promise<Access[]> {
     const accessesWithGranteeUser = await this.accessService.accesses({
       include: {
         GranteeUser: true
       },
+      orderBy: { granteeUserId: 'asc' },
       where: { userId: this.request.user.id }
     });
 
     return accessesWithGranteeUser.map((access) => {
+      if (access.GranteeUser) {
+        return {
+          alias: access.alias,
+          grantee: access.GranteeUser?.id,
+          id: access.id,
+          type: 'RESTRICTED_VIEW'
+        };
+      }
+
       return {
-        granteeAlias: access.GranteeUser.alias
+        alias: access.alias,
+        grantee: 'Public',
+        id: access.id,
+        type: 'PUBLIC'
       };
     });
   }
+
+  @HasPermission(permissions.createAccess)
+  @Post()
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  public async createAccess(
+    @Body() data: CreateAccessDto
+  ): Promise<AccessModel> {
+    if (
+      this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION') &&
+      this.request.user.subscription.type === 'Basic'
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    try {
+      return await this.accessService.createAccess({
+        alias: data.alias || undefined,
+        GranteeUser: data.granteeUserId
+          ? { connect: { id: data.granteeUserId } }
+          : undefined,
+        User: { connect: { id: this.request.user.id } }
+      });
+    } catch {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.BAD_REQUEST),
+        StatusCodes.BAD_REQUEST
+      );
+    }
+  }
+
+  @Delete(':id')
+  @HasPermission(permissions.deleteAccess)
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  public async deleteAccess(@Param('id') id: string): Promise<AccessModel> {
+    const access = await this.accessService.access({ id });
+
+    if (!access || access.userId !== this.request.user.id) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    return this.accessService.deleteAccess({
+      id
+    });
+  }
 }

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

@@ -1,12 +1,14 @@
-import { PrismaService } from '@ghostfolio/api/services/prisma.service';
+import { ConfigurationModule } from '@ghostfolio/api/services/configuration/configuration.module';
+import { PrismaModule } from '@ghostfolio/api/services/prisma/prisma.module';
 import { Module } from '@nestjs/common';
 
 import { AccessController } from './access.controller';
 import { AccessService } from './access.service';
 
 @Module({
-  imports: [],
   controllers: [AccessController],
-  providers: [AccessService, PrismaService]
+  exports: [AccessService],
+  imports: [ConfigurationModule, 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 { PrismaService } from '@ghostfolio/api/services/prisma/prisma.service';
+import { AccessWithGranteeUser } from '@ghostfolio/common/types';
 import { Injectable } from '@nestjs/common';
-import { Prisma } from '@prisma/client';
-
-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,15 @@
+import { IsOptional, IsString, IsUUID } from 'class-validator';
+
+export class CreateAccessDto {
+  @IsOptional()
+  @IsString()
+  alias?: string;
+
+  @IsOptional()
+  @IsUUID()
+  granteeUserId?: string;
+
+  @IsOptional()
+  @IsString()
+  type?: 'PUBLIC';
+}

apps/api/src/app/access/interfaces/access.interface.ts

@@ -1,3 +0,0 @@
-export interface Access {
-  granteeAlias: string;
-}

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

@@ -0,0 +1,48 @@
+import { HasPermission } from '@ghostfolio/api/decorators/has-permission.decorator';
+import { HasPermissionGuard } from '@ghostfolio/api/guards/has-permission.guard';
+import { 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 { AccountBalance } from '@prisma/client';
+import { StatusCodes, getReasonPhrase } from 'http-status-codes';
+
+import { AccountBalanceService } from './account-balance.service';
+
+@Controller('account-balance')
+export class AccountBalanceController {
+  public constructor(
+    private readonly accountBalanceService: AccountBalanceService,
+    @Inject(REQUEST) private readonly request: RequestWithUser
+  ) {}
+
+  @HasPermission(permissions.deleteAccountBalance)
+  @Delete(':id')
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  public async deleteAccountBalance(
+    @Param('id') id: string
+  ): Promise<AccountBalance> {
+    const accountBalance = await this.accountBalanceService.accountBalance({
+      id
+    });
+
+    if (!accountBalance || accountBalance.userId !== this.request.user.id) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    return this.accountBalanceService.deleteAccountBalance({
+      id
+    });
+  }
+}

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

@@ -0,0 +1,14 @@
+import { ExchangeRateDataModule } from '@ghostfolio/api/services/exchange-rate-data/exchange-rate-data.module';
+import { PrismaModule } from '@ghostfolio/api/services/prisma/prisma.module';
+import { Module } from '@nestjs/common';
+
+import { AccountBalanceController } from './account-balance.controller';
+import { AccountBalanceService } from './account-balance.service';
+
+@Module({
+  controllers: [AccountBalanceController],
+  exports: [AccountBalanceService],
+  imports: [ExchangeRateDataModule, PrismaModule],
+  providers: [AccountBalanceService]
+})
+export class AccountBalanceModule {}

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

@@ -0,0 +1,91 @@
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data/exchange-rate-data.service';
+import { PrismaService } from '@ghostfolio/api/services/prisma/prisma.service';
+import { AccountBalancesResponse, Filter } from '@ghostfolio/common/interfaces';
+import { UserWithSettings } from '@ghostfolio/common/types';
+import { Injectable } from '@nestjs/common';
+import { AccountBalance, Prisma } from '@prisma/client';
+
+@Injectable()
+export class AccountBalanceService {
+  public constructor(
+    private readonly exchangeRateDataService: ExchangeRateDataService,
+    private readonly prismaService: PrismaService
+  ) {}
+
+  public async accountBalance(
+    accountBalanceWhereInput: Prisma.AccountBalanceWhereInput
+  ): Promise<AccountBalance | null> {
+    return this.prismaService.accountBalance.findFirst({
+      include: {
+        Account: true
+      },
+      where: accountBalanceWhereInput
+    });
+  }
+
+  public async createAccountBalance(
+    data: Prisma.AccountBalanceCreateInput
+  ): Promise<AccountBalance> {
+    return this.prismaService.accountBalance.create({
+      data
+    });
+  }
+
+  public async deleteAccountBalance(
+    where: Prisma.AccountBalanceWhereUniqueInput
+  ): Promise<AccountBalance> {
+    return this.prismaService.accountBalance.delete({
+      where
+    });
+  }
+
+  public async getAccountBalances({
+    filters,
+    user,
+    withExcludedAccounts
+  }: {
+    filters?: Filter[];
+    user: UserWithSettings;
+    withExcludedAccounts?: boolean;
+  }): Promise<AccountBalancesResponse> {
+    const where: Prisma.AccountBalanceWhereInput = { userId: user.id };
+
+    const accountFilter = filters?.find(({ type }) => {
+      return type === 'ACCOUNT';
+    });
+
+    if (accountFilter) {
+      where.accountId = accountFilter.id;
+    }
+
+    if (withExcludedAccounts === false) {
+      where.Account = { isExcluded: false };
+    }
+
+    const balances = await this.prismaService.accountBalance.findMany({
+      where,
+      orderBy: {
+        date: 'asc'
+      },
+      select: {
+        Account: true,
+        date: true,
+        id: true,
+        value: true
+      }
+    });
+
+    return {
+      balances: balances.map((balance) => {
+        return {
+          ...balance,
+          valueInBaseCurrency: this.exchangeRateDataService.toCurrency(
+            balance.value,
+            balance.Account.currency,
+            user.Settings.settings.baseCurrency
+          )
+        };
+      })
+    };
+  }
+}

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

@@ -1,7 +1,19 @@
-import { RequestWithUser } from '@ghostfolio/api/app/interfaces/request-with-user.type';
-import { nullifyValuesInObjects } from '@ghostfolio/api/helper/object.helper';
-import { ImpersonationService } from '@ghostfolio/api/services/impersonation.service';
-import { getPermissions, hasPermission, permissions } from '@ghostfolio/helper';
+import { AccountBalanceService } from '@ghostfolio/api/app/account-balance/account-balance.service';
+import { PortfolioService } from '@ghostfolio/api/app/portfolio/portfolio.service';
+import { HasPermission } from '@ghostfolio/api/decorators/has-permission.decorator';
+import { HasPermissionGuard } from '@ghostfolio/api/guards/has-permission.guard';
+import { RedactValuesInResponseInterceptor } from '@ghostfolio/api/interceptors/redact-values-in-response.interceptor';
+import { ImpersonationService } from '@ghostfolio/api/services/impersonation/impersonation.service';
+import { HEADER_KEY_IMPERSONATION } from '@ghostfolio/common/config';
+import {
+  AccountBalancesResponse,
+  Accounts
+} from '@ghostfolio/common/interfaces';
+import { permissions } from '@ghostfolio/common/permissions';
+import type {
+  AccountWithValue,
+  RequestWithUser
+} from '@ghostfolio/common/types';
 import {
   Body,
   Controller,
@@ -13,40 +25,33 @@ import {
   Param,
   Post,
   Put,
-  UseGuards
+  UseGuards,
+  UseInterceptors
 } from '@nestjs/common';
 import { REQUEST } from '@nestjs/core';
 import { AuthGuard } from '@nestjs/passport';
-import { Account as AccountModel, Order } from '@prisma/client';
+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 { TransferBalanceDto } from './transfer-balance.dto';
 import { UpdateAccountDto } from './update-account.dto';
 
 @Controller('account')
 export class AccountController {
   public constructor(
+    private readonly accountBalanceService: AccountBalanceService,
     private readonly accountService: AccountService,
     private readonly impersonationService: ImpersonationService,
+    private readonly portfolioService: PortfolioService,
     @Inject(REQUEST) private readonly request: RequestWithUser
   ) {}
 
   @Delete(':id')
-  @UseGuards(AuthGuard('jwt'))
+  @HasPermission(permissions.deleteAccount)
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
   public async deleteAccount(@Param('id') id: string): Promise<AccountModel> {
-    if (
-      !hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.deleteAccount
-      )
-    ) {
-      throw new HttpException(
-        getReasonPhrase(StatusCodes.FORBIDDEN),
-        StatusCodes.FORBIDDEN
-      );
-    }
-
     const account = await this.accountService.accountWithOrders(
       {
         id_userId: {
@@ -76,66 +81,58 @@ export class AccountController {
   }
 
   @Get()
-  @UseGuards(AuthGuard('jwt'))
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  @UseInterceptors(RedactValuesInResponseInterceptor)
   public async getAllAccounts(
-    @Headers('impersonation-id') impersonationId
-  ): Promise<AccountModel[]> {
-    const impersonationUserId = await this.impersonationService.validateImpersonationId(
-      impersonationId,
-      this.request.user.id
-    );
+    @Headers(HEADER_KEY_IMPERSONATION.toLowerCase()) impersonationId
+  ): Promise<Accounts> {
+    const impersonationUserId =
+      await this.impersonationService.validateImpersonationId(impersonationId);
 
-    let accounts = await this.accountService.accounts({
-      include: { Order: true, Platform: true },
-      orderBy: { name: 'asc' },
-      where: { userId: impersonationUserId || this.request.user.id }
+    return this.portfolioService.getAccountsWithAggregations({
+      userId: impersonationUserId || this.request.user.id,
+      withExcludedAccounts: true
     });
-
-    if (
-      impersonationUserId &&
-      !hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.readForeignPortfolio
-      )
-    ) {
-      accounts = nullifyValuesInObjects(accounts, [
-        'fee',
-        'quantity',
-        'unitPrice'
-      ]);
-    }
-
-    return accounts;
   }
 
   @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
-      }
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  @UseInterceptors(RedactValuesInResponseInterceptor)
+  public async getAccountById(
+    @Headers(HEADER_KEY_IMPERSONATION.toLowerCase()) impersonationId,
+    @Param('id') id: string
+  ): Promise<AccountWithValue> {
+    const impersonationUserId =
+      await this.impersonationService.validateImpersonationId(impersonationId);
+
+    const accountsWithAggregations =
+      await this.portfolioService.getAccountsWithAggregations({
+        filters: [{ id, type: 'ACCOUNT' }],
+        userId: impersonationUserId || this.request.user.id,
+        withExcludedAccounts: true
+      });
+
+    return accountsWithAggregations.accounts[0];
+  }
+
+  @Get(':id/balances')
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  @UseInterceptors(RedactValuesInResponseInterceptor)
+  public async getAccountBalancesById(
+    @Param('id') id: string
+  ): Promise<AccountBalancesResponse> {
+    return this.accountBalanceService.getAccountBalances({
+      filters: [{ id, type: 'ACCOUNT' }],
+      user: this.request.user
     });
   }
 
+  @HasPermission(permissions.createAccount)
   @Post()
-  @UseGuards(AuthGuard('jwt'))
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
   public async createAccount(
     @Body() data: CreateAccountDto
   ): Promise<AccountModel> {
-    if (
-      !hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.createAccount
-      )
-    ) {
-      throw new HttpException(
-        getReasonPhrase(StatusCodes.FORBIDDEN),
-        StatusCodes.FORBIDDEN
-      );
-    }
-
     if (data.platformId) {
       const platformId = data.platformId;
       delete data.platformId;
@@ -161,21 +158,64 @@ export class AccountController {
     }
   }
 
-  @Put(':id')
-  @UseGuards(AuthGuard('jwt'))
-  public async update(@Param('id') id: string, @Body() data: UpdateAccountDto) {
-    if (
-      !hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.updateAccount
-      )
-    ) {
+  @HasPermission(permissions.updateAccount)
+  @Post('transfer-balance')
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  public async transferAccountBalance(
+    @Body() { accountIdFrom, accountIdTo, balance }: TransferBalanceDto
+  ) {
+    const accountsOfUser = await this.accountService.getAccounts(
+      this.request.user.id
+    );
+
+    const accountFrom = accountsOfUser.find(({ id }) => {
+      return id === accountIdFrom;
+    });
+
+    const accountTo = accountsOfUser.find(({ id }) => {
+      return id === accountIdTo;
+    });
+
+    if (!accountFrom || !accountTo) {
       throw new HttpException(
-        getReasonPhrase(StatusCodes.FORBIDDEN),
-        StatusCodes.FORBIDDEN
+        getReasonPhrase(StatusCodes.NOT_FOUND),
+        StatusCodes.NOT_FOUND
       );
     }
 
+    if (accountFrom.id === accountTo.id) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.BAD_REQUEST),
+        StatusCodes.BAD_REQUEST
+      );
+    }
+
+    if (accountFrom.balance < balance) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.BAD_REQUEST),
+        StatusCodes.BAD_REQUEST
+      );
+    }
+
+    await this.accountService.updateAccountBalance({
+      accountId: accountFrom.id,
+      amount: -balance,
+      currency: accountFrom.currency,
+      userId: this.request.user.id
+    });
+
+    await this.accountService.updateAccountBalance({
+      accountId: accountTo.id,
+      amount: balance,
+      currency: accountFrom.currency,
+      userId: this.request.user.id
+    });
+  }
+
+  @HasPermission(permissions.updateAccount)
+  @Put(':id')
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  public async update(@Param('id') id: string, @Body() data: UpdateAccountDto) {
     const originalAccount = await this.accountService.account({
       id_userId: {
         id,

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

@@ -1,30 +1,31 @@
-import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
-import { DataProviderService } from '@ghostfolio/api/services/data-provider.service';
-import { AlphaVantageService } from '@ghostfolio/api/services/data-provider/alpha-vantage/alpha-vantage.service';
-import { GhostfolioScraperApiService } from '@ghostfolio/api/services/data-provider/ghostfolio-scraper-api/ghostfolio-scraper-api.service';
-import { RakutenRapidApiService } from '@ghostfolio/api/services/data-provider/rakuten-rapid-api/rakuten-rapid-api.service';
-import { YahooFinanceService } from '@ghostfolio/api/services/data-provider/yahoo-finance/yahoo-finance.service';
-import { ImpersonationService } from '@ghostfolio/api/services/impersonation.service';
-import { PrismaService } from '@ghostfolio/api/services/prisma.service';
+import { AccountBalanceModule } from '@ghostfolio/api/app/account-balance/account-balance.module';
+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/configuration.module';
+import { DataProviderModule } from '@ghostfolio/api/services/data-provider/data-provider.module';
+import { ExchangeRateDataModule } from '@ghostfolio/api/services/exchange-rate-data/exchange-rate-data.module';
+import { ImpersonationModule } from '@ghostfolio/api/services/impersonation/impersonation.module';
+import { PrismaModule } from '@ghostfolio/api/services/prisma/prisma.module';
 import { Module } from '@nestjs/common';
 
-import { RedisCacheModule } from '../redis-cache/redis-cache.module';
 import { AccountController } from './account.controller';
 import { AccountService } from './account.service';
 
 @Module({
-  imports: [RedisCacheModule],
   controllers: [AccountController],
-  providers: [
-    AccountService,
-    AlphaVantageService,
-    ConfigurationService,
-    DataProviderService,
-    GhostfolioScraperApiService,
-    ImpersonationService,
-    PrismaService,
-    RakutenRapidApiService,
-    YahooFinanceService
-  ]
+  exports: [AccountService],
+  imports: [
+    AccountBalanceModule,
+    ConfigurationModule,
+    DataProviderModule,
+    ExchangeRateDataModule,
+    ImpersonationModule,
+    PortfolioModule,
+    PrismaModule,
+    RedisCacheModule,
+    UserModule
+  ],
+  providers: [AccountService]
 })
 export class AccountModule {}

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

@@ -1,22 +1,32 @@
-import { PrismaService } from '@ghostfolio/api/services/prisma.service';
+import { AccountBalanceService } from '@ghostfolio/api/app/account-balance/account-balance.service';
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data/exchange-rate-data.service';
+import { PrismaService } from '@ghostfolio/api/services/prisma/prisma.service';
+import { Filter } from '@ghostfolio/common/interfaces';
 import { Injectable } from '@nestjs/common';
-import { Account, Order, Prisma } from '@prisma/client';
+import { Account, Order, Platform, Prisma } from '@prisma/client';
+import Big from 'big.js';
+import { groupBy } from 'lodash';
 
-import { RedisCacheService } from '../redis-cache/redis-cache.service';
+import { CashDetails } from './interfaces/cash-details.interface';
 
 @Injectable()
 export class AccountService {
   public constructor(
-    private readonly redisCacheService: RedisCacheService,
-    private prisma: PrismaService
+    private readonly accountBalanceService: AccountBalanceService,
+    private readonly exchangeRateDataService: ExchangeRateDataService,
+    private readonly prismaService: PrismaService
   ) {}
 
-  public async account(
-    accountWhereUniqueInput: Prisma.AccountWhereUniqueInput
-  ): Promise<Account | null> {
-    return this.prisma.account.findUnique({
-      where: accountWhereUniqueInput
+  public async account({
+    id_userId
+  }: Prisma.AccountWhereUniqueInput): Promise<Account | null> {
+    const { id, userId } = id_userId;
+
+    const [account] = await this.accounts({
+      where: { id, userId }
     });
+
+    return account;
   }
 
   public async accountWithOrders(
@@ -27,7 +37,7 @@ export class AccountService {
       Order?: Order[];
     }
   > {
-    return this.prisma.account.findUnique({
+    return this.prismaService.account.findUnique({
       include: accountInclude,
       where: accountWhereUniqueInput
     });
@@ -39,11 +49,18 @@ export class AccountService {
     take?: number;
     cursor?: Prisma.AccountWhereUniqueInput;
     where?: Prisma.AccountWhereInput;
-    orderBy?: Prisma.AccountOrderByInput;
-  }): Promise<Account[]> {
-    const { include, skip, take, cursor, where, orderBy } = params;
+    orderBy?: Prisma.AccountOrderByWithRelationInput;
+  }): Promise<
+    (Account & {
+      Order?: Order[];
+      Platform?: Platform;
+    })[]
+  > {
+    const { include = {}, skip, take, cursor, where, orderBy } = params;
 
-    return this.prisma.account.findMany({
+    include.balances = { orderBy: { date: 'desc' }, take: 1 };
+
+    const accounts = await this.prismaService.account.findMany({
       cursor,
       include,
       orderBy,
@@ -51,28 +68,126 @@ export class AccountService {
       take,
       where
     });
+
+    return accounts.map((account) => {
+      account = { ...account, balance: account.balances[0]?.value ?? 0 };
+
+      delete account.balances;
+
+      return account;
+    });
   }
 
   public async createAccount(
     data: Prisma.AccountCreateInput,
     aUserId: string
   ): Promise<Account> {
-    return this.prisma.account.create({
+    const account = await this.prismaService.account.create({
       data
     });
+
+    await this.prismaService.accountBalance.create({
+      data: {
+        Account: {
+          connect: {
+            id_userId: { id: account.id, userId: aUserId }
+          }
+        },
+        value: data.balance
+      }
+    });
+
+    return account;
   }
 
   public async deleteAccount(
     where: Prisma.AccountWhereUniqueInput,
     aUserId: string
   ): Promise<Account> {
-    this.redisCacheService.remove(`${aUserId}.portfolio`);
-
-    return this.prisma.account.delete({
+    return this.prismaService.account.delete({
       where
     });
   }
 
+  public async getAccounts(aUserId: string): Promise<Account[]> {
+    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({
+    currency,
+    filters = [],
+    userId,
+    withExcludedAccounts = false
+  }: {
+    currency: string;
+    filters?: Filter[];
+    userId: string;
+    withExcludedAccounts?: boolean;
+  }): Promise<CashDetails> {
+    let totalCashBalanceInBaseCurrency = new Big(0);
+
+    const where: Prisma.AccountWhereInput = {
+      userId
+    };
+
+    if (withExcludedAccounts === false) {
+      where.isExcluded = false;
+    }
+
+    const {
+      ACCOUNT: filtersByAccount,
+      ASSET_CLASS: filtersByAssetClass,
+      TAG: filtersByTag
+    } = groupBy(filters, (filter) => {
+      return filter.type;
+    });
+
+    if (filtersByAccount?.length > 0) {
+      where.id = {
+        in: filtersByAccount.map(({ id }) => {
+          return id;
+        })
+      };
+    }
+
+    const accounts = await this.accounts({ where });
+
+    for (const account of accounts) {
+      totalCashBalanceInBaseCurrency = totalCashBalanceInBaseCurrency.plus(
+        this.exchangeRateDataService.toCurrency(
+          account.balance,
+          account.currency,
+          currency
+        )
+      );
+    }
+
+    return {
+      accounts,
+      balanceInBaseCurrency: totalCashBalanceInBaseCurrency.toNumber()
+    };
+  }
+
   public async updateAccount(
     params: {
       where: Prisma.AccountWhereUniqueInput;
@@ -81,9 +196,65 @@ export class AccountService {
     aUserId: string
   ): Promise<Account> {
     const { data, where } = params;
-    return this.prisma.account.update({
+
+    await this.prismaService.accountBalance.create({
+      data: {
+        Account: {
+          connect: {
+            id_userId: where.id_userId
+          }
+        },
+        value: <number>data.balance
+      }
+    });
+
+    return this.prismaService.account.update({
       data,
       where
     });
   }
+
+  public async updateAccountBalance({
+    accountId,
+    amount,
+    currency,
+    date = new Date(),
+    userId
+  }: {
+    accountId: string;
+    amount: number;
+    currency: string;
+    date?: Date;
+    userId: string;
+  }) {
+    const { balance, currency: currencyOfAccount } = await this.account({
+      id_userId: {
+        userId,
+        id: accountId
+      }
+    });
+
+    const amountInCurrencyOfAccount =
+      await this.exchangeRateDataService.toCurrencyAtDate(
+        amount,
+        currency,
+        currencyOfAccount,
+        date
+      );
+
+    if (amountInCurrencyOfAccount) {
+      await this.accountBalanceService.createAccountBalance({
+        date,
+        Account: {
+          connect: {
+            id_userId: {
+              userId,
+              id: accountId
+            }
+          }
+        },
+        value: new Big(balance).plus(amountInCurrencyOfAccount).toNumber()
+      });
+    }
+  }
 }

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

@@ -1,9 +1,34 @@
-import { AccountType } from '@prisma/client';
-import { IsString, ValidateIf } from 'class-validator';
+import { Transform, TransformFnParams } from 'class-transformer';
+import {
+  IsBoolean,
+  IsNumber,
+  IsOptional,
+  IsString,
+  ValidateIf
+} from 'class-validator';
+import { isString } from 'lodash';
 
 export class CreateAccountDto {
+  @IsNumber()
+  balance: number;
+
+  @IsOptional()
   @IsString()
-  accountType: AccountType;
+  @Transform(({ value }: TransformFnParams) =>
+    isString(value) ? value.trim() : value
+  )
+  comment?: string;
+
+  @IsString()
+  currency: string;
+
+  @IsOptional()
+  @IsString()
+  id?: string;
+
+  @IsBoolean()
+  @IsOptional()
+  isExcluded?: boolean;
 
   @IsString()
   name: string;

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/transfer-balance.dto.ts

@@ -0,0 +1,13 @@
+import { IsNumber, IsPositive, IsString } from 'class-validator';
+
+export class TransferBalanceDto {
+  @IsString()
+  accountIdFrom: string;
+
+  @IsString()
+  accountIdTo: string;
+
+  @IsNumber()
+  @IsPositive()
+  balance: number;
+}

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

@@ -1,13 +1,34 @@
-import { AccountType } from '@prisma/client';
-import { IsString, ValidateIf } from 'class-validator';
+import { Transform, TransformFnParams } from 'class-transformer';
+import {
+  IsBoolean,
+  IsNumber,
+  IsOptional,
+  IsString,
+  ValidateIf
+} from 'class-validator';
+import { isString } from 'lodash';
 
 export class UpdateAccountDto {
+  @IsNumber()
+  balance: number;
+
+  @IsOptional()
   @IsString()
-  accountType: AccountType;
+  @Transform(({ value }: TransformFnParams) =>
+    isString(value) ? value.trim() : value
+  )
+  comment?: string;
+
+  @IsString()
+  currency: string;
 
   @IsString()
   id: string;
 
+  @IsBoolean()
+  @IsOptional()
+  isExcluded?: boolean;
+
   @IsString()
   name: string;
 

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

@@ -1,64 +1,343 @@
-import { RequestWithUser } from '@ghostfolio/api/app/interfaces/request-with-user.type';
-import { DataGatheringService } from '@ghostfolio/api/services/data-gathering.service';
-import { getPermissions, hasPermission, permissions } from '@ghostfolio/helper';
+import { HasPermission } from '@ghostfolio/api/decorators/has-permission.decorator';
+import { HasPermissionGuard } from '@ghostfolio/api/guards/has-permission.guard';
+import { TransformDataSourceInRequestInterceptor } from '@ghostfolio/api/interceptors/transform-data-source-in-request.interceptor';
+import { ApiService } from '@ghostfolio/api/services/api/api.service';
+import { DataGatheringService } from '@ghostfolio/api/services/data-gathering/data-gathering.service';
+import { ManualService } from '@ghostfolio/api/services/data-provider/manual/manual.service';
+import { MarketDataService } from '@ghostfolio/api/services/market-data/market-data.service';
+import { PropertyDto } from '@ghostfolio/api/services/property/property.dto';
 import {
+  GATHER_ASSET_PROFILE_PROCESS,
+  GATHER_ASSET_PROFILE_PROCESS_OPTIONS
+} from '@ghostfolio/common/config';
+import {
+  getAssetProfileIdentifier,
+  resetHours
+} from '@ghostfolio/common/helper';
+import {
+  AdminData,
+  AdminMarketData,
+  AdminMarketDataDetails,
+  EnhancedSymbolProfile
+} from '@ghostfolio/common/interfaces';
+import { permissions } from '@ghostfolio/common/permissions';
+import type {
+  MarketDataPreset,
+  RequestWithUser
+} from '@ghostfolio/common/types';
+import {
+  Body,
   Controller,
+  Delete,
   Get,
   HttpException,
   Inject,
+  Logger,
+  Param,
+  Patch,
   Post,
-  UseGuards
+  Put,
+  Query,
+  UseGuards,
+  UseInterceptors
 } from '@nestjs/common';
 import { REQUEST } from '@nestjs/core';
 import { AuthGuard } from '@nestjs/passport';
+import { DataSource, MarketData, Prisma, SymbolProfile } from '@prisma/client';
+import { isDate, parseISO } from 'date-fns';
 import { StatusCodes, getReasonPhrase } from 'http-status-codes';
 
 import { AdminService } from './admin.service';
-import { AdminData } from './interfaces/admin-data.interface';
+import { UpdateAssetProfileDto } from './update-asset-profile.dto';
+import { UpdateBulkMarketDataDto } from './update-bulk-market-data.dto';
+import { UpdateMarketDataDto } from './update-market-data.dto';
 
 @Controller('admin')
 export class AdminController {
   public constructor(
     private readonly adminService: AdminService,
+    private readonly apiService: ApiService,
     private readonly dataGatheringService: DataGatheringService,
+    private readonly manualService: ManualService,
+    private readonly marketDataService: MarketDataService,
     @Inject(REQUEST) private readonly request: RequestWithUser
   ) {}
 
   @Get()
-  @UseGuards(AuthGuard('jwt'))
+  @HasPermission(permissions.accessAdminControl)
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
   public async getAdminData(): Promise<AdminData> {
-    if (
-      !hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.accessAdminControl
-      )
-    ) {
-      throw new HttpException(
-        getReasonPhrase(StatusCodes.FORBIDDEN),
-        StatusCodes.FORBIDDEN
-      );
-    }
-
     return this.adminService.get();
   }
 
+  @HasPermission(permissions.accessAdminControl)
+  @Post('gather')
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  public async gather7Days(): Promise<void> {
+    this.dataGatheringService.gather7Days();
+  }
+
+  @HasPermission(permissions.accessAdminControl)
   @Post('gather/max')
-  @UseGuards(AuthGuard('jwt'))
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
   public async gatherMax(): Promise<void> {
-    if (
-      !hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.accessAdminControl
-      )
-    ) {
-      throw new HttpException(
-        getReasonPhrase(StatusCodes.FORBIDDEN),
-        StatusCodes.FORBIDDEN
-      );
-    }
+    const uniqueAssets = await this.dataGatheringService.getUniqueAssets();
+
+    await this.dataGatheringService.addJobsToQueue(
+      uniqueAssets.map(({ dataSource, symbol }) => {
+        return {
+          data: {
+            dataSource,
+            symbol
+          },
+          name: GATHER_ASSET_PROFILE_PROCESS,
+          opts: {
+            ...GATHER_ASSET_PROFILE_PROCESS_OPTIONS,
+            jobId: getAssetProfileIdentifier({ dataSource, symbol })
+          }
+        };
+      })
+    );
 
     this.dataGatheringService.gatherMax();
+  }
+
+  @HasPermission(permissions.accessAdminControl)
+  @Post('gather/profile-data')
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  public async gatherProfileData(): Promise<void> {
+    const uniqueAssets = await this.dataGatheringService.getUniqueAssets();
+
+    await this.dataGatheringService.addJobsToQueue(
+      uniqueAssets.map(({ dataSource, symbol }) => {
+        return {
+          data: {
+            dataSource,
+            symbol
+          },
+          name: GATHER_ASSET_PROFILE_PROCESS,
+          opts: {
+            ...GATHER_ASSET_PROFILE_PROCESS_OPTIONS,
+            jobId: getAssetProfileIdentifier({ dataSource, symbol })
+          }
+        };
+      })
+    );
+  }
+
+  @HasPermission(permissions.accessAdminControl)
+  @Post('gather/profile-data/:dataSource/:symbol')
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  public async gatherProfileDataForSymbol(
+    @Param('dataSource') dataSource: DataSource,
+    @Param('symbol') symbol: string
+  ): Promise<void> {
+    await this.dataGatheringService.addJobToQueue({
+      data: {
+        dataSource,
+        symbol
+      },
+      name: GATHER_ASSET_PROFILE_PROCESS,
+      opts: {
+        ...GATHER_ASSET_PROFILE_PROCESS_OPTIONS,
+        jobId: getAssetProfileIdentifier({ dataSource, symbol })
+      }
+    });
+  }
+
+  @Post('gather/:dataSource/:symbol')
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  @HasPermission(permissions.accessAdminControl)
+  public async gatherSymbol(
+    @Param('dataSource') dataSource: DataSource,
+    @Param('symbol') symbol: string
+  ): Promise<void> {
+    this.dataGatheringService.gatherSymbol({ dataSource, symbol });
 
     return;
   }
+
+  @HasPermission(permissions.accessAdminControl)
+  @Post('gather/:dataSource/:symbol/:dateString')
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  public async gatherSymbolForDate(
+    @Param('dataSource') dataSource: DataSource,
+    @Param('dateString') dateString: string,
+    @Param('symbol') symbol: string
+  ): Promise<MarketData> {
+    const date = parseISO(dateString);
+
+    if (!isDate(date)) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.BAD_REQUEST),
+        StatusCodes.BAD_REQUEST
+      );
+    }
+
+    return this.dataGatheringService.gatherSymbolForDate({
+      dataSource,
+      date,
+      symbol
+    });
+  }
+
+  @Get('market-data')
+  @HasPermission(permissions.accessAdminControl)
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  public async getMarketData(
+    @Query('assetSubClasses') filterByAssetSubClasses?: string,
+    @Query('presetId') presetId?: MarketDataPreset,
+    @Query('query') filterBySearchQuery?: string,
+    @Query('skip') skip?: number,
+    @Query('sortColumn') sortColumn?: string,
+    @Query('sortDirection') sortDirection?: Prisma.SortOrder,
+    @Query('take') take?: number
+  ): Promise<AdminMarketData> {
+    const filters = this.apiService.buildFiltersFromQueryParams({
+      filterByAssetSubClasses,
+      filterBySearchQuery
+    });
+
+    return this.adminService.getMarketData({
+      filters,
+      presetId,
+      sortColumn,
+      sortDirection,
+      skip: isNaN(skip) ? undefined : skip,
+      take: isNaN(take) ? undefined : take
+    });
+  }
+
+  @Get('market-data/:dataSource/:symbol')
+  @HasPermission(permissions.accessAdminControl)
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  public async getMarketDataBySymbol(
+    @Param('dataSource') dataSource: DataSource,
+    @Param('symbol') symbol: string
+  ): Promise<AdminMarketDataDetails> {
+    return this.adminService.getMarketDataBySymbol({ dataSource, symbol });
+  }
+
+  @HasPermission(permissions.accessAdminControl)
+  @Post('market-data/:dataSource/:symbol/test')
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  public async testMarketData(
+    @Body() data: { scraperConfiguration: string },
+    @Param('dataSource') dataSource: DataSource,
+    @Param('symbol') symbol: string
+  ): Promise<{ price: number }> {
+    try {
+      const scraperConfiguration = JSON.parse(data.scraperConfiguration);
+      const price = await this.manualService.test(scraperConfiguration);
+
+      if (price) {
+        return { price };
+      }
+
+      throw new Error('Could not parse the current market price');
+    } catch (error) {
+      Logger.error(error);
+
+      throw new HttpException(error.message, StatusCodes.BAD_REQUEST);
+    }
+  }
+
+  @HasPermission(permissions.accessAdminControl)
+  @Post('market-data/:dataSource/:symbol')
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  public async updateMarketData(
+    @Body() data: UpdateBulkMarketDataDto,
+    @Param('dataSource') dataSource: DataSource,
+    @Param('symbol') symbol: string
+  ) {
+    const dataBulkUpdate: Prisma.MarketDataUpdateInput[] = data.marketData.map(
+      ({ date, marketPrice }) => ({
+        dataSource,
+        marketPrice,
+        symbol,
+        date: resetHours(parseISO(date)),
+        state: 'CLOSE'
+      })
+    );
+
+    return this.marketDataService.updateMany({
+      data: dataBulkUpdate
+    });
+  }
+
+  /**
+   * @deprecated
+   */
+  @HasPermission(permissions.accessAdminControl)
+  @Put('market-data/:dataSource/:symbol/:dateString')
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  public async update(
+    @Param('dataSource') dataSource: DataSource,
+    @Param('dateString') dateString: string,
+    @Param('symbol') symbol: string,
+    @Body() data: UpdateMarketDataDto
+  ) {
+    const date = parseISO(dateString);
+
+    return this.marketDataService.updateMarketData({
+      data: { marketPrice: data.marketPrice, state: 'CLOSE' },
+      where: {
+        dataSource_date_symbol: {
+          dataSource,
+          date,
+          symbol
+        }
+      }
+    });
+  }
+
+  @HasPermission(permissions.accessAdminControl)
+  @Post('profile-data/:dataSource/:symbol')
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  @UseInterceptors(TransformDataSourceInRequestInterceptor)
+  public async addProfileData(
+    @Param('dataSource') dataSource: DataSource,
+    @Param('symbol') symbol: string
+  ): Promise<SymbolProfile | never> {
+    return this.adminService.addAssetProfile({
+      dataSource,
+      symbol,
+      currency: this.request.user.Settings.settings.baseCurrency
+    });
+  }
+
+  @Delete('profile-data/:dataSource/:symbol')
+  @HasPermission(permissions.accessAdminControl)
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  public async deleteProfileData(
+    @Param('dataSource') dataSource: DataSource,
+    @Param('symbol') symbol: string
+  ): Promise<void> {
+    return this.adminService.deleteProfileData({ dataSource, symbol });
+  }
+
+  @HasPermission(permissions.accessAdminControl)
+  @Patch('profile-data/:dataSource/:symbol')
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  public async patchAssetProfileData(
+    @Body() assetProfileData: UpdateAssetProfileDto,
+    @Param('dataSource') dataSource: DataSource,
+    @Param('symbol') symbol: string
+  ): Promise<EnhancedSymbolProfile> {
+    return this.adminService.patchAssetProfileData({
+      ...assetProfileData,
+      dataSource,
+      symbol
+    });
+  }
+
+  @HasPermission(permissions.accessAdminControl)
+  @Put('settings/:key')
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  public async updateProperty(
+    @Param('key') key: string,
+    @Body() data: PropertyDto
+  ) {
+    return await this.adminService.putSetting(key, data.value);
+  }
 }

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

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

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

@@ -1,120 +1,470 @@
-import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data.service';
-import { PrismaService } from '@ghostfolio/api/services/prisma.service';
-import { Injectable } from '@nestjs/common';
-import { Currency } from '@prisma/client';
-
-import { AdminData } from './interfaces/admin-data.interface';
+import { SubscriptionService } from '@ghostfolio/api/app/subscription/subscription.service';
+import { environment } from '@ghostfolio/api/environments/environment';
+import { ConfigurationService } from '@ghostfolio/api/services/configuration/configuration.service';
+import { DataProviderService } from '@ghostfolio/api/services/data-provider/data-provider.service';
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data/exchange-rate-data.service';
+import { MarketDataService } from '@ghostfolio/api/services/market-data/market-data.service';
+import { PrismaService } from '@ghostfolio/api/services/prisma/prisma.service';
+import { PropertyService } from '@ghostfolio/api/services/property/property.service';
+import { SymbolProfileService } from '@ghostfolio/api/services/symbol-profile/symbol-profile.service';
+import {
+  DEFAULT_CURRENCY,
+  PROPERTY_CURRENCIES,
+  PROPERTY_IS_READ_ONLY_MODE,
+  PROPERTY_IS_USER_SIGNUP_ENABLED
+} from '@ghostfolio/common/config';
+import {
+  AdminData,
+  AdminMarketData,
+  AdminMarketDataDetails,
+  AdminMarketDataItem,
+  Filter,
+  UniqueAsset
+} from '@ghostfolio/common/interfaces';
+import { MarketDataPreset } from '@ghostfolio/common/types';
+import { BadRequestException, Injectable } from '@nestjs/common';
+import {
+  AssetSubClass,
+  DataSource,
+  Prisma,
+  Property,
+  SymbolProfile
+} from '@prisma/client';
+import { differenceInDays } from 'date-fns';
+import { groupBy } from 'lodash';
 
 @Injectable()
 export class AdminService {
   public constructor(
-    private exchangeRateDataService: ExchangeRateDataService,
-    private prisma: PrismaService
+    private readonly configurationService: ConfigurationService,
+    private readonly dataProviderService: DataProviderService,
+    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 addAssetProfile({
+    currency,
+    dataSource,
+    symbol
+  }: UniqueAsset & { currency?: string }): Promise<SymbolProfile | never> {
+    try {
+      if (dataSource === 'MANUAL') {
+        return this.symbolProfileService.add({
+          currency,
+          dataSource,
+          symbol
+        });
+      }
+
+      const assetProfiles = await this.dataProviderService.getAssetProfiles([
+        { dataSource, symbol }
+      ]);
+
+      if (!assetProfiles[symbol]?.currency) {
+        throw new BadRequestException(
+          `Asset profile not found for ${symbol} (${dataSource})`
+        );
+      }
+
+      return await this.symbolProfileService.add(
+        assetProfiles[symbol] as Prisma.SymbolProfileCreateInput
+      );
+    } catch (error) {
+      if (
+        error instanceof Prisma.PrismaClientKnownRequestError &&
+        error.code === 'P2002'
+      ) {
+        throw new BadRequestException(
+          `Asset profile of ${symbol} (${dataSource}) already exists`
+        );
+      }
+
+      throw error;
+    }
+  }
+
+  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
-          )
-        }
-      ],
-      lastDataGathering: await this.getLastDataGathering(),
-      transactionCount: await this.prisma.order.count(),
-      userCount: await this.prisma.user.count(),
-      users: await this.getUsersWithAnalytics()
+      exchangeRates: this.exchangeRateDataService
+        .getCurrencies()
+        .filter((currency) => {
+          return currency !== DEFAULT_CURRENCY;
+        })
+        .map((currency) => {
+          const label1 = DEFAULT_CURRENCY;
+          const label2 = currency;
+
+          return {
+            label1,
+            label2,
+            dataSource:
+              DataSource[
+                this.configurationService.get('DATA_SOURCE_EXCHANGE_RATES')
+              ],
+            symbol: `${label1}${label2}`,
+            value: this.exchangeRateDataService.toCurrency(
+              1,
+              DEFAULT_CURRENCY,
+              currency
+            )
+          };
+        }),
+      settings: await this.propertyService.get(),
+      transactionCount: await this.prismaService.order.count(),
+      userCount: await this.prismaService.user.count(),
+      users: await this.getUsersWithAnalytics(),
+      version: environment.version
     };
   }
 
-  private async getLastDataGathering() {
-    const lastDataGathering = await this.prisma.property.findUnique({
-      where: { key: 'LAST_DATA_GATHERING' }
-    });
+  public async getMarketData({
+    filters,
+    presetId,
+    sortColumn,
+    sortDirection,
+    skip,
+    take = Number.MAX_SAFE_INTEGER
+  }: {
+    filters?: Filter[];
+    presetId?: MarketDataPreset;
+    skip?: number;
+    sortColumn?: string;
+    sortDirection?: Prisma.SortOrder;
+    take?: number;
+  }): Promise<AdminMarketData> {
+    let orderBy: Prisma.Enumerable<Prisma.SymbolProfileOrderByWithRelationInput> =
+      [{ symbol: 'asc' }];
+    const where: Prisma.SymbolProfileWhereInput = {};
 
-    if (lastDataGathering?.value) {
-      return new Date(lastDataGathering.value);
+    if (presetId === 'CURRENCIES') {
+      return this.getMarketDataForCurrencies();
+    } else if (
+      presetId === 'ETF_WITHOUT_COUNTRIES' ||
+      presetId === 'ETF_WITHOUT_SECTORS'
+    ) {
+      filters = [{ id: 'ETF', type: 'ASSET_SUB_CLASS' }];
     }
 
-    const dataGatheringInProgress = await this.prisma.property.findUnique({
-      where: { key: 'LOCKED_DATA_GATHERING' }
+    const searchQuery = filters.find(({ type }) => {
+      return type === 'SEARCH_QUERY';
+    })?.id;
+
+    const { ASSET_SUB_CLASS: filtersByAssetSubClass } = groupBy(
+      filters,
+      ({ type }) => {
+        return type;
+      }
+    );
+
+    const marketDataItems = await this.prismaService.marketData.groupBy({
+      _count: true,
+      by: ['dataSource', 'symbol']
     });
 
-    if (dataGatheringInProgress) {
-      return 'IN_PROGRESS';
+    if (filtersByAssetSubClass) {
+      where.assetSubClass = AssetSubClass[filtersByAssetSubClass[0].id];
     }
 
-    return null;
+    if (searchQuery) {
+      where.OR = [
+        { id: { mode: 'insensitive', startsWith: searchQuery } },
+        { isin: { mode: 'insensitive', startsWith: searchQuery } },
+        { name: { mode: 'insensitive', startsWith: searchQuery } },
+        { symbol: { mode: 'insensitive', startsWith: searchQuery } }
+      ];
+    }
+
+    if (sortColumn) {
+      orderBy = [{ [sortColumn]: sortDirection }];
+
+      if (sortColumn === 'activitiesCount') {
+        orderBy = {
+          Order: {
+            _count: sortDirection
+          }
+        };
+      }
+    }
+
+    let [assetProfiles, count] = await Promise.all([
+      this.prismaService.symbolProfile.findMany({
+        orderBy,
+        skip,
+        take,
+        where,
+        select: {
+          _count: {
+            select: { Order: true }
+          },
+          assetClass: true,
+          assetSubClass: true,
+          comment: true,
+          countries: true,
+          currency: true,
+          dataSource: true,
+          name: true,
+          Order: {
+            orderBy: [{ date: 'asc' }],
+            select: { date: true },
+            take: 1
+          },
+          scraperConfiguration: true,
+          sectors: true,
+          symbol: true
+        }
+      }),
+      this.prismaService.symbolProfile.count({ where })
+    ]);
+
+    let marketData = assetProfiles.map(
+      ({
+        _count,
+        assetClass,
+        assetSubClass,
+        comment,
+        countries,
+        currency,
+        dataSource,
+        name,
+        Order,
+        sectors,
+        symbol
+      }) => {
+        const countriesCount = countries ? Object.keys(countries).length : 0;
+        const marketDataItemCount =
+          marketDataItems.find((marketDataItem) => {
+            return (
+              marketDataItem.dataSource === dataSource &&
+              marketDataItem.symbol === symbol
+            );
+          })?._count ?? 0;
+        const sectorsCount = sectors ? Object.keys(sectors).length : 0;
+
+        return {
+          assetClass,
+          assetSubClass,
+          comment,
+          currency,
+          countriesCount,
+          dataSource,
+          name,
+          symbol,
+          marketDataItemCount,
+          sectorsCount,
+          activitiesCount: _count.Order,
+          date: Order?.[0]?.date
+        };
+      }
+    );
+
+    if (presetId) {
+      if (presetId === 'ETF_WITHOUT_COUNTRIES') {
+        marketData = marketData.filter(({ countriesCount }) => {
+          return countriesCount === 0;
+        });
+      } else if (presetId === 'ETF_WITHOUT_SECTORS') {
+        marketData = marketData.filter(({ sectorsCount }) => {
+          return sectorsCount === 0;
+        });
+      }
+
+      count = marketData.length;
+    }
+
+    return {
+      count,
+      marketData
+    };
   }
 
-  private async getUsersWithAnalytics() {
-    return await this.prisma.user.findMany({
-      orderBy: {
+  public async getMarketDataBySymbol({
+    dataSource,
+    symbol
+  }: UniqueAsset): Promise<AdminMarketDataDetails> {
+    const [[assetProfile], marketData] = await Promise.all([
+      this.symbolProfileService.getSymbolProfiles([
+        {
+          dataSource,
+          symbol
+        }
+      ]),
+      this.marketDataService.marketDataItems({
+        orderBy: {
+          date: 'asc'
+        },
+        where: {
+          dataSource,
+          symbol
+        }
+      })
+    ]);
+
+    return {
+      marketData,
+      assetProfile: assetProfile ?? {
+        symbol,
+        currency: '-'
+      }
+    };
+  }
+
+  public async patchAssetProfileData({
+    assetClass,
+    assetSubClass,
+    comment,
+    currency,
+    dataSource,
+    name,
+    scraperConfiguration,
+    symbol,
+    symbolMapping
+  }: Prisma.SymbolProfileUpdateInput & UniqueAsset) {
+    await this.symbolProfileService.updateSymbolProfile({
+      assetClass,
+      assetSubClass,
+      comment,
+      currency,
+      dataSource,
+      name,
+      scraperConfiguration,
+      symbol,
+      symbolMapping
+    });
+
+    const [symbolProfile] = await this.symbolProfileService.getSymbolProfiles([
+      {
+        dataSource,
+        symbol
+      }
+    ]);
+
+    return symbolProfile;
+  }
+
+  public async putSetting(key: string, value: string) {
+    let response: Property;
+
+    if (value) {
+      response = await this.propertyService.put({ key, value });
+    } else {
+      response = await this.propertyService.delete({ key });
+    }
+
+    if (key === PROPERTY_IS_READ_ONLY_MODE && value === 'true') {
+      await this.putSetting(PROPERTY_IS_USER_SIGNUP_ENABLED, 'false');
+    } else if (key === PROPERTY_CURRENCIES) {
+      await this.exchangeRateDataService.initialize();
+    }
+
+    return response;
+  }
+
+  private async getMarketDataForCurrencies(): Promise<AdminMarketData> {
+    const marketDataItems = await this.prismaService.marketData.groupBy({
+      _count: true,
+      by: ['dataSource', 'symbol']
+    });
+
+    const marketData: AdminMarketDataItem[] = this.exchangeRateDataService
+      .getCurrencyPairs()
+      .map(({ dataSource, symbol }) => {
+        const marketDataItemCount =
+          marketDataItems.find((marketDataItem) => {
+            return (
+              marketDataItem.dataSource === dataSource &&
+              marketDataItem.symbol === symbol
+            );
+          })?._count ?? 0;
+
+        return {
+          dataSource,
+          marketDataItemCount,
+          symbol,
+          assetClass: 'CASH',
+          countriesCount: 0,
+          currency: symbol.replace(DEFAULT_CURRENCY, ''),
+          name: symbol,
+          sectorsCount: 0
+        };
+      });
+
+    return { marketData, count: marketData.length };
+  }
+
+  private async getUsersWithAnalytics(): Promise<AdminData['users']> {
+    let orderBy: any = {
+      createdAt: 'desc'
+    };
+    let where;
+
+    if (this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION')) {
+      orderBy = {
         Analytics: {
           updatedAt: 'desc'
         }
-      },
+      };
+      where = {
+        NOT: {
+          Analytics: null
+        }
+      };
+    }
+
+    const usersWithAnalytics = await this.prismaService.user.findMany({
+      orderBy,
+      where,
       select: {
         _count: {
           select: { Account: true, Order: true }
         },
-        alias: true,
         Analytics: {
           select: {
             activityCount: true,
+            country: true,
             updatedAt: true
           }
         },
         createdAt: true,
-        id: true
+        id: true,
+        Subscription: true
       },
-      take: 20,
-      where: {
-        NOT: {
-          Analytics: null
-        }
-      }
+      take: 30
     });
+
+    return usersWithAnalytics.map(
+      ({ _count, Analytics, createdAt, id, Subscription }) => {
+        const daysSinceRegistration =
+          differenceInDays(new Date(), createdAt) + 1;
+        const engagement = Analytics
+          ? Analytics.activityCount / daysSinceRegistration
+          : undefined;
+
+        const subscription = this.configurationService.get(
+          'ENABLE_FEATURE_SUBSCRIPTION'
+        )
+          ? this.subscriptionService.getSubscription(Subscription)
+          : undefined;
+
+        return {
+          createdAt,
+          engagement,
+          id,
+          subscription,
+          accountCount: _count.Account || 0,
+          country: Analytics?.country,
+          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/queue/queue.controller.ts

@@ -0,0 +1,48 @@
+import { HasPermission } from '@ghostfolio/api/decorators/has-permission.decorator';
+import { HasPermissionGuard } from '@ghostfolio/api/guards/has-permission.guard';
+import { AdminJobs } from '@ghostfolio/common/interfaces';
+import { permissions } from '@ghostfolio/common/permissions';
+import {
+  Controller,
+  Delete,
+  Get,
+  Param,
+  Query,
+  UseGuards
+} from '@nestjs/common';
+import { AuthGuard } from '@nestjs/passport';
+import { JobStatus } from 'bull';
+
+import { QueueService } from './queue.service';
+
+@Controller('admin/queue')
+export class QueueController {
+  public constructor(private readonly queueService: QueueService) {}
+
+  @Delete('job')
+  @HasPermission(permissions.accessAdminControl)
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  public async deleteJobs(
+    @Query('status') filterByStatus?: string
+  ): Promise<void> {
+    const status = <JobStatus[]>filterByStatus?.split(',') ?? undefined;
+    return this.queueService.deleteJobs({ status });
+  }
+
+  @Get('job')
+  @HasPermission(permissions.accessAdminControl)
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  public async getJobs(
+    @Query('status') filterByStatus?: string
+  ): Promise<AdminJobs> {
+    const status = <JobStatus[]>filterByStatus?.split(',') ?? undefined;
+    return this.queueService.getJobs({ status });
+  }
+
+  @Delete('job/:id')
+  @HasPermission(permissions.accessAdminControl)
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  public async deleteJob(@Param('id') id: string): Promise<void> {
+    return this.queueService.deleteJob(id);
+  }
+}

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

@@ -0,0 +1,12 @@
+import { DataGatheringModule } from '@ghostfolio/api/services/data-gathering/data-gathering.module';
+import { Module } from '@nestjs/common';
+
+import { QueueController } from './queue.controller';
+import { QueueService } from './queue.service';
+
+@Module({
+  controllers: [QueueController],
+  imports: [DataGatheringModule],
+  providers: [QueueService]
+})
+export class QueueModule {}

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

@@ -0,0 +1,67 @@
+import {
+  DATA_GATHERING_QUEUE,
+  QUEUE_JOB_STATUS_LIST
+} from '@ghostfolio/common/config';
+import { AdminJobs } from '@ghostfolio/common/interfaces';
+import { InjectQueue } from '@nestjs/bull';
+import { Injectable } from '@nestjs/common';
+import { JobStatus, Queue } from 'bull';
+
+@Injectable()
+export class QueueService {
+  public constructor(
+    @InjectQueue(DATA_GATHERING_QUEUE)
+    private readonly dataGatheringQueue: Queue
+  ) {}
+
+  public async deleteJob(aId: string) {
+    return (await this.dataGatheringQueue.getJob(aId))?.remove();
+  }
+
+  public async deleteJobs({
+    status = QUEUE_JOB_STATUS_LIST
+  }: {
+    status?: JobStatus[];
+  }) {
+    for (const statusItem of status) {
+      await this.dataGatheringQueue.clean(
+        300,
+        statusItem === 'waiting' ? 'wait' : statusItem
+      );
+    }
+  }
+
+  public async getJobs({
+    limit = 1000,
+    status = QUEUE_JOB_STATUS_LIST
+  }: {
+    limit?: number;
+    status?: JobStatus[];
+  }): Promise<AdminJobs> {
+    const jobs = await this.dataGatheringQueue.getJobs(status);
+
+    const jobsWithState = await Promise.all(
+      jobs
+        .filter((job) => {
+          return job;
+        })
+        .slice(0, limit)
+        .map(async (job) => {
+          return {
+            attemptsMade: job.attemptsMade + 1,
+            data: job.data,
+            finishedOn: job.finishedOn,
+            id: job.id,
+            name: job.name,
+            stacktrace: job.stacktrace,
+            state: await job.getState(),
+            timestamp: job.timestamp
+          };
+        })
+    );
+
+    return {
+      jobs: jobsWithState
+    };
+  }
+}

apps/api/src/app/admin/update-asset-profile.dto.ts

@@ -0,0 +1,34 @@
+import { AssetClass, AssetSubClass, Prisma } from '@prisma/client';
+import { IsEnum, IsObject, IsOptional, IsString } from 'class-validator';
+
+export class UpdateAssetProfileDto {
+  @IsEnum(AssetClass, { each: true })
+  @IsOptional()
+  assetClass?: AssetClass;
+
+  @IsEnum(AssetSubClass, { each: true })
+  @IsOptional()
+  assetSubClass?: AssetSubClass;
+
+  @IsString()
+  @IsOptional()
+  comment?: string;
+
+  @IsString()
+  @IsOptional()
+  currency?: string;
+
+  @IsString()
+  @IsOptional()
+  name?: string;
+
+  @IsObject()
+  @IsOptional()
+  scraperConfiguration?: Prisma.InputJsonObject;
+
+  @IsObject()
+  @IsOptional()
+  symbolMapping?: {
+    [dataProvider: string]: string;
+  };
+}

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

@@ -0,0 +1,11 @@
+import { Type } from 'class-transformer';
+import { ArrayNotEmpty, IsArray, isNotEmptyObject } from 'class-validator';
+
+import { UpdateMarketDataDto } from './update-market-data.dto';
+
+export class UpdateBulkMarketDataDto {
+  @ArrayNotEmpty()
+  @IsArray()
+  @Type(() => UpdateMarketDataDto)
+  marketData: UpdateMarketDataDto[];
+}

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

@@ -0,0 +1,10 @@
+import { IsISO8601, IsNumber, IsOptional } from 'class-validator';
+
+export class UpdateMarketDataDto {
+  @IsISO8601()
+  @IsOptional()
+  date?: string;
+
+  @IsNumber()
+  marketPrice: number;
+}

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

@@ -1,31 +1,17 @@
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data/exchange-rate-data.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 redisCacheService: RedisCacheService
+    private readonly exchangeRateDataService: ExchangeRateDataService
   ) {
     this.initialize();
   }
 
   private async initialize() {
-    this.redisCacheService.reset();
-
-    const isDataGatheringLocked = await this.prisma.property.findUnique({
-      where: { key: 'LOCKED_DATA_GATHERING' }
-    });
-
-    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' }]
-        }
-      });
-    }
+    try {
+      await this.exchangeRateDataService.initialize();
+    } catch {}
   }
 }

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

@@ -1,32 +1,45 @@
 import { join } from 'path';
 
+import { ConfigurationModule } from '@ghostfolio/api/services/configuration/configuration.module';
+import { CronService } from '@ghostfolio/api/services/cron.service';
+import { DataGatheringModule } from '@ghostfolio/api/services/data-gathering/data-gathering.module';
+import { DataProviderModule } from '@ghostfolio/api/services/data-provider/data-provider.module';
+import { ExchangeRateDataModule } from '@ghostfolio/api/services/exchange-rate-data/exchange-rate-data.module';
+import { PrismaModule } from '@ghostfolio/api/services/prisma/prisma.module';
+import { TwitterBotModule } from '@ghostfolio/api/services/twitter-bot/twitter-bot.module';
+import {
+  DEFAULT_LANGUAGE_CODE,
+  SUPPORTED_LANGUAGE_CODES
+} from '@ghostfolio/common/config';
+import { BullModule } from '@nestjs/bull';
 import { Module } from '@nestjs/common';
 import { ConfigModule } from '@nestjs/config';
 import { ScheduleModule } from '@nestjs/schedule';
 import { ServeStaticModule } from '@nestjs/serve-static';
+import { StatusCodes } from 'http-status-codes';
 
-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 { GhostfolioScraperApiService } from '../services/data-provider/ghostfolio-scraper-api/ghostfolio-scraper-api.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 { AuthDeviceModule } from './auth-device/auth-device.module';
 import { AuthModule } from './auth/auth.module';
+import { BenchmarkModule } from './benchmark/benchmark.module';
 import { CacheModule } from './cache/cache.module';
-import { ExperimentalModule } from './experimental/experimental.module';
+import { ExchangeRateModule } from './exchange-rate/exchange-rate.module';
+import { ExportModule } from './export/export.module';
+import { HealthModule } from './health/health.module';
+import { ImportModule } from './import/import.module';
 import { InfoModule } from './info/info.module';
+import { LogoModule } from './logo/logo.module';
 import { OrderModule } from './order/order.module';
+import { PlatformModule } from './platform/platform.module';
 import { PortfolioModule } from './portfolio/portfolio.module';
 import { RedisCacheModule } from './redis-cache/redis-cache.module';
+import { SitemapModule } from './sitemap/sitemap.module';
+import { SubscriptionModule } from './subscription/subscription.module';
 import { SymbolModule } from './symbol/symbol.module';
+import { TagModule } from './tag/tag.module';
 import { UserModule } from './user/user.module';
 
 @Module({
@@ -34,44 +47,66 @@ import { UserModule } from './user/user.module';
     AdminModule,
     AccessModule,
     AccountModule,
+    AuthDeviceModule,
     AuthModule,
+    BenchmarkModule,
+    BullModule.forRoot({
+      redis: {
+        host: process.env.REDIS_HOST,
+        port: parseInt(process.env.REDIS_PORT ?? '6379', 10),
+        password: process.env.REDIS_PASSWORD
+      }
+    }),
     CacheModule,
     ConfigModule.forRoot(),
-    ExperimentalModule,
+    ConfigurationModule,
+    DataGatheringModule,
+    DataProviderModule,
+    ExchangeRateModule,
+    ExchangeRateDataModule,
+    ExportModule,
+    HealthModule,
+    ImportModule,
     InfoModule,
+    LogoModule,
     OrderModule,
+    PlatformModule,
     PortfolioModule,
+    PrismaModule,
     RedisCacheModule,
     ScheduleModule.forRoot(),
     ServeStaticModule.forRoot({
-      serveStaticOptions: {
-        /*etag: false // Disable etag header to fix PWA
-        setHeaders: (res, path) => {
-          if (path.includes('ngsw.json')) {
-            // Disable cache (https://stackoverflow.com/questions/22632593/how-to-disable-webpage-caching-in-expressjs-nodejs/39775595)
-            // https://gertjans.home.xs4all.nl/javascript/cache-control.html#no-cache
-            res.set('Cache-Control', 'no-cache, no-store, must-revalidate');
-          }
-        }*/
-      },
+      exclude: ['/api*', '/sitemap.xml'],
       rootPath: join(__dirname, '..', 'client'),
-      exclude: ['/api*']
+      serveStaticOptions: {
+        setHeaders: (res) => {
+          if (res.req?.path === '/') {
+            let languageCode = DEFAULT_LANGUAGE_CODE;
+
+            try {
+              const code = res.req.headers['accept-language']
+                .split(',')[0]
+                .split('-')[0];
+
+              if (SUPPORTED_LANGUAGE_CODES.includes(code)) {
+                languageCode = code;
+              }
+            } catch {}
+
+            res.set('Location', `/${languageCode}`);
+            res.statusCode = StatusCodes.MOVED_PERMANENTLY;
+          }
+        }
+      }
     }),
+    SitemapModule,
+    SubscriptionModule,
     SymbolModule,
+    TagModule,
+    TwitterBotModule,
     UserModule
   ],
   controllers: [AppController],
-  providers: [
-    AlphaVantageService,
-    ConfigurationService,
-    CronService,
-    DataGatheringService,
-    DataProviderService,
-    ExchangeRateDataService,
-    GhostfolioScraperApiService,
-    PrismaService,
-    RakutenRapidApiService,
-    YahooFinanceService
-  ]
+  providers: [CronService]
 })
 export class AppModule {}

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

@@ -0,0 +1,18 @@
+import { AuthDeviceService } from '@ghostfolio/api/app/auth-device/auth-device.service';
+import { HasPermission } from '@ghostfolio/api/decorators/has-permission.decorator';
+import { HasPermissionGuard } from '@ghostfolio/api/guards/has-permission.guard';
+import { permissions } from '@ghostfolio/common/permissions';
+import { Controller, Delete, Param, UseGuards } from '@nestjs/common';
+import { AuthGuard } from '@nestjs/passport';
+
+@Controller('auth-device')
+export class AuthDeviceController {
+  public constructor(private readonly authDeviceService: AuthDeviceService) {}
+
+  @Delete(':id')
+  @HasPermission(permissions.deleteAuthDevice)
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  public async deleteAuthDevice(@Param('id') id: string): Promise<void> {
+    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/configuration.module';
+import { PrismaModule } from '@ghostfolio/api/services/prisma/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/configuration.service';
+import { PrismaService } from '@ghostfolio/api/services/prisma/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,30 +1,65 @@
-import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
+import { WebAuthService } from '@ghostfolio/api/app/auth/web-auth.service';
+import { HasPermissionGuard } from '@ghostfolio/api/guards/has-permission.guard';
+import { ConfigurationService } from '@ghostfolio/api/services/configuration/configuration.service';
+import { DEFAULT_LANGUAGE_CODE } from '@ghostfolio/common/config';
+import { OAuthResponse } from '@ghostfolio/common/interfaces';
 import {
+  Body,
   Controller,
   Get,
   HttpException,
   Param,
+  Post,
   Req,
   Res,
-  UseGuards
+  UseGuards,
+  VERSION_NEUTRAL,
+  Version
 } from '@nestjs/common';
 import { AuthGuard } from '@nestjs/passport';
+import { Request, Response } from 'express';
 import { StatusCodes, getReasonPhrase } from 'http-status-codes';
 
 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
   ) {}
 
+  /**
+   * @deprecated
+   */
   @Get('anonymous/:accessToken')
-  public async accessTokenLogin(@Param('accessToken') accessToken: string) {
+  public async accessTokenLoginGet(
+    @Param('accessToken') accessToken: string
+  ): Promise<OAuthResponse> {
+    try {
+      const authToken =
+        await this.authService.validateAnonymousLogin(accessToken);
+      return { authToken };
+    } catch {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+  }
+
+  @Post('anonymous')
+  public async accessTokenLogin(
+    @Body() body: { accessToken: string }
+  ): Promise<OAuthResponse> {
     try {
       const authToken = await this.authService.validateAnonymousLogin(
-        accessToken
+        body.accessToken
       );
       return { authToken };
     } catch {
@@ -43,14 +78,83 @@ export class AuthController {
 
   @Get('google/callback')
   @UseGuards(AuthGuard('google'))
-  public googleLoginCallback(@Req() req, @Res() res) {
+  @Version(VERSION_NEUTRAL)
+  public googleLoginCallback(
+    @Req() request: Request,
+    @Res() response: Response
+  ) {
     // Handles the Google OAuth2 callback
-    const jwt: string = req.user.jwt;
+    const jwt: string = (<any>request.user).jwt;
 
     if (jwt) {
-      res.redirect(`${this.configurationService.get('ROOT_URL')}/auth/${jwt}`);
+      response.redirect(
+        `${this.configurationService.get(
+          'ROOT_URL'
+        )}/${DEFAULT_LANGUAGE_CODE}/auth/${jwt}`
+      );
     } else {
-      res.redirect(`${this.configurationService.get('ROOT_URL')}/auth`);
+      response.redirect(
+        `${this.configurationService.get(
+          'ROOT_URL'
+        )}/${DEFAULT_LANGUAGE_CODE}/auth`
+      );
+    }
+  }
+
+  @Post('internet-identity')
+  public async internetIdentityLogin(
+    @Body() body: { principalId: string }
+  ): Promise<OAuthResponse> {
+    try {
+      const authToken = await this.authService.validateInternetIdentityLogin(
+        body.principalId
+      );
+      return { authToken };
+    } catch {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+  }
+
+  @Get('webauthn/generate-registration-options')
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  public async generateRegistrationOptions() {
+    return this.webAuthService.generateRegistrationOptions();
+  }
+
+  @Post('webauthn/verify-attestation')
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  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,13 @@
-import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
-import { PrismaService } from '@ghostfolio/api/services/prisma.service';
+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/configuration.module';
+import { PrismaModule } from '@ghostfolio/api/services/prisma/prisma.module';
+import { PropertyModule } from '@ghostfolio/api/services/property/property.module';
 import { Module } from '@nestjs/common';
 import { JwtModule } from '@nestjs/jwt';
 
-import { UserService } from '../user/user.service';
 import { AuthController } from './auth.controller';
 import { AuthService } from './auth.service';
 import { GoogleStrategy } from './google.strategy';
@@ -12,18 +16,22 @@ import { JwtStrategy } from './jwt.strategy';
 @Module({
   controllers: [AuthController],
   imports: [
+    ConfigurationModule,
     JwtModule.register({
       secret: process.env.JWT_SECRET_KEY,
       signOptions: { expiresIn: '180 days' }
-    })
+    }),
+    PrismaModule,
+    PropertyModule,
+    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,10 @@
-import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
+import { UserService } from '@ghostfolio/api/app/user/user.service';
+import { ConfigurationService } from '@ghostfolio/api/services/configuration/configuration.service';
+import { PropertyService } from '@ghostfolio/api/services/property/property.service';
 import { Injectable, InternalServerErrorException } from '@nestjs/common';
 import { JwtService } from '@nestjs/jwt';
+import { Provider } from '@prisma/client';
 
-import { UserService } from '../user/user.service';
 import { ValidateOAuthLoginParams } from './interfaces/interfaces';
 
 @Injectable()
@@ -10,10 +12,11 @@ export class AuthService {
   public constructor(
     private readonly configurationService: ConfigurationService,
     private readonly jwtService: JwtService,
+    private readonly propertyService: PropertyService,
     private readonly userService: UserService
   ) {}
 
-  public async validateAnonymousLogin(accessToken: string) {
+  public async validateAnonymousLogin(accessToken: string): Promise<string> {
     return new Promise(async (resolve, reject) => {
       try {
         const hashedAccessToken = this.userService.createAccessToken(
@@ -26,7 +29,7 @@ export class AuthService {
         });
 
         if (user) {
-          const jwt: string = this.jwtService.sign({
+          const jwt = this.jwtService.sign({
             id: user.id
           });
 
@@ -40,6 +43,42 @@ export class AuthService {
     });
   }
 
+  public async validateInternetIdentityLogin(principalId: string) {
+    try {
+      const provider: Provider = 'INTERNET_IDENTITY';
+
+      let [user] = await this.userService.users({
+        where: { provider, thirdPartyId: principalId }
+      });
+
+      if (!user) {
+        const isUserSignupEnabled =
+          await this.propertyService.isUserSignupEnabled();
+
+        if (!isUserSignupEnabled || true) {
+          throw new Error('Sign up forbidden');
+        }
+
+        // Create new user if not found
+        user = await this.userService.createUser({
+          data: {
+            provider,
+            thirdPartyId: principalId
+          }
+        });
+      }
+
+      return this.jwtService.sign({
+        id: user.id
+      });
+    } catch (error) {
+      throw new InternalServerErrorException(
+        'validateInternetIdentityLogin',
+        error.message
+      );
+    }
+  }
+
   public async validateOAuthLogin({
     provider,
     thirdPartyId
@@ -50,20 +89,30 @@ export class AuthService {
       });
 
       if (!user) {
+        const isUserSignupEnabled =
+          await this.propertyService.isUserSignupEnabled();
+
+        if (!isUserSignupEnabled) {
+          throw new Error('Sign up forbidden');
+        }
+
         // Create new user if not found
         user = await this.userService.createUser({
-          provider,
-          thirdPartyId
+          data: {
+            provider,
+            thirdPartyId
+          }
         });
       }
 
-      const jwt: string = this.jwtService.sign({
+      return this.jwtService.sign({
         id: user.id
       });
-
-      return jwt;
-    } catch (err) {
-      throw new InternalServerErrorException('validateOAuthLogin', err.message);
+    } catch (error) {
+      throw new InternalServerErrorException(
+        'validateOAuthLogin',
+        error.message
+      );
     }
   }
 }

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

@@ -1,5 +1,5 @@
-import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
-import { Injectable } from '@nestjs/common';
+import { ConfigurationService } from '@ghostfolio/api/services/configuration/configuration.service';
+import { Injectable, Logger } from '@nestjs/common';
 import { PassportStrategy } from '@nestjs/passport';
 import { Provider } from '@prisma/client';
 import { Strategy } from 'passport-google-oauth20';
@@ -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,34 +1,46 @@
-import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
-import { PrismaService } from '@ghostfolio/api/services/prisma.service';
+import { UserService } from '@ghostfolio/api/app/user/user.service';
+import { ConfigurationService } from '@ghostfolio/api/services/configuration/configuration.service';
+import { PrismaService } from '@ghostfolio/api/services/prisma/prisma.service';
+import { HEADER_KEY_TIMEZONE } from '@ghostfolio/common/config';
 import { Injectable, UnauthorizedException } from '@nestjs/common';
 import { PassportStrategy } from '@nestjs/passport';
+import * as countriesAndTimezones from 'countries-and-timezones';
 import { ExtractJwt, Strategy } from 'passport-jwt';
 
-import { UserService } from '../user/user.service';
-
 @Injectable()
 export class JwtStrategy extends PassportStrategy(Strategy, 'jwt') {
   public constructor(
-    readonly configurationService: ConfigurationService,
-    private prisma: PrismaService,
+    private readonly configurationService: ConfigurationService,
+    private readonly prismaService: PrismaService,
     private readonly userService: UserService
   ) {
     super({
       jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+      passReqToCallback: true,
       secretOrKey: configurationService.get('JWT_SECRET_KEY')
     });
   }
 
-  public async validate({ id }: { id: string }) {
+  public async validate(request: Request, { id }: { id: string }) {
     try {
+      const timezone = request.headers[HEADER_KEY_TIMEZONE.toLowerCase()];
       const user = await this.userService.user({ id });
 
       if (user) {
-        await this.prisma.analytics.upsert({
-          create: { User: { connect: { id: user.id } } },
-          update: { activityCount: { increment: 1 }, updatedAt: new Date() },
-          where: { userId: user.id }
-        });
+        if (this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION')) {
+          const country =
+            countriesAndTimezones.getCountryForTimezone(timezone)?.id;
+
+          await this.prismaService.analytics.upsert({
+            create: { country, User: { connect: { id: user.id } } },
+            update: {
+              country,
+              activityCount: { increment: 1 },
+              updatedAt: new Date()
+            },
+            where: { userId: user.id }
+          });
+        }
 
         return user;
       } else {

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

@@ -0,0 +1,229 @@
+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/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: '',
+      timeout: 60000,
+      attestationType: 'indirect',
+      authenticatorSelection: {
+        authenticatorAttachment: 'platform',
+        requireResidentKey: false,
+        userVerification: 'required'
+      }
+    };
+
+    const options = await 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 = {
+        expectedChallenge,
+        expectedOrigin: this.expectedOrigin,
+        expectedRPID: this.rpID,
+        response: {
+          clientExtensionResults: credential.clientExtensionResults,
+          id: credential.id,
+          rawId: credential.rawId,
+          response: credential.response,
+          type: 'public-key'
+        }
+      };
+      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,
+          credentialId: Buffer.from(credentialID),
+          credentialPublicKey: Buffer.from(credentialPublicKey),
+          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 = await 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 = {
+        authenticator: {
+          credentialID: device.credentialId,
+          credentialPublicKey: device.credentialPublicKey,
+          counter: device.counter
+        },
+        expectedChallenge: `${user.authChallenge}`,
+        expectedOrigin: this.expectedOrigin,
+        expectedRPID: this.rpID,
+        response: {
+          clientExtensionResults: credential.clientExtensionResults,
+          id: credential.id,
+          rawId: credential.rawId,
+          response: credential.response,
+          type: 'public-key'
+        }
+      };
+      verification = await 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/benchmark/benchmark.controller.ts

@@ -0,0 +1,120 @@
+import { HasPermission } from '@ghostfolio/api/decorators/has-permission.decorator';
+import { HasPermissionGuard } from '@ghostfolio/api/guards/has-permission.guard';
+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 type {
+  BenchmarkMarketDataDetails,
+  BenchmarkResponse,
+  UniqueAsset
+} from '@ghostfolio/common/interfaces';
+import { permissions } from '@ghostfolio/common/permissions';
+import type { RequestWithUser } from '@ghostfolio/common/types';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpException,
+  Inject,
+  Param,
+  Post,
+  UseGuards,
+  UseInterceptors
+} from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
+import { AuthGuard } from '@nestjs/passport';
+import { DataSource } from '@prisma/client';
+import { StatusCodes, getReasonPhrase } from 'http-status-codes';
+
+import { BenchmarkService } from './benchmark.service';
+
+@Controller('benchmark')
+export class BenchmarkController {
+  public constructor(
+    private readonly benchmarkService: BenchmarkService,
+    @Inject(REQUEST) private readonly request: RequestWithUser
+  ) {}
+
+  @HasPermission(permissions.accessAdminControl)
+  @Post()
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  public async addBenchmark(@Body() { dataSource, symbol }: UniqueAsset) {
+    try {
+      const benchmark = await this.benchmarkService.addBenchmark({
+        dataSource,
+        symbol
+      });
+
+      if (!benchmark) {
+        throw new HttpException(
+          getReasonPhrase(StatusCodes.NOT_FOUND),
+          StatusCodes.NOT_FOUND
+        );
+      }
+
+      return benchmark;
+    } catch {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.INTERNAL_SERVER_ERROR),
+        StatusCodes.INTERNAL_SERVER_ERROR
+      );
+    }
+  }
+
+  @Delete(':dataSource/:symbol')
+  @HasPermission(permissions.accessAdminControl)
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  public async deleteBenchmark(
+    @Param('dataSource') dataSource: DataSource,
+    @Param('symbol') symbol: string
+  ) {
+    try {
+      const benchmark = await this.benchmarkService.deleteBenchmark({
+        dataSource,
+        symbol
+      });
+
+      if (!benchmark) {
+        throw new HttpException(
+          getReasonPhrase(StatusCodes.NOT_FOUND),
+          StatusCodes.NOT_FOUND
+        );
+      }
+
+      return benchmark;
+    } catch {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.INTERNAL_SERVER_ERROR),
+        StatusCodes.INTERNAL_SERVER_ERROR
+      );
+    }
+  }
+
+  @Get()
+  @UseInterceptors(TransformDataSourceInRequestInterceptor)
+  @UseInterceptors(TransformDataSourceInResponseInterceptor)
+  public async getBenchmark(): Promise<BenchmarkResponse> {
+    return {
+      benchmarks: await this.benchmarkService.getBenchmarks()
+    };
+  }
+
+  @Get(':dataSource/:symbol/:startDateString')
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  @UseInterceptors(TransformDataSourceInRequestInterceptor)
+  public async getBenchmarkMarketDataBySymbol(
+    @Param('dataSource') dataSource: DataSource,
+    @Param('startDateString') startDateString: string,
+    @Param('symbol') symbol: string
+  ): Promise<BenchmarkMarketDataDetails> {
+    const startDate = new Date(startDateString);
+    const userCurrency = this.request.user.Settings.settings.baseCurrency;
+
+    return this.benchmarkService.getMarketDataBySymbol({
+      dataSource,
+      startDate,
+      symbol,
+      userCurrency
+    });
+  }
+}

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

@@ -0,0 +1,31 @@
+import { RedisCacheModule } from '@ghostfolio/api/app/redis-cache/redis-cache.module';
+import { SymbolModule } from '@ghostfolio/api/app/symbol/symbol.module';
+import { ConfigurationModule } from '@ghostfolio/api/services/configuration/configuration.module';
+import { DataProviderModule } from '@ghostfolio/api/services/data-provider/data-provider.module';
+import { ExchangeRateDataModule } from '@ghostfolio/api/services/exchange-rate-data/exchange-rate-data.module';
+import { MarketDataModule } from '@ghostfolio/api/services/market-data/market-data.module';
+import { PrismaModule } from '@ghostfolio/api/services/prisma/prisma.module';
+import { PropertyModule } from '@ghostfolio/api/services/property/property.module';
+import { SymbolProfileModule } from '@ghostfolio/api/services/symbol-profile/symbol-profile.module';
+import { Module } from '@nestjs/common';
+
+import { BenchmarkController } from './benchmark.controller';
+import { BenchmarkService } from './benchmark.service';
+
+@Module({
+  controllers: [BenchmarkController],
+  exports: [BenchmarkService],
+  imports: [
+    ConfigurationModule,
+    DataProviderModule,
+    ExchangeRateDataModule,
+    MarketDataModule,
+    PrismaModule,
+    PropertyModule,
+    RedisCacheModule,
+    SymbolModule,
+    SymbolProfileModule
+  ],
+  providers: [BenchmarkService]
+})
+export class BenchmarkModule {}

apps/api/src/app/benchmark/benchmark.service.spec.ts

@@ -0,0 +1,24 @@
+import { BenchmarkService } from './benchmark.service';
+
+describe('BenchmarkService', () => {
+  let benchmarkService: BenchmarkService;
+
+  beforeAll(async () => {
+    benchmarkService = new BenchmarkService(
+      null,
+      null,
+      null,
+      null,
+      null,
+      null,
+      null,
+      null
+    );
+  });
+
+  it('calculateChangeInPercentage', async () => {
+    expect(benchmarkService.calculateChangeInPercentage(1, 2)).toEqual(1);
+    expect(benchmarkService.calculateChangeInPercentage(2, 2)).toEqual(0);
+    expect(benchmarkService.calculateChangeInPercentage(2, 1)).toEqual(-0.5);
+  });
+});

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

@@ -0,0 +1,415 @@
+import { RedisCacheService } from '@ghostfolio/api/app/redis-cache/redis-cache.service';
+import { SymbolService } from '@ghostfolio/api/app/symbol/symbol.service';
+import { DataProviderService } from '@ghostfolio/api/services/data-provider/data-provider.service';
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data/exchange-rate-data.service';
+import { MarketDataService } from '@ghostfolio/api/services/market-data/market-data.service';
+import { PrismaService } from '@ghostfolio/api/services/prisma/prisma.service';
+import { PropertyService } from '@ghostfolio/api/services/property/property.service';
+import { SymbolProfileService } from '@ghostfolio/api/services/symbol-profile/symbol-profile.service';
+import {
+  MAX_CHART_ITEMS,
+  PROPERTY_BENCHMARKS
+} from '@ghostfolio/common/config';
+import {
+  DATE_FORMAT,
+  calculateBenchmarkTrend,
+  parseDate
+} from '@ghostfolio/common/helper';
+import {
+  Benchmark,
+  BenchmarkMarketDataDetails,
+  BenchmarkProperty,
+  BenchmarkResponse,
+  UniqueAsset
+} from '@ghostfolio/common/interfaces';
+import { BenchmarkTrend } from '@ghostfolio/common/types';
+import { Injectable, Logger } from '@nestjs/common';
+import { SymbolProfile } from '@prisma/client';
+import Big from 'big.js';
+import { format, isSameDay, subDays } from 'date-fns';
+import { isNumber, last, uniqBy } from 'lodash';
+import ms from 'ms';
+
+@Injectable()
+export class BenchmarkService {
+  private readonly CACHE_KEY_BENCHMARKS = 'BENCHMARKS';
+
+  public constructor(
+    private readonly dataProviderService: DataProviderService,
+    private readonly exchangeRateDataService: ExchangeRateDataService,
+    private readonly marketDataService: MarketDataService,
+    private readonly prismaService: PrismaService,
+    private readonly propertyService: PropertyService,
+    private readonly redisCacheService: RedisCacheService,
+    private readonly symbolProfileService: SymbolProfileService,
+    private readonly symbolService: SymbolService
+  ) {}
+
+  public calculateChangeInPercentage(baseValue: number, currentValue: number) {
+    if (baseValue && currentValue) {
+      return new Big(currentValue).div(baseValue).minus(1).toNumber();
+    }
+
+    return 0;
+  }
+
+  public async getBenchmarkTrends({ dataSource, symbol }: UniqueAsset) {
+    const historicalData = await this.marketDataService.marketDataItems({
+      orderBy: {
+        date: 'desc'
+      },
+      where: {
+        dataSource,
+        symbol,
+        date: { gte: subDays(new Date(), 400) }
+      }
+    });
+
+    const fiftyDayAverage = calculateBenchmarkTrend({
+      historicalData,
+      days: 50
+    });
+    const twoHundredDayAverage = calculateBenchmarkTrend({
+      historicalData,
+      days: 200
+    });
+
+    return { trend50d: fiftyDayAverage, trend200d: twoHundredDayAverage };
+  }
+
+  public async getBenchmarks({
+    enableSharing = false,
+    useCache = true
+  } = {}): Promise<BenchmarkResponse['benchmarks']> {
+    let benchmarks: BenchmarkResponse['benchmarks'];
+
+    if (useCache) {
+      try {
+        benchmarks = JSON.parse(
+          await this.redisCacheService.get(this.CACHE_KEY_BENCHMARKS)
+        );
+
+        if (benchmarks) {
+          return benchmarks;
+        }
+      } catch {}
+    }
+
+    const benchmarkAssetProfiles = await this.getBenchmarkAssetProfiles({
+      enableSharing
+    });
+
+    const promisesAllTimeHighs: Promise<{ date: Date; marketPrice: number }>[] =
+      [];
+    const promisesBenchmarkTrends: Promise<{
+      trend50d: BenchmarkTrend;
+      trend200d: BenchmarkTrend;
+    }>[] = [];
+
+    const quotes = await this.dataProviderService.getQuotes({
+      items: benchmarkAssetProfiles.map(({ dataSource, symbol }) => {
+        return { dataSource, symbol };
+      })
+    });
+
+    for (const { dataSource, symbol } of benchmarkAssetProfiles) {
+      promisesAllTimeHighs.push(
+        this.marketDataService.getMax({ dataSource, symbol })
+      );
+      promisesBenchmarkTrends.push(
+        this.getBenchmarkTrends({ dataSource, symbol })
+      );
+    }
+
+    const [allTimeHighs, benchmarkTrends] = await Promise.all([
+      Promise.all(promisesAllTimeHighs),
+      Promise.all(promisesBenchmarkTrends)
+    ]);
+    let storeInCache = true;
+
+    benchmarks = allTimeHighs.map((allTimeHigh, index) => {
+      const { marketPrice } =
+        quotes[benchmarkAssetProfiles[index].symbol] ?? {};
+
+      let performancePercentFromAllTimeHigh = 0;
+
+      if (allTimeHigh?.marketPrice && marketPrice) {
+        performancePercentFromAllTimeHigh = this.calculateChangeInPercentage(
+          allTimeHigh.marketPrice,
+          marketPrice
+        );
+      } else {
+        storeInCache = false;
+      }
+
+      return {
+        marketCondition: this.getMarketCondition(
+          performancePercentFromAllTimeHigh
+        ),
+        name: benchmarkAssetProfiles[index].name,
+        performances: {
+          allTimeHigh: {
+            date: allTimeHigh?.date,
+            performancePercent: performancePercentFromAllTimeHigh
+          }
+        },
+        trend50d: benchmarkTrends[index].trend50d,
+        trend200d: benchmarkTrends[index].trend200d
+      };
+    });
+
+    if (storeInCache) {
+      await this.redisCacheService.set(
+        this.CACHE_KEY_BENCHMARKS,
+        JSON.stringify(benchmarks),
+        ms('4 hours') / 1000
+      );
+    }
+
+    return benchmarks;
+  }
+
+  public async getBenchmarkAssetProfiles({
+    enableSharing = false
+  } = {}): Promise<Partial<SymbolProfile>[]> {
+    const symbolProfileIds: string[] = (
+      ((await this.propertyService.getByKey(
+        PROPERTY_BENCHMARKS
+      )) as BenchmarkProperty[]) ?? []
+    )
+      .filter((benchmark) => {
+        if (enableSharing) {
+          return benchmark.enableSharing;
+        }
+
+        return true;
+      })
+      .map(({ symbolProfileId }) => {
+        return symbolProfileId;
+      });
+
+    const assetProfiles =
+      await this.symbolProfileService.getSymbolProfilesByIds(symbolProfileIds);
+
+    return assetProfiles
+      .map(({ dataSource, id, name, symbol }) => {
+        return {
+          dataSource,
+          id,
+          name,
+          symbol
+        };
+      })
+      .sort((a, b) => a.name.localeCompare(b.name));
+  }
+
+  public async getMarketDataBySymbol({
+    dataSource,
+    startDate,
+    symbol,
+    userCurrency
+  }: {
+    startDate: Date;
+    userCurrency: string;
+  } & UniqueAsset): Promise<BenchmarkMarketDataDetails> {
+    const marketData: { date: string; value: number }[] = [];
+
+    const [currentSymbolItem, marketDataItems] = await Promise.all([
+      this.symbolService.get({
+        dataGatheringItem: {
+          dataSource,
+          symbol
+        }
+      }),
+      this.marketDataService.marketDataItems({
+        orderBy: {
+          date: 'asc'
+        },
+        where: {
+          dataSource,
+          symbol,
+          date: {
+            gte: startDate
+          }
+        }
+      })
+    ]);
+
+    const exchangeRates =
+      await this.exchangeRateDataService.getExchangeRatesByCurrency({
+        startDate,
+        currencies: [currentSymbolItem.currency],
+        targetCurrency: userCurrency
+      });
+
+    const exchangeRateAtStartDate =
+      exchangeRates[`${currentSymbolItem.currency}${userCurrency}`]?.[
+        format(startDate, DATE_FORMAT)
+      ];
+
+    const marketPriceAtStartDate = marketDataItems?.find(({ date }) => {
+      return isSameDay(date, startDate);
+    })?.marketPrice;
+
+    if (!marketPriceAtStartDate) {
+      Logger.error(
+        `No historical market data has been found for ${symbol} (${dataSource}) at ${format(
+          startDate,
+          DATE_FORMAT
+        )}`,
+        'BenchmarkService'
+      );
+
+      return { marketData };
+    }
+
+    const step = Math.round(
+      marketDataItems.length / Math.min(marketDataItems.length, MAX_CHART_ITEMS)
+    );
+
+    let i = 0;
+
+    for (let marketDataItem of marketDataItems) {
+      if (i % step !== 0) {
+        continue;
+      }
+
+      const exchangeRate =
+        exchangeRates[`${currentSymbolItem.currency}${userCurrency}`]?.[
+          format(marketDataItem.date, DATE_FORMAT)
+        ];
+
+      const exchangeRateFactor =
+        isNumber(exchangeRateAtStartDate) && isNumber(exchangeRate)
+          ? exchangeRate / exchangeRateAtStartDate
+          : 1;
+
+      marketData.push({
+        date: format(marketDataItem.date, DATE_FORMAT),
+        value:
+          marketPriceAtStartDate === 0
+            ? 0
+            : this.calculateChangeInPercentage(
+                marketPriceAtStartDate,
+                marketDataItem.marketPrice * exchangeRateFactor
+              ) * 100
+      });
+    }
+
+    const includesToday = isSameDay(
+      parseDate(last(marketData).date),
+      new Date()
+    );
+
+    if (currentSymbolItem?.marketPrice && !includesToday) {
+      const exchangeRate =
+        exchangeRates[`${currentSymbolItem.currency}${userCurrency}`]?.[
+          format(new Date(), DATE_FORMAT)
+        ];
+
+      const exchangeRateFactor =
+        isNumber(exchangeRateAtStartDate) && isNumber(exchangeRate)
+          ? exchangeRate / exchangeRateAtStartDate
+          : 1;
+
+      marketData.push({
+        date: format(new Date(), DATE_FORMAT),
+        value:
+          this.calculateChangeInPercentage(
+            marketPriceAtStartDate,
+            currentSymbolItem.marketPrice * exchangeRateFactor
+          ) * 100
+      });
+    }
+
+    return {
+      marketData
+    };
+  }
+
+  public async addBenchmark({
+    dataSource,
+    symbol
+  }: UniqueAsset): Promise<Partial<SymbolProfile>> {
+    const assetProfile = await this.prismaService.symbolProfile.findFirst({
+      where: {
+        dataSource,
+        symbol
+      }
+    });
+
+    if (!assetProfile) {
+      return;
+    }
+
+    let benchmarks =
+      ((await this.propertyService.getByKey(
+        PROPERTY_BENCHMARKS
+      )) as BenchmarkProperty[]) ?? [];
+
+    benchmarks.push({ symbolProfileId: assetProfile.id });
+
+    benchmarks = uniqBy(benchmarks, 'symbolProfileId');
+
+    await this.propertyService.put({
+      key: PROPERTY_BENCHMARKS,
+      value: JSON.stringify(benchmarks)
+    });
+
+    return {
+      dataSource,
+      symbol,
+      id: assetProfile.id,
+      name: assetProfile.name
+    };
+  }
+
+  public async deleteBenchmark({
+    dataSource,
+    symbol
+  }: UniqueAsset): Promise<Partial<SymbolProfile>> {
+    const assetProfile = await this.prismaService.symbolProfile.findFirst({
+      where: {
+        dataSource,
+        symbol
+      }
+    });
+
+    if (!assetProfile) {
+      return null;
+    }
+
+    let benchmarks =
+      ((await this.propertyService.getByKey(
+        PROPERTY_BENCHMARKS
+      )) as BenchmarkProperty[]) ?? [];
+
+    benchmarks = benchmarks.filter(({ symbolProfileId }) => {
+      return symbolProfileId !== assetProfile.id;
+    });
+
+    await this.propertyService.put({
+      key: PROPERTY_BENCHMARKS,
+      value: JSON.stringify(benchmarks)
+    });
+
+    return {
+      dataSource,
+      symbol,
+      id: assetProfile.id,
+      name: assetProfile.name
+    };
+  }
+
+  private getMarketCondition(
+    aPerformanceInPercent: number
+  ): Benchmark['marketCondition'] {
+    if (aPerformanceInPercent === 0) {
+      return 'ALL_TIME_HIGH';
+    } else if (aPerformanceInPercent <= -0.2) {
+      return 'BEAR_MARKET';
+    } else {
+      return 'NEUTRAL_MARKET';
+    }
+  }
+}

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

@@ -1,26 +1,18 @@
-import { RequestWithUser } from '@ghostfolio/api/app/interfaces/request-with-user.type';
-import { Controller, Inject, Param, Post, UseGuards } from '@nestjs/common';
-import { REQUEST } from '@nestjs/core';
+import { RedisCacheService } from '@ghostfolio/api/app/redis-cache/redis-cache.service';
+import { HasPermission } from '@ghostfolio/api/decorators/has-permission.decorator';
+import { HasPermissionGuard } from '@ghostfolio/api/guards/has-permission.guard';
+import { permissions } from '@ghostfolio/common/permissions';
+import { Controller, Post, UseGuards } from '@nestjs/common';
 import { AuthGuard } from '@nestjs/passport';
 
-import { RedisCacheService } from '../redis-cache/redis-cache.service';
-import { CacheService } from './cache.service';
-
 @Controller('cache')
 export class CacheController {
-  public constructor(
-    private readonly cacheService: CacheService,
-    private readonly redisCacheService: RedisCacheService,
-    @Inject(REQUEST) private readonly request: RequestWithUser
-  ) {
-    this.redisCacheService.reset();
-  }
+  public constructor(private readonly redisCacheService: RedisCacheService) {}
 
+  @HasPermission(permissions.accessAdminControl)
   @Post('flush')
-  @UseGuards(AuthGuard('jwt'))
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
   public async flushCache(): Promise<void> {
-    this.redisCacheService.reset();
-
-    return this.cacheService.flush(this.request.user.id);
+    return this.redisCacheService.reset();
   }
 }

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

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

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

@@ -1,17 +0,0 @@
-import { PrismaService } from '@ghostfolio/api/services/prisma.service';
-import { Injectable } from '@nestjs/common';
-
-@Injectable()
-export class CacheService {
-  public constructor(private prisma: PrismaService) {}
-
-  public async flush(aUserId: string): Promise<void> {
-    await this.prisma.property.deleteMany({
-      where: {
-        OR: [{ key: 'LAST_DATA_GATHERING' }, { key: 'LOCKED_DATA_GATHERING' }]
-      }
-    });
-
-    return;
-  }
-}

apps/api/src/app/exchange-rate/exchange-rate.controller.ts

@@ -0,0 +1,44 @@
+import { HasPermissionGuard } from '@ghostfolio/api/guards/has-permission.guard';
+import { IDataProviderHistoricalResponse } from '@ghostfolio/api/services/interfaces/interfaces';
+import {
+  Controller,
+  Get,
+  HttpException,
+  Param,
+  UseGuards
+} from '@nestjs/common';
+import { AuthGuard } from '@nestjs/passport';
+import { parseISO } from 'date-fns';
+import { StatusCodes, getReasonPhrase } from 'http-status-codes';
+
+import { ExchangeRateService } from './exchange-rate.service';
+
+@Controller('exchange-rate')
+export class ExchangeRateController {
+  public constructor(
+    private readonly exchangeRateService: ExchangeRateService
+  ) {}
+
+  @Get(':symbol/:dateString')
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  public async getExchangeRate(
+    @Param('dateString') dateString: string,
+    @Param('symbol') symbol: string
+  ): Promise<IDataProviderHistoricalResponse> {
+    const date = parseISO(dateString);
+
+    const exchangeRate = await this.exchangeRateService.getExchangeRate({
+      date,
+      symbol
+    });
+
+    if (exchangeRate) {
+      return { marketPrice: exchangeRate };
+    }
+
+    throw new HttpException(
+      getReasonPhrase(StatusCodes.NOT_FOUND),
+      StatusCodes.NOT_FOUND
+    );
+  }
+}

apps/api/src/app/exchange-rate/exchange-rate.module.ts

@@ -0,0 +1,13 @@
+import { ExchangeRateDataModule } from '@ghostfolio/api/services/exchange-rate-data/exchange-rate-data.module';
+import { Module } from '@nestjs/common';
+
+import { ExchangeRateController } from './exchange-rate.controller';
+import { ExchangeRateService } from './exchange-rate.service';
+
+@Module({
+  controllers: [ExchangeRateController],
+  exports: [ExchangeRateService],
+  imports: [ExchangeRateDataModule],
+  providers: [ExchangeRateService]
+})
+export class ExchangeRateModule {}

apps/api/src/app/exchange-rate/exchange-rate.service.ts

@@ -0,0 +1,26 @@
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data/exchange-rate-data.service';
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class ExchangeRateService {
+  public constructor(
+    private readonly exchangeRateDataService: ExchangeRateDataService
+  ) {}
+
+  public async getExchangeRate({
+    date,
+    symbol
+  }: {
+    date: Date;
+    symbol: string;
+  }): Promise<number> {
+    const [currency1, currency2] = symbol.split('-');
+
+    return this.exchangeRateDataService.toCurrencyAtDate(
+      1,
+      currency1,
+      currency2,
+      date
+    );
+  }
+}

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,91 +0,0 @@
-import { RequestWithUser } from '@ghostfolio/api/app/interfaces/request-with-user.type';
-import {
-  baseCurrency,
-  benchmarks,
-  isApiTokenAuthorized
-} from '@ghostfolio/helper';
-import {
-  Body,
-  Controller,
-  Get,
-  Headers,
-  HttpException,
-  Inject,
-  Param,
-  Post
-} from '@nestjs/common';
-import { REQUEST } from '@nestjs/core';
-import { parse } from 'date-fns';
-import { StatusCodes, getReasonPhrase } from 'http-status-codes';
-
-import { CreateOrderDto } from './create-order.dto';
-import { ExperimentalService } from './experimental.service';
-import { Data } from './interfaces/data.interface';
-
-@Controller('experimental')
-export class ExperimentalController {
-  public constructor(
-    private readonly experimentalService: ExperimentalService,
-    @Inject(REQUEST) private readonly request: RequestWithUser
-  ) {}
-
-  @Get('benchmarks')
-  public async getBenchmarks(
-    @Headers('Authorization') apiToken: string
-  ): Promise<string[]> {
-    if (!isApiTokenAuthorized(apiToken)) {
-      throw new HttpException(
-        getReasonPhrase(StatusCodes.FORBIDDEN),
-        StatusCodes.FORBIDDEN
-      );
-    }
-
-    return benchmarks;
-  }
-
-  @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,31 +0,0 @@
-import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
-import { DataProviderService } from '@ghostfolio/api/services/data-provider.service';
-import { AlphaVantageService } from '@ghostfolio/api/services/data-provider/alpha-vantage/alpha-vantage.service';
-import { GhostfolioScraperApiService } from '@ghostfolio/api/services/data-provider/ghostfolio-scraper-api/ghostfolio-scraper-api.service';
-import { RakutenRapidApiService } from '@ghostfolio/api/services/data-provider/rakuten-rapid-api/rakuten-rapid-api.service';
-import { YahooFinanceService } from '@ghostfolio/api/services/data-provider/yahoo-finance/yahoo-finance.service';
-import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data.service';
-import { PrismaService } from '@ghostfolio/api/services/prisma.service';
-import { RulesService } from '@ghostfolio/api/services/rules.service';
-import { Module } from '@nestjs/common';
-
-import { ExperimentalController } from './experimental.controller';
-import { ExperimentalService } from './experimental.service';
-
-@Module({
-  imports: [],
-  controllers: [ExperimentalController],
-  providers: [
-    AlphaVantageService,
-    ConfigurationService,
-    DataProviderService,
-    ExchangeRateDataService,
-    ExperimentalService,
-    GhostfolioScraperApiService,
-    PrismaService,
-    RakutenRapidApiService,
-    RulesService,
-    YahooFinanceService
-  ]
-})
-export class ExperimentalModule {}

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

@@ -1,65 +0,0 @@
-import { Portfolio } from '@ghostfolio/api/models/portfolio';
-import { DataProviderService } from '@ghostfolio/api/services/data-provider.service';
-import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data.service';
-import { PrismaService } from '@ghostfolio/api/services/prisma.service';
-import { RulesService } from '@ghostfolio/api/services/rules.service';
-import { Injectable } from '@nestjs/common';
-import { Currency, Type } from '@prisma/client';
-import { parseISO } from 'date-fns';
-
-import { OrderWithAccount } from '../order/interfaces/order-with-account.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: OrderWithAccount[] = aOrders.map((order) => {
-      return {
-        ...order,
-        accountId: undefined,
-        accountUserId: undefined,
-        createdAt: new Date(),
-        dataSource: undefined,
-        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,28 @@
+import { HasPermissionGuard } from '@ghostfolio/api/guards/has-permission.guard';
+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'), HasPermissionGuard)
+  public async export(
+    @Query('activityIds') activityIds?: string[]
+  ): Promise<Export> {
+    return this.exportService.export({
+      activityIds,
+      userCurrency: this.request.user.Settings.settings.baseCurrency,
+      userId: this.request.user.id
+    });
+  }
+}

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

@@ -0,0 +1,24 @@
+import { AccountModule } from '@ghostfolio/api/app/account/account.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/configuration.module';
+import { DataGatheringModule } from '@ghostfolio/api/services/data-gathering/data-gathering.module';
+import { DataProviderModule } from '@ghostfolio/api/services/data-provider/data-provider.module';
+import { Module } from '@nestjs/common';
+
+import { ExportController } from './export.controller';
+import { ExportService } from './export.service';
+
+@Module({
+  imports: [
+    AccountModule,
+    ConfigurationModule,
+    DataGatheringModule,
+    DataProviderModule,
+    OrderModule,
+    RedisCacheModule
+  ],
+  controllers: [ExportController],
+  providers: [ExportService]
+})
+export class ExportModule {}

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

@@ -0,0 +1,97 @@
+import { AccountService } from '@ghostfolio/api/app/account/account.service';
+import { OrderService } from '@ghostfolio/api/app/order/order.service';
+import { environment } from '@ghostfolio/api/environments/environment';
+import { Export } from '@ghostfolio/common/interfaces';
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class ExportService {
+  public constructor(
+    private readonly accountService: AccountService,
+    private readonly orderService: OrderService
+  ) {}
+
+  public async export({
+    activityIds,
+    userCurrency,
+    userId
+  }: {
+    activityIds?: string[];
+    userCurrency: string;
+    userId: string;
+  }): Promise<Export> {
+    const accounts = (
+      await this.accountService.accounts({
+        orderBy: {
+          name: 'asc'
+        },
+        where: { userId }
+      })
+    ).map(
+      ({ balance, comment, currency, id, isExcluded, name, platformId }) => {
+        return {
+          balance,
+          comment,
+          currency,
+          id,
+          isExcluded,
+          name,
+          platformId
+        };
+      }
+    );
+
+    let { activities } = await this.orderService.getOrders({
+      userCurrency,
+      userId,
+      includeDrafts: true,
+      sortColumn: 'date',
+      sortDirection: 'asc',
+      withExcludedAccounts: true
+    });
+
+    if (activityIds) {
+      activities = activities.filter((activity) => {
+        return activityIds.includes(activity.id);
+      });
+    }
+
+    return {
+      meta: { date: new Date().toISOString(), version: environment.version },
+      accounts,
+      activities: activities.map(
+        ({
+          accountId,
+          comment,
+          date,
+          fee,
+          id,
+          quantity,
+          SymbolProfile,
+          type,
+          unitPrice
+        }) => {
+          return {
+            accountId,
+            comment,
+            fee,
+            id,
+            quantity,
+            type,
+            unitPrice,
+            currency: SymbolProfile.currency,
+            dataSource: SymbolProfile.dataSource,
+            date: date.toISOString(),
+            symbol:
+              type === 'FEE' ||
+              type === 'INTEREST' ||
+              type === 'ITEM' ||
+              type === 'LIABILITY'
+                ? SymbolProfile.name
+                : SymbolProfile.symbol
+          };
+        }
+      )
+    };
+  }
+}

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

@@ -0,0 +1,56 @@
+import { TransformDataSourceInRequestInterceptor } from '@ghostfolio/api/interceptors/transform-data-source-in-request.interceptor';
+import {
+  Controller,
+  Get,
+  HttpException,
+  Param,
+  UseInterceptors
+} from '@nestjs/common';
+import { DataSource } from '@prisma/client';
+import { StatusCodes, getReasonPhrase } from 'http-status-codes';
+
+import { HealthService } from './health.service';
+
+@Controller('health')
+export class HealthController {
+  public constructor(private readonly healthService: HealthService) {}
+
+  @Get()
+  public async getHealth() {}
+
+  @Get('data-enhancer/:name')
+  public async getHealthOfDataEnhancer(@Param('name') name: string) {
+    const hasResponse =
+      await this.healthService.hasResponseFromDataEnhancer(name);
+
+    if (hasResponse !== true) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.SERVICE_UNAVAILABLE),
+        StatusCodes.SERVICE_UNAVAILABLE
+      );
+    }
+  }
+
+  @Get('data-provider/:dataSource')
+  @UseInterceptors(TransformDataSourceInRequestInterceptor)
+  public async getHealthOfDataProvider(
+    @Param('dataSource') dataSource: DataSource
+  ) {
+    if (!DataSource[dataSource]) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.NOT_FOUND),
+        StatusCodes.NOT_FOUND
+      );
+    }
+
+    const hasResponse =
+      await this.healthService.hasResponseFromDataProvider(dataSource);
+
+    if (hasResponse !== true) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.SERVICE_UNAVAILABLE),
+        StatusCodes.SERVICE_UNAVAILABLE
+      );
+    }
+  }
+}

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

@@ -0,0 +1,14 @@
+import { ConfigurationModule } from '@ghostfolio/api/services/configuration/configuration.module';
+import { DataEnhancerModule } from '@ghostfolio/api/services/data-provider/data-enhancer/data-enhancer.module';
+import { DataProviderModule } from '@ghostfolio/api/services/data-provider/data-provider.module';
+import { Module } from '@nestjs/common';
+
+import { HealthController } from './health.controller';
+import { HealthService } from './health.service';
+
+@Module({
+  controllers: [HealthController],
+  imports: [ConfigurationModule, DataEnhancerModule, DataProviderModule],
+  providers: [HealthService]
+})
+export class HealthModule {}

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

@@ -0,0 +1,20 @@
+import { DataEnhancerService } from '@ghostfolio/api/services/data-provider/data-enhancer/data-enhancer.service';
+import { DataProviderService } from '@ghostfolio/api/services/data-provider/data-provider.service';
+import { Injectable } from '@nestjs/common';
+import { DataSource } from '@prisma/client';
+
+@Injectable()
+export class HealthService {
+  public constructor(
+    private readonly dataEnhancerService: DataEnhancerService,
+    private readonly dataProviderService: DataProviderService
+  ) {}
+
+  public async hasResponseFromDataEnhancer(aName: string) {
+    return this.dataEnhancerService.enhance(aName);
+  }
+
+  public async hasResponseFromDataProvider(aDataSource: DataSource) {
+    return this.dataProviderService.checkQuote(aDataSource);
+  }
+}

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

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

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

@@ -0,0 +1,111 @@
+import { HasPermission } from '@ghostfolio/api/decorators/has-permission.decorator';
+import { HasPermissionGuard } from '@ghostfolio/api/guards/has-permission.guard';
+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/configuration.service';
+import { ImportResponse } from '@ghostfolio/common/interfaces';
+import { hasPermission, permissions } from '@ghostfolio/common/permissions';
+import type { RequestWithUser } from '@ghostfolio/common/types';
+import {
+  Body,
+  Controller,
+  Get,
+  HttpException,
+  Inject,
+  Logger,
+  Param,
+  Post,
+  Query,
+  UseGuards,
+  UseInterceptors
+} from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
+import { AuthGuard } from '@nestjs/passport';
+import { DataSource } from '@prisma/client';
+import { StatusCodes, getReasonPhrase } from 'http-status-codes';
+
+import { 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'), HasPermissionGuard)
+  @HasPermission(permissions.createOrder)
+  @UseInterceptors(TransformDataSourceInRequestInterceptor)
+  @UseInterceptors(TransformDataSourceInResponseInterceptor)
+  public async import(
+    @Body() importData: ImportDataDto,
+    @Query('dryRun') isDryRun?: boolean
+  ): Promise<ImportResponse> {
+    if (
+      !hasPermission(this.request.user.permissions, permissions.createAccount)
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    let maxActivitiesToImport = this.configurationService.get(
+      'MAX_ACTIVITIES_TO_IMPORT'
+    );
+
+    if (
+      this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION') &&
+      this.request.user.subscription.type === 'Premium'
+    ) {
+      maxActivitiesToImport = Number.MAX_SAFE_INTEGER;
+    }
+
+    const userCurrency = this.request.user.Settings.settings.baseCurrency;
+
+    try {
+      const activities = await this.importService.import({
+        isDryRun,
+        maxActivitiesToImport,
+        userCurrency,
+        accountsDto: importData.accounts ?? [],
+        activitiesDto: importData.activities,
+        userId: this.request.user.id
+      });
+
+      return { activities };
+    } catch (error) {
+      Logger.error(error, ImportController);
+
+      throw new HttpException(
+        {
+          error: getReasonPhrase(StatusCodes.BAD_REQUEST),
+          message: [error.message]
+        },
+        StatusCodes.BAD_REQUEST
+      );
+    }
+  }
+
+  @Get('dividends/:dataSource/:symbol')
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  @UseInterceptors(TransformDataSourceInRequestInterceptor)
+  @UseInterceptors(TransformDataSourceInResponseInterceptor)
+  public async gatherDividends(
+    @Param('dataSource') dataSource: DataSource,
+    @Param('symbol') symbol: string
+  ): Promise<ImportResponse> {
+    const userCurrency = this.request.user.Settings.settings.baseCurrency;
+
+    const activities = await this.importService.getDividends({
+      dataSource,
+      symbol,
+      userCurrency
+    });
+
+    return { activities };
+  }
+}

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

@@ -0,0 +1,36 @@
+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 { PlatformModule } from '@ghostfolio/api/app/platform/platform.module';
+import { PortfolioModule } from '@ghostfolio/api/app/portfolio/portfolio.module';
+import { RedisCacheModule } from '@ghostfolio/api/app/redis-cache/redis-cache.module';
+import { ConfigurationModule } from '@ghostfolio/api/services/configuration/configuration.module';
+import { DataGatheringModule } from '@ghostfolio/api/services/data-gathering/data-gathering.module';
+import { DataProviderModule } from '@ghostfolio/api/services/data-provider/data-provider.module';
+import { ExchangeRateDataModule } from '@ghostfolio/api/services/exchange-rate-data/exchange-rate-data.module';
+import { PrismaModule } from '@ghostfolio/api/services/prisma/prisma.module';
+import { SymbolProfileModule } from '@ghostfolio/api/services/symbol-profile/symbol-profile.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,
+    ExchangeRateDataModule,
+    OrderModule,
+    PlatformModule,
+    PortfolioModule,
+    PrismaModule,
+    RedisCacheModule,
+    SymbolProfileModule
+  ],
+  providers: [ImportService]
+})
+export class ImportModule {}

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

@@ -0,0 +1,616 @@
+import { AccountService } from '@ghostfolio/api/app/account/account.service';
+import { CreateAccountDto } from '@ghostfolio/api/app/account/create-account.dto';
+import { CreateOrderDto } from '@ghostfolio/api/app/order/create-order.dto';
+import {
+  Activity,
+  ActivityError
+} from '@ghostfolio/api/app/order/interfaces/activities.interface';
+import { OrderService } from '@ghostfolio/api/app/order/order.service';
+import { PlatformService } from '@ghostfolio/api/app/platform/platform.service';
+import { PortfolioService } from '@ghostfolio/api/app/portfolio/portfolio.service';
+import { ConfigurationService } from '@ghostfolio/api/services/configuration/configuration.service';
+import { DataGatheringService } from '@ghostfolio/api/services/data-gathering/data-gathering.service';
+import { DataProviderService } from '@ghostfolio/api/services/data-provider/data-provider.service';
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data/exchange-rate-data.service';
+import { SymbolProfileService } from '@ghostfolio/api/services/symbol-profile/symbol-profile.service';
+import {
+  DATE_FORMAT,
+  getAssetProfileIdentifier,
+  parseDate
+} from '@ghostfolio/common/helper';
+import { UniqueAsset } from '@ghostfolio/common/interfaces';
+import {
+  AccountWithPlatform,
+  OrderWithAccount
+} from '@ghostfolio/common/types';
+import { Injectable } from '@nestjs/common';
+import { DataSource, Prisma, SymbolProfile } from '@prisma/client';
+import Big from 'big.js';
+import { endOfToday, format, isAfter, isSameSecond, parseISO } from 'date-fns';
+import { uniqBy } from 'lodash';
+import { v4 as uuidv4 } from 'uuid';
+
+@Injectable()
+export class ImportService {
+  public constructor(
+    private readonly accountService: AccountService,
+    private readonly configurationService: ConfigurationService,
+    private readonly dataGatheringService: DataGatheringService,
+    private readonly dataProviderService: DataProviderService,
+    private readonly exchangeRateDataService: ExchangeRateDataService,
+    private readonly orderService: OrderService,
+    private readonly platformService: PlatformService,
+    private readonly portfolioService: PortfolioService,
+    private readonly symbolProfileService: SymbolProfileService
+  ) {}
+
+  public async getDividends({
+    dataSource,
+    symbol,
+    userCurrency
+  }: UniqueAsset & { userCurrency: string }): Promise<Activity[]> {
+    try {
+      const { firstBuyDate, historicalData, orders } =
+        await this.portfolioService.getPosition(dataSource, undefined, symbol);
+
+      const [[assetProfile], dividends] = await Promise.all([
+        this.symbolProfileService.getSymbolProfiles([
+          {
+            dataSource,
+            symbol
+          }
+        ]),
+        await this.dataProviderService.getDividends({
+          dataSource,
+          symbol,
+          from: parseDate(firstBuyDate),
+          granularity: 'day',
+          to: new Date()
+        })
+      ]);
+
+      const accounts = orders.map((order) => {
+        return order.Account;
+      });
+
+      const Account = this.isUniqueAccount(accounts) ? accounts[0] : undefined;
+
+      return Object.entries(dividends).map(([dateString, { marketPrice }]) => {
+        const quantity =
+          historicalData.find((historicalDataItem) => {
+            return historicalDataItem.date === dateString;
+          })?.quantity ?? 0;
+
+        const value = new Big(quantity).mul(marketPrice).toNumber();
+
+        const date = parseDate(dateString);
+        const isDuplicate = orders.some((activity) => {
+          return (
+            activity.accountId === Account?.id &&
+            activity.SymbolProfile.currency === assetProfile.currency &&
+            activity.SymbolProfile.dataSource === assetProfile.dataSource &&
+            isSameSecond(activity.date, date) &&
+            activity.quantity === quantity &&
+            activity.SymbolProfile.symbol === assetProfile.symbol &&
+            activity.type === 'DIVIDEND' &&
+            activity.unitPrice === marketPrice
+          );
+        });
+
+        const error: ActivityError = isDuplicate
+          ? { code: 'IS_DUPLICATE' }
+          : undefined;
+
+        return {
+          Account,
+          date,
+          error,
+          quantity,
+          value,
+          accountId: Account?.id,
+          accountUserId: undefined,
+          comment: undefined,
+          createdAt: undefined,
+          fee: 0,
+          feeInBaseCurrency: 0,
+          id: assetProfile.id,
+          isDraft: false,
+          SymbolProfile: <SymbolProfile>(<unknown>assetProfile),
+          symbolProfileId: assetProfile.id,
+          type: 'DIVIDEND',
+          unitPrice: marketPrice,
+          updatedAt: undefined,
+          userId: Account?.userId,
+          valueInBaseCurrency: this.exchangeRateDataService.toCurrency(
+            value,
+            assetProfile.currency,
+            userCurrency
+          )
+        };
+      });
+    } catch {
+      return [];
+    }
+  }
+
+  public async import({
+    accountsDto,
+    activitiesDto,
+    isDryRun = false,
+    maxActivitiesToImport,
+    userCurrency,
+    userId
+  }: {
+    accountsDto: Partial<CreateAccountDto>[];
+    activitiesDto: Partial<CreateOrderDto>[];
+    isDryRun?: boolean;
+    maxActivitiesToImport: number;
+    userCurrency: string;
+    userId: string;
+  }): Promise<Activity[]> {
+    const accountIdMapping: { [oldAccountId: string]: string } = {};
+
+    if (!isDryRun && accountsDto?.length) {
+      const [existingAccounts, existingPlatforms] = await Promise.all([
+        this.accountService.accounts({
+          where: {
+            id: {
+              in: accountsDto.map(({ id }) => {
+                return id;
+              })
+            }
+          }
+        }),
+        this.platformService.getPlatforms()
+      ]);
+
+      for (const account of accountsDto) {
+        // Check if there is any existing account with the same ID
+        const accountWithSameId = existingAccounts.find(
+          (existingAccount) => existingAccount.id === account.id
+        );
+
+        // If there is no account or if the account belongs to a different user then create a new account
+        if (!accountWithSameId || accountWithSameId.userId !== userId) {
+          let oldAccountId: string;
+          const platformId = account.platformId;
+
+          delete account.platformId;
+
+          if (accountWithSameId) {
+            oldAccountId = account.id;
+            delete account.id;
+          }
+
+          let accountObject: Prisma.AccountCreateInput = {
+            ...account,
+            User: { connect: { id: userId } }
+          };
+
+          if (
+            existingPlatforms.some(({ id }) => {
+              return id === platformId;
+            })
+          ) {
+            accountObject = {
+              ...accountObject,
+              Platform: { connect: { id: platformId } }
+            };
+          }
+
+          const newAccount = await this.accountService.createAccount(
+            accountObject,
+            userId
+          );
+
+          // Store the new to old account ID mappings for updating activities
+          if (accountWithSameId && oldAccountId) {
+            accountIdMapping[oldAccountId] = newAccount.id;
+          }
+        }
+      }
+    }
+
+    for (const activity of activitiesDto) {
+      if (!activity.dataSource) {
+        if (activity.type === 'ITEM' || activity.type === 'LIABILITY') {
+          activity.dataSource = DataSource.MANUAL;
+        } else {
+          activity.dataSource =
+            this.dataProviderService.getDataSourceForImport();
+        }
+      }
+
+      // If a new account is created, then update the accountId in all activities
+      if (!isDryRun) {
+        if (Object.keys(accountIdMapping).includes(activity.accountId)) {
+          activity.accountId = accountIdMapping[activity.accountId];
+        }
+      }
+    }
+
+    const assetProfiles = await this.validateActivities({
+      activitiesDto,
+      maxActivitiesToImport
+    });
+
+    const activitiesExtendedWithErrors = await this.extendActivitiesWithErrors({
+      activitiesDto,
+      userCurrency,
+      userId
+    });
+
+    const accounts = (await this.accountService.getAccounts(userId)).map(
+      ({ id, name }) => {
+        return { id, name };
+      }
+    );
+
+    if (isDryRun) {
+      accountsDto.forEach(({ id, name }) => {
+        accounts.push({ id, name });
+      });
+    }
+
+    const activities: Activity[] = [];
+
+    for (let [
+      index,
+      {
+        accountId,
+        comment,
+        date,
+        error,
+        fee,
+        quantity,
+        SymbolProfile,
+        type,
+        unitPrice
+      }
+    ] of activitiesExtendedWithErrors.entries()) {
+      const assetProfile = assetProfiles[
+        getAssetProfileIdentifier({
+          dataSource: SymbolProfile.dataSource,
+          symbol: SymbolProfile.symbol
+        })
+      ] ?? {
+        currency: SymbolProfile.currency,
+        dataSource: SymbolProfile.dataSource,
+        symbol: SymbolProfile.symbol
+      };
+      const {
+        assetClass,
+        assetSubClass,
+        countries,
+        createdAt,
+        currency,
+        dataSource,
+        figi,
+        figiComposite,
+        figiShareClass,
+        id,
+        isin,
+        name,
+        scraperConfiguration,
+        sectors,
+        symbol,
+        symbolMapping,
+        url,
+        updatedAt
+      } = assetProfile;
+      const validatedAccount = accounts.find(({ id }) => {
+        return id === accountId;
+      });
+
+      let order:
+        | OrderWithAccount
+        | (Omit<OrderWithAccount, 'Account'> & {
+            Account?: { id: string; name: string };
+          });
+
+      if (SymbolProfile.currency !== assetProfile.currency) {
+        // Convert the unit price and fee to the asset currency if the imported
+        // activity is in a different currency
+        unitPrice = await this.exchangeRateDataService.toCurrencyAtDate(
+          unitPrice,
+          SymbolProfile.currency,
+          assetProfile.currency,
+          date
+        );
+
+        if (!unitPrice) {
+          throw new Error(
+            `activities.${index} historical exchange rate at ${format(
+              date,
+              DATE_FORMAT
+            )} is not available from "${SymbolProfile.currency}" to "${
+              assetProfile.currency
+            }"`
+          );
+        }
+
+        fee = await this.exchangeRateDataService.toCurrencyAtDate(
+          fee,
+          SymbolProfile.currency,
+          assetProfile.currency,
+          date
+        );
+      }
+
+      if (isDryRun) {
+        order = {
+          comment,
+          date,
+          fee,
+          quantity,
+          type,
+          unitPrice,
+          userId,
+          accountId: validatedAccount?.id,
+          accountUserId: undefined,
+          createdAt: new Date(),
+          id: uuidv4(),
+          isDraft: isAfter(date, endOfToday()),
+          SymbolProfile: {
+            assetClass,
+            assetSubClass,
+            countries,
+            createdAt,
+            currency,
+            dataSource,
+            figi,
+            figiComposite,
+            figiShareClass,
+            id,
+            isin,
+            name,
+            scraperConfiguration,
+            sectors,
+            symbol,
+            symbolMapping,
+            updatedAt,
+            url,
+            comment: assetProfile.comment
+          },
+          Account: validatedAccount,
+          symbolProfileId: undefined,
+          updatedAt: new Date()
+        };
+      } else {
+        if (error) {
+          continue;
+        }
+
+        order = await this.orderService.createOrder({
+          comment,
+          date,
+          fee,
+          quantity,
+          type,
+          unitPrice,
+          userId,
+          accountId: validatedAccount?.id,
+          SymbolProfile: {
+            connectOrCreate: {
+              create: {
+                currency,
+                dataSource,
+                symbol
+              },
+              where: {
+                dataSource_symbol: {
+                  dataSource,
+                  symbol
+                }
+              }
+            }
+          },
+          updateAccountBalance: false,
+          User: { connect: { id: userId } }
+        });
+      }
+
+      const value = new Big(quantity).mul(unitPrice).toNumber();
+
+      activities.push({
+        ...order,
+        error,
+        value,
+        feeInBaseCurrency: this.exchangeRateDataService.toCurrency(
+          fee,
+          currency,
+          userCurrency
+        ),
+        // @ts-ignore
+        SymbolProfile: assetProfile,
+        valueInBaseCurrency: this.exchangeRateDataService.toCurrency(
+          value,
+          currency,
+          userCurrency
+        )
+      });
+    }
+
+    activities.sort((activity1, activity2) => {
+      return Number(activity1.date) - Number(activity2.date);
+    });
+
+    if (!isDryRun) {
+      // Gather symbol data in the background, if not dry run
+      const uniqueActivities = uniqBy(activities, ({ SymbolProfile }) => {
+        return getAssetProfileIdentifier({
+          dataSource: SymbolProfile.dataSource,
+          symbol: SymbolProfile.symbol
+        });
+      });
+
+      this.dataGatheringService.gatherSymbols(
+        uniqueActivities.map(({ date, SymbolProfile }) => {
+          return {
+            date,
+            dataSource: SymbolProfile.dataSource,
+            symbol: SymbolProfile.symbol
+          };
+        })
+      );
+    }
+
+    return activities;
+  }
+
+  private async extendActivitiesWithErrors({
+    activitiesDto,
+    userCurrency,
+    userId
+  }: {
+    activitiesDto: Partial<CreateOrderDto>[];
+    userCurrency: string;
+    userId: string;
+  }): Promise<Partial<Activity>[]> {
+    let { activities: existingActivities } = await this.orderService.getOrders({
+      userCurrency,
+      userId,
+      includeDrafts: true,
+      withExcludedAccounts: true
+    });
+
+    return activitiesDto.map(
+      ({
+        accountId,
+        comment,
+        currency,
+        dataSource,
+        date: dateString,
+        fee,
+        quantity,
+        symbol,
+        type,
+        unitPrice
+      }) => {
+        const date = parseISO(dateString);
+        const isDuplicate = existingActivities.some((activity) => {
+          return (
+            activity.accountId === accountId &&
+            activity.SymbolProfile.currency === currency &&
+            activity.SymbolProfile.dataSource === dataSource &&
+            isSameSecond(activity.date, date) &&
+            activity.fee === fee &&
+            activity.quantity === quantity &&
+            activity.SymbolProfile.symbol === symbol &&
+            activity.type === type &&
+            activity.unitPrice === unitPrice
+          );
+        });
+
+        const error: ActivityError = isDuplicate
+          ? { code: 'IS_DUPLICATE' }
+          : undefined;
+
+        return {
+          accountId,
+          comment,
+          date,
+          error,
+          fee,
+          quantity,
+          type,
+          unitPrice,
+          SymbolProfile: {
+            currency,
+            dataSource,
+            symbol,
+            assetClass: null,
+            assetSubClass: null,
+            comment: null,
+            countries: null,
+            createdAt: undefined,
+            figi: null,
+            figiComposite: null,
+            figiShareClass: null,
+            id: undefined,
+            isin: null,
+            name: null,
+            scraperConfiguration: null,
+            sectors: null,
+            symbolMapping: null,
+            updatedAt: undefined,
+            url: null
+          }
+        };
+      }
+    );
+  }
+
+  private isUniqueAccount(accounts: AccountWithPlatform[]) {
+    const uniqueAccountIds = new Set<string>();
+
+    for (const account of accounts) {
+      uniqueAccountIds.add(account.id);
+    }
+
+    return uniqueAccountIds.size === 1;
+  }
+
+  private async validateActivities({
+    activitiesDto,
+    maxActivitiesToImport
+  }: {
+    activitiesDto: Partial<CreateOrderDto>[];
+    maxActivitiesToImport: number;
+  }) {
+    if (activitiesDto?.length > maxActivitiesToImport) {
+      throw new Error(`Too many activities (${maxActivitiesToImport} at most)`);
+    }
+
+    const assetProfiles: {
+      [assetProfileIdentifier: string]: Partial<SymbolProfile>;
+    } = {};
+
+    const uniqueActivitiesDto = uniqBy(
+      activitiesDto,
+      ({ dataSource, symbol }) => {
+        return getAssetProfileIdentifier({ dataSource, symbol });
+      }
+    );
+
+    for (const [
+      index,
+      { currency, dataSource, symbol }
+    ] of uniqueActivitiesDto.entries()) {
+      if (!this.configurationService.get('DATA_SOURCES').includes(dataSource)) {
+        throw new Error(
+          `activities.${index}.dataSource ("${dataSource}") is not valid`
+        );
+      }
+
+      const assetProfile = (
+        await this.dataProviderService.getAssetProfiles([
+          { dataSource, symbol }
+        ])
+      )?.[symbol];
+
+      if (!assetProfile?.name) {
+        throw new Error(
+          `activities.${index}.symbol ("${symbol}") is not valid for the specified data source ("${dataSource}")`
+        );
+      }
+
+      if (
+        assetProfile.currency !== currency &&
+        !this.exchangeRateDataService.hasCurrencyPair(
+          currency,
+          assetProfile.currency
+        )
+      ) {
+        throw new Error(
+          `activities.${index}.currency ("${currency}") does not match with "${assetProfile.currency}" and no exchange rate is available from "${currency}" to "${assetProfile.currency}"`
+        );
+      }
+
+      assetProfiles[getAssetProfileIdentifier({ dataSource, symbol })] =
+        assetProfile;
+    }
+
+    return assetProfiles;
+  }
+}

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

@@ -1,13 +1,15 @@
-import { Controller, Get } from '@nestjs/common';
+import { TransformDataSourceInResponseInterceptor } from '@ghostfolio/api/interceptors/transform-data-source-in-response.interceptor';
+import { InfoItem } from '@ghostfolio/common/interfaces';
+import { Controller, Get, UseInterceptors } from '@nestjs/common';
 
 import { InfoService } from './info.service';
-import { InfoItem } from './interfaces/info-item.interface';
 
 @Controller('info')
 export class InfoController {
   public constructor(private readonly infoService: InfoService) {}
 
   @Get()
+  @UseInterceptors(TransformDataSourceInResponseInterceptor)
   public async getInfo(): Promise<InfoItem> {
     return this.infoService.get();
   }

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

@@ -1,5 +1,15 @@
-import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
-import { PrismaService } from '@ghostfolio/api/services/prisma.service';
+import { BenchmarkModule } from '@ghostfolio/api/app/benchmark/benchmark.module';
+import { PlatformModule } from '@ghostfolio/api/app/platform/platform.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/configuration.module';
+import { DataGatheringModule } from '@ghostfolio/api/services/data-gathering/data-gathering.module';
+import { DataProviderModule } from '@ghostfolio/api/services/data-provider/data-provider.module';
+import { ExchangeRateDataModule } from '@ghostfolio/api/services/exchange-rate-data/exchange-rate-data.module';
+import { PrismaModule } from '@ghostfolio/api/services/prisma/prisma.module';
+import { PropertyModule } from '@ghostfolio/api/services/property/property.module';
+import { SymbolProfileModule } from '@ghostfolio/api/services/symbol-profile/symbol-profile.module';
+import { TagModule } from '@ghostfolio/api/services/tag/tag.module';
 import { Module } from '@nestjs/common';
 import { JwtModule } from '@nestjs/jwt';
 
@@ -7,13 +17,24 @@ import { InfoController } from './info.controller';
 import { InfoService } from './info.service';
 
 @Module({
+  controllers: [InfoController],
   imports: [
+    BenchmarkModule,
+    ConfigurationModule,
+    DataGatheringModule,
+    DataProviderModule,
+    ExchangeRateDataModule,
     JwtModule.register({
       secret: process.env.JWT_SECRET_KEY,
       signOptions: { expiresIn: '30 days' }
-    })
+    }),
+    PlatformModule,
+    PropertyModule,
+    RedisCacheModule,
+    SymbolProfileModule,
+    TagModule,
+    UserModule
   ],
-  controllers: [InfoController],
-  providers: [ConfigurationService, InfoService, PrismaService]
+  providers: [InfoService]
 })
 export class InfoModule {}

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

@@ -1,58 +1,370 @@
-import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
-import { PrismaService } from '@ghostfolio/api/services/prisma.service';
-import { permissions } from '@ghostfolio/helper';
-import { Injectable } from '@nestjs/common';
+import { BenchmarkService } from '@ghostfolio/api/app/benchmark/benchmark.service';
+import { PlatformService } from '@ghostfolio/api/app/platform/platform.service';
+import { RedisCacheService } from '@ghostfolio/api/app/redis-cache/redis-cache.service';
+import { UserService } from '@ghostfolio/api/app/user/user.service';
+import { ConfigurationService } from '@ghostfolio/api/services/configuration/configuration.service';
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data/exchange-rate-data.service';
+import { PropertyService } from '@ghostfolio/api/services/property/property.service';
+import { TagService } from '@ghostfolio/api/services/tag/tag.service';
+import {
+  DEFAULT_CURRENCY,
+  PROPERTY_BETTER_UPTIME_MONITOR_ID,
+  PROPERTY_COUNTRIES_OF_SUBSCRIBERS,
+  PROPERTY_DEMO_USER_ID,
+  PROPERTY_IS_READ_ONLY_MODE,
+  PROPERTY_SLACK_COMMUNITY_USERS,
+  PROPERTY_STRIPE_CONFIG,
+  ghostfolioFearAndGreedIndexDataSource
+} from '@ghostfolio/common/config';
+import {
+  DATE_FORMAT,
+  encodeDataSource,
+  extractNumberFromString
+} from '@ghostfolio/common/helper';
+import {
+  InfoItem,
+  Statistics,
+  Subscription
+} from '@ghostfolio/common/interfaces';
+import { permissions } from '@ghostfolio/common/permissions';
+import { SubscriptionOffer } from '@ghostfolio/common/types';
+import { Injectable, Logger } from '@nestjs/common';
 import { JwtService } from '@nestjs/jwt';
-import { Currency } from '@prisma/client';
-
-import { InfoItem } from './interfaces/info-item.interface';
+import * as cheerio from 'cheerio';
+import { format, subDays } from 'date-fns';
+import got from 'got';
 
 @Injectable()
 export class InfoService {
-  private static DEMO_USER_ID = '9b112b4d-3b7d-4bad-9bdd-3b0f7b4dac2f';
+  private static CACHE_KEY_STATISTICS = 'STATISTICS';
 
   public constructor(
+    private readonly benchmarkService: BenchmarkService,
     private readonly configurationService: ConfigurationService,
-    private jwtService: JwtService,
-    private prisma: PrismaService
+    private readonly exchangeRateDataService: ExchangeRateDataService,
+    private readonly jwtService: JwtService,
+    private readonly platformService: PlatformService,
+    private readonly propertyService: PropertyService,
+    private readonly redisCacheService: RedisCacheService,
+    private readonly tagService: TagService,
+    private readonly userService: UserService
   ) {}
 
   public async get(): Promise<InfoItem> {
-    const platforms = await this.prisma.platform.findMany({
-      orderBy: { name: 'asc' },
-      select: { id: true, name: true }
+    const info: Partial<InfoItem> = {};
+    let isReadOnlyMode: boolean;
+    const platforms = await this.platformService.getPlatforms({
+      orderBy: { name: 'asc' }
     });
 
     const globalPermissions: string[] = [];
 
+    if (this.configurationService.get('ENABLE_FEATURE_BLOG')) {
+      globalPermissions.push(permissions.enableBlog);
+    }
+
+    if (this.configurationService.get('ENABLE_FEATURE_FEAR_AND_GREED_INDEX')) {
+      if (this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION')) {
+        info.fearAndGreedDataSource = encodeDataSource(
+          ghostfolioFearAndGreedIndexDataSource
+        );
+      } else {
+        info.fearAndGreedDataSource = ghostfolioFearAndGreedIndexDataSource;
+      }
+
+      globalPermissions.push(permissions.enableFearAndGreedIndex);
+    }
+
+    if (this.configurationService.get('ENABLE_FEATURE_READ_ONLY_MODE')) {
+      isReadOnlyMode = (await this.propertyService.getByKey(
+        PROPERTY_IS_READ_ONLY_MODE
+      )) as boolean;
+    }
+
     if (this.configurationService.get('ENABLE_FEATURE_SOCIAL_LOGIN')) {
       globalPermissions.push(permissions.enableSocialLogin);
     }
 
-    if (this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION')) {
-      globalPermissions.push(permissions.enableSubscription);
+    if (this.configurationService.get('ENABLE_FEATURE_STATISTICS')) {
+      globalPermissions.push(permissions.enableStatistics);
     }
 
+    if (this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION')) {
+      globalPermissions.push(permissions.enableSubscription);
+
+      info.countriesOfSubscribers =
+        ((await this.propertyService.getByKey(
+          PROPERTY_COUNTRIES_OF_SUBSCRIBERS
+        )) as string[]) ?? [];
+      info.stripePublicKey = this.configurationService.get('STRIPE_PUBLIC_KEY');
+    }
+
+    if (this.configurationService.get('ENABLE_FEATURE_SYSTEM_MESSAGE')) {
+      globalPermissions.push(permissions.enableSystemMessage);
+    }
+
+    const isUserSignupEnabled =
+      await this.propertyService.isUserSignupEnabled();
+
+    if (isUserSignupEnabled) {
+      globalPermissions.push(permissions.createUserAccount);
+    }
+
+    const [benchmarks, demoAuthToken, statistics, subscriptions, tags] =
+      await Promise.all([
+        this.benchmarkService.getBenchmarkAssetProfiles(),
+        this.getDemoAuthToken(),
+        this.getStatistics(),
+        this.getSubscriptions(),
+        this.tagService.get()
+      ]);
+
     return {
+      ...info,
+      benchmarks,
+      demoAuthToken,
       globalPermissions,
+      isReadOnlyMode,
       platforms,
-      currencies: Object.values(Currency),
-      demoAuthToken: this.getDemoAuthToken(),
-      lastDataGathering: await this.getLastDataGathering()
+      statistics,
+      subscriptions,
+      tags,
+      baseCurrency: DEFAULT_CURRENCY,
+      currencies: this.exchangeRateDataService.getCurrencies()
     };
   }
 
-  private getDemoAuthToken() {
-    return this.jwtService.sign({
-      id: InfoService.DEMO_USER_ID
+  private async countActiveUsers(aDays: number) {
+    return this.userService.count({
+      where: {
+        AND: [
+          {
+            NOT: {
+              Analytics: null
+            }
+          },
+          {
+            Analytics: {
+              updatedAt: {
+                gt: subDays(new Date(), aDays)
+              }
+            }
+          }
+        ]
+      }
     });
   }
 
-  private async getLastDataGathering() {
-    const lastDataGathering = await this.prisma.property.findUnique({
-      where: { key: 'LAST_DATA_GATHERING' }
-    });
+  private async countDockerHubPulls(): Promise<number> {
+    try {
+      const abortController = new AbortController();
 
-    return lastDataGathering?.value ? new Date(lastDataGathering.value) : null;
+      setTimeout(() => {
+        abortController.abort();
+      }, this.configurationService.get('REQUEST_TIMEOUT'));
+
+      const { pull_count } = await got(
+        `https://hub.docker.com/v2/repositories/ghostfolio/ghostfolio`,
+        {
+          headers: { 'User-Agent': 'request' },
+          // @ts-ignore
+          signal: abortController.signal
+        }
+      ).json<any>();
+
+      return pull_count;
+    } catch (error) {
+      Logger.error(error, 'InfoService - DockerHub');
+
+      return undefined;
+    }
+  }
+
+  private async countGitHubContributors(): Promise<number> {
+    try {
+      const abortController = new AbortController();
+
+      setTimeout(() => {
+        abortController.abort();
+      }, this.configurationService.get('REQUEST_TIMEOUT'));
+
+      const { body } = await got('https://github.com/ghostfolio/ghostfolio', {
+        // @ts-ignore
+        signal: abortController.signal
+      });
+
+      const $ = cheerio.load(body);
+
+      return extractNumberFromString({
+        value: $(
+          `a[href="/ghostfolio/ghostfolio/graphs/contributors"] .Counter`
+        ).text()
+      });
+    } catch (error) {
+      Logger.error(error, 'InfoService - GitHub');
+
+      return undefined;
+    }
+  }
+
+  private async countGitHubStargazers(): Promise<number> {
+    try {
+      const abortController = new AbortController();
+
+      setTimeout(() => {
+        abortController.abort();
+      }, this.configurationService.get('REQUEST_TIMEOUT'));
+
+      const { stargazers_count } = await got(
+        `https://api.github.com/repos/ghostfolio/ghostfolio`,
+        {
+          headers: { 'User-Agent': 'request' },
+          // @ts-ignore
+          signal: abortController.signal
+        }
+      ).json<any>();
+
+      return stargazers_count;
+    } catch (error) {
+      Logger.error(error, 'InfoService - GitHub');
+
+      return undefined;
+    }
+  }
+
+  private async countNewUsers(aDays: number) {
+    return this.userService.count({
+      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 async getDemoAuthToken() {
+    const demoUserId = (await this.propertyService.getByKey(
+      PROPERTY_DEMO_USER_ID
+    )) as string;
+
+    if (demoUserId) {
+      return this.jwtService.sign({
+        id: demoUserId
+      });
+    }
+
+    return undefined;
+  }
+
+  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 dockerHubPulls = await this.countDockerHubPulls();
+    const gitHubContributors = await this.countGitHubContributors();
+    const gitHubStargazers = await this.countGitHubStargazers();
+    const slackCommunityUsers = await this.countSlackCommunityUsers();
+    const uptime = await this.getUptime();
+
+    statistics = {
+      activeUsers1d,
+      activeUsers30d,
+      dockerHubPulls,
+      gitHubContributors,
+      gitHubStargazers,
+      newUsers30d,
+      slackCommunityUsers,
+      uptime
+    };
+
+    await this.redisCacheService.set(
+      InfoService.CACHE_KEY_STATISTICS,
+      JSON.stringify(statistics)
+    );
+
+    return statistics;
+  }
+
+  private async getSubscriptions(): Promise<{
+    [offer in SubscriptionOffer]: Subscription;
+  }> {
+    if (!this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION')) {
+      return undefined;
+    }
+
+    return (
+      ((await this.propertyService.getByKey(PROPERTY_STRIPE_CONFIG)) as any) ??
+      {}
+    );
+  }
+
+  private async getUptime(): Promise<number> {
+    {
+      try {
+        const monitorId = (await this.propertyService.getByKey(
+          PROPERTY_BETTER_UPTIME_MONITOR_ID
+        )) as string;
+
+        const abortController = new AbortController();
+
+        setTimeout(() => {
+          abortController.abort();
+        }, this.configurationService.get('REQUEST_TIMEOUT'));
+
+        const { data } = await got(
+          `https://uptime.betterstack.com/api/v2/monitors/${monitorId}/sla?from=${format(
+            subDays(new Date(), 90),
+            DATE_FORMAT
+          )}&to${format(new Date(), DATE_FORMAT)}`,
+          {
+            headers: {
+              Authorization: `Bearer ${this.configurationService.get(
+                'BETTER_UPTIME_API_KEY'
+              )}`
+            },
+            // @ts-ignore
+            signal: abortController.signal
+          }
+        ).json<any>();
+
+        return data.attributes.availability / 100;
+      } catch (error) {
+        Logger.error(error, 'InfoService - Better Stack');
+
+        return undefined;
+      }
+    }
   }
 }

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,6 +0,0 @@
-import { Account, Settings, User } from '@prisma/client';
-
-export type UserWithSettings = User & {
-  Account: Account[];
-  Settings: Settings;
-};

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

@@ -0,0 +1,54 @@
+import { TransformDataSourceInRequestInterceptor } from '@ghostfolio/api/interceptors/transform-data-source-in-request.interceptor';
+import {
+  Controller,
+  Get,
+  HttpStatus,
+  Param,
+  Query,
+  Res,
+  UseInterceptors
+} from '@nestjs/common';
+import { DataSource } from '@prisma/client';
+import { Response } from 'express';
+
+import { LogoService } from './logo.service';
+
+@Controller('logo')
+export class LogoController {
+  public constructor(private readonly logoService: LogoService) {}
+
+  @Get(':dataSource/:symbol')
+  @UseInterceptors(TransformDataSourceInRequestInterceptor)
+  public async getLogoByDataSourceAndSymbol(
+    @Param('dataSource') dataSource: DataSource,
+    @Param('symbol') symbol: string,
+    @Res() response: Response
+  ) {
+    try {
+      const buffer = await this.logoService.getLogoByDataSourceAndSymbol({
+        dataSource,
+        symbol
+      });
+
+      response.contentType('image/png');
+      response.send(buffer);
+    } catch {
+      response.status(HttpStatus.NOT_FOUND).send();
+    }
+  }
+
+  @Get()
+  public async getLogoByUrl(
+    @Query('url') url: string,
+    @Res() response: Response
+  ) {
+    try {
+      const buffer = await this.logoService.getLogoByUrl(url);
+
+      response.contentType('image/png');
+      response.send(buffer);
+    } catch {
+      response.status(HttpStatus.NOT_FOUND).send();
+    }
+  }
+}

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

@@ -0,0 +1,13 @@
+import { ConfigurationModule } from '@ghostfolio/api/services/configuration/configuration.module';
+import { SymbolProfileModule } from '@ghostfolio/api/services/symbol-profile/symbol-profile.module';
+import { Module } from '@nestjs/common';
+
+import { LogoController } from './logo.controller';
+import { LogoService } from './logo.service';
+
+@Module({
+  controllers: [LogoController],
+  imports: [ConfigurationModule, SymbolProfileModule],
+  providers: [LogoService]
+})
+export class LogoModule {}

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

@@ -0,0 +1,61 @@
+import { ConfigurationService } from '@ghostfolio/api/services/configuration/configuration.service';
+import { SymbolProfileService } from '@ghostfolio/api/services/symbol-profile/symbol-profile.service';
+import { UniqueAsset } from '@ghostfolio/common/interfaces';
+import { HttpException, Injectable } from '@nestjs/common';
+import { DataSource } from '@prisma/client';
+import got from 'got';
+import { StatusCodes, getReasonPhrase } from 'http-status-codes';
+
+@Injectable()
+export class LogoService {
+  public constructor(
+    private readonly configurationService: ConfigurationService,
+    private readonly symbolProfileService: SymbolProfileService
+  ) {}
+
+  public async getLogoByDataSourceAndSymbol({
+    dataSource,
+    symbol
+  }: UniqueAsset) {
+    if (!DataSource[dataSource]) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.NOT_FOUND),
+        StatusCodes.NOT_FOUND
+      );
+    }
+
+    const [assetProfile] = await this.symbolProfileService.getSymbolProfiles([
+      { dataSource, symbol }
+    ]);
+
+    if (!assetProfile) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.NOT_FOUND),
+        StatusCodes.NOT_FOUND
+      );
+    }
+
+    return this.getBuffer(assetProfile.url);
+  }
+
+  public async getLogoByUrl(aUrl: string) {
+    return this.getBuffer(aUrl);
+  }
+
+  private getBuffer(aUrl: string) {
+    const abortController = new AbortController();
+
+    setTimeout(() => {
+      abortController.abort();
+    }, this.configurationService.get('REQUEST_TIMEOUT'));
+
+    return got(
+      `https://t0.gstatic.com/faviconV2?client=SOCIAL&type=FAVICON&fallback_opts=TYPE,SIZE,URL&url=${aUrl}&size=64`,
+      {
+        headers: { 'User-Agent': 'request' },
+        // @ts-ignore
+        signal: abortController.signal
+      }
+    ).buffer();
+  }
+}

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

@@ -1,31 +1,76 @@
-import { Currency, DataSource, Type } from '@prisma/client';
-import { IsISO8601, IsNumber, IsString, ValidateIf } from 'class-validator';
+import {
+  AssetClass,
+  AssetSubClass,
+  DataSource,
+  Tag,
+  Type
+} from '@prisma/client';
+import { Transform, TransformFnParams } from 'class-transformer';
+import {
+  IsArray,
+  IsBoolean,
+  IsEnum,
+  IsISO8601,
+  IsNumber,
+  IsOptional,
+  IsString,
+  Min
+} from 'class-validator';
+import { isString } from 'lodash';
 
 export class CreateOrderDto {
+  @IsOptional()
   @IsString()
-  accountId: string;
+  accountId?: string;
+
+  @IsOptional()
+  @IsEnum(AssetClass, { each: true })
+  assetClass?: AssetClass;
+
+  @IsOptional()
+  @IsEnum(AssetSubClass, { each: true })
+  assetSubClass?: AssetSubClass;
+
+  @IsOptional()
+  @IsString()
+  @Transform(({ value }: TransformFnParams) =>
+    isString(value) ? value.trim() : value
+  )
+  comment?: string;
 
   @IsString()
-  currency: Currency;
+  currency: string;
 
-  @IsString()
-  dataSource: DataSource;
+  @IsOptional()
+  @IsEnum(DataSource, { each: true })
+  dataSource?: DataSource;
 
   @IsISO8601()
   date: string;
 
   @IsNumber()
+  @Min(0)
   fee: number;
 
   @IsNumber()
+  @Min(0)
   quantity: number;
 
   @IsString()
   symbol: string;
 
-  @IsString()
+  @IsArray()
+  @IsOptional()
+  tags?: Tag[];
+
+  @IsEnum(Type, { each: true })
   type: Type;
 
   @IsNumber()
+  @Min(0)
   unitPrice: number;
+
+  @IsBoolean()
+  @IsOptional()
+  updateAccountBalance?: boolean;
 }

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

@@ -0,0 +1,19 @@
+import { OrderWithAccount } from '@ghostfolio/common/types';
+
+export interface Activities {
+  activities: Activity[];
+  count: number;
+}
+
+export interface Activity extends OrderWithAccount {
+  error?: ActivityError;
+  feeInBaseCurrency: number;
+  updateAccountBalance?: boolean;
+  value: number;
+  valueInBaseCurrency: number;
+}
+
+export interface ActivityError {
+  code: 'IS_DUPLICATE';
+  message?: string;
+}

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

@@ -1,5 +0,0 @@
-import { Account, Order, Platform } from '@prisma/client';
-
-type AccountWithPlatform = Account & { Platform?: Platform };
-
-export type OrderWithAccount = Order & { Account?: AccountWithPlatform };

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

@@ -1,7 +1,14 @@
-import { RequestWithUser } from '@ghostfolio/api/app/interfaces/request-with-user.type';
-import { nullifyValuesInObjects } from '@ghostfolio/api/helper/object.helper';
-import { ImpersonationService } from '@ghostfolio/api/services/impersonation.service';
-import { getPermissions, hasPermission, permissions } from '@ghostfolio/helper';
+import { HasPermission } from '@ghostfolio/api/decorators/has-permission.decorator';
+import { HasPermissionGuard } from '@ghostfolio/api/guards/has-permission.guard';
+import { RedactValuesInResponseInterceptor } from '@ghostfolio/api/interceptors/redact-values-in-response.interceptor';
+import { TransformDataSourceInRequestInterceptor } from '@ghostfolio/api/interceptors/transform-data-source-in-request.interceptor';
+import { TransformDataSourceInResponseInterceptor } from '@ghostfolio/api/interceptors/transform-data-source-in-response.interceptor';
+import { ApiService } from '@ghostfolio/api/services/api/api.service';
+import { DataGatheringService } from '@ghostfolio/api/services/data-gathering/data-gathering.service';
+import { ImpersonationService } from '@ghostfolio/api/services/impersonation/impersonation.service';
+import { HEADER_KEY_IMPERSONATION } from '@ghostfolio/common/config';
+import { hasPermission, permissions } from '@ghostfolio/common/permissions';
+import type { RequestWithUser } from '@ghostfolio/common/types';
 import {
   Body,
   Controller,
@@ -13,34 +20,49 @@ import {
   Param,
   Post,
   Put,
-  UseGuards
+  Query,
+  UseGuards,
+  UseInterceptors
 } from '@nestjs/common';
 import { REQUEST } from '@nestjs/core';
 import { AuthGuard } from '@nestjs/passport';
-import { Order as OrderModel } from '@prisma/client';
+import { Order as OrderModel, Prisma } from '@prisma/client';
 import { parseISO } from 'date-fns';
 import { StatusCodes, getReasonPhrase } from 'http-status-codes';
 
 import { CreateOrderDto } from './create-order.dto';
+import { Activities } from './interfaces/activities.interface';
 import { OrderService } from './order.service';
 import { UpdateOrderDto } from './update-order.dto';
 
 @Controller('order')
 export class OrderController {
   public constructor(
+    private readonly apiService: ApiService,
+    private readonly dataGatheringService: DataGatheringService,
     private readonly impersonationService: ImpersonationService,
     private readonly orderService: OrderService,
     @Inject(REQUEST) private readonly request: RequestWithUser
   ) {}
 
+  @Delete()
+  @HasPermission(permissions.deleteOrder)
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  public async deleteOrders(): Promise<number> {
+    return this.orderService.deleteOrders({
+      userId: this.request.user.id
+    });
+  }
+
   @Delete(':id')
-  @UseGuards(AuthGuard('jwt'))
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
   public async deleteOrder(@Param('id') id: string): Promise<OrderModel> {
+    const order = await this.orderService.order({ id });
+
     if (
-      !hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.deleteOrder
-      )
+      !hasPermission(this.request.user.permissions, permissions.deleteOrder) ||
+      !order ||
+      order.userId !== this.request.user.id
     ) {
       throw new HttpException(
         getReasonPhrase(StatusCodes.FORBIDDEN),
@@ -48,72 +70,102 @@ export class OrderController {
       );
     }
 
-    return this.orderService.deleteOrder(
-      {
-        id_userId: {
-          id,
-          userId: this.request.user.id
-        }
-      },
-      this.request.user.id
-    );
+    return this.orderService.deleteOrder({
+      id
+    });
   }
 
   @Get()
-  @UseGuards(AuthGuard('jwt'))
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  @UseInterceptors(RedactValuesInResponseInterceptor)
+  @UseInterceptors(TransformDataSourceInResponseInterceptor)
   public async getAllOrders(
-    @Headers('impersonation-id') impersonationId
-  ): Promise<OrderModel[]> {
-    const impersonationUserId = await this.impersonationService.validateImpersonationId(
-      impersonationId,
-      this.request.user.id
-    );
+    @Headers(HEADER_KEY_IMPERSONATION.toLowerCase()) impersonationId,
+    @Query('accounts') filterByAccounts?: string,
+    @Query('assetClasses') filterByAssetClasses?: string,
+    @Query('skip') skip?: number,
+    @Query('sortColumn') sortColumn?: string,
+    @Query('sortDirection') sortDirection?: Prisma.SortOrder,
+    @Query('tags') filterByTags?: string,
+    @Query('take') take?: number
+  ): Promise<Activities> {
+    const filters = this.apiService.buildFiltersFromQueryParams({
+      filterByAccounts,
+      filterByAssetClasses,
+      filterByTags
+    });
 
-    let orders = await this.orderService.orders({
-      include: {
-        Account: {
-          include: {
-            Platform: true
+    const impersonationUserId =
+      await this.impersonationService.validateImpersonationId(impersonationId);
+    const userCurrency = this.request.user.Settings.settings.baseCurrency;
+
+    const { activities, count } = await this.orderService.getOrders({
+      filters,
+      sortColumn,
+      sortDirection,
+      userCurrency,
+      includeDrafts: true,
+      skip: isNaN(skip) ? undefined : skip,
+      take: isNaN(take) ? undefined : take,
+      userId: impersonationUserId || this.request.user.id,
+      withExcludedAccounts: true
+    });
+
+    return { activities, count };
+  }
+
+  @HasPermission(permissions.createOrder)
+  @Post()
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  @UseInterceptors(TransformDataSourceInRequestInterceptor)
+  public async createOrder(@Body() data: CreateOrderDto): Promise<OrderModel> {
+    const order = await 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
+            }
           }
         }
       },
-      orderBy: { date: 'desc' },
-      where: { userId: impersonationUserId || this.request.user.id }
+      User: { connect: { id: this.request.user.id } },
+      userId: this.request.user.id
     });
 
-    if (
-      impersonationUserId &&
-      !hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.readForeignPortfolio
-      )
-    ) {
-      orders = nullifyValuesInObjects(orders, ['fee', 'quantity', 'unitPrice']);
+    if (data.dataSource && !order.isDraft) {
+      // Gather symbol data in the background, if data source is set
+      // (not MANUAL) and not draft
+      this.dataGatheringService.gatherSymbols([
+        {
+          dataSource: data.dataSource,
+          date: order.date,
+          symbol: data.symbol
+        }
+      ]);
     }
 
-    return orders;
+    return order;
   }
 
-  @Get(':id')
-  @UseGuards(AuthGuard('jwt'))
-  public async getOrderById(@Param('id') id: string): Promise<OrderModel> {
-    return this.orderService.order({
-      id_userId: {
-        id,
-        userId: this.request.user.id
-      }
+  @HasPermission(permissions.updateOrder)
+  @Put(':id')
+  @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
+  @UseInterceptors(TransformDataSourceInRequestInterceptor)
+  public async update(@Param('id') id: string, @Body() data: UpdateOrderDto) {
+    const originalOrder = await this.orderService.order({
+      id
     });
-  }
 
-  @Post()
-  @UseGuards(AuthGuard('jwt'))
-  public async createOrder(@Body() data: CreateOrderDto): Promise<OrderModel> {
-    if (
-      !hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.createOrder
-      )
-    ) {
+    if (!originalOrder || originalOrder.userId !== this.request.user.id) {
       throw new HttpException(
         getReasonPhrase(StatusCodes.FORBIDDEN),
         StatusCodes.FORBIDDEN
@@ -125,8 +177,8 @@ export class OrderController {
     const accountId = data.accountId;
     delete data.accountId;
 
-    return this.orderService.createOrder(
-      {
+    return this.orderService.updateOrder({
+      data: {
         ...data,
         date,
         Account: {
@@ -134,66 +186,24 @@ export class OrderController {
             id_userId: { id: accountId, userId: this.request.user.id }
           }
         },
-        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: UpdateOrderDto) {
-    if (
-      !hasPermission(
-        getPermissions(this.request.user.role),
-        permissions.updateOrder
-      )
-    ) {
-      throw new HttpException(
-        getReasonPhrase(StatusCodes.FORBIDDEN),
-        StatusCodes.FORBIDDEN
-      );
-    }
-
-    const originalOrder = await this.orderService.order({
-      id_userId: {
-        id,
-        userId: 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
+          update: {
+            assetClass: data.assetClass,
+            assetSubClass: data.assetSubClass,
+            name: data.symbol
           }
-        }
+        },
+        User: { connect: { id: this.request.user.id } }
       },
-      this.request.user.id
-    );
+      where: {
+        id
+      }
+    });
   }
 }

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

@@ -1,34 +1,37 @@
-import { ConfigurationService } from '@ghostfolio/api/services/configuration.service';
-import { DataGatheringService } from '@ghostfolio/api/services/data-gathering.service';
-import { DataProviderService } from '@ghostfolio/api/services/data-provider.service';
-import { AlphaVantageService } from '@ghostfolio/api/services/data-provider/alpha-vantage/alpha-vantage.service';
-import { GhostfolioScraperApiService } from '@ghostfolio/api/services/data-provider/ghostfolio-scraper-api/ghostfolio-scraper-api.service';
-import { RakutenRapidApiService } from '@ghostfolio/api/services/data-provider/rakuten-rapid-api/rakuten-rapid-api.service';
-import { YahooFinanceService } from '@ghostfolio/api/services/data-provider/yahoo-finance/yahoo-finance.service';
-import { ImpersonationService } from '@ghostfolio/api/services/impersonation.service';
-import { PrismaService } from '@ghostfolio/api/services/prisma.service';
+import { AccountBalanceService } from '@ghostfolio/api/app/account-balance/account-balance.service';
+import { AccountService } from '@ghostfolio/api/app/account/account.service';
+import { CacheModule } from '@ghostfolio/api/app/cache/cache.module';
+import { RedisCacheModule } from '@ghostfolio/api/app/redis-cache/redis-cache.module';
+import { UserModule } from '@ghostfolio/api/app/user/user.module';
+import { ApiModule } from '@ghostfolio/api/services/api/api.module';
+import { ConfigurationModule } from '@ghostfolio/api/services/configuration/configuration.module';
+import { DataGatheringModule } from '@ghostfolio/api/services/data-gathering/data-gathering.module';
+import { DataProviderModule } from '@ghostfolio/api/services/data-provider/data-provider.module';
+import { ExchangeRateDataModule } from '@ghostfolio/api/services/exchange-rate-data/exchange-rate-data.module';
+import { ImpersonationModule } from '@ghostfolio/api/services/impersonation/impersonation.module';
+import { PrismaModule } from '@ghostfolio/api/services/prisma/prisma.module';
+import { SymbolProfileModule } from '@ghostfolio/api/services/symbol-profile/symbol-profile.module';
 import { Module } from '@nestjs/common';
 
-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,
-    GhostfolioScraperApiService,
-    ImpersonationService,
-    OrderService,
-    PrismaService,
-    RakutenRapidApiService,
-    YahooFinanceService
-  ]
+  exports: [OrderService],
+  imports: [
+    ApiModule,
+    CacheModule,
+    ConfigurationModule,
+    DataGatheringModule,
+    DataProviderModule,
+    ExchangeRateDataModule,
+    ImpersonationModule,
+    PrismaModule,
+    RedisCacheModule,
+    SymbolProfileModule,
+    UserModule
+  ],
+  providers: [AccountBalanceService, AccountService, OrderService]
 })
 export class OrderModule {}

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

@@ -1,40 +1,452 @@
-import { DataGatheringService } from '@ghostfolio/api/services/data-gathering.service';
-import { PrismaService } from '@ghostfolio/api/services/prisma.service';
+import { AccountService } from '@ghostfolio/api/app/account/account.service';
+import { DataGatheringService } from '@ghostfolio/api/services/data-gathering/data-gathering.service';
+import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data/exchange-rate-data.service';
+import { PrismaService } from '@ghostfolio/api/services/prisma/prisma.service';
+import { SymbolProfileService } from '@ghostfolio/api/services/symbol-profile/symbol-profile.service';
+import {
+  GATHER_ASSET_PROFILE_PROCESS,
+  GATHER_ASSET_PROFILE_PROCESS_OPTIONS
+} from '@ghostfolio/common/config';
+import { getAssetProfileIdentifier } from '@ghostfolio/common/helper';
+import { Filter } from '@ghostfolio/common/interfaces';
+import { OrderWithAccount } from '@ghostfolio/common/types';
 import { Injectable } from '@nestjs/common';
-import { Order, Prisma } from '@prisma/client';
+import {
+  AssetClass,
+  AssetSubClass,
+  DataSource,
+  Order,
+  Prisma,
+  Tag,
+  Type as TypeOfOrder
+} from '@prisma/client';
+import Big from 'big.js';
+import { endOfToday, isAfter } from 'date-fns';
+import { groupBy } from 'lodash';
+import { v4 as uuidv4 } from 'uuid';
 
-import { CacheService } from '../cache/cache.service';
-import { RedisCacheService } from '../redis-cache/redis-cache.service';
-import { OrderWithAccount } from './interfaces/order-with-account.type';
+import { Activities } from './interfaces/activities.interface';
 
 @Injectable()
 export class OrderService {
   public constructor(
-    private readonly cacheService: CacheService,
+    private readonly accountService: AccountService,
     private readonly dataGatheringService: DataGatheringService,
-    private readonly redisCacheService: RedisCacheService,
-    private prisma: PrismaService
+    private readonly exchangeRateDataService: ExchangeRateDataService,
+    private readonly prismaService: PrismaService,
+    private readonly symbolProfileService: SymbolProfileService
   ) {}
 
+  public async createOrder(
+    data: Prisma.OrderCreateInput & {
+      accountId?: string;
+      assetClass?: AssetClass;
+      assetSubClass?: AssetSubClass;
+      currency?: string;
+      dataSource?: DataSource;
+      symbol?: string;
+      tags?: Tag[];
+      updateAccountBalance?: boolean;
+      userId: string;
+    }
+  ): Promise<Order> {
+    let Account;
+
+    if (data.accountId) {
+      Account = {
+        connect: {
+          id_userId: {
+            userId: data.userId,
+            id: data.accountId
+          }
+        }
+      };
+    }
+
+    const accountId = data.accountId;
+    let currency = data.currency;
+    const tags = data.tags ?? [];
+    const updateAccountBalance = data.updateAccountBalance ?? false;
+    const userId = data.userId;
+
+    if (
+      data.type === 'FEE' ||
+      data.type === 'INTEREST' ||
+      data.type === 'ITEM' ||
+      data.type === 'LIABILITY'
+    ) {
+      const assetClass = data.assetClass;
+      const assetSubClass = data.assetSubClass;
+      currency = data.SymbolProfile.connectOrCreate.create.currency;
+      const dataSource: DataSource = 'MANUAL';
+      const id = uuidv4();
+      const name = data.SymbolProfile.connectOrCreate.create.symbol;
+
+      data.id = id;
+      data.SymbolProfile.connectOrCreate.create.assetClass = assetClass;
+      data.SymbolProfile.connectOrCreate.create.assetSubClass = assetSubClass;
+      data.SymbolProfile.connectOrCreate.create.currency = currency;
+      data.SymbolProfile.connectOrCreate.create.dataSource = dataSource;
+      data.SymbolProfile.connectOrCreate.create.name = name;
+      data.SymbolProfile.connectOrCreate.create.symbol = id;
+      data.SymbolProfile.connectOrCreate.where.dataSource_symbol = {
+        dataSource,
+        symbol: id
+      };
+    }
+
+    if (data.SymbolProfile.connectOrCreate.create.dataSource !== 'MANUAL') {
+      this.dataGatheringService.addJobToQueue({
+        data: {
+          dataSource: data.SymbolProfile.connectOrCreate.create.dataSource,
+          symbol: data.SymbolProfile.connectOrCreate.create.symbol
+        },
+        name: GATHER_ASSET_PROFILE_PROCESS,
+        opts: {
+          ...GATHER_ASSET_PROFILE_PROCESS_OPTIONS,
+          jobId: getAssetProfileIdentifier({
+            dataSource: data.SymbolProfile.connectOrCreate.create.dataSource,
+            symbol: data.SymbolProfile.connectOrCreate.create.symbol
+          })
+        }
+      });
+    }
+
+    delete data.accountId;
+    delete data.assetClass;
+    delete data.assetSubClass;
+
+    if (!data.comment) {
+      delete data.comment;
+    }
+
+    delete data.currency;
+    delete data.dataSource;
+    delete data.symbol;
+    delete data.tags;
+    delete data.updateAccountBalance;
+    delete data.userId;
+
+    const orderData: Prisma.OrderCreateInput = data;
+
+    const isDraft =
+      data.type === 'FEE' ||
+      data.type === 'INTEREST' ||
+      data.type === 'ITEM' ||
+      data.type === 'LIABILITY'
+        ? false
+        : isAfter(data.date as Date, endOfToday());
+
+    const order = await this.prismaService.order.create({
+      data: {
+        ...orderData,
+        Account,
+        isDraft,
+        tags: {
+          connect: tags.map(({ id }) => {
+            return { id };
+          })
+        }
+      }
+    });
+
+    if (updateAccountBalance === true) {
+      let amount = new Big(data.unitPrice)
+        .mul(data.quantity)
+        .plus(data.fee)
+        .toNumber();
+
+      if (data.type === 'BUY') {
+        amount = new Big(amount).mul(-1).toNumber();
+      }
+
+      await this.accountService.updateAccountBalance({
+        accountId,
+        amount,
+        currency,
+        userId,
+        date: data.date as Date
+      });
+    }
+
+    return order;
+  }
+
+  public async deleteOrder(
+    where: Prisma.OrderWhereUniqueInput
+  ): Promise<Order> {
+    const order = await this.prismaService.order.delete({
+      where
+    });
+
+    if (
+      order.type === 'FEE' ||
+      order.type === 'INTEREST' ||
+      order.type === 'ITEM' ||
+      order.type === 'LIABILITY'
+    ) {
+      await this.symbolProfileService.deleteById(order.symbolProfileId);
+    }
+
+    return order;
+  }
+
+  public async deleteOrders(where: Prisma.OrderWhereInput): Promise<number> {
+    const { count } = await this.prismaService.order.deleteMany({
+      where
+    });
+
+    return count;
+  }
+
+  public async getOrders({
+    filters,
+    includeDrafts = false,
+    skip,
+    sortColumn,
+    sortDirection,
+    take = Number.MAX_SAFE_INTEGER,
+    types,
+    userCurrency,
+    userId,
+    withExcludedAccounts = false
+  }: {
+    filters?: Filter[];
+    includeDrafts?: boolean;
+    skip?: number;
+    sortColumn?: string;
+    sortDirection?: Prisma.SortOrder;
+    take?: number;
+    types?: TypeOfOrder[];
+    userCurrency: string;
+    userId: string;
+    withExcludedAccounts?: boolean;
+  }): Promise<Activities> {
+    let orderBy: Prisma.Enumerable<Prisma.OrderOrderByWithRelationInput> = [
+      { date: 'asc' }
+    ];
+    const where: Prisma.OrderWhereInput = { userId };
+
+    const {
+      ACCOUNT: filtersByAccount,
+      ASSET_CLASS: filtersByAssetClass,
+      TAG: filtersByTag
+    } = groupBy(filters, (filter) => {
+      return filter.type;
+    });
+
+    if (filtersByAccount?.length > 0) {
+      where.accountId = {
+        in: filtersByAccount.map(({ id }) => {
+          return id;
+        })
+      };
+    }
+
+    if (includeDrafts === false) {
+      where.isDraft = false;
+    }
+
+    if (filtersByAssetClass?.length > 0) {
+      where.SymbolProfile = {
+        OR: [
+          {
+            AND: [
+              {
+                OR: filtersByAssetClass.map(({ id }) => {
+                  return { assetClass: AssetClass[id] };
+                })
+              },
+              {
+                OR: [
+                  { SymbolProfileOverrides: { is: null } },
+                  { SymbolProfileOverrides: { assetClass: null } }
+                ]
+              }
+            ]
+          },
+          {
+            SymbolProfileOverrides: {
+              OR: filtersByAssetClass.map(({ id }) => {
+                return { assetClass: AssetClass[id] };
+              })
+            }
+          }
+        ]
+      };
+    }
+
+    if (filtersByTag?.length > 0) {
+      where.tags = {
+        some: {
+          OR: filtersByTag.map(({ id }) => {
+            return { id };
+          })
+        }
+      };
+    }
+
+    if (sortColumn) {
+      orderBy = [{ [sortColumn]: sortDirection }];
+    }
+
+    if (types) {
+      where.OR = types.map((type) => {
+        return {
+          type: {
+            equals: type
+          }
+        };
+      });
+    }
+
+    const [orders, count] = await Promise.all([
+      this.orders({
+        orderBy,
+        skip,
+        take,
+        where,
+        include: {
+          // eslint-disable-next-line @typescript-eslint/naming-convention
+          Account: {
+            include: {
+              Platform: true
+            }
+          },
+          // eslint-disable-next-line @typescript-eslint/naming-convention
+          SymbolProfile: true,
+          tags: true
+        }
+      }),
+      this.prismaService.order.count({ where })
+    ]);
+
+    const activities = orders
+      .filter((order) => {
+        return (
+          withExcludedAccounts ||
+          !order.Account ||
+          order.Account?.isExcluded === false
+        );
+      })
+      .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
+          )
+        };
+      });
+
+    return { activities, count };
+  }
+
   public async order(
     orderWhereUniqueInput: Prisma.OrderWhereUniqueInput
   ): Promise<Order | null> {
-    return this.prisma.order.findUnique({
+    return this.prismaService.order.findUnique({
       where: orderWhereUniqueInput
     });
   }
 
-  public async orders(params: {
+  public async updateOrder({
+    data,
+    where
+  }: {
+    data: Prisma.OrderUpdateInput & {
+      assetClass?: AssetClass;
+      assetSubClass?: AssetSubClass;
+      currency?: string;
+      dataSource?: DataSource;
+      symbol?: string;
+      tags?: Tag[];
+    };
+    where: Prisma.OrderWhereUniqueInput;
+  }): Promise<Order> {
+    if (data.Account.connect.id_userId.id === null) {
+      delete data.Account;
+    }
+
+    if (!data.comment) {
+      data.comment = null;
+    }
+
+    const tags = data.tags ?? [];
+
+    let isDraft = false;
+
+    if (
+      data.type === 'FEE' ||
+      data.type === 'INTEREST' ||
+      data.type === 'ITEM' ||
+      data.type === 'LIABILITY'
+    ) {
+      delete data.SymbolProfile.connect;
+    } else {
+      delete data.SymbolProfile.update;
+
+      isDraft = isAfter(data.date as Date, endOfToday());
+
+      if (!isDraft) {
+        // Gather symbol data of order in the background, if not draft
+        this.dataGatheringService.gatherSymbols([
+          {
+            dataSource: data.SymbolProfile.connect.dataSource_symbol.dataSource,
+            date: <Date>data.date,
+            symbol: data.SymbolProfile.connect.dataSource_symbol.symbol
+          }
+        ]);
+      }
+    }
+
+    delete data.assetClass;
+    delete data.assetSubClass;
+    delete data.currency;
+    delete data.dataSource;
+    delete data.symbol;
+    delete data.tags;
+
+    // Remove existing tags
+    await this.prismaService.order.update({
+      data: { tags: { set: [] } },
+      where
+    });
+
+    return this.prismaService.order.update({
+      data: {
+        ...data,
+        isDraft,
+        tags: {
+          connect: tags.map(({ id }) => {
+            return { id };
+          })
+        }
+      },
+      where
+    });
+  }
+
+  private async orders(params: {
     include?: Prisma.OrderInclude;
     skip?: number;
     take?: number;
     cursor?: Prisma.OrderWhereUniqueInput;
     where?: Prisma.OrderWhereInput;
-    orderBy?: Prisma.OrderOrderByInput;
+    orderBy?: Prisma.Enumerable<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,
@@ -43,63 +455,4 @@ export class OrderService {
       where
     });
   }
-
-  public async createOrder(
-    data: Prisma.OrderCreateInput,
-    aUserId: string
-  ): Promise<Order> {
-    this.redisCacheService.remove(`${aUserId}.portfolio`);
-
-    // Gather symbol data of order in the background
-    this.dataGatheringService.gatherSymbols([
-      {
-        date: <Date>data.date,
-        symbol: data.symbol
-      }
-    ]);
-
-    await this.cacheService.flush(aUserId);
-
-    return this.prisma.order.create({
-      data
-    });
-  }
-
-  public async deleteOrder(
-    where: Prisma.OrderWhereUniqueInput,
-    aUserId: string
-  ): Promise<Order> {
-    this.redisCacheService.remove(`${aUserId}.portfolio`);
-
-    return this.prisma.order.delete({
-      where
-    });
-  }
-
-  public async updateOrder(
-    params: {
-      where: Prisma.OrderWhereUniqueInput;
-      data: Prisma.OrderUpdateInput;
-    },
-    aUserId: string
-  ): Promise<Order> {
-    const { data, where } = params;
-
-    this.redisCacheService.remove(`${aUserId}.portfolio`);
-
-    // Gather symbol data of order in the background
-    this.dataGatheringService.gatherSymbols([
-      {
-        date: <Date>data.date,
-        symbol: <string>data.symbol
-      }
-    ]);
-
-    await this.cacheService.flush(aUserId);
-
-    return this.prisma.order.update({
-      data,
-      where
-    });
-  }
 }

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

@@ -1,12 +1,44 @@
-import { Currency, DataSource, Type } from '@prisma/client';
-import { IsISO8601, IsNumber, IsString, ValidateIf } from 'class-validator';
+import {
+  AssetClass,
+  AssetSubClass,
+  DataSource,
+  Tag,
+  Type
+} from '@prisma/client';
+import { Transform, TransformFnParams } from 'class-transformer';
+import {
+  IsArray,
+  IsEnum,
+  IsISO8601,
+  IsNumber,
+  IsOptional,
+  IsString,
+  Min
+} from 'class-validator';
+import { isString } from 'lodash';
 
 export class UpdateOrderDto {
+  @IsOptional()
   @IsString()
-  accountId: string;
+  accountId?: string;
+
+  @IsEnum(AssetClass, { each: true })
+  @IsOptional()
+  assetClass?: AssetClass;
+
+  @IsEnum(AssetSubClass, { each: true })
+  @IsOptional()
+  assetSubClass?: AssetSubClass;
+
+  @IsOptional()
+  @IsString()
+  @Transform(({ value }: TransformFnParams) =>
+    isString(value) ? value.trim() : value
+  )
+  comment?: string;
 
   @IsString()
-  currency: Currency;
+  currency: string;
 
   @IsString()
   dataSource: DataSource;
@@ -15,20 +47,27 @@ export class UpdateOrderDto {
   date: string;
 
   @IsNumber()
+  @Min(0)
   fee: number;
 
   @IsString()
   id: string;
 
   @IsNumber()
+  @Min(0)
   quantity: number;
 
   @IsString()
   symbol: string;
 
+  @IsArray()
+  @IsOptional()
+  tags?: Tag[];
+
   @IsString()
   type: Type;
 
   @IsNumber()
+  @Min(0)
   unitPrice: number;
 }