Initial commit

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

@@ -0,0 +1,32 @@
+import { Controller, Get, Inject, UseGuards } from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
+import { AuthGuard } from '@nestjs/passport';
+import { RequestWithUser } from 'apps/api/src/app/interfaces/request-with-user.type';
+
+import { AccessService } from './access.service';
+import { Access } from './interfaces/access.interface';
+
+@Controller('access')
+export class AccessController {
+  public constructor(
+    private readonly accessService: AccessService,
+    @Inject(REQUEST) private readonly request: RequestWithUser
+  ) {}
+
+  @Get()
+  @UseGuards(AuthGuard('jwt'))
+  public async getAllAccesses(): Promise<Access[]> {
+    const accessesWithGranteeUser = await this.accessService.accesses({
+      include: {
+        GranteeUser: true
+      },
+      where: { userId: this.request.user.id }
+    });
+
+    return accessesWithGranteeUser.map((access) => {
+      return {
+        granteeAlias: access.GranteeUser.alias
+      };
+    });
+  }
+}

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

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

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

@@ -0,0 +1,30 @@
+import { Injectable } from '@nestjs/common';
+import { Prisma } from '@prisma/client';
+
+import { PrismaService } from '../../services/prisma.service';
+import { AccessWithGranteeUser } from './interfaces/access-with-grantee-user.type';
+
+@Injectable()
+export class AccessService {
+  public constructor(private prisma: PrismaService) {}
+
+  public async accesses(params: {
+    include?: Prisma.AccessInclude;
+    skip?: number;
+    take?: number;
+    cursor?: Prisma.AccessWhereUniqueInput;
+    where?: Prisma.AccessWhereInput;
+    orderBy?: Prisma.AccessOrderByInput;
+  }): Promise<AccessWithGranteeUser[]> {
+    const { include, skip, take, cursor, where, orderBy } = params;
+
+    return this.prisma.access.findMany({
+      cursor,
+      include,
+      orderBy,
+      skip,
+      take,
+      where
+    });
+  }
+}

apps/api/src/app/access/interfaces/access-with-grantee-user.type.ts

@@ -0,0 +1,3 @@
+import { Access, User } from '@prisma/client';
+
+export type AccessWithGranteeUser = Access & { GranteeUser?: User };

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

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

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

@@ -0,0 +1,64 @@
+import {
+  Controller,
+  Get,
+  HttpException,
+  Inject,
+  Post,
+  UseGuards
+} from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
+import { AuthGuard } from '@nestjs/passport';
+import { RequestWithUser } from 'apps/api/src/app/interfaces/request-with-user.type';
+import { StatusCodes, getReasonPhrase } from 'http-status-codes';
+import { getPermissions, hasPermission, permissions } from 'libs/helper/src';
+
+import { DataGatheringService } from '../../services/data-gathering.service';
+import { AdminService } from './admin.service';
+import { AdminData } from './interfaces/admin-data.interface';
+
+@Controller('admin')
+export class AdminController {
+  public constructor(
+    private readonly adminService: AdminService,
+    private readonly dataGatheringService: DataGatheringService,
+    @Inject(REQUEST) private readonly request: RequestWithUser
+  ) {}
+
+  @Get()
+  @UseGuards(AuthGuard('jwt'))
+  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();
+  }
+
+  @Post('gather/max')
+  @UseGuards(AuthGuard('jwt'))
+  public async gatherMax(): Promise<void> {
+    if (
+      !hasPermission(
+        getPermissions(this.request.user.role),
+        permissions.accessAdminControl
+      )
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    this.dataGatheringService.gatherMax();
+
+    return;
+  }
+}

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

@@ -0,0 +1,27 @@
+import { Module } from '@nestjs/common';
+
+import { DataGatheringService } from '../../services/data-gathering.service';
+import { DataProviderService } from '../../services/data-provider.service';
+import { AlphaVantageService } from '../../services/data-provider/alpha-vantage/alpha-vantage.service';
+import { RakutenRapidApiService } from '../../services/data-provider/rakuten-rapid-api/rakuten-rapid-api.service';
+import { YahooFinanceService } from '../../services/data-provider/yahoo-finance/yahoo-finance.service';
+import { ExchangeRateDataService } from '../../services/exchange-rate-data.service';
+import { PrismaService } from '../../services/prisma.service';
+import { AdminController } from './admin.controller';
+import { AdminService } from './admin.service';
+
+@Module({
+  imports: [],
+  controllers: [AdminController],
+  providers: [
+    AdminService,
+    AlphaVantageService,
+    DataGatheringService,
+    DataProviderService,
+    ExchangeRateDataService,
+    PrismaService,
+    RakutenRapidApiService,
+    YahooFinanceService
+  ]
+})
+export class AdminModule {}

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

@@ -0,0 +1,108 @@
+import { Injectable } from '@nestjs/common';
+import { Currency } from '@prisma/client';
+
+import { ExchangeRateDataService } from '../../services/exchange-rate-data.service';
+import { PrismaService } from '../../services/prisma.service';
+import { AdminData } from './interfaces/admin-data.interface';
+
+@Injectable()
+export class AdminService {
+  public constructor(
+    private exchangeRateDataService: ExchangeRateDataService,
+    private prisma: PrismaService
+  ) {}
+
+  public async get(): Promise<AdminData> {
+    return {
+      analytics: await this.getUserAnalytics(),
+      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()
+    };
+  }
+
+  private async getLastDataGathering() {
+    const lastDataGathering = await this.prisma.property.findUnique({
+      where: { key: 'LAST_DATA_GATHERING' }
+    });
+
+    if (lastDataGathering?.value) {
+      return new Date(lastDataGathering.value);
+    }
+
+    const dataGatheringInProgress = await this.prisma.property.findUnique({
+      where: { key: 'LOCKED_DATA_GATHERING' }
+    });
+
+    if (dataGatheringInProgress) {
+      return 'IN_PROGRESS';
+    }
+
+    return null;
+  }
+
+  private async getUserAnalytics() {
+    return await this.prisma.analytics.findMany({
+      orderBy: { updatedAt: 'desc' },
+      select: {
+        activityCount: true,
+        updatedAt: true,
+        User: {
+          select: {
+            alias: true,
+            createdAt: true,
+            id: true
+          }
+        }
+      },
+      take: 20
+    });
+  }
+}

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

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

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

@@ -0,0 +1,31 @@
+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
+  ) {
+    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' }]
+        }
+      });
+    }
+  }
+}

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

@@ -0,0 +1,71 @@
+import { join } from 'path';
+
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { ScheduleModule } from '@nestjs/schedule';
+import { ServeStaticModule } from '@nestjs/serve-static';
+
+import { CronService } from '../services/cron.service';
+import { DataGatheringService } from '../services/data-gathering.service';
+import { DataProviderService } from '../services/data-provider.service';
+import { AlphaVantageService } from '../services/data-provider/alpha-vantage/alpha-vantage.service';
+import { RakutenRapidApiService } from '../services/data-provider/rakuten-rapid-api/rakuten-rapid-api.service';
+import { YahooFinanceService } from '../services/data-provider/yahoo-finance/yahoo-finance.service';
+import { ExchangeRateDataService } from '../services/exchange-rate-data.service';
+import { PrismaService } from '../services/prisma.service';
+import { AccessModule } from './access/access.module';
+import { AdminModule } from './admin/admin.module';
+import { AppController } from './app.controller';
+import { AuthModule } from './auth/auth.module';
+import { CacheModule } from './cache/cache.module';
+import { ExperimentalModule } from './experimental/experimental.module';
+import { InfoModule } from './info/info.module';
+import { OrderModule } from './order/order.module';
+import { PortfolioModule } from './portfolio/portfolio.module';
+import { RedisCacheModule } from './redis-cache/redis-cache.module';
+import { SymbolModule } from './symbol/symbol.module';
+import { UserModule } from './user/user.module';
+
+@Module({
+  imports: [
+    AdminModule,
+    AccessModule,
+    AuthModule,
+    CacheModule,
+    ConfigModule.forRoot(),
+    ExperimentalModule,
+    InfoModule,
+    OrderModule,
+    PortfolioModule,
+    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');
+          }
+        }*/
+      },
+      rootPath: join(__dirname, '..', 'client'),
+      exclude: ['/api*']
+    }),
+    SymbolModule,
+    UserModule
+  ],
+  controllers: [AppController],
+  providers: [
+    AlphaVantageService,
+    CronService,
+    DataGatheringService,
+    DataProviderService,
+    ExchangeRateDataService,
+    PrismaService,
+    RakutenRapidApiService,
+    YahooFinanceService
+  ]
+})
+export class AppModule {}

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

@@ -0,0 +1,52 @@
+import {
+  Controller,
+  Get,
+  HttpException,
+  Param,
+  Req,
+  Res,
+  UseGuards
+} from '@nestjs/common';
+import { AuthGuard } from '@nestjs/passport';
+import { StatusCodes, getReasonPhrase } from 'http-status-codes';
+
+import { AuthService } from './auth.service';
+
+@Controller('auth')
+export class AuthController {
+  public constructor(private readonly authService: AuthService) {}
+
+  @Get('anonymous/:accessToken')
+  public async accessTokenLogin(@Param('accessToken') accessToken: string) {
+    try {
+      const authToken = await this.authService.validateAnonymousLogin(
+        accessToken
+      );
+      return { authToken };
+    } catch {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+  }
+
+  @Get('google')
+  @UseGuards(AuthGuard('google'))
+  public googleLogin() {
+    // Initiates the Google OAuth2 login flow
+  }
+
+  @Get('google/callback')
+  @UseGuards(AuthGuard('google'))
+  public googleLoginCallback(@Req() req, @Res() res) {
+    // Handles the Google OAuth2 callback
+    const jwt: string = req.user.jwt;
+
+    if (jwt) {
+      res.redirect(`${process.env.ROOT_URL}/auth/${jwt}`);
+    } else {
+      res.redirect(`${process.env.ROOT_URL}/auth`);
+    }
+  }
+}

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

@@ -0,0 +1,27 @@
+import { Module } from '@nestjs/common';
+import { JwtModule } from '@nestjs/jwt';
+
+import { PrismaService } from '../../services/prisma.service';
+import { UserService } from '../user/user.service';
+import { AuthController } from './auth.controller';
+import { AuthService } from './auth.service';
+import { GoogleStrategy } from './google.strategy';
+import { JwtStrategy } from './jwt.strategy';
+
+@Module({
+  controllers: [AuthController],
+  imports: [
+    JwtModule.register({
+      secret: process.env.JWT_SECRET_KEY,
+      signOptions: { expiresIn: '180 days' }
+    })
+  ],
+  providers: [
+    AuthService,
+    GoogleStrategy,
+    JwtStrategy,
+    PrismaService,
+    UserService
+  ]
+})
+export class AuthModule {}

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

@@ -0,0 +1,67 @@
+import { Injectable, InternalServerErrorException } from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+
+import { UserService } from '../user/user.service';
+import { ValidateOAuthLoginParams } from './interfaces/interfaces';
+
+@Injectable()
+export class AuthService {
+  public constructor(
+    private jwtService: JwtService,
+    private readonly userService: UserService
+  ) {}
+
+  public async validateAnonymousLogin(accessToken: string) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const hashedAccessToken = this.userService.createAccessToken(
+          accessToken,
+          process.env.ACCESS_TOKEN_SALT
+        );
+
+        const [user] = await this.userService.users({
+          where: { accessToken: hashedAccessToken }
+        });
+
+        if (user) {
+          const jwt: string = this.jwtService.sign({
+            id: user.id
+          });
+
+          resolve(jwt);
+        } else {
+          throw new Error();
+        }
+      } catch {
+        reject();
+      }
+    });
+  }
+
+  public async validateOAuthLogin({
+    provider,
+    thirdPartyId
+  }: ValidateOAuthLoginParams): Promise<string> {
+    try {
+      let [user] = await this.userService.users({
+        where: { provider, thirdPartyId }
+      });
+
+      if (!user) {
+        // Create new user if not found
+        user = await this.userService.createUser({
+          provider,
+          thirdPartyId
+        });
+      }
+
+      const jwt: string = this.jwtService.sign({
+        id: user.id
+      });
+
+      return jwt;
+    } catch (err) {
+      throw new InternalServerErrorException('validateOAuthLogin', err.message);
+    }
+  }
+}

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

@@ -0,0 +1,43 @@
+import { Injectable } from '@nestjs/common';
+import { PassportStrategy } from '@nestjs/passport';
+import { Provider } from '@prisma/client';
+import { Strategy } from 'passport-google-oauth20';
+
+import { AuthService } from './auth.service';
+
+@Injectable()
+export class GoogleStrategy extends PassportStrategy(Strategy, 'google') {
+  public constructor(private readonly authService: AuthService) {
+    super({
+      callbackURL: `${process.env.ROOT_URL}/api/auth/google/callback`,
+      clientID: process.env.GOOGLE_CLIENT_ID,
+      clientSecret: process.env.GOOGLE_SECRET,
+      passReqToCallback: true,
+      scope: ['email', 'profile']
+    });
+  }
+
+  public async validate(
+    request: any,
+    token: string,
+    refreshToken: string,
+    profile,
+    done: Function,
+    done2: Function
+  ) {
+    try {
+      const jwt: string = await this.authService.validateOAuthLogin({
+        provider: Provider.GOOGLE,
+        thirdPartyId: profile.id
+      });
+      const user = {
+        jwt
+      };
+
+      done(null, user);
+    } catch (err) {
+      console.error(err);
+      done(err, false);
+    }
+  }
+}

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

@@ -0,0 +1,6 @@
+import { Provider } from '@prisma/client';
+
+export interface ValidateOAuthLoginParams {
+  provider: Provider;
+  thirdPartyId: string;
+}

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

@@ -0,0 +1,39 @@
+import { Injectable, UnauthorizedException } from '@nestjs/common';
+import { PassportStrategy } from '@nestjs/passport';
+import { ExtractJwt, Strategy } from 'passport-jwt';
+
+import { PrismaService } from '../../services/prisma.service';
+import { UserService } from '../user/user.service';
+
+@Injectable()
+export class JwtStrategy extends PassportStrategy(Strategy, 'jwt') {
+  public constructor(
+    private prisma: PrismaService,
+    private readonly userService: UserService
+  ) {
+    super({
+      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+      secretOrKey: process.env.JWT_SECRET_KEY
+    });
+  }
+
+  public async validate({ id }: { id: string }) {
+    try {
+      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 }
+        });
+
+        return user;
+      } else {
+        throw '';
+      }
+    } catch (err) {
+      throw new UnauthorizedException('unauthorized', err.message);
+    }
+  }
+}

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

@@ -0,0 +1,26 @@
+import { Controller, Inject, Param, Post, UseGuards } from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
+import { AuthGuard } from '@nestjs/passport';
+import { RequestWithUser } from 'apps/api/src/app/interfaces/request-with-user.type';
+
+import { 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();
+  }
+
+  @Post('flush')
+  @UseGuards(AuthGuard('jwt'))
+  public async flushCache(): Promise<void> {
+    this.redisCacheService.reset();
+
+    return this.cacheService.flush(this.request.user.id);
+  }
+}

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

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+
+import { PrismaService } from '../../services/prisma.service';
+import { RedisCacheModule } from '../redis-cache/redis-cache.module';
+import { CacheController } from './cache.controller';
+import { CacheService } from './cache.service';
+
+@Module({
+  imports: [RedisCacheModule],
+  controllers: [CacheController],
+  providers: [CacheService, PrismaService]
+})
+export class CacheModule {}

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

@@ -0,0 +1,19 @@
+import { Injectable } from '@nestjs/common';
+import { Prisma, User } from '@prisma/client';
+
+import { PrismaService } from '../../services/prisma.service';
+
+@Injectable()
+export class CacheService {
+  public constructor(private prisma: PrismaService) {}
+
+  public 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/experimental/create-order.dto.ts

@@ -0,0 +1,22 @@
+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

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

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

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

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

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

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

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

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

@@ -0,0 +1,14 @@
+import { Controller, Get } 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()
+  public async getInfo(): Promise<InfoItem> {
+    return this.infoService.get();
+  }
+}

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

@@ -0,0 +1,18 @@
+import { Module } from '@nestjs/common';
+import { JwtModule } from '@nestjs/jwt';
+
+import { PrismaService } from '../../services/prisma.service';
+import { InfoController } from './info.controller';
+import { InfoService } from './info.service';
+
+@Module({
+  imports: [
+    JwtModule.register({
+      secret: process.env.JWT_SECRET_KEY,
+      signOptions: { expiresIn: '30 days' }
+    })
+  ],
+  controllers: [InfoController],
+  providers: [InfoService, PrismaService]
+})
+export class InfoModule {}

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

@@ -0,0 +1,44 @@
+import { Injectable } from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+import { Currency } from '@prisma/client';
+
+import { PrismaService } from '../../services/prisma.service';
+import { InfoItem } from './interfaces/info-item.interface';
+
+@Injectable()
+export class InfoService {
+  private static DEMO_USER_ID = '9b112b4d-3b7d-4bad-9bdd-3b0f7b4dac2f';
+
+  public constructor(
+    private jwtService: JwtService,
+    private prisma: PrismaService
+  ) {}
+
+  public async get(): Promise<InfoItem> {
+    const platforms = await this.prisma.platform.findMany({
+      orderBy: { name: 'asc' },
+      select: { id: true, name: true }
+    });
+
+    return {
+      platforms,
+      currencies: Object.values(Currency),
+      demoAuthToken: this.getDemoAuthToken(),
+      lastDataGathering: await this.getLastDataGathering()
+    };
+  }
+
+  private getDemoAuthToken() {
+    return this.jwtService.sign({
+      id: InfoService.DEMO_USER_ID
+    });
+  }
+
+  private async getLastDataGathering() {
+    const lastDataGathering = await this.prisma.property.findUnique({
+      where: { key: 'LAST_DATA_GATHERING' }
+    });
+
+    return lastDataGathering?.value ? new Date(lastDataGathering.value) : null;
+  }
+}

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

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

apps/api/src/app/interfaces/request-with-user.type.ts

@@ -0,0 +1,3 @@
+import { UserWithSettings } from './user-with-settings';
+
+export type RequestWithUser = Request & { user: UserWithSettings };

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

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

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

@@ -0,0 +1,29 @@
+import { Currency, Type } from '@prisma/client';
+import { IsISO8601, IsNumber, IsString, ValidateIf } from 'class-validator';
+
+export class CreateOrderDto {
+  @IsString()
+  currency: Currency;
+
+  @IsISO8601()
+  date: string;
+
+  @IsNumber()
+  fee: number;
+
+  @IsString()
+  @ValidateIf((object, value) => value !== null)
+  platformId: string | null;
+
+  @IsNumber()
+  quantity: number;
+
+  @IsString()
+  symbol: string;
+
+  @IsString()
+  type: Type;
+
+  @IsNumber()
+  unitPrice: number;
+}

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

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

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

@@ -0,0 +1,218 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Headers,
+  HttpException,
+  Inject,
+  Param,
+  Post,
+  Put,
+  UseGuards
+} from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
+import { AuthGuard } from '@nestjs/passport';
+import { Order as OrderModel } from '@prisma/client';
+import { RequestWithUser } from 'apps/api/src/app/interfaces/request-with-user.type';
+import { parseISO } from 'date-fns';
+import { StatusCodes, getReasonPhrase } from 'http-status-codes';
+import { getPermissions, hasPermission, permissions } from 'libs/helper/src';
+
+import { nullifyValuesInObjects } from '../../helper/object.helper';
+import { ImpersonationService } from '../../services/impersonation.service';
+import { CreateOrderDto } from './create-order.dto';
+import { OrderService } from './order.service';
+import { UpdateOrderDto } from './update-order.dto';
+
+@Controller('order')
+export class OrderController {
+  public constructor(
+    private readonly impersonationService: ImpersonationService,
+    private readonly orderService: OrderService,
+    @Inject(REQUEST) private readonly request: RequestWithUser
+  ) {}
+
+  @Delete(':id')
+  @UseGuards(AuthGuard('jwt'))
+  public async deleteOrder(@Param('id') id: string): Promise<OrderModel> {
+    if (
+      !hasPermission(
+        getPermissions(this.request.user.role),
+        permissions.deleteOrder
+      )
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    return this.orderService.deleteOrder(
+      {
+        id_userId: {
+          id,
+          userId: this.request.user.id
+        }
+      },
+      this.request.user.id
+    );
+  }
+
+  @Get()
+  @UseGuards(AuthGuard('jwt'))
+  public async getAllOrders(
+    @Headers('impersonation-id') impersonationId
+  ): Promise<OrderModel[]> {
+    const impersonationUserId = await this.impersonationService.validateImpersonationId(
+      impersonationId,
+      this.request.user.id
+    );
+
+    let orders = await this.orderService.orders({
+      include: {
+        Platform: true
+      },
+      orderBy: { date: 'desc' },
+      where: { userId: impersonationUserId || this.request.user.id }
+    });
+
+    if (
+      impersonationUserId &&
+      !hasPermission(
+        getPermissions(this.request.user.role),
+        permissions.readForeignPortfolio
+      )
+    ) {
+      orders = nullifyValuesInObjects(orders, ['fee', 'quantity', 'unitPrice']);
+    }
+
+    return orders;
+  }
+
+  @Get(':id')
+  @UseGuards(AuthGuard('jwt'))
+  public async getOrderById(@Param('id') id: string): Promise<OrderModel> {
+    return this.orderService.order({
+      id_userId: {
+        id,
+        userId: this.request.user.id
+      }
+    });
+  }
+
+  @Post()
+  @UseGuards(AuthGuard('jwt'))
+  public async createOrder(@Body() data: CreateOrderDto): Promise<OrderModel> {
+    if (
+      !hasPermission(
+        getPermissions(this.request.user.role),
+        permissions.createOrder
+      )
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    const date = parseISO(data.date);
+
+    if (data.platformId) {
+      const platformId = data.platformId;
+      delete data.platformId;
+
+      return this.orderService.createOrder(
+        {
+          ...data,
+          date,
+          Platform: { connect: { id: platformId } },
+          User: { connect: { id: this.request.user.id } }
+        },
+        this.request.user.id
+      );
+    } else {
+      delete data.platformId;
+
+      return this.orderService.createOrder(
+        {
+          ...data,
+          date,
+          User: { connect: { id: this.request.user.id } }
+        },
+        this.request.user.id
+      );
+    }
+  }
+
+  @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
+      }
+    });
+
+    const date = parseISO(data.date);
+
+    if (data.platformId) {
+      const platformId = data.platformId;
+      delete data.platformId;
+
+      return this.orderService.updateOrder(
+        {
+          data: {
+            ...data,
+            date,
+            Platform: { connect: { id: platformId } },
+            User: { connect: { id: this.request.user.id } }
+          },
+          where: {
+            id_userId: {
+              id,
+              userId: this.request.user.id
+            }
+          }
+        },
+        this.request.user.id
+      );
+    } else {
+      // platformId is null, remove it
+      delete data.platformId;
+
+      return this.orderService.updateOrder(
+        {
+          data: {
+            ...data,
+            date,
+            Platform: originalOrder.platformId
+              ? { disconnect: true }
+              : undefined,
+            User: { connect: { id: this.request.user.id } }
+          },
+          where: {
+            id_userId: {
+              id,
+              userId: this.request.user.id
+            }
+          }
+        },
+        this.request.user.id
+      );
+    }
+  }
+}

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

@@ -0,0 +1,30 @@
+import { Module } from '@nestjs/common';
+
+import { DataGatheringService } from '../../services/data-gathering.service';
+import { DataProviderService } from '../../services/data-provider.service';
+import { AlphaVantageService } from '../../services/data-provider/alpha-vantage/alpha-vantage.service';
+import { RakutenRapidApiService } from '../../services/data-provider/rakuten-rapid-api/rakuten-rapid-api.service';
+import { YahooFinanceService } from '../../services/data-provider/yahoo-finance/yahoo-finance.service';
+import { ImpersonationService } from '../../services/impersonation.service';
+import { PrismaService } from '../../services/prisma.service';
+import { CacheService } from '../cache/cache.service';
+import { RedisCacheModule } from '../redis-cache/redis-cache.module';
+import { OrderController } from './order.controller';
+import { OrderService } from './order.service';
+
+@Module({
+  imports: [RedisCacheModule],
+  controllers: [OrderController],
+  providers: [
+    AlphaVantageService,
+    CacheService,
+    DataGatheringService,
+    DataProviderService,
+    ImpersonationService,
+    OrderService,
+    PrismaService,
+    RakutenRapidApiService,
+    YahooFinanceService
+  ]
+})
+export class OrderModule {}

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

@@ -0,0 +1,105 @@
+import { Injectable } from '@nestjs/common';
+import { Order, Prisma } from '@prisma/client';
+
+import { DataGatheringService } from '../../services/data-gathering.service';
+import { PrismaService } from '../../services/prisma.service';
+import { CacheService } from '../cache/cache.service';
+import { RedisCacheService } from '../redis-cache/redis-cache.service';
+import { OrderWithPlatform } from './interfaces/order-with-platform.type';
+
+@Injectable()
+export class OrderService {
+  public constructor(
+    private readonly cacheService: CacheService,
+    private readonly dataGatheringService: DataGatheringService,
+    private readonly redisCacheService: RedisCacheService,
+    private prisma: PrismaService
+  ) {}
+
+  public async order(
+    orderWhereUniqueInput: Prisma.OrderWhereUniqueInput
+  ): Promise<Order | null> {
+    return this.prisma.order.findUnique({
+      where: orderWhereUniqueInput
+    });
+  }
+
+  public async orders(params: {
+    include?: Prisma.OrderInclude;
+    skip?: number;
+    take?: number;
+    cursor?: Prisma.OrderWhereUniqueInput;
+    where?: Prisma.OrderWhereInput;
+    orderBy?: Prisma.OrderOrderByInput;
+  }): Promise<OrderWithPlatform[]> {
+    const { include, skip, take, cursor, where, orderBy } = params;
+
+    return this.prisma.order.findMany({
+      cursor,
+      include,
+      orderBy,
+      skip,
+      take,
+      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

@@ -0,0 +1,32 @@
+import { Currency, Type } from '@prisma/client';
+import { IsISO8601, IsNumber, IsString, ValidateIf } from 'class-validator';
+
+export class UpdateOrderDto {
+  @IsString()
+  currency: Currency;
+
+  @IsISO8601()
+  date: string;
+
+  @IsNumber()
+  fee: number;
+
+  @IsString()
+  @ValidateIf((object, value) => value !== null)
+  platformId: string | null;
+
+  @IsString()
+  id: string;
+
+  @IsNumber()
+  quantity: number;
+
+  @IsString()
+  symbol: string;
+
+  @IsString()
+  type: Type;
+
+  @IsNumber()
+  unitPrice: number;
+}

apps/api/src/app/portfolio/interfaces/date-range.type.ts

@@ -0,0 +1 @@
+export type DateRange = '1d' | '1y' | '5y' | 'max' | 'ytd';

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

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

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

@@ -0,0 +1,7 @@
+export interface PortfolioOverview {
+  committedFunds: number;
+  fees: number;
+  ordersCount: number;
+  totalBuy: number;
+  totalSell: number;
+}

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

@@ -0,0 +1,7 @@
+export interface PortfolioPerformance {
+  currentGrossPerformance: number;
+  currentGrossPerformancePercent: number;
+  currentNetPerformance: number;
+  currentNetPerformancePercent: number;
+  currentValue: number;
+}

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

@@ -0,0 +1,21 @@
+export interface PortfolioPositionDetail {
+  averagePrice: number;
+  currency: string;
+  firstBuyDate: string;
+  grossPerformance: number;
+  grossPerformancePercent: number;
+  historicalData: HistoricalDataItem[];
+  investment: number;
+  marketPrice: number;
+  maxPrice: number;
+  minPrice: number;
+  quantity: number;
+  symbol: string;
+}
+
+export interface HistoricalDataItem {
+  averagePrice?: number;
+  date: string;
+  grossPerformancePercent?: number;
+  value: number;
+}

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

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

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

@@ -0,0 +1,9 @@
+export interface PortfolioReport {
+  rules: { [group: string]: PortfolioReportRule[] };
+}
+
+export interface PortfolioReportRule {
+  evaluation: string;
+  name: string;
+  value: boolean;
+}

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

@@ -0,0 +1,326 @@
+import {
+  Controller,
+  Get,
+  Headers,
+  HttpException,
+  Inject,
+  Param,
+  Query,
+  Res,
+  UseGuards
+} from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
+import { AuthGuard } from '@nestjs/passport';
+import { Response } from 'express';
+import { StatusCodes, getReasonPhrase } from 'http-status-codes';
+import { getPermissions, hasPermission, permissions } from 'libs/helper/src';
+
+import {
+  hasNotDefinedValuesInObject,
+  nullifyValuesInObject
+} from '../../helper/object.helper';
+import { ExchangeRateDataService } from '../../services/exchange-rate-data.service';
+import { ImpersonationService } from '../../services/impersonation.service';
+import { RequestWithUser } from '../interfaces/request-with-user.type';
+import { PortfolioItem } from './interfaces/portfolio-item.interface';
+import { PortfolioOverview } from './interfaces/portfolio-overview.interface';
+import { PortfolioPerformance } from './interfaces/portfolio-performance.interface';
+import {
+  HistoricalDataItem,
+  PortfolioPositionDetail
+} from './interfaces/portfolio-position-detail.interface';
+import { PortfolioPosition } from './interfaces/portfolio-position.interface';
+import { PortfolioReport } from './interfaces/portfolio-report.interface';
+import { PortfolioService } from './portfolio.service';
+
+@Controller('portfolio')
+export class PortfolioController {
+  public constructor(
+    private readonly exchangeRateDataService: ExchangeRateDataService,
+    private readonly impersonationService: ImpersonationService,
+    private portfolioService: PortfolioService,
+    @Inject(REQUEST) private readonly request: RequestWithUser
+  ) {}
+
+  @Get()
+  @UseGuards(AuthGuard('jwt'))
+  public async findAll(
+    @Headers('impersonation-id') impersonationId
+  ): Promise<PortfolioItem[]> {
+    let portfolio = await this.portfolioService.findAll(impersonationId);
+
+    if (
+      impersonationId &&
+      !hasPermission(
+        getPermissions(this.request.user.role),
+        permissions.readForeignPortfolio
+      )
+    ) {
+      portfolio = portfolio.map((portfolioItem) => {
+        Object.keys(portfolioItem.positions).forEach((symbol) => {
+          portfolioItem.positions[symbol].investment =
+            portfolioItem.positions[symbol].investment > 0 ? 1 : 0;
+          portfolioItem.positions[symbol].investmentInOriginalCurrency =
+            portfolioItem.positions[symbol].investmentInOriginalCurrency > 0
+              ? 1
+              : 0;
+          portfolioItem.positions[symbol].quantity =
+            portfolioItem.positions[symbol].quantity > 0 ? 1 : 0;
+        });
+
+        portfolioItem.investment = null;
+
+        return portfolioItem;
+      });
+    }
+
+    return portfolio;
+  }
+
+  @Get('chart')
+  @UseGuards(AuthGuard('jwt'))
+  public async getChart(
+    @Headers('impersonation-id') impersonationId,
+    @Query('range') range,
+    @Res() res: Response
+  ): Promise<HistoricalDataItem[]> {
+    let chartData = await this.portfolioService.getChart(
+      impersonationId,
+      range
+    );
+
+    let hasNullValue = false;
+
+    chartData.forEach((chartDataItem) => {
+      if (hasNotDefinedValuesInObject(chartDataItem)) {
+        hasNullValue = true;
+      }
+    });
+
+    if (hasNullValue) {
+      res.status(StatusCodes.ACCEPTED);
+    }
+
+    if (
+      impersonationId &&
+      !hasPermission(
+        getPermissions(this.request.user.role),
+        permissions.readForeignPortfolio
+      )
+    ) {
+      let maxValue = 0;
+
+      chartData.forEach((portfolioItem) => {
+        if (portfolioItem.value > maxValue) {
+          maxValue = portfolioItem.value;
+        }
+      });
+
+      chartData = chartData.map((historicalDataItem) => {
+        return {
+          ...historicalDataItem,
+          marketPrice: Number((historicalDataItem.value / maxValue).toFixed(2))
+        };
+      });
+    }
+
+    return <any>res.json(chartData);
+  }
+
+  @Get('details')
+  @UseGuards(AuthGuard('jwt'))
+  public async getDetails(
+    @Headers('impersonation-id') impersonationId,
+    @Query('range') range,
+    @Res() res: Response
+  ): Promise<{ [symbol: string]: PortfolioPosition }> {
+    let details: { [symbol: string]: PortfolioPosition } = {};
+
+    const impersonationUserId = await this.impersonationService.validateImpersonationId(
+      impersonationId,
+      this.request.user.id
+    );
+
+    const portfolio = await this.portfolioService.createPortfolio(
+      impersonationUserId || this.request.user.id
+    );
+
+    try {
+      details = await portfolio.getDetails(range);
+    } catch (error) {
+      console.error(error);
+
+      res.status(StatusCodes.ACCEPTED);
+    }
+
+    if (hasNotDefinedValuesInObject(details)) {
+      res.status(StatusCodes.ACCEPTED);
+    }
+
+    if (
+      impersonationId &&
+      !hasPermission(
+        getPermissions(this.request.user.role),
+        permissions.readForeignPortfolio
+      )
+    ) {
+      const totalInvestment = Object.values(details)
+        .map((portfolioPosition) => {
+          return portfolioPosition.investment;
+        })
+        .reduce((a, b) => a + b, 0);
+
+      const totalValue = Object.values(details)
+        .map((portfolioPosition) => {
+          return this.exchangeRateDataService.toCurrency(
+            portfolioPosition.quantity * portfolioPosition.marketPrice,
+            portfolioPosition.currency,
+            this.request.user.Settings.currency
+          );
+        })
+        .reduce((a, b) => a + b, 0);
+
+      for (const [symbol, portfolioPosition] of Object.entries(details)) {
+        portfolioPosition.grossPerformance = null;
+        portfolioPosition.investment =
+          portfolioPosition.investment / totalInvestment;
+
+        for (const [platform, { current, original }] of Object.entries(
+          portfolioPosition.platforms
+        )) {
+          portfolioPosition.platforms[platform].current = current / totalValue;
+          portfolioPosition.platforms[platform].original =
+            original / totalInvestment;
+        }
+
+        portfolioPosition.quantity = null;
+      }
+    }
+
+    return <any>res.json(details);
+  }
+
+  @Get('overview')
+  @UseGuards(AuthGuard('jwt'))
+  public async getOverview(
+    @Headers('impersonation-id') impersonationId
+  ): Promise<PortfolioOverview> {
+    let overview = await this.portfolioService.getOverview(impersonationId);
+
+    if (
+      impersonationId &&
+      !hasPermission(
+        getPermissions(this.request.user.role),
+        permissions.readForeignPortfolio
+      )
+    ) {
+      overview = nullifyValuesInObject(overview, [
+        'committedFunds',
+        'fees',
+        'totalBuy',
+        'totalSell'
+      ]);
+    }
+
+    return overview;
+  }
+
+  @Get('performance')
+  @UseGuards(AuthGuard('jwt'))
+  public async getPerformance(
+    @Headers('impersonation-id') impersonationId,
+    @Query('range') range,
+    @Res() res: Response
+  ): Promise<PortfolioPerformance> {
+    const impersonationUserId = await this.impersonationService.validateImpersonationId(
+      impersonationId,
+      this.request.user.id
+    );
+
+    const portfolio = await this.portfolioService.createPortfolio(
+      impersonationUserId || this.request.user.id
+    );
+
+    let performance = await portfolio.getPerformance(range);
+
+    if (hasNotDefinedValuesInObject(performance)) {
+      res.status(StatusCodes.ACCEPTED);
+    }
+
+    if (
+      impersonationId &&
+      !hasPermission(
+        getPermissions(this.request.user.role),
+        permissions.readForeignPortfolio
+      )
+    ) {
+      performance = nullifyValuesInObject(performance, [
+        'currentGrossPerformance',
+        'currentNetPerformance',
+        'currentValue'
+      ]);
+    }
+
+    return <any>res.json(performance);
+  }
+
+  @Get('position/:symbol')
+  @UseGuards(AuthGuard('jwt'))
+  public async getPosition(
+    @Headers('impersonation-id') impersonationId,
+    @Param('symbol') symbol
+  ): Promise<PortfolioPositionDetail> {
+    let position = await this.portfolioService.getPosition(
+      impersonationId,
+      symbol
+    );
+
+    if (position) {
+      if (
+        impersonationId &&
+        !hasPermission(
+          getPermissions(this.request.user.role),
+          permissions.readForeignPortfolio
+        )
+      ) {
+        position = nullifyValuesInObject(position, ['grossPerformance']);
+      }
+
+      return position;
+    }
+
+    throw new HttpException(
+      getReasonPhrase(StatusCodes.NOT_FOUND),
+      StatusCodes.NOT_FOUND
+    );
+  }
+
+  @Get('report')
+  @UseGuards(AuthGuard('jwt'))
+  public async getReport(
+    @Headers('impersonation-id') impersonationId
+  ): Promise<PortfolioReport> {
+    const impersonationUserId = await this.impersonationService.validateImpersonationId(
+      impersonationId,
+      this.request.user.id
+    );
+
+    const portfolio = await this.portfolioService.createPortfolio(
+      impersonationUserId || this.request.user.id
+    );
+
+    let report = await portfolio.getReport();
+
+    if (
+      impersonationId &&
+      !hasPermission(
+        getPermissions(this.request.user.role),
+        permissions.readForeignPortfolio
+      )
+    ) {
+      // TODO: Filter out absolute numbers
+    }
+
+    return report;
+  }
+}

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

@@ -0,0 +1,38 @@
+import { Module } from '@nestjs/common';
+
+import { DataGatheringService } from '../../services/data-gathering.service';
+import { DataProviderService } from '../../services/data-provider.service';
+import { AlphaVantageService } from '../../services/data-provider/alpha-vantage/alpha-vantage.service';
+import { RakutenRapidApiService } from '../../services/data-provider/rakuten-rapid-api/rakuten-rapid-api.service';
+import { YahooFinanceService } from '../../services/data-provider/yahoo-finance/yahoo-finance.service';
+import { ExchangeRateDataService } from '../../services/exchange-rate-data.service';
+import { ImpersonationService } from '../../services/impersonation.service';
+import { PrismaService } from '../../services/prisma.service';
+import { RulesService } from '../../services/rules.service';
+import { CacheService } from '../cache/cache.service';
+import { OrderService } from '../order/order.service';
+import { RedisCacheModule } from '../redis-cache/redis-cache.module';
+import { UserService } from '../user/user.service';
+import { PortfolioController } from './portfolio.controller';
+import { PortfolioService } from './portfolio.service';
+
+@Module({
+  imports: [RedisCacheModule],
+  controllers: [PortfolioController],
+  providers: [
+    AlphaVantageService,
+    CacheService,
+    DataGatheringService,
+    DataProviderService,
+    ExchangeRateDataService,
+    ImpersonationService,
+    OrderService,
+    PortfolioService,
+    PrismaService,
+    RakutenRapidApiService,
+    RulesService,
+    UserService,
+    YahooFinanceService
+  ]
+})
+export class PortfolioModule {}

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

@@ -0,0 +1,385 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
+import { RequestWithUser } from 'apps/api/src/app/interfaces/request-with-user.type';
+import {
+  add,
+  format,
+  getDate,
+  getMonth,
+  getYear,
+  isAfter,
+  isSameDay,
+  parse,
+  parseISO,
+  setDate,
+  setMonth,
+  sub
+} from 'date-fns';
+import { isEmpty } from 'lodash';
+import * as roundTo from 'round-to';
+
+import { Portfolio } from '../../models/portfolio';
+import { DataProviderService } from '../../services/data-provider.service';
+import { ExchangeRateDataService } from '../../services/exchange-rate-data.service';
+import { ImpersonationService } from '../../services/impersonation.service';
+import { IOrder } from '../../services/interfaces/interfaces';
+import { RulesService } from '../../services/rules.service';
+import { OrderService } from '../order/order.service';
+import { RedisCacheService } from '../redis-cache/redis-cache.service';
+import { UserService } from '../user/user.service';
+import { DateRange } from './interfaces/date-range.type';
+import { PortfolioItem } from './interfaces/portfolio-item.interface';
+import { PortfolioOverview } from './interfaces/portfolio-overview.interface';
+import {
+  HistoricalDataItem,
+  PortfolioPositionDetail
+} from './interfaces/portfolio-position-detail.interface';
+
+@Injectable()
+export class PortfolioService {
+  public constructor(
+    private readonly dataProviderService: DataProviderService,
+    private readonly exchangeRateDataService: ExchangeRateDataService,
+    private readonly impersonationService: ImpersonationService,
+    private readonly orderService: OrderService,
+    private readonly redisCacheService: RedisCacheService,
+    @Inject(REQUEST) private readonly request: RequestWithUser,
+    private readonly rulesService: RulesService,
+    private readonly userService: UserService
+  ) {}
+
+  private convertDateRangeToDate(aDateRange: DateRange, aMinDate: Date) {
+    let currentDate = new Date();
+
+    const normalizedMinDate =
+      getDate(aMinDate) === 1
+        ? aMinDate
+        : add(setDate(aMinDate, 1), { months: 1 });
+
+    const year = getYear(currentDate);
+    const month = getMonth(currentDate);
+    const day = getDate(currentDate);
+
+    currentDate = new Date(Date.UTC(year, month, day, 0));
+
+    switch (aDateRange) {
+      case '1d':
+        return sub(currentDate, {
+          days: 1
+        });
+      case 'ytd':
+        currentDate = setDate(currentDate, 1);
+        currentDate = setMonth(currentDate, 0);
+        return isAfter(currentDate, normalizedMinDate)
+          ? currentDate
+          : undefined;
+      case '1y':
+        currentDate = setDate(currentDate, 1);
+        currentDate = sub(currentDate, {
+          years: 1
+        });
+        return isAfter(currentDate, normalizedMinDate)
+          ? currentDate
+          : undefined;
+      case '5y':
+        currentDate = setDate(currentDate, 1);
+        currentDate = sub(currentDate, {
+          years: 5
+        });
+        return isAfter(currentDate, normalizedMinDate)
+          ? currentDate
+          : undefined;
+      default:
+        // Gets handled as all data
+        return undefined;
+    }
+  }
+
+  public async createPortfolio(aUserId: string): Promise<Portfolio> {
+    let portfolio: Portfolio;
+    let stringifiedPortfolio = await this.redisCacheService.get(
+      `${aUserId}.portfolio`
+    );
+
+    const user = await this.userService.user({ id: aUserId });
+
+    if (stringifiedPortfolio) {
+      // Get portfolio from redis
+      const {
+        orders,
+        portfolioItems
+      }: { orders: IOrder[]; portfolioItems: PortfolioItem[] } = JSON.parse(
+        stringifiedPortfolio
+      );
+
+      portfolio = new Portfolio(
+        this.dataProviderService,
+        this.exchangeRateDataService,
+        this.rulesService
+      ).createFromData({ orders, portfolioItems, user });
+    } else {
+      // Get portfolio from database
+      const orders = await this.orderService.orders({
+        include: {
+          Platform: true
+        },
+        orderBy: { date: 'asc' },
+        where: { userId: aUserId }
+      });
+
+      portfolio = new Portfolio(
+        this.dataProviderService,
+        this.exchangeRateDataService,
+        this.rulesService
+      );
+      portfolio.setUser(user);
+      await portfolio.setOrders(orders);
+
+      // Cache data for the next time...
+      const portfolioData = {
+        orders: portfolio.getOrders(),
+        portfolioItems: portfolio.getPortfolioItems()
+      };
+
+      await this.redisCacheService.set(
+        `${aUserId}.portfolio`,
+        JSON.stringify(portfolioData)
+      );
+    }
+
+    // Enrich portfolio with current data
+    return await portfolio.addCurrentPortfolioItems();
+  }
+
+  public async findAll(aImpersonationId: string): Promise<PortfolioItem[]> {
+    try {
+      const impersonationUserId = await this.impersonationService.validateImpersonationId(
+        aImpersonationId,
+        this.request.user.id
+      );
+
+      const portfolio = await this.createPortfolio(
+        impersonationUserId || this.request.user.id
+      );
+      return portfolio.get();
+    } catch (error) {
+      console.error(error);
+    }
+  }
+
+  public async getChart(
+    aImpersonationId: string,
+    aDateRange: DateRange = 'max'
+  ): Promise<HistoricalDataItem[]> {
+    const impersonationUserId = await this.impersonationService.validateImpersonationId(
+      aImpersonationId,
+      this.request.user.id
+    );
+
+    const portfolio = await this.createPortfolio(
+      impersonationUserId || this.request.user.id
+    );
+
+    if (portfolio.getOrders().length <= 0) {
+      return [];
+    }
+
+    const dateRangeDate = this.convertDateRangeToDate(
+      aDateRange,
+      portfolio.getMinDate()
+    );
+
+    return portfolio
+      .get()
+      .filter((portfolioItem) => {
+        if (dateRangeDate === undefined) {
+          return true;
+        }
+
+        return (
+          isSameDay(parseISO(portfolioItem.date), dateRangeDate) ||
+          isAfter(parseISO(portfolioItem.date), dateRangeDate)
+        );
+      })
+      .map((portfolioItem) => {
+        return {
+          date: format(parseISO(portfolioItem.date), 'yyyy-MM-dd'),
+          grossPerformancePercent: portfolioItem.grossPerformancePercent,
+          marketPrice: portfolioItem.value || null,
+          value: portfolioItem.value || null
+        };
+      });
+  }
+
+  public async getOverview(
+    aImpersonationId: string
+  ): Promise<PortfolioOverview> {
+    const impersonationUserId = await this.impersonationService.validateImpersonationId(
+      aImpersonationId,
+      this.request.user.id
+    );
+
+    const portfolio = await this.createPortfolio(
+      impersonationUserId || this.request.user.id
+    );
+
+    const committedFunds = portfolio.getCommittedFunds();
+    const fees = portfolio.getFees();
+
+    return {
+      committedFunds,
+      fees,
+      ordersCount: portfolio.getOrders().length,
+      totalBuy: portfolio.getTotalBuy(),
+      totalSell: portfolio.getTotalSell()
+    };
+  }
+
+  public async getPosition(
+    aImpersonationId: string,
+    aSymbol: string
+  ): Promise<PortfolioPositionDetail> {
+    const impersonationUserId = await this.impersonationService.validateImpersonationId(
+      aImpersonationId,
+      this.request.user.id
+    );
+
+    const portfolio = await this.createPortfolio(
+      impersonationUserId || this.request.user.id
+    );
+
+    const positions = portfolio.getPositions(new Date())[aSymbol];
+
+    if (positions) {
+      let {
+        averagePrice,
+        currency,
+        firstBuyDate,
+        investment,
+        marketPrice,
+        quantity
+      } = portfolio.getPositions(new Date())[aSymbol];
+
+      const historicalData = await this.dataProviderService.getHistorical(
+        [aSymbol],
+        'day',
+        parseISO(firstBuyDate),
+        new Date()
+      );
+
+      if (marketPrice === 0) {
+        marketPrice = averagePrice;
+      }
+
+      const historicalDataArray: HistoricalDataItem[] = [];
+      let maxPrice = marketPrice;
+      let minPrice = marketPrice;
+
+      if (historicalData[aSymbol]) {
+        for (const [date, { marketPrice }] of Object.entries(
+          historicalData[aSymbol]
+        )) {
+          historicalDataArray.push({
+            averagePrice,
+            date,
+            value: marketPrice
+          });
+
+          if (
+            marketPrice &&
+            (marketPrice > maxPrice || maxPrice === undefined)
+          ) {
+            maxPrice = marketPrice;
+          }
+
+          if (
+            marketPrice &&
+            (marketPrice < minPrice || minPrice === undefined)
+          ) {
+            minPrice = marketPrice;
+          }
+        }
+      }
+
+      return {
+        averagePrice,
+        currency,
+        firstBuyDate,
+        investment,
+        marketPrice,
+        maxPrice,
+        minPrice,
+        quantity,
+        grossPerformance: this.exchangeRateDataService.toCurrency(
+          marketPrice - averagePrice,
+          currency,
+          this.request.user.Settings.currency
+        ),
+        grossPerformancePercent: roundTo(
+          (marketPrice - averagePrice) / averagePrice,
+          4
+        ),
+        historicalData: historicalDataArray,
+        symbol: aSymbol
+      };
+    } else if (portfolio.getMinDate()) {
+      const currentData = await this.dataProviderService.get([aSymbol]);
+
+      let historicalData = await this.dataProviderService.getHistorical(
+        [aSymbol],
+        'day',
+        portfolio.getMinDate(),
+        new Date()
+      );
+
+      if (isEmpty(historicalData)) {
+        historicalData = await this.dataProviderService.getHistoricalRaw(
+          [aSymbol],
+          portfolio.getMinDate(),
+          new Date()
+        );
+      }
+
+      const historicalDataArray: HistoricalDataItem[] = [];
+
+      for (const [date, { marketPrice, performance }] of Object.entries(
+        historicalData[aSymbol]
+      ).reverse()) {
+        historicalDataArray.push({
+          date,
+          value: marketPrice
+        });
+      }
+
+      return {
+        averagePrice: undefined,
+        currency: currentData[aSymbol].currency,
+        firstBuyDate: undefined,
+        grossPerformance: undefined,
+        grossPerformancePercent: undefined,
+        historicalData: historicalDataArray,
+        investment: undefined,
+        marketPrice: currentData[aSymbol].marketPrice,
+        maxPrice: undefined,
+        minPrice: undefined,
+        quantity: undefined,
+        symbol: aSymbol
+      };
+    }
+
+    return {
+      averagePrice: undefined,
+      currency: undefined,
+      firstBuyDate: undefined,
+      grossPerformance: undefined,
+      grossPerformancePercent: undefined,
+      historicalData: [],
+      investment: undefined,
+      marketPrice: undefined,
+      maxPrice: undefined,
+      minPrice: undefined,
+      quantity: undefined,
+      symbol: aSymbol
+    };
+  }
+}

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

@@ -0,0 +1,24 @@
+import { CacheModule, Module } from '@nestjs/common';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import * as redisStore from 'cache-manager-redis-store';
+
+import { RedisCacheService } from './redis-cache.service';
+
+@Module({
+  imports: [
+    CacheModule.registerAsync({
+      imports: [ConfigModule],
+      inject: [ConfigService],
+      useFactory: async (configService: ConfigService) => ({
+        host: configService.get('REDIS_HOST'),
+        max: configService.get('MAX_ITEM_IN_CACHE'),
+        port: configService.get('REDIS_PORT'),
+        store: redisStore,
+        ttl: configService.get('CACHE_TTL')
+      })
+    })
+  ],
+  providers: [RedisCacheService],
+  exports: [RedisCacheService]
+})
+export class RedisCacheModule {}

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

@@ -0,0 +1,23 @@
+import { CACHE_MANAGER, Inject, Injectable } from '@nestjs/common';
+import { Cache } from 'cache-manager';
+
+@Injectable()
+export class RedisCacheService {
+  public constructor(@Inject(CACHE_MANAGER) private readonly cache: Cache) {}
+
+  public async get(key: string): Promise<string> {
+    return await this.cache.get(key);
+  }
+
+  public async remove(key: string) {
+    await this.cache.del(key);
+  }
+
+  public async reset() {
+    await this.cache.reset();
+  }
+
+  public async set(key: string, value: string) {
+    await this.cache.set(key, value, { ttl: Number(process.env.CACHE_TTL) });
+  }
+}

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

@@ -0,0 +1,4 @@
+export interface LookupItem {
+  name: string;
+  symbol: string;
+}

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

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

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

@@ -0,0 +1,50 @@
+import {
+  Controller,
+  Get,
+  HttpException,
+  Inject,
+  Param,
+  Query,
+  UseGuards
+} from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
+import { AuthGuard } from '@nestjs/passport';
+import { RequestWithUser } from 'apps/api/src/app/interfaces/request-with-user.type';
+import { StatusCodes, getReasonPhrase } from 'http-status-codes';
+
+import { LookupItem } from './interfaces/lookup-item.interface';
+import { SymbolItem } from './interfaces/symbol-item.interface';
+import { SymbolService } from './symbol.service';
+
+@Controller('symbol')
+export class SymbolController {
+  public constructor(
+    private readonly symbolService: SymbolService,
+    @Inject(REQUEST) private readonly request: RequestWithUser
+  ) {}
+
+  /**
+   * Must be before /:symbol
+   */
+  @Get('lookup')
+  @UseGuards(AuthGuard('jwt'))
+  public async lookupSymbol(@Query() { query }): Promise<LookupItem[]> {
+    try {
+      return this.symbolService.lookup(query);
+    } catch {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.INTERNAL_SERVER_ERROR),
+        StatusCodes.INTERNAL_SERVER_ERROR
+      );
+    }
+  }
+
+  /**
+   * Must be after /lookup
+   */
+  @Get(':symbol')
+  @UseGuards(AuthGuard('jwt'))
+  public async getPosition(@Param('symbol') symbol): Promise<SymbolItem> {
+    return this.symbolService.get(symbol);
+  }
+}

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

@@ -0,0 +1,23 @@
+import { Module } from '@nestjs/common';
+
+import { DataProviderService } from '../../services/data-provider.service';
+import { AlphaVantageService } from '../../services/data-provider/alpha-vantage/alpha-vantage.service';
+import { RakutenRapidApiService } from '../../services/data-provider/rakuten-rapid-api/rakuten-rapid-api.service';
+import { YahooFinanceService } from '../../services/data-provider/yahoo-finance/yahoo-finance.service';
+import { PrismaService } from '../../services/prisma.service';
+import { SymbolController } from './symbol.controller';
+import { SymbolService } from './symbol.service';
+
+@Module({
+  imports: [],
+  controllers: [SymbolController],
+  providers: [
+    AlphaVantageService,
+    DataProviderService,
+    PrismaService,
+    RakutenRapidApiService,
+    SymbolService,
+    YahooFinanceService
+  ]
+})
+export class SymbolModule {}

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

@@ -0,0 +1,68 @@
+import { Injectable } from '@nestjs/common';
+import { Currency } from '@prisma/client';
+import { convertFromYahooSymbol } from 'apps/api/src/services/data-provider/yahoo-finance/yahoo-finance.service';
+import * as bent from 'bent';
+
+import { DataProviderService } from '../../services/data-provider.service';
+import { LookupItem } from './interfaces/lookup-item.interface';
+import { SymbolItem } from './interfaces/symbol-item.interface';
+
+@Injectable()
+export class SymbolService {
+  public constructor(
+    private readonly dataProviderService: DataProviderService
+  ) {}
+
+  public async get(aSymbol: string): Promise<SymbolItem> {
+    const response = await this.dataProviderService.get([aSymbol]);
+    const { currency, marketPrice } = response[aSymbol];
+
+    return {
+      marketPrice,
+      currency: <Currency>(<unknown>currency)
+    };
+  }
+
+  public async lookup(aQuery: string): Promise<LookupItem[]> {
+    const get = bent(
+      `https://query1.finance.yahoo.com/v1/finance/search?q=${aQuery}&lang=en-US&region=US&quotesCount=8&newsCount=0&enableFuzzyQuery=false&quotesQueryId=tss_match_phrase_query&multiQuoteQueryId=multi_quote_single_token_query&newsQueryId=news_cie_vespa&enableCb=true&enableNavLinks=false&enableEnhancedTrivialQuery=true`,
+      'GET',
+      'json',
+      200
+    );
+
+    try {
+      const { quotes } = await get();
+
+      return quotes
+        .filter(({ isYahooFinance }) => {
+          return isYahooFinance;
+        })
+        .filter(({ quoteType }) => {
+          return (
+            quoteType === 'CRYPTOCURRENCY' ||
+            quoteType === 'EQUITY' ||
+            quoteType === 'ETF'
+          );
+        })
+        .filter(({ quoteType, symbol }) => {
+          if (quoteType === 'CRYPTOCURRENCY') {
+            // Only allow cryptocurrencies in USD
+            return symbol.includes('USD');
+          }
+
+          return true;
+        })
+        .map(({ longname, shortname, symbol }) => {
+          return {
+            name: longname || shortname,
+            symbol: convertFromYahooSymbol(symbol)
+          };
+        });
+    } catch (error) {
+      console.error(error);
+
+      throw error;
+    }
+  }
+}

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

@@ -0,0 +1,4 @@
+export interface Access {
+  alias?: string;
+  id: string;
+}

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

@@ -0,0 +1,4 @@
+export interface UserItem {
+  accessToken?: string;
+  authToken: string;
+}

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

@@ -0,0 +1,20 @@
+import { Currency } from '@prisma/client';
+
+import { Access } from './access.interface';
+
+export interface User {
+  access: Access[];
+  alias?: string;
+  id: string;
+  permissions: string[];
+  settings: UserSettings;
+  subscription: {
+    expiresAt: Date;
+    type: 'Diamond';
+  };
+}
+
+export interface UserSettings {
+  baseCurrency: Currency;
+  locale: string;
+}

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

@@ -0,0 +1,7 @@
+import { Currency } from '@prisma/client';
+import { IsString } from 'class-validator';
+
+export class UpdateUserSettingsDto {
+  @IsString()
+  currency: Currency;
+}

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

@@ -0,0 +1,73 @@
+import {
+  Body,
+  Controller,
+  Get,
+  HttpException,
+  Inject,
+  Param,
+  Post,
+  Put,
+  UseGuards
+} from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
+import { JwtService } from '@nestjs/jwt';
+import { AuthGuard } from '@nestjs/passport';
+import { Provider } from '@prisma/client';
+import { RequestWithUser } from 'apps/api/src/app/interfaces/request-with-user.type';
+import { StatusCodes, getReasonPhrase } from 'http-status-codes';
+import { getPermissions, hasPermission, permissions } from 'libs/helper/src';
+
+import { UserItem } from './interfaces/user-item.interface';
+import { User } from './interfaces/user.interface';
+import { UpdateUserSettingsDto } from './update-user-settings.dto';
+import { UserService } from './user.service';
+
+@Controller('user')
+export class UserController {
+  public constructor(
+    private jwtService: JwtService,
+    @Inject(REQUEST) private readonly request: RequestWithUser,
+    private readonly userService: UserService
+  ) {}
+
+  @Get()
+  @UseGuards(AuthGuard('jwt'))
+  public async getUser(@Param('id') id: string): Promise<User> {
+    return this.userService.getUser(this.request.user);
+  }
+
+  @Post()
+  public async signupUser(): Promise<UserItem> {
+    const { accessToken, id } = await this.userService.createUser({
+      provider: Provider.ANONYMOUS
+    });
+
+    return {
+      accessToken,
+      authToken: this.jwtService.sign({
+        id
+      })
+    };
+  }
+
+  @Put('settings')
+  @UseGuards(AuthGuard('jwt'))
+  public async updateUserSettings(@Body() data: UpdateUserSettingsDto) {
+    if (
+      !hasPermission(
+        getPermissions(this.request.user.role),
+        permissions.updateUserSettings
+      )
+    ) {
+      throw new HttpException(
+        getReasonPhrase(StatusCodes.FORBIDDEN),
+        StatusCodes.FORBIDDEN
+      );
+    }
+
+    return await this.userService.updateUserSettings({
+      currency: data.currency,
+      userId: this.request.user.id
+    });
+  }
+}

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

@@ -0,0 +1,18 @@
+import { Module } from '@nestjs/common';
+import { JwtModule } from '@nestjs/jwt';
+
+import { PrismaService } from '../../services/prisma.service';
+import { UserController } from './user.controller';
+import { UserService } from './user.service';
+
+@Module({
+  imports: [
+    JwtModule.register({
+      secret: process.env.JWT_SECRET_KEY,
+      signOptions: { expiresIn: '30 days' }
+    })
+  ],
+  controllers: [UserController],
+  providers: [PrismaService, UserService]
+})
+export class UserModule {}

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

@@ -0,0 +1,185 @@
+import { Injectable } from '@nestjs/common';
+import { Currency, Prisma, Provider, User } from '@prisma/client';
+import { add } from 'date-fns';
+import { locale, resetHours } from 'libs/helper/src';
+import { getPermissions } from 'libs/helper/src';
+
+import { PrismaService } from '../../services/prisma.service';
+import { UserWithSettings } from '../interfaces/user-with-settings';
+import { User as IUser } from './interfaces/user.interface';
+
+const crypto = require('crypto');
+
+@Injectable()
+export class UserService {
+  public static DEFAULT_CURRENCY = Currency.USD;
+
+  public constructor(private prisma: PrismaService) {}
+
+  public async getUser({
+    alias,
+    id,
+    role,
+    Settings
+  }: UserWithSettings): Promise<IUser> {
+    const access = await this.prisma.access.findMany({
+      include: {
+        User: true
+      },
+      orderBy: { User: { alias: 'asc' } },
+      where: { GranteeUser: { id } }
+    });
+
+    return {
+      alias,
+      id,
+      access: access.map((accessItem) => {
+        return {
+          alias: accessItem.User.alias,
+          id: accessItem.id
+        };
+      }),
+      permissions: getPermissions(role),
+      settings: {
+        baseCurrency: Settings?.currency || UserService.DEFAULT_CURRENCY,
+        locale
+      },
+      subscription: {
+        expiresAt: resetHours(add(new Date(), { days: 7 })),
+        type: 'Diamond'
+      }
+    };
+  }
+
+  public async user(
+    userWhereUniqueInput: Prisma.UserWhereUniqueInput
+  ): Promise<UserWithSettings | null> {
+    const user = await this.prisma.user.findUnique({
+      include: { Settings: true },
+      where: userWhereUniqueInput
+    });
+
+    if (user?.Settings) {
+      if (!user.Settings.currency) {
+        // Set default currency if needed
+        user.Settings.currency = UserService.DEFAULT_CURRENCY;
+      }
+    } else if (user) {
+      // Set default settings if needed
+      user.Settings = {
+        currency: UserService.DEFAULT_CURRENCY,
+        updatedAt: new Date(),
+        userId: user?.id
+      };
+    }
+
+    return user;
+  }
+
+  public async users(params: {
+    skip?: number;
+    take?: number;
+    cursor?: Prisma.UserWhereUniqueInput;
+    where?: Prisma.UserWhereInput;
+    orderBy?: Prisma.UserOrderByInput;
+  }): Promise<User[]> {
+    const { skip, take, cursor, where, orderBy } = params;
+    return this.prisma.user.findMany({
+      skip,
+      take,
+      cursor,
+      where,
+      orderBy
+    });
+  }
+
+  public createAccessToken(password: string, salt: string): string {
+    const hash = crypto.createHmac('sha512', salt);
+    hash.update(password);
+
+    return hash.digest('hex');
+  }
+
+  public async createUser(data?: Prisma.UserCreateInput): Promise<User> {
+    let user = await this.prisma.user.create({
+      data
+    });
+
+    if (data.provider === Provider.ANONYMOUS) {
+      const accessToken = this.createAccessToken(
+        user.id,
+        this.getRandomString(10)
+      );
+
+      const hashedAccessToken = this.createAccessToken(
+        accessToken,
+        process.env.ACCESS_TOKEN_SALT
+      );
+
+      user = await this.prisma.user.update({
+        data: { accessToken: hashedAccessToken },
+        where: { id: user.id }
+      });
+
+      return { ...user, accessToken };
+    }
+
+    return user;
+  }
+
+  public async updateUser(params: {
+    where: Prisma.UserWhereUniqueInput;
+    data: Prisma.UserUpdateInput;
+  }): Promise<User> {
+    const { where, data } = params;
+    return this.prisma.user.update({
+      data,
+      where
+    });
+  }
+
+  public async deleteUser(where: Prisma.UserWhereUniqueInput): Promise<User> {
+    return this.prisma.user.delete({
+      where
+    });
+  }
+
+  private getRandomString(length: number) {
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+    const result = [];
+
+    for (let i = 0; i < length; i++) {
+      result.push(
+        characters.charAt(Math.floor(Math.random() * characters.length))
+      );
+    }
+    return result.join('');
+  }
+
+  public async updateUserSettings({
+    currency,
+    userId
+  }: {
+    currency: Currency;
+    userId: string;
+  }) {
+    await this.prisma.settings.upsert({
+      create: {
+        currency,
+        User: {
+          connect: {
+            id: userId
+          }
+        }
+      },
+      update: {
+        currency
+      },
+      where: {
+        userId: userId
+      }
+    });
+
+    return;
+  }
+}

apps/api/src/environments/environment.prod.ts

@@ -0,0 +1,3 @@
+export const environment = {
+  production: true
+};

apps/api/src/environments/environment.ts

@@ -0,0 +1,3 @@
+export const environment = {
+  production: false
+};

apps/api/src/helper/object.helper.ts

@@ -0,0 +1,29 @@
+import { cloneDeep, isObject } from 'lodash';
+
+export function hasNotDefinedValuesInObject(aObject: Object): boolean {
+  for (const key in aObject) {
+    if (aObject[key] === null || aObject[key] === null) {
+      return true;
+    } else if (isObject(aObject[key])) {
+      return hasNotDefinedValuesInObject(aObject[key]);
+    }
+  }
+
+  return false;
+}
+
+export function nullifyValuesInObject<T>(aObject: T, keys: string[]): T {
+  const object = cloneDeep(aObject);
+
+  keys.forEach((key) => {
+    object[key] = null;
+  });
+
+  return object;
+}
+
+export function nullifyValuesInObjects<T>(aObjects: T[], keys: string[]): T[] {
+  return aObjects.map((object) => {
+    return nullifyValuesInObject(object, keys);
+  });
+}

apps/api/src/main.ts

@@ -0,0 +1,25 @@
+import { Logger, ValidationPipe } from '@nestjs/common';
+import { NestFactory } from '@nestjs/core';
+
+import { AppModule } from './app/app.module';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  app.enableCors();
+  const globalPrefix = 'api';
+  app.setGlobalPrefix(globalPrefix);
+  app.useGlobalPipes(
+    new ValidationPipe({
+      forbidNonWhitelisted: true,
+      transform: true,
+      whitelist: true
+    })
+  );
+
+  const port = process.env.PORT || 3333;
+  await app.listen(port, () => {
+    Logger.log(`Listening at http://localhost:${port}`);
+  });
+}
+
+bootstrap();

apps/api/src/models/interfaces/evaluation-result.interface.ts

@@ -0,0 +1,4 @@
+export interface EvaluationResult {
+  evaluation: string;
+  value: boolean;
+}

apps/api/src/models/interfaces/portfolio.interface.ts

@@ -0,0 +1,30 @@
+import {
+  PortfolioItem,
+  Position
+} from 'apps/api/src/app/portfolio/interfaces/portfolio-item.interface';
+
+import { Order } from '../order';
+
+export interface PortfolioInterface {
+  get(aDate?: Date): PortfolioItem[];
+
+  getCommittedFunds(): number;
+
+  getFees(): number;
+
+  getPositions(
+    aDate: Date
+  ): {
+    [symbol: string]: Position;
+  };
+
+  getSymbols(aDate?: Date): string[];
+
+  getTotalBuy(): number;
+
+  getTotalSell(): number;
+
+  getOrders(): Order[];
+
+  getValue(aDate?: Date): number;
+}

apps/api/src/models/interfaces/rule.interface.ts

@@ -0,0 +1,14 @@
+import { PortfolioPosition } from '../../app/portfolio/interfaces/portfolio-position.interface';
+import { EvaluationResult } from './evaluation-result.interface';
+
+export interface RuleInterface {
+  evaluate(
+    aPortfolioPositionMap: {
+      [symbol: string]: PortfolioPosition;
+    },
+    aFees: number,
+    aRuleSettingsMap: {
+      [key: string]: any;
+    }
+  ): EvaluationResult;
+}

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

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

apps/api/src/models/order.ts

@@ -0,0 +1,72 @@
+import { Currency, Platform } from '@prisma/client';
+import { v4 as uuidv4 } from 'uuid';
+
+import { IOrder } from '../services/interfaces/interfaces';
+import { OrderType } from './order-type';
+
+export class Order {
+  private currency: Currency;
+  private fee: number;
+  private date: string;
+  private id: string;
+  private quantity: number;
+  private platform: Platform;
+  private symbol: string;
+  private total: number;
+  private type: OrderType;
+  private unitPrice: number;
+
+  public constructor(data: IOrder) {
+    this.currency = data.currency;
+    this.fee = data.fee;
+    this.date = data.date;
+    this.id = data.id || uuidv4();
+    this.platform = data.platform;
+    this.quantity = data.quantity;
+    this.symbol = data.symbol;
+    this.type = data.type;
+    this.unitPrice = data.unitPrice;
+
+    this.total = this.quantity * data.unitPrice;
+  }
+
+  public getCurrency() {
+    return this.currency;
+  }
+
+  public getDate() {
+    return this.date;
+  }
+
+  public getFee() {
+    return this.fee;
+  }
+
+  public getId() {
+    return this.id;
+  }
+
+  public getPlatform() {
+    return this.platform;
+  }
+
+  public getQuantity() {
+    return this.quantity;
+  }
+
+  public getSymbol() {
+    return this.symbol;
+  }
+
+  public getTotal() {
+    return this.total;
+  }
+
+  public getType() {
+    return this.type;
+  }
+
+  public getUnitPrice() {
+    return this.unitPrice;
+  }
+}

apps/api/src/models/portfolio.spec.ts

@@ -0,0 +1,558 @@
+import { Test } from '@nestjs/testing';
+import { Currency, Role, Type } from '@prisma/client';
+import { baseCurrency } from 'libs/helper/src';
+import { getYesterday } from 'libs/helper/src';
+import { getUtc } from 'libs/helper/src';
+
+import { DataProviderService } from '../services/data-provider.service';
+import { AlphaVantageService } from '../services/data-provider/alpha-vantage/alpha-vantage.service';
+import { RakutenRapidApiService } from '../services/data-provider/rakuten-rapid-api/rakuten-rapid-api.service';
+import { YahooFinanceService } from '../services/data-provider/yahoo-finance/yahoo-finance.service';
+import { ExchangeRateDataService } from '../services/exchange-rate-data.service';
+import { PrismaService } from '../services/prisma.service';
+import { RulesService } from '../services/rules.service';
+import { Portfolio } from './portfolio';
+
+describe('Portfolio', () => {
+  let alphaVantageService: AlphaVantageService;
+  let dataProviderService: DataProviderService;
+  let exchangeRateDataService: ExchangeRateDataService;
+  let portfolio: Portfolio;
+  let prismaService: PrismaService;
+  let rakutenRapidApiService: RakutenRapidApiService;
+  let rulesService: RulesService;
+  let yahooFinanceService: YahooFinanceService;
+
+  beforeAll(async () => {
+    const app = await Test.createTestingModule({
+      imports: [],
+      providers: [
+        AlphaVantageService,
+        DataProviderService,
+        ExchangeRateDataService,
+        PrismaService,
+        RakutenRapidApiService,
+        RulesService,
+        YahooFinanceService
+      ]
+    }).compile();
+
+    alphaVantageService = app.get<AlphaVantageService>(AlphaVantageService);
+    dataProviderService = app.get<DataProviderService>(DataProviderService);
+    exchangeRateDataService = app.get<ExchangeRateDataService>(
+      ExchangeRateDataService
+    );
+    prismaService = app.get<PrismaService>(PrismaService);
+    rakutenRapidApiService = app.get<RakutenRapidApiService>(
+      RakutenRapidApiService
+    );
+    rulesService = app.get<RulesService>(RulesService);
+    yahooFinanceService = app.get<YahooFinanceService>(YahooFinanceService);
+
+    await exchangeRateDataService.initialize();
+
+    portfolio = new Portfolio(
+      dataProviderService,
+      exchangeRateDataService,
+      rulesService
+    );
+    portfolio.setUser({
+      accessToken: null,
+      alias: 'Test',
+      createdAt: new Date(),
+      id: '',
+      provider: null,
+      role: Role.USER,
+      Settings: {
+        currency: Currency.CHF,
+        updatedAt: new Date(),
+        userId: ''
+      },
+      thirdPartyId: null,
+      updatedAt: new Date()
+    });
+  });
+
+  describe('works with no orders', () => {
+    it('should return []', () => {
+      expect(portfolio.get(new Date())).toEqual([]);
+      expect(portfolio.getFees()).toEqual(0);
+      expect(portfolio.getPositions(new Date())).toEqual({});
+    });
+
+    it('should return empty details', async () => {
+      const details = await portfolio.getDetails('1d');
+      expect(details).toEqual({});
+    });
+
+    it('should return empty details', async () => {
+      const details = await portfolio.getDetails('max');
+      expect(details).toEqual({});
+    });
+
+    it('should return zero performance for 1d', async () => {
+      const performance = await portfolio.getPerformance('1d');
+      expect(performance).toEqual({
+        currentGrossPerformance: 0,
+        currentGrossPerformancePercent: 0,
+        currentNetPerformance: 0,
+        currentNetPerformancePercent: 0,
+        currentValue: 0
+      });
+    });
+
+    it('should return zero performance for max', async () => {
+      const performance = await portfolio.getPerformance('max');
+      expect(performance).toEqual({
+        currentGrossPerformance: 0,
+        currentGrossPerformancePercent: 0,
+        currentNetPerformance: 0,
+        currentNetPerformancePercent: 0,
+        currentValue: 0
+      });
+    });
+  });
+
+  describe(`works with today's orders`, () => {
+    it('should return ["BTC"]', async () => {
+      await portfolio.setOrders([
+        {
+          createdAt: null,
+          currency: Currency.USD,
+          fee: 0,
+          date: new Date(),
+          id: '8d999347-dee2-46ee-88e1-26b344e71fcc',
+          platformId: null,
+          quantity: 1,
+          symbol: 'BTCUSD',
+          type: Type.BUY,
+          unitPrice: 49631.24,
+          updatedAt: null,
+          userId: null
+        }
+      ]);
+
+      expect(portfolio.getCommittedFunds()).toEqual(
+        exchangeRateDataService.toCurrency(
+          1 * 49631.24,
+          Currency.USD,
+          baseCurrency
+        )
+      );
+
+      const details = await portfolio.getDetails('1d');
+      expect(details).toMatchObject({
+        BTCUSD: {
+          currency: Currency.USD,
+          exchange: 'Other',
+          grossPerformance: 0,
+          grossPerformancePercent: 0,
+          investment: exchangeRateDataService.toCurrency(
+            1 * 49631.24,
+            Currency.USD,
+            baseCurrency
+          ),
+          isMarketOpen: true,
+          // marketPrice: 57973.008,
+          name: 'Bitcoin USD',
+          platforms: {
+            Other: {
+              /*current: exchangeRateDataService.toCurrency(
+                1 * 49631.24,
+                Currency.USD,
+                baseCurrency
+              ),*/
+              original: exchangeRateDataService.toCurrency(
+                1 * 49631.24,
+                Currency.USD,
+                baseCurrency
+              )
+            }
+          },
+          quantity: 1,
+          // shareCurrent: 0.9999999559148652,
+          shareInvestment: 1,
+          symbol: 'BTCUSD',
+          type: 'Cryptocurrency'
+        }
+      });
+
+      expect(portfolio.getFees()).toEqual(0);
+
+      /*const performance1d = await portfolio.getPerformance('1d');
+      expect(performance1d).toEqual({
+        currentGrossPerformance: 0,
+        currentGrossPerformancePercent: 0,
+        currentNetPerformance: 0,
+        currentNetPerformancePercent: 0,
+        currentValue: exchangeRateDataService.toBaseCurrency(
+          1 * 49631.24,
+          Currency.USD,
+          baseCurrency
+        )
+      });*/
+
+      /*const performanceMax = await portfolio.getPerformance('max');
+      expect(performanceMax).toEqual({
+        currentGrossPerformance: 0,
+        currentGrossPerformancePercent: 0,
+        currentNetPerformance: 0,
+        currentNetPerformancePercent: 0,
+        currentValue: exchangeRateDataService.toBaseCurrency(
+          1 * 49631.24,
+          Currency.USD,
+          baseCurrency
+        )
+      });*/
+
+      expect(portfolio.getPositions(getYesterday())).toMatchObject({});
+
+      expect(portfolio.getSymbols(getYesterday())).toEqual(['BTCUSD']);
+    });
+  });
+
+  describe('works with orders', () => {
+    it('should return ["ETHUSD"]', async () => {
+      await portfolio.setOrders([
+        {
+          createdAt: null,
+          currency: Currency.USD,
+          fee: 0,
+          date: new Date(getUtc('2018-01-05')),
+          id: '4a5a5c6e-659d-45cc-9fd4-fd6c873b50fb',
+          platformId: null,
+          quantity: 0.2,
+          symbol: 'ETHUSD',
+          type: Type.BUY,
+          unitPrice: 991.49,
+          updatedAt: null,
+          userId: null
+        }
+      ]);
+
+      expect(portfolio.getCommittedFunds()).toEqual(
+        exchangeRateDataService.toCurrency(
+          0.2 * 991.49,
+          Currency.USD,
+          baseCurrency
+        )
+      );
+
+      const details = await portfolio.getDetails('1d');
+      expect(details).toMatchObject({
+        ETHUSD: {
+          currency: Currency.USD,
+          exchange: 'Other',
+          // grossPerformance: 0,
+          // grossPerformancePercent: 0,
+          investment: exchangeRateDataService.toCurrency(
+            0.2 * 991.49,
+            Currency.USD,
+            baseCurrency
+          ),
+          // marketPrice: 57973.008,
+          name: 'Ethereum USD',
+          platforms: {
+            Other: {
+              /*current: exchangeRateDataService.toCurrency(
+                0.2 * 991.49,
+                Currency.USD,
+                baseCurrency
+              ),*/
+              original: exchangeRateDataService.toCurrency(
+                0.2 * 991.49,
+                Currency.USD,
+                baseCurrency
+              )
+            }
+          },
+          quantity: 0.2,
+          shareCurrent: 1,
+          shareInvestment: 1,
+          symbol: 'ETHUSD',
+          type: 'Cryptocurrency'
+        }
+      });
+
+      expect(portfolio.getFees()).toEqual(0);
+
+      /*const performance = await portfolio.getPerformance('max');
+      expect(performance).toEqual({
+        currentGrossPerformance: 0,
+        currentGrossPerformancePercent: 0,
+        currentNetPerformance: 0,
+        currentNetPerformancePercent: 0,
+        currentValue: 0
+      });*/
+
+      expect(portfolio.getPositions(getYesterday())).toMatchObject({
+        ETHUSD: {
+          averagePrice: 991.49,
+          currency: Currency.USD,
+          firstBuyDate: '2018-01-05T00:00:00.000Z',
+          investment: exchangeRateDataService.toCurrency(
+            0.2 * 991.49,
+            Currency.USD,
+            baseCurrency
+          ),
+          investmentInOriginalCurrency: 0.2 * 991.49,
+          // marketPrice: 0,
+          quantity: 0.2
+        }
+      });
+
+      expect(portfolio.getSymbols(getYesterday())).toEqual(['ETHUSD']);
+    });
+
+    it('should return ["ETHUSD"]', async () => {
+      await portfolio.setOrders([
+        {
+          createdAt: null,
+          currency: Currency.USD,
+          fee: 0,
+          date: new Date(getUtc('2018-01-05')),
+          id: '4a5a5c6e-659d-45cc-9fd4-fd6c873b50fb',
+          platformId: null,
+          quantity: 0.2,
+          symbol: 'ETHUSD',
+          type: Type.BUY,
+          unitPrice: 991.49,
+          updatedAt: null,
+          userId: null
+        },
+        {
+          createdAt: null,
+          currency: Currency.USD,
+          fee: 0,
+          date: new Date(getUtc('2018-01-28')),
+          id: '4a5a5c6e-659d-45cc-9fd4-fd6c873b50fc',
+          platformId: null,
+          quantity: 0.3,
+          symbol: 'ETHUSD',
+          type: Type.BUY,
+          unitPrice: 1050,
+          updatedAt: null,
+          userId: null
+        }
+      ]);
+
+      expect(portfolio.getCommittedFunds()).toEqual(
+        exchangeRateDataService.toCurrency(
+          0.2 * 991.49,
+          Currency.USD,
+          baseCurrency
+        ) +
+          exchangeRateDataService.toCurrency(
+            0.3 * 1050,
+            Currency.USD,
+            baseCurrency
+          )
+      );
+
+      expect(portfolio.getFees()).toEqual(0);
+
+      expect(portfolio.getPositions(getYesterday())).toMatchObject({
+        ETHUSD: {
+          averagePrice: (0.2 * 991.49 + 0.3 * 1050) / (0.2 + 0.3),
+          currency: Currency.USD,
+          firstBuyDate: '2018-01-05T00:00:00.000Z',
+          investment:
+            exchangeRateDataService.toCurrency(
+              0.2 * 991.49,
+              Currency.USD,
+              baseCurrency
+            ) +
+            exchangeRateDataService.toCurrency(
+              0.3 * 1050,
+              Currency.USD,
+              baseCurrency
+            ),
+          investmentInOriginalCurrency: 0.2 * 991.49 + 0.3 * 1050,
+          // marketPrice: 0,
+          quantity: 0.5
+        }
+      });
+
+      expect(portfolio.getSymbols(getYesterday())).toEqual(['ETHUSD']);
+    });
+
+    it('should return ["BTCUSD", "ETHUSD"]', async () => {
+      await portfolio.setOrders([
+        {
+          createdAt: null,
+          currency: Currency.EUR,
+          date: new Date(getUtc('2017-08-16')),
+          fee: 2.99,
+          id: 'd96795b2-6ae6-420e-aa21-fabe5e45d475',
+          platformId: null,
+          quantity: 0.05614682,
+          symbol: 'BTCUSD',
+          type: Type.BUY,
+          unitPrice: 3562.089535970158,
+          updatedAt: null,
+          userId: null
+        },
+        {
+          createdAt: null,
+          currency: Currency.USD,
+          fee: 2.99,
+          date: new Date(getUtc('2018-01-05')),
+          id: '4a5a5c6e-659d-45cc-9fd4-fd6c873b50fb',
+          platformId: null,
+          quantity: 0.2,
+          symbol: 'ETHUSD',
+          type: Type.BUY,
+          unitPrice: 991.49,
+          updatedAt: null,
+          userId: null
+        }
+      ]);
+
+      expect(portfolio.getCommittedFunds()).toEqual(
+        exchangeRateDataService.toCurrency(
+          0.05614682 * 3562.089535970158,
+          Currency.EUR,
+          baseCurrency
+        ) +
+          exchangeRateDataService.toCurrency(
+            0.2 * 991.49,
+            Currency.USD,
+            baseCurrency
+          )
+      );
+
+      expect(portfolio.getFees()).toEqual(
+        exchangeRateDataService.toCurrency(2.99, Currency.EUR, baseCurrency) +
+          exchangeRateDataService.toCurrency(2.99, Currency.USD, baseCurrency)
+      );
+
+      expect(portfolio.getPositions(getYesterday())).toMatchObject({
+        BTCUSD: {
+          averagePrice: 3562.089535970158,
+          currency: Currency.EUR,
+          firstBuyDate: '2017-08-16T00:00:00.000Z',
+          investment: exchangeRateDataService.toCurrency(
+            0.05614682 * 3562.089535970158,
+            Currency.EUR,
+            baseCurrency
+          ),
+          investmentInOriginalCurrency: 0.05614682 * 3562.089535970158,
+          // marketPrice: 0,
+          quantity: 0.05614682
+        },
+        ETHUSD: {
+          averagePrice: 991.49,
+          currency: Currency.USD,
+          firstBuyDate: '2018-01-05T00:00:00.000Z',
+          investment: exchangeRateDataService.toCurrency(
+            0.2 * 991.49,
+            Currency.USD,
+            baseCurrency
+          ),
+          investmentInOriginalCurrency: 0.2 * 991.49,
+          // marketPrice: 0,
+          quantity: 0.2
+        }
+      });
+
+      expect(portfolio.getSymbols(getYesterday())).toEqual([
+        'BTCUSD',
+        'ETHUSD'
+      ]);
+    });
+
+    it('should work with buy and sell', async () => {
+      await portfolio.setOrders([
+        {
+          createdAt: null,
+          currency: Currency.USD,
+          fee: 1.0,
+          date: new Date(getUtc('2018-01-05')),
+          id: '4a5a5c6e-659d-45cc-9fd4-fd6c873b50fb',
+          platformId: null,
+          quantity: 0.2,
+          symbol: 'ETHUSD',
+          type: Type.BUY,
+          unitPrice: 991.49,
+          updatedAt: null,
+          userId: null
+        },
+        {
+          createdAt: null,
+          currency: Currency.USD,
+          fee: 1.0,
+          date: new Date(getUtc('2018-01-28')),
+          id: '4a5a5c6e-659d-45cc-9fd4-fd6c873b50fc',
+          platformId: null,
+          quantity: 0.1,
+          symbol: 'ETHUSD',
+          type: Type.SELL,
+          unitPrice: 1050,
+          updatedAt: null,
+          userId: null
+        },
+        {
+          createdAt: null,
+          currency: Currency.USD,
+          fee: 1.0,
+          date: new Date(getUtc('2018-01-31')),
+          id: '4a5a5c6e-659d-45cc-9fd4-fd6c873b50fc',
+          platformId: null,
+          quantity: 0.2,
+          symbol: 'ETHUSD',
+          type: Type.BUY,
+          unitPrice: 1050,
+          updatedAt: null,
+          userId: null
+        }
+      ]);
+
+      // TODO: Fix
+      /*expect(portfolio.getCommittedFunds()).toEqual(
+        exchangeRateDataService.toCurrency(
+          0.2 * 991.49,
+          Currency.USD,
+          baseCurrency
+        ) -
+          exchangeRateDataService.toCurrency(
+            0.1 * 1050,
+            Currency.USD,
+            baseCurrency
+          ) +
+          exchangeRateDataService.toCurrency(
+            0.2 * 1050,
+            Currency.USD,
+            baseCurrency
+          )
+      );*/
+
+      expect(portfolio.getFees()).toEqual(
+        exchangeRateDataService.toCurrency(3, Currency.USD, baseCurrency)
+      );
+
+      expect(portfolio.getPositions(getYesterday())).toMatchObject({
+        ETHUSD: {
+          averagePrice:
+            (0.2 * 991.49 - 0.1 * 1050 + 0.2 * 1050) / (0.2 - 0.1 + 0.2),
+          currency: Currency.USD,
+          firstBuyDate: '2018-01-05T00:00:00.000Z',
+          // TODO: Fix
+          /*investment: exchangeRateDataService.toCurrency(
+            0.2 * 991.49 - 0.1 * 1050 + 0.2 * 1050,
+            Currency.USD,
+            baseCurrency
+          ),*/
+          investmentInOriginalCurrency: 0.2 * 991.49 - 0.1 * 1050 + 0.2 * 1050,
+          // marketPrice: 0,
+          quantity: 0.2 - 0.1 + 0.2
+        }
+      });
+
+      expect(portfolio.getSymbols(getYesterday())).toEqual(['ETHUSD']);
+    });
+  });
+
+  afterAll(async () => {
+    prismaService.$disconnect();
+  });
+});

apps/api/src/models/portfolio.ts

@@ -0,0 +1,820 @@
+import {
+  PortfolioItem,
+  Position
+} from 'apps/api/src/app/portfolio/interfaces/portfolio-item.interface';
+import {
+  add,
+  format,
+  getDate,
+  getMonth,
+  getYear,
+  isAfter,
+  isBefore,
+  isSameDay,
+  isToday,
+  isYesterday,
+  parseISO,
+  setDate,
+  setMonth,
+  sub
+} from 'date-fns';
+import { getToday, getYesterday, resetHours } from 'libs/helper/src';
+import { cloneDeep, isEmpty } from 'lodash';
+import * as roundTo from 'round-to';
+
+import { UserWithSettings } from '../app/interfaces/user-with-settings';
+import { OrderWithPlatform } from '../app/order/interfaces/order-with-platform.type';
+import { DateRange } from '../app/portfolio/interfaces/date-range.type';
+import { PortfolioPerformance } from '../app/portfolio/interfaces/portfolio-performance.interface';
+import { PortfolioPosition } from '../app/portfolio/interfaces/portfolio-position.interface';
+import { PortfolioReport } from '../app/portfolio/interfaces/portfolio-report.interface';
+import { DataProviderService } from '../services/data-provider.service';
+import { ExchangeRateDataService } from '../services/exchange-rate-data.service';
+import { IOrder } from '../services/interfaces/interfaces';
+import { RulesService } from '../services/rules.service';
+import { PortfolioInterface } from './interfaces/portfolio.interface';
+import { Order } from './order';
+import { CurrencyClusterRiskBaseCurrencyCurrentInvestment } from './rules/currency-cluster-risk/base-currency-current-investment';
+import { CurrencyClusterRiskBaseCurrencyInitialInvestment } from './rules/currency-cluster-risk/base-currency-initial-investment';
+import { CurrencyClusterRiskCurrentInvestment } from './rules/currency-cluster-risk/current-investment';
+import { CurrencyClusterRiskInitialInvestment } from './rules/currency-cluster-risk/initial-investment';
+import { FeeRatioInitialInvestment } from './rules/fees/fee-ratio-initial-investment';
+import { PlatformClusterRiskCurrentInvestment } from './rules/platform-cluster-risk/current-investment';
+import { PlatformClusterRiskInitialInvestment } from './rules/platform-cluster-risk/initial-investment';
+import { PlatformClusterRiskSinglePlatform } from './rules/platform-cluster-risk/single-platform';
+
+export class Portfolio implements PortfolioInterface {
+  private orders: Order[] = [];
+  private portfolioItems: PortfolioItem[] = [];
+  private user: UserWithSettings;
+
+  public constructor(
+    private dataProviderService: DataProviderService,
+    private exchangeRateDataService: ExchangeRateDataService,
+    private rulesService: RulesService
+  ) {}
+
+  public async addCurrentPortfolioItems() {
+    const currentData = await this.dataProviderService.get(this.getSymbols());
+
+    let currentDate = new Date();
+
+    const year = getYear(currentDate);
+    const month = getMonth(currentDate);
+    const day = getDate(currentDate);
+
+    const today = new Date(Date.UTC(year, month, day));
+    const yesterday = getYesterday();
+
+    const [portfolioItemsYesterday] = this.get(yesterday);
+
+    let positions: { [symbol: string]: Position } = {};
+
+    this.getSymbols().forEach((symbol) => {
+      positions[symbol] = {
+        averagePrice: portfolioItemsYesterday?.positions[symbol]?.averagePrice,
+        currency: portfolioItemsYesterday?.positions[symbol]?.currency,
+        firstBuyDate: portfolioItemsYesterday?.positions[symbol]?.firstBuyDate,
+        investment: portfolioItemsYesterday?.positions[symbol]?.investment,
+        investmentInOriginalCurrency:
+          portfolioItemsYesterday?.positions[symbol]
+            ?.investmentInOriginalCurrency,
+        marketPrice: currentData[symbol]?.marketPrice,
+        quantity: portfolioItemsYesterday?.positions[symbol]?.quantity
+      };
+    });
+
+    if (portfolioItemsYesterday?.investment) {
+      const portfolioItemsLength = this.portfolioItems.push(
+        cloneDeep({
+          date: today.toISOString(),
+          grossPerformancePercent: 0,
+          investment: portfolioItemsYesterday?.investment,
+          positions: positions,
+          value: 0
+        })
+      );
+
+      // Set value after pushing today's portfolio items
+      this.portfolioItems[portfolioItemsLength - 1].value = this.getValue(
+        today
+      );
+    }
+
+    return this;
+  }
+
+  public createFromData({
+    orders,
+    portfolioItems,
+    user
+  }: {
+    orders: IOrder[];
+    portfolioItems: PortfolioItem[];
+    user: UserWithSettings;
+  }): Portfolio {
+    orders.forEach(
+      ({
+        currency,
+        fee,
+        date,
+        id,
+        platform,
+        quantity,
+        symbol,
+        type,
+        unitPrice
+      }) => {
+        this.orders.push(
+          new Order({
+            currency,
+            fee,
+            date,
+            id,
+            platform,
+            quantity,
+            symbol,
+            type,
+            unitPrice
+          })
+        );
+      }
+    );
+
+    portfolioItems.forEach(
+      ({ date, grossPerformancePercent, investment, positions, value }) => {
+        this.portfolioItems.push({
+          date,
+          grossPerformancePercent,
+          investment,
+          positions,
+          value
+        });
+      }
+    );
+
+    this.setUser(user);
+
+    return this;
+  }
+
+  private convertDateRangeToDate(aDateRange: DateRange, aMinDate: Date) {
+    let currentDate = new Date();
+
+    const normalizedMinDate =
+      getDate(aMinDate) === 1
+        ? aMinDate
+        : add(setDate(aMinDate, 1), { months: 1 });
+
+    const year = getYear(currentDate);
+    const month = getMonth(currentDate);
+    const day = getDate(currentDate);
+
+    currentDate = new Date(Date.UTC(year, month, day, 0));
+
+    switch (aDateRange) {
+      case '1d':
+        return sub(currentDate, {
+          days: 1
+        });
+      case 'ytd':
+        currentDate = setDate(currentDate, 1);
+        currentDate = setMonth(currentDate, 0);
+        return isAfter(currentDate, normalizedMinDate)
+          ? currentDate
+          : undefined;
+      case '1y':
+        currentDate = setDate(currentDate, 1);
+        currentDate = sub(currentDate, {
+          years: 1
+        });
+        return isAfter(currentDate, normalizedMinDate)
+          ? currentDate
+          : undefined;
+      case '5y':
+        currentDate = setDate(currentDate, 1);
+        currentDate = sub(currentDate, {
+          years: 5
+        });
+        return isAfter(currentDate, normalizedMinDate)
+          ? currentDate
+          : undefined;
+      default:
+        // Gets handled as all data
+        return undefined;
+    }
+  }
+
+  public get(aDate?: Date): PortfolioItem[] {
+    if (aDate) {
+      const filteredPortfolio = this.portfolioItems.find((item) => {
+        return isSameDay(aDate, new Date(item.date));
+      });
+
+      if (filteredPortfolio) {
+        return [cloneDeep(filteredPortfolio)];
+      }
+    }
+
+    return cloneDeep(this.portfolioItems);
+  }
+
+  public getCommittedFunds() {
+    return this.getTotalBuy() - this.getTotalSell();
+  }
+
+  public async getDetails(
+    aDateRange: DateRange = 'max'
+  ): Promise<{ [symbol: string]: PortfolioPosition }> {
+    const dateRangeDate = this.convertDateRangeToDate(
+      aDateRange,
+      this.getMinDate()
+    );
+
+    const [portfolioItemsBefore] = this.get(dateRangeDate);
+
+    const [portfolioItemsNow] = await this.get(new Date());
+
+    const investment = this.getInvestment(new Date());
+    const portfolioItems = this.get(new Date());
+    const symbols = this.getSymbols(new Date());
+    const value = this.getValue();
+
+    const details: { [symbol: string]: PortfolioPosition } = {};
+
+    const data = await this.dataProviderService.get(symbols);
+
+    symbols.forEach((symbol) => {
+      const platforms: PortfolioPosition['platforms'] = {};
+      const [portfolioItem] = portfolioItems;
+
+      const ordersBySymbol = this.getOrders().filter((order) => {
+        return order.getSymbol() === symbol;
+      });
+
+      ordersBySymbol.forEach((orderOfSymbol) => {
+        let currentValueOfSymbol = this.exchangeRateDataService.toCurrency(
+          orderOfSymbol.getQuantity() *
+            portfolioItemsNow.positions[symbol].marketPrice,
+          orderOfSymbol.getCurrency(),
+          this.user.Settings.currency
+        );
+        let originalValueOfSymbol = this.exchangeRateDataService.toCurrency(
+          orderOfSymbol.getQuantity() * orderOfSymbol.getUnitPrice(),
+          orderOfSymbol.getCurrency(),
+          this.user.Settings.currency
+        );
+
+        if (orderOfSymbol.getType() === 'SELL') {
+          currentValueOfSymbol *= -1;
+          originalValueOfSymbol *= -1;
+        }
+
+        if (platforms[orderOfSymbol.getPlatform()?.name || 'Other']?.current) {
+          platforms[
+            orderOfSymbol.getPlatform()?.name || 'Other'
+          ].current += currentValueOfSymbol;
+          platforms[
+            orderOfSymbol.getPlatform()?.name || 'Other'
+          ].original += originalValueOfSymbol;
+        } else {
+          platforms[orderOfSymbol.getPlatform()?.name || 'Other'] = {
+            current: currentValueOfSymbol,
+            original: originalValueOfSymbol
+          };
+        }
+      });
+
+      let now = portfolioItemsNow.positions[symbol].marketPrice;
+
+      // 1d
+      let before = portfolioItemsBefore.positions[symbol].marketPrice;
+
+      if (aDateRange === 'ytd') {
+        before =
+          portfolioItemsBefore.positions[symbol].marketPrice ||
+          portfolioItemsNow.positions[symbol].averagePrice;
+      } else if (
+        aDateRange === '1y' ||
+        aDateRange === '5y' ||
+        aDateRange === 'max'
+      ) {
+        before = portfolioItemsNow.positions[symbol].averagePrice;
+      }
+
+      if (
+        !isBefore(
+          parseISO(portfolioItemsNow.positions[symbol].firstBuyDate),
+          parseISO(portfolioItemsBefore.date)
+        )
+      ) {
+        // Trade was not before the date of portfolioItemsBefore, then override it with average price
+        // (e.g. on same day)
+        before = portfolioItemsNow.positions[symbol].averagePrice;
+      }
+
+      if (isToday(parseISO(portfolioItemsNow.positions[symbol].firstBuyDate))) {
+        now = portfolioItemsNow.positions[symbol].averagePrice;
+      }
+
+      details[symbol] = {
+        ...data[symbol],
+        platforms,
+        symbol,
+        grossPerformance: roundTo(
+          portfolioItemsNow.positions[symbol].quantity * (now - before),
+          2
+        ),
+        grossPerformancePercent: roundTo((now - before) / before, 4),
+        investment: portfolioItem.positions[symbol].investment,
+        quantity: portfolioItem.positions[symbol].quantity,
+        shareCurrent:
+          this.exchangeRateDataService.toCurrency(
+            portfolioItem.positions[symbol].quantity * now,
+            data[symbol]?.currency,
+            this.user.Settings.currency
+          ) / value,
+        shareInvestment: portfolioItem.positions[symbol].investment / investment
+      };
+    });
+
+    return details;
+  }
+
+  public getFees(aDate = new Date(0)) {
+    return this.orders
+      .filter((order) => {
+        // Filter out all orders before given date
+        return isBefore(aDate, new Date(order.getDate()));
+      })
+      .map((order) => {
+        return this.exchangeRateDataService.toCurrency(
+          order.getFee(),
+          order.getCurrency(),
+          this.user.Settings.currency
+        );
+      })
+      .reduce((previous, current) => previous + current, 0);
+  }
+
+  public getInvestment(aDate: Date): number {
+    return this.get(aDate)[0]?.investment || 0;
+  }
+
+  public getMinDate() {
+    if (this.orders.length > 0) {
+      return new Date(this.orders[0].getDate());
+    }
+
+    return null;
+  }
+
+  public async getPerformance(
+    aDateRange: DateRange = 'max'
+  ): Promise<PortfolioPerformance> {
+    const dateRangeDate = this.convertDateRangeToDate(
+      aDateRange,
+      this.getMinDate()
+    );
+
+    const currentInvestment = this.getInvestment(new Date());
+    const currentValue = await this.getValue();
+
+    let originalInvestment = currentInvestment;
+    let originalValue = this.getCommittedFunds();
+
+    if (dateRangeDate) {
+      originalInvestment = this.getInvestment(dateRangeDate);
+      originalValue = (await this.getValue(dateRangeDate)) || originalValue;
+    }
+
+    const fees = this.getFees(dateRangeDate);
+
+    const currentGrossPerformance =
+      currentValue - currentInvestment - (originalValue - originalInvestment);
+
+    // https://www.skillsyouneed.com/num/percent-change.html
+    const currentGrossPerformancePercent =
+      currentGrossPerformance / originalInvestment || 0;
+
+    const currentNetPerformance = currentGrossPerformance - fees;
+
+    // https://www.skillsyouneed.com/num/percent-change.html
+    const currentNetPerformancePercent =
+      currentNetPerformance / originalInvestment || 0;
+
+    return {
+      currentGrossPerformance,
+      currentGrossPerformancePercent,
+      currentNetPerformance,
+      currentNetPerformancePercent,
+      currentValue
+    };
+  }
+
+  public getPositions(aDate: Date) {
+    const [portfolioItem] = this.get(aDate);
+
+    if (portfolioItem) {
+      return portfolioItem.positions;
+    }
+
+    return {};
+  }
+
+  public getPortfolioItems() {
+    return this.portfolioItems;
+  }
+
+  public async getReport(): Promise<PortfolioReport> {
+    const details = await this.getDetails();
+
+    if (isEmpty(details)) {
+      return {
+        rules: {}
+      };
+    }
+
+    return {
+      rules: {
+        currencyClusterRisk: await this.rulesService.evaluate(
+          this,
+          [
+            new CurrencyClusterRiskBaseCurrencyInitialInvestment(
+              this.exchangeRateDataService
+            ),
+            new CurrencyClusterRiskBaseCurrencyCurrentInvestment(
+              this.exchangeRateDataService
+            ),
+            new CurrencyClusterRiskInitialInvestment(
+              this.exchangeRateDataService
+            ),
+            new CurrencyClusterRiskCurrentInvestment(
+              this.exchangeRateDataService
+            )
+          ],
+          { baseCurrency: this.user.Settings.currency }
+        ),
+        platformClusterRisk: await this.rulesService.evaluate(
+          this,
+          [
+            new PlatformClusterRiskSinglePlatform(this.exchangeRateDataService),
+            new PlatformClusterRiskInitialInvestment(
+              this.exchangeRateDataService
+            ),
+            new PlatformClusterRiskCurrentInvestment(
+              this.exchangeRateDataService
+            )
+          ],
+          { baseCurrency: this.user.Settings.currency }
+        ),
+        fees: await this.rulesService.evaluate(
+          this,
+          [new FeeRatioInitialInvestment(this.exchangeRateDataService)],
+          { baseCurrency: this.user.Settings.currency }
+        )
+      }
+    };
+  }
+
+  public getSymbols(aDate?: Date) {
+    let symbols: string[] = [];
+
+    if (aDate) {
+      const positions = this.getPositions(aDate);
+
+      for (const symbol in positions) {
+        if (positions[symbol].quantity > 0) {
+          symbols.push(symbol);
+        }
+      }
+    } else {
+      symbols = this.orders.map((order) => {
+        return order.getSymbol();
+      });
+    }
+
+    // unique values
+    return Array.from(new Set(symbols));
+  }
+
+  public getTotalBuy() {
+    return this.orders
+      .filter((order) => order.getType() === 'BUY')
+      .map((order) => {
+        return this.exchangeRateDataService.toCurrency(
+          order.getTotal(),
+          order.getCurrency(),
+          this.user.Settings.currency
+        );
+      })
+      .reduce((previous, current) => previous + current, 0);
+  }
+
+  public getTotalSell() {
+    return this.orders
+      .filter((order) => order.getType() === 'SELL')
+      .map((order) => {
+        return this.exchangeRateDataService.toCurrency(
+          order.getTotal(),
+          order.getCurrency(),
+          this.user.Settings.currency
+        );
+      })
+      .reduce((previous, current) => previous + current, 0);
+  }
+
+  public getOrders() {
+    return this.orders;
+  }
+
+  private getOrdersByType(aFilter: string[]) {
+    return this.orders.filter((order) => {
+      return aFilter.includes(order.getType());
+    });
+  }
+
+  public getValue(aDate = getToday()) {
+    const positions = this.getPositions(aDate);
+    let value = 0;
+
+    const [portfolioItem] = this.get(aDate);
+
+    for (const symbol in positions) {
+      if (portfolioItem.positions[symbol]?.quantity > 0) {
+        if (
+          isBefore(
+            aDate,
+            parseISO(portfolioItem.positions[symbol]?.firstBuyDate)
+          ) ||
+          portfolioItem.positions[symbol]?.marketPrice === 0
+        ) {
+          value += this.exchangeRateDataService.toCurrency(
+            portfolioItem.positions[symbol]?.quantity *
+              portfolioItem.positions[symbol]?.averagePrice,
+            portfolioItem.positions[symbol]?.currency,
+            this.user.Settings.currency
+          );
+        } else {
+          value += this.exchangeRateDataService.toCurrency(
+            portfolioItem.positions[symbol]?.quantity *
+              portfolioItem.positions[symbol]?.marketPrice,
+            portfolioItem.positions[symbol]?.currency,
+            this.user.Settings.currency
+          );
+        }
+      }
+    }
+
+    return isFinite(value) ? value : null;
+  }
+
+  public async setOrders(aOrders: OrderWithPlatform[]) {
+    this.orders = [];
+
+    // Map data
+    aOrders.forEach((order) => {
+      this.orders.push(
+        new Order({
+          currency: <any>order.currency,
+          date: order.date.toISOString(),
+          fee: order.fee,
+          platform: order.Platform,
+          quantity: order.quantity,
+          symbol: order.symbol,
+          type: <any>order.type,
+          unitPrice: order.unitPrice
+        })
+      );
+    });
+
+    await this.update();
+
+    return this;
+  }
+
+  public setUser(aUser: UserWithSettings) {
+    this.user = aUser;
+
+    return this;
+  }
+
+  /**
+   * TODO: Refactor
+   */
+  private async update() {
+    this.portfolioItems = [];
+
+    let currentDate = this.getMinDate();
+
+    if (!currentDate) {
+      return;
+    }
+
+    // Set current date to first of month
+    currentDate = setDate(currentDate, 1);
+
+    const historicalData = await this.dataProviderService.getHistorical(
+      this.getSymbols(),
+      'month',
+      currentDate,
+      new Date()
+    );
+
+    while (isBefore(currentDate, Date.now())) {
+      const positions: { [symbol: string]: Position } = {};
+      this.getSymbols().forEach((symbol) => {
+        positions[symbol] = {
+          averagePrice: 0,
+          currency: undefined,
+          firstBuyDate: null,
+          investment: 0,
+          investmentInOriginalCurrency: 0,
+          marketPrice:
+            historicalData[symbol]?.[format(currentDate, 'yyyy-MM-dd')]
+              ?.marketPrice || 0,
+          quantity: 0
+        };
+      });
+
+      if (!isYesterday(currentDate) && !isToday(currentDate)) {
+        // Add to portfolio (ignore yesterday and today because they are added later)
+        this.portfolioItems.push(
+          cloneDeep({
+            date: currentDate.toISOString(),
+            grossPerformancePercent: 0,
+            investment: 0,
+            positions: positions,
+            value: 0
+          })
+        );
+      }
+
+      const year = getYear(currentDate);
+      const month = getMonth(currentDate);
+      const day = getDate(currentDate);
+
+      // Count month one up for iteration
+      currentDate = new Date(Date.UTC(year, month + 1, day, 0));
+    }
+
+    const yesterday = getYesterday();
+
+    let positions: { [symbol: string]: Position } = {};
+
+    if (isAfter(yesterday, this.getMinDate())) {
+      // Add yesterday
+      this.getSymbols().forEach((symbol) => {
+        positions[symbol] = {
+          averagePrice: 0,
+          currency: undefined,
+          firstBuyDate: null,
+          investment: 0,
+          investmentInOriginalCurrency: 0,
+          marketPrice:
+            historicalData[symbol]?.[format(yesterday, 'yyyy-MM-dd')]
+              ?.marketPrice || 0,
+          quantity: 0
+        };
+      });
+
+      this.portfolioItems.push(
+        cloneDeep({
+          date: yesterday.toISOString(),
+          grossPerformancePercent: 0,
+          investment: 0,
+          positions: positions,
+          value: 0
+        })
+      );
+    }
+
+    this.updatePortfolioItems();
+  }
+
+  private updatePortfolioItems() {
+    // console.time('update-portfolio-items');
+
+    let currentDate = new Date();
+
+    const year = getYear(currentDate);
+    const month = getMonth(currentDate);
+    const day = getDate(currentDate);
+
+    currentDate = new Date(Date.UTC(year, month, day, 0));
+
+    if (this.portfolioItems?.length === 1) {
+      // At least one portfolio items is needed, keep it but change the date to today.
+      // This happens if there are only orders from today
+      this.portfolioItems[0].date = currentDate.toISOString();
+    } else {
+      // Only keep entries which are not before first buy date
+      this.portfolioItems = this.portfolioItems.filter((portfolioItem) => {
+        return (
+          isSameDay(parseISO(portfolioItem.date), this.getMinDate()) ||
+          isAfter(parseISO(portfolioItem.date), this.getMinDate())
+        );
+      });
+    }
+
+    this.orders.forEach((order) => {
+      let index = this.portfolioItems.findIndex((item) => {
+        const dateOfOrder = setDate(parseISO(order.getDate()), 1);
+        return isSameDay(parseISO(item.date), dateOfOrder);
+      });
+
+      if (index === -1) {
+        // if not found, we only have one order, which means we do not loop below
+        index = 0;
+      }
+
+      for (let i = index; i < this.portfolioItems.length; i++) {
+        // Set currency
+        this.portfolioItems[i].positions[
+          order.getSymbol()
+        ].currency = order.getCurrency();
+
+        if (order.getType() === 'BUY') {
+          if (
+            !this.portfolioItems[i].positions[order.getSymbol()].firstBuyDate
+          ) {
+            this.portfolioItems[i].positions[
+              order.getSymbol()
+            ].firstBuyDate = resetHours(
+              parseISO(order.getDate())
+            ).toISOString();
+          }
+
+          this.portfolioItems[i].positions[
+            order.getSymbol()
+          ].quantity += order.getQuantity();
+          this.portfolioItems[i].positions[
+            order.getSymbol()
+          ].investment += this.exchangeRateDataService.toCurrency(
+            order.getTotal(),
+            order.getCurrency(),
+            this.user.Settings.currency
+          );
+          this.portfolioItems[i].positions[
+            order.getSymbol()
+          ].investmentInOriginalCurrency += order.getTotal();
+
+          this.portfolioItems[
+            i
+          ].investment += this.exchangeRateDataService.toCurrency(
+            order.getTotal(),
+            order.getCurrency(),
+            this.user.Settings.currency
+          );
+        } else if (order.getType() === 'SELL') {
+          this.portfolioItems[i].positions[
+            order.getSymbol()
+          ].quantity -= order.getQuantity();
+
+          if (
+            this.portfolioItems[i].positions[order.getSymbol()].quantity === 0
+          ) {
+            this.portfolioItems[i].positions[order.getSymbol()].investment = 0;
+            this.portfolioItems[i].positions[
+              order.getSymbol()
+            ].investmentInOriginalCurrency = 0;
+          } else {
+            this.portfolioItems[i].positions[
+              order.getSymbol()
+            ].investment -= this.exchangeRateDataService.toCurrency(
+              order.getTotal(),
+              order.getCurrency(),
+              this.user.Settings.currency
+            );
+            this.portfolioItems[i].positions[
+              order.getSymbol()
+            ].investmentInOriginalCurrency -= order.getTotal();
+          }
+
+          this.portfolioItems[
+            i
+          ].investment -= this.exchangeRateDataService.toCurrency(
+            order.getTotal(),
+            order.getCurrency(),
+            this.user.Settings.currency
+          );
+        }
+
+        this.portfolioItems[i].positions[order.getSymbol()].averagePrice =
+          this.portfolioItems[i].positions[order.getSymbol()]
+            .investmentInOriginalCurrency /
+          this.portfolioItems[i].positions[order.getSymbol()].quantity;
+
+        const currentValue = this.getValue(
+          parseISO(this.portfolioItems[i].date)
+        );
+
+        this.portfolioItems[i].grossPerformancePercent =
+          currentValue / this.portfolioItems[i].investment - 1 || 0;
+        this.portfolioItems[i].value = currentValue;
+      }
+    });
+
+    // console.timeEnd('update-portfolio-items');
+  }
+}

apps/api/src/models/rule.ts

@@ -0,0 +1,63 @@
+import { Currency } from '@prisma/client';
+import { groupBy } from 'libs/helper/src';
+
+import { PortfolioPosition } from '../app/portfolio/interfaces/portfolio-position.interface';
+import { ExchangeRateDataService } from '../services/exchange-rate-data.service';
+import { EvaluationResult } from './interfaces/evaluation-result.interface';
+import { RuleInterface } from './interfaces/rule.interface';
+
+export abstract class Rule implements RuleInterface {
+  private name: string;
+
+  public constructor(
+    public exchangeRateDataService: ExchangeRateDataService,
+    {
+      name
+    }: {
+      name: string;
+    }
+  ) {
+    this.name = name;
+  }
+
+  public abstract evaluate(
+    aPortfolioPositionMap: {
+      [symbol: string]: PortfolioPosition;
+    },
+    aFees: number,
+    aRuleSettingsMap?: {
+      [key: string]: any;
+    }
+  ): EvaluationResult;
+
+  public getName() {
+    return this.name;
+  }
+
+  public groupPositionsByAttribute(
+    aPositions: { [symbol: string]: PortfolioPosition },
+    aAttribute: keyof PortfolioPosition,
+    aBaseCurrency: Currency
+  ) {
+    return Array.from(
+      groupBy(aAttribute, Object.values(aPositions)).entries()
+    ).map(([attributeValue, objs]) => ({
+      groupKey: attributeValue,
+      investment: objs.reduce(
+        (previousValue, currentValue) =>
+          previousValue + currentValue.investment,
+        0
+      ),
+      value: objs.reduce(
+        (previousValue, currentValue) =>
+          previousValue +
+          this.exchangeRateDataService.toCurrency(
+            currentValue.quantity * currentValue.marketPrice,
+            currentValue.currency,
+            aBaseCurrency
+          ),
+        0
+      )
+    }));
+  }
+}

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

@@ -0,0 +1,64 @@
+import { PortfolioPosition } from 'apps/api/src/app/portfolio/interfaces/portfolio-position.interface';
+import { ExchangeRateDataService } from 'apps/api/src/services/exchange-rate-data.service';
+
+import { Rule } from '../../rule';
+
+export class CurrencyClusterRiskBaseCurrencyCurrentInvestment extends Rule {
+  public constructor(public exchangeRateDataService: ExchangeRateDataService) {
+    super(exchangeRateDataService, {
+      name: 'Current Investment: Base Currency'
+    });
+  }
+
+  public evaluate(
+    aPositions: { [symbol: string]: PortfolioPosition },
+    aFees: number,
+    aRuleSettingsMap?: {
+      [key: string]: any;
+    }
+  ) {
+    const ruleSettings =
+      aRuleSettingsMap[CurrencyClusterRiskBaseCurrencyCurrentInvestment.name];
+
+    const positionsGroupedByCurrency = this.groupPositionsByAttribute(
+      aPositions,
+      'currency',
+      ruleSettings.baseCurrency
+    );
+
+    let maxItem = positionsGroupedByCurrency[0];
+    let totalValue = 0;
+
+    positionsGroupedByCurrency.forEach((groupItem) => {
+      // Calculate total value
+      totalValue += groupItem.value;
+
+      // Find maximum
+      if (groupItem.investment > maxItem.investment) {
+        maxItem = groupItem;
+      }
+    });
+
+    const baseCurrencyItem = positionsGroupedByCurrency.find((item) => {
+      return item.groupKey === ruleSettings.baseCurrency;
+    });
+
+    const baseCurrencyValueRatio = baseCurrencyItem?.value / totalValue || 0;
+
+    if (maxItem.groupKey !== ruleSettings.baseCurrency) {
+      return {
+        evaluation: `The major part of your current investment is not in your base currency (${(
+          baseCurrencyValueRatio * 100
+        ).toPrecision(3)}% in ${ruleSettings.baseCurrency})`,
+        value: false
+      };
+    }
+
+    return {
+      evaluation: `The major part of your current investment is in your base currency (${(
+        baseCurrencyValueRatio * 100
+      ).toPrecision(3)}% in ${ruleSettings.baseCurrency})`,
+      value: true
+    };
+  }
+}

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

@@ -0,0 +1,65 @@
+import { PortfolioPosition } from 'apps/api/src/app/portfolio/interfaces/portfolio-position.interface';
+import { ExchangeRateDataService } from 'apps/api/src/services/exchange-rate-data.service';
+
+import { Rule } from '../../rule';
+
+export class CurrencyClusterRiskBaseCurrencyInitialInvestment extends Rule {
+  public constructor(public exchangeRateDataService: ExchangeRateDataService) {
+    super(exchangeRateDataService, {
+      name: 'Initial Investment: Base Currency'
+    });
+  }
+
+  public evaluate(
+    aPositions: { [symbol: string]: PortfolioPosition },
+    aFees: number,
+    aRuleSettingsMap?: {
+      [key: string]: any;
+    }
+  ) {
+    const ruleSettings =
+      aRuleSettingsMap[CurrencyClusterRiskBaseCurrencyInitialInvestment.name];
+
+    const positionsGroupedByCurrency = this.groupPositionsByAttribute(
+      aPositions,
+      'currency',
+      ruleSettings.baseCurrency
+    );
+
+    let maxItem = positionsGroupedByCurrency[0];
+    let totalInvestment = 0;
+
+    positionsGroupedByCurrency.forEach((groupItem) => {
+      // Calculate total investment
+      totalInvestment += groupItem.investment;
+
+      // Find maximum
+      if (groupItem.investment > maxItem.investment) {
+        maxItem = groupItem;
+      }
+    });
+
+    const baseCurrencyItem = positionsGroupedByCurrency.find((item) => {
+      return item.groupKey === ruleSettings.baseCurrency;
+    });
+
+    const baseCurrencyInvestmentRatio =
+      baseCurrencyItem?.investment / totalInvestment || 0;
+
+    if (maxItem.groupKey !== ruleSettings.baseCurrency) {
+      return {
+        evaluation: `The major part of your initial investment is not in your base currency (${(
+          baseCurrencyInvestmentRatio * 100
+        ).toPrecision(3)}% in ${ruleSettings.baseCurrency})`,
+        value: false
+      };
+    }
+
+    return {
+      evaluation: `The major part of your initial investment is in your base currency (${(
+        baseCurrencyInvestmentRatio * 100
+      ).toPrecision(3)}% in ${ruleSettings.baseCurrency})`,
+      value: true
+    };
+  }
+}

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

@@ -0,0 +1,64 @@
+import { PortfolioPosition } from 'apps/api/src/app/portfolio/interfaces/portfolio-position.interface';
+import { ExchangeRateDataService } from 'apps/api/src/services/exchange-rate-data.service';
+
+import { Rule } from '../../rule';
+
+export class CurrencyClusterRiskCurrentInvestment extends Rule {
+  public constructor(public exchangeRateDataService: ExchangeRateDataService) {
+    super(exchangeRateDataService, {
+      name: 'Current Investment'
+    });
+  }
+
+  public evaluate(
+    aPositions: { [symbol: string]: PortfolioPosition },
+    aFees: number,
+    aRuleSettingsMap?: {
+      [key: string]: any;
+    }
+  ) {
+    const ruleSettings =
+      aRuleSettingsMap[CurrencyClusterRiskCurrentInvestment.name];
+
+    const positionsGroupedByCurrency = this.groupPositionsByAttribute(
+      aPositions,
+      'currency',
+      ruleSettings.baseCurrency
+    );
+
+    let maxItem = positionsGroupedByCurrency[0];
+    let totalValue = 0;
+
+    positionsGroupedByCurrency.forEach((groupItem) => {
+      // Calculate total value
+      totalValue += groupItem.value;
+
+      // Find maximum
+      if (groupItem.value > maxItem.value) {
+        maxItem = groupItem;
+      }
+    });
+
+    const maxValueRatio = maxItem.value / totalValue;
+
+    if (maxValueRatio > ruleSettings.threshold) {
+      return {
+        evaluation: `Over ${
+          ruleSettings.threshold * 100
+        }% of your current investment is in ${maxItem.groupKey} (${(
+          maxValueRatio * 100
+        ).toPrecision(3)}%)`,
+        value: false
+      };
+    }
+
+    return {
+      evaluation: `The major part of your current investment is in ${
+        maxItem.groupKey
+      } (${(maxValueRatio * 100).toPrecision(3)}%) and does not exceed ${
+        ruleSettings.threshold * 100
+      }%`,
+      value: true
+    };
+  }
+}

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

@@ -0,0 +1,64 @@
+import { PortfolioPosition } from 'apps/api/src/app/portfolio/interfaces/portfolio-position.interface';
+import { ExchangeRateDataService } from 'apps/api/src/services/exchange-rate-data.service';
+
+import { Rule } from '../../rule';
+
+export class CurrencyClusterRiskInitialInvestment extends Rule {
+  public constructor(public exchangeRateDataService: ExchangeRateDataService) {
+    super(exchangeRateDataService, {
+      name: 'Initial Investment'
+    });
+  }
+
+  public evaluate(
+    aPositions: { [symbol: string]: PortfolioPosition },
+    aFees: number,
+    aRuleSettingsMap?: {
+      [key: string]: any;
+    }
+  ) {
+    const ruleSettings =
+      aRuleSettingsMap[CurrencyClusterRiskInitialInvestment.name];
+
+    const positionsGroupedByCurrency = this.groupPositionsByAttribute(
+      aPositions,
+      'currency',
+      ruleSettings.baseCurrency
+    );
+
+    let maxItem = positionsGroupedByCurrency[0];
+    let totalInvestment = 0;
+
+    positionsGroupedByCurrency.forEach((groupItem) => {
+      // Calculate total investment
+      totalInvestment += groupItem.investment;
+
+      // Find maximum
+      if (groupItem.investment > maxItem.investment) {
+        maxItem = groupItem;
+      }
+    });
+
+    const maxInvestmentRatio = maxItem.investment / totalInvestment;
+
+    if (maxInvestmentRatio > ruleSettings.threshold) {
+      return {
+        evaluation: `Over ${
+          ruleSettings.threshold * 100
+        }% of your initial investment is in ${maxItem.groupKey} (${(
+          maxInvestmentRatio * 100
+        ).toPrecision(3)}%)`,
+        value: false
+      };
+    }
+
+    return {
+      evaluation: `The major part of your initial investment is in ${
+        maxItem.groupKey
+      } (${(maxInvestmentRatio * 100).toPrecision(3)}%) and does not exceed ${
+        ruleSettings.threshold * 100
+      }%`,
+      value: true
+    };
+  }
+}

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

@@ -0,0 +1,53 @@
+import { PortfolioPosition } from 'apps/api/src/app/portfolio/interfaces/portfolio-position.interface';
+import { ExchangeRateDataService } from 'apps/api/src/services/exchange-rate-data.service';
+
+import { Rule } from '../../rule';
+
+export class FeeRatioInitialInvestment extends Rule {
+  public constructor(public exchangeRateDataService: ExchangeRateDataService) {
+    super(exchangeRateDataService, {
+      name: 'Initial Investment'
+    });
+  }
+
+  public evaluate(
+    aPositions: { [symbol: string]: PortfolioPosition },
+    aFees: number,
+    aRuleSettingsMap?: {
+      [key: string]: any;
+    }
+  ) {
+    const ruleSettings = aRuleSettingsMap[FeeRatioInitialInvestment.name];
+
+    const positionsGroupedByCurrency = this.groupPositionsByAttribute(
+      aPositions,
+      'currency',
+      ruleSettings.baseCurrency
+    );
+
+    let totalInvestment = 0;
+
+    positionsGroupedByCurrency.forEach((groupItem) => {
+      // Calculate total investment
+      totalInvestment += groupItem.investment;
+    });
+
+    const feeRatio = aFees / totalInvestment;
+
+    if (feeRatio > ruleSettings.threshold) {
+      return {
+        evaluation: `The fees do exceed ${
+          ruleSettings.threshold * 100
+        }% of your initial investment (${(feeRatio * 100).toPrecision(3)}%)`,
+        value: false
+      };
+    }
+
+    return {
+      evaluation: `The fees do not exceed ${
+        ruleSettings.threshold * 100
+      }% of your initial investment (${(feeRatio * 100).toPrecision(3)}%)`,
+      value: true
+    };
+  }
+}

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

@@ -0,0 +1,83 @@
+import { PortfolioPosition } from 'apps/api/src/app/portfolio/interfaces/portfolio-position.interface';
+import { ExchangeRateDataService } from 'apps/api/src/services/exchange-rate-data.service';
+
+import { Rule } from '../../rule';
+
+export class PlatformClusterRiskCurrentInvestment extends Rule {
+  public constructor(public exchangeRateDataService: ExchangeRateDataService) {
+    super(exchangeRateDataService, {
+      name: 'Current Investment'
+    });
+  }
+
+  public evaluate(
+    aPositions: { [symbol: string]: PortfolioPosition },
+    aFees: number,
+    aRuleSettingsMap?: {
+      [key: string]: any;
+    }
+  ) {
+    const ruleSettings =
+      aRuleSettingsMap[PlatformClusterRiskCurrentInvestment.name];
+
+    const platforms: {
+      [symbol: string]: Pick<PortfolioPosition, 'name'> & {
+        investment: number;
+      };
+    } = {};
+
+    Object.values(aPositions).forEach((position) => {
+      for (const [platform, { current }] of Object.entries(
+        position.platforms
+      )) {
+        if (platforms[platform]?.investment) {
+          platforms[platform].investment += current;
+        } else {
+          platforms[platform] = {
+            investment: current,
+            name: platform
+          };
+        }
+      }
+    });
+
+    let maxItem;
+    let totalInvestment = 0;
+
+    Object.values(platforms).forEach((platform) => {
+      if (!maxItem) {
+        maxItem = platform;
+      }
+
+      // Calculate total investment
+      totalInvestment += platform.investment;
+
+      // Find maximum
+      if (platform.investment > maxItem?.investment) {
+        maxItem = platform;
+      }
+    });
+
+    const maxInvestmentRatio = maxItem.investment / totalInvestment;
+
+    if (maxInvestmentRatio > ruleSettings.threshold) {
+      return {
+        evaluation: `Over ${
+          ruleSettings.threshold * 100
+        }% of your current investment is at ${maxItem.name} (${(
+          maxInvestmentRatio * 100
+        ).toPrecision(3)}%)`,
+        value: false
+      };
+    }
+
+    return {
+      evaluation: `The major part of your current investment is at ${
+        maxItem.name
+      } (${(maxInvestmentRatio * 100).toPrecision(3)}%) and does not exceed ${
+        ruleSettings.threshold * 100
+      }%`,
+      value: true
+    };
+  }
+}

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

@@ -0,0 +1,83 @@
+import { PortfolioPosition } from 'apps/api/src/app/portfolio/interfaces/portfolio-position.interface';
+import { ExchangeRateDataService } from 'apps/api/src/services/exchange-rate-data.service';
+
+import { Rule } from '../../rule';
+
+export class PlatformClusterRiskInitialInvestment extends Rule {
+  public constructor(public exchangeRateDataService: ExchangeRateDataService) {
+    super(exchangeRateDataService, {
+      name: 'Initial Investment'
+    });
+  }
+
+  public evaluate(
+    aPositions: { [symbol: string]: PortfolioPosition },
+    aFees: number,
+    aRuleSettingsMap?: {
+      [key: string]: any;
+    }
+  ) {
+    const ruleSettings =
+      aRuleSettingsMap[PlatformClusterRiskInitialInvestment.name];
+
+    const platforms: {
+      [symbol: string]: Pick<PortfolioPosition, 'name'> & {
+        investment: number;
+      };
+    } = {};
+
+    Object.values(aPositions).forEach((position) => {
+      for (const [platform, { original }] of Object.entries(
+        position.platforms
+      )) {
+        if (platforms[platform]?.investment) {
+          platforms[platform].investment += original;
+        } else {
+          platforms[platform] = {
+            investment: original,
+            name: platform
+          };
+        }
+      }
+    });
+
+    let maxItem;
+    let totalInvestment = 0;
+
+    Object.values(platforms).forEach((platform) => {
+      if (!maxItem) {
+        maxItem = platform;
+      }
+
+      // Calculate total investment
+      totalInvestment += platform.investment;
+
+      // Find maximum
+      if (platform.investment > maxItem?.investment) {
+        maxItem = platform;
+      }
+    });
+
+    const maxInvestmentRatio = maxItem.investment / totalInvestment;
+
+    if (maxInvestmentRatio > ruleSettings.threshold) {
+      return {
+        evaluation: `Over ${
+          ruleSettings.threshold * 100
+        }% of your initial investment is at ${maxItem.name} (${(
+          maxInvestmentRatio * 100
+        ).toPrecision(3)}%)`,
+        value: false
+      };
+    }
+
+    return {
+      evaluation: `The major part of your initial investment is at ${
+        maxItem.name
+      } (${(maxInvestmentRatio * 100).toPrecision(3)}%) and does not exceed ${
+        ruleSettings.threshold * 100
+      }%`,
+      value: true
+    };
+  }
+}

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

@@ -0,0 +1,36 @@
+import { PortfolioPosition } from 'apps/api/src/app/portfolio/interfaces/portfolio-position.interface';
+import { ExchangeRateDataService } from 'apps/api/src/services/exchange-rate-data.service';
+
+import { Rule } from '../../rule';
+
+export class PlatformClusterRiskSinglePlatform extends Rule {
+  public constructor(public exchangeRateDataService: ExchangeRateDataService) {
+    super(exchangeRateDataService, {
+      name: 'Single Platform'
+    });
+  }
+
+  public evaluate(positions: { [symbol: string]: PortfolioPosition }) {
+    const platforms: string[] = [];
+
+    Object.values(positions).forEach((position) => {
+      for (const [platform] of Object.entries(position.platforms)) {
+        if (!platforms.includes(platform)) {
+          platforms.push(platform);
+        }
+      }
+    });
+
+    if (platforms.length === 1) {
+      return {
+        evaluation: `All your investment is managed by a single platform`,
+        value: false
+      };
+    }
+
+    return {
+      evaluation: `Your investment is managed by ${platforms.length} platforms`,
+      value: true
+    };
+  }
+}

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

@@ -0,0 +1,23 @@
+import { Injectable } from '@nestjs/common';
+import { Cron, CronExpression } from '@nestjs/schedule';
+
+import { DataGatheringService } from './data-gathering.service';
+import { ExchangeRateDataService } from './exchange-rate-data.service';
+
+@Injectable()
+export class CronService {
+  public constructor(
+    private readonly dataGatheringService: DataGatheringService,
+    private readonly exchangeRateDataService: ExchangeRateDataService
+  ) {}
+
+  @Cron(CronExpression.EVERY_MINUTE)
+  public async runEveryMinute() {
+    await this.dataGatheringService.gather7Days();
+  }
+
+  @Cron(CronExpression.EVERY_12_HOURS)
+  public async runEveryTwelveHours() {
+    await this.exchangeRateDataService.loadCurrencies();
+  }
+}

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

@@ -0,0 +1,256 @@
+import { Injectable } from '@nestjs/common';
+import {
+  differenceInHours,
+  format,
+  getDate,
+  getMonth,
+  getYear,
+  isBefore,
+  subDays
+} from 'date-fns';
+import { benchmarks, currencyPairs } from 'libs/helper/src';
+import { getUtc, resetHours } from 'libs/helper/src';
+
+import { DataProviderService } from './data-provider.service';
+import { PrismaService } from './prisma.service';
+
+@Injectable()
+export class DataGatheringService {
+  public constructor(
+    private dataProviderService: DataProviderService,
+    private prisma: PrismaService
+  ) {}
+
+  public async gather7Days() {
+    const isDataGatheringNeeded = await this.isDataGatheringNeeded();
+
+    if (isDataGatheringNeeded) {
+      console.log('7d data gathering has been started.');
+      console.time('data-gathering');
+
+      await this.prisma.property.create({
+        data: {
+          key: 'LOCKED_DATA_GATHERING',
+          value: new Date().toISOString()
+        }
+      });
+
+      const symbols = await this.getSymbols7D();
+
+      try {
+        await this.gatherSymbols(symbols);
+
+        await this.prisma.property.upsert({
+          create: {
+            key: 'LAST_DATA_GATHERING',
+            value: new Date().toISOString()
+          },
+          update: { value: new Date().toISOString() },
+          where: { key: 'LAST_DATA_GATHERING' }
+        });
+      } catch (error) {
+        console.error(error);
+      }
+
+      await this.prisma.property.delete({
+        where: {
+          key: 'LOCKED_DATA_GATHERING'
+        }
+      });
+
+      console.log('7d data gathering has been completed.');
+      console.timeEnd('data-gathering');
+    }
+  }
+
+  public async gatherMax() {
+    const isDataGatheringNeeded = await this.isDataGatheringNeeded();
+
+    if (isDataGatheringNeeded) {
+      console.log('Max data gathering has been started.');
+      console.time('data-gathering');
+
+      await this.prisma.property.create({
+        data: {
+          key: 'LOCKED_DATA_GATHERING',
+          value: new Date().toISOString()
+        }
+      });
+
+      const symbols = await this.getSymbolsMax();
+
+      try {
+        await this.gatherSymbols(symbols);
+
+        await this.prisma.property.upsert({
+          create: {
+            key: 'LAST_DATA_GATHERING',
+            value: new Date().toISOString()
+          },
+          update: { value: new Date().toISOString() },
+          where: { key: 'LAST_DATA_GATHERING' }
+        });
+      } catch (error) {
+        console.error(error);
+      }
+
+      await this.prisma.property.delete({
+        where: {
+          key: 'LOCKED_DATA_GATHERING'
+        }
+      });
+
+      console.log('Max data gathering has been completed.');
+      console.timeEnd('data-gathering');
+    }
+  }
+
+  public async gatherSymbols(
+    aSymbolsWithStartDate: { date: Date; symbol: string }[]
+  ) {
+    let hasError = false;
+
+    for (const { date, symbol } of aSymbolsWithStartDate) {
+      try {
+        const historicalData = await this.dataProviderService.getHistoricalRaw(
+          [symbol],
+          date,
+          new Date()
+        );
+
+        let currentDate = date;
+        let lastMarketPrice: number;
+
+        while (
+          isBefore(
+            currentDate,
+            new Date(
+              Date.UTC(
+                getYear(new Date()),
+                getMonth(new Date()),
+                getDate(new Date()),
+                0
+              )
+            )
+          )
+        ) {
+          if (
+            historicalData[symbol]?.[format(currentDate, 'yyyy-MM-dd')]
+              ?.marketPrice
+          ) {
+            lastMarketPrice =
+              historicalData[symbol]?.[format(currentDate, 'yyyy-MM-dd')]
+                ?.marketPrice;
+          }
+
+          try {
+            await this.prisma.marketData.create({
+              data: {
+                symbol,
+                date: currentDate,
+                marketPrice: lastMarketPrice
+              }
+            });
+          } catch {}
+
+          // Count month one up for iteration
+          currentDate = new Date(
+            Date.UTC(
+              getYear(currentDate),
+              getMonth(currentDate),
+              getDate(currentDate) + 1,
+              0
+            )
+          );
+        }
+      } catch (error) {
+        hasError = true;
+        console.error(error);
+      }
+    }
+
+    if (hasError) {
+      throw '';
+    }
+  }
+
+  private async getSymbols7D(): Promise<{ date: Date; symbol: string }[]> {
+    const startDate = subDays(resetHours(new Date()), 7);
+
+    let distinctOrders = await this.prisma.order.findMany({
+      distinct: ['symbol'],
+      orderBy: [{ symbol: 'asc' }],
+      select: { symbol: true }
+    });
+
+    const distinctOrdersWithDate = distinctOrders.map((distinctOrder) => {
+      return {
+        ...distinctOrder,
+        date: startDate
+      };
+    });
+
+    const benchmarksToGather = benchmarks.map((symbol) => {
+      return {
+        symbol,
+        date: startDate
+      };
+    });
+
+    const currencyPairsToGather = currencyPairs.map((symbol) => {
+      return {
+        symbol,
+        date: startDate
+      };
+    });
+
+    return [
+      ...benchmarksToGather,
+      ...currencyPairsToGather,
+      ...distinctOrdersWithDate
+    ];
+  }
+
+  private async getSymbolsMax() {
+    const startDate = new Date(getUtc('2000-01-01'));
+
+    let distinctOrders = await this.prisma.order.findMany({
+      distinct: ['symbol'],
+      orderBy: [{ date: 'asc' }],
+      select: { date: true, symbol: true }
+    });
+
+    const benchmarksToGather = benchmarks.map((symbol) => {
+      return {
+        symbol,
+        date: startDate
+      };
+    });
+
+    const currencyPairsToGather = currencyPairs.map((symbol) => {
+      return {
+        symbol,
+        date: startDate
+      };
+    });
+
+    return [...benchmarksToGather, ...currencyPairsToGather, ...distinctOrders];
+  }
+
+  private async isDataGatheringNeeded() {
+    const lastDataGathering = await this.prisma.property.findUnique({
+      where: { key: 'LAST_DATA_GATHERING' }
+    });
+
+    const isDataGatheringLocked = await this.prisma.property.findUnique({
+      where: { key: 'LOCKED_DATA_GATHERING' }
+    });
+
+    const diffInHours = differenceInHours(
+      new Date(),
+      new Date(lastDataGathering?.value)
+    );
+
+    return (diffInHours >= 1 || !lastDataGathering) && !isDataGatheringLocked;
+  }
+}

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

@@ -0,0 +1,139 @@
+import { Injectable } from '@nestjs/common';
+import { MarketData } from '@prisma/client';
+import { format } from 'date-fns';
+import { isCrypto, isRakutenRapidApi } from 'libs/helper/src';
+
+import { AlphaVantageService } from './data-provider/alpha-vantage/alpha-vantage.service';
+import { RakutenRapidApiService } from './data-provider/rakuten-rapid-api/rakuten-rapid-api.service';
+import { YahooFinanceService } from './data-provider/yahoo-finance/yahoo-finance.service';
+import { DataProviderInterface } from './interfaces/data-provider.interface';
+import { Granularity } from './interfaces/granularity.type';
+import {
+  IDataProviderHistoricalResponse,
+  IDataProviderResponse
+} from './interfaces/interfaces';
+import { PrismaService } from './prisma.service';
+
+@Injectable()
+export class DataProviderService implements DataProviderInterface {
+  public constructor(
+    private alphaVantageService: AlphaVantageService,
+    private prisma: PrismaService,
+    private rakutenRapidApiService: RakutenRapidApiService,
+    private yahooFinanceService: YahooFinanceService
+  ) {
+    this.rakutenRapidApiService.setPrisma(this.prisma);
+  }
+
+  public async get(
+    aSymbols: string[]
+  ): Promise<{ [symbol: string]: IDataProviderResponse }> {
+    if (aSymbols.length === 1) {
+      const symbol = aSymbols[0];
+
+      if (isRakutenRapidApi(symbol)) {
+        return this.rakutenRapidApiService.get(aSymbols);
+      }
+    }
+
+    return this.yahooFinanceService.get(aSymbols);
+  }
+
+  public async getHistorical(
+    aSymbols: string[],
+    aGranularity: Granularity = 'month',
+    from: Date,
+    to: Date
+  ): Promise<{
+    [symbol: string]: { [date: string]: IDataProviderHistoricalResponse };
+  }> {
+    let response: {
+      [symbol: string]: { [date: string]: IDataProviderHistoricalResponse };
+    } = {};
+
+    let granularityQuery =
+      aGranularity === 'month'
+        ? `AND (date_part('day', date) = 1 OR date >= TIMESTAMP 'yesterday')`
+        : '';
+
+    let rangeQuery =
+      from && to
+        ? `AND date >= '${format(from, 'yyyy-MM-dd')}' AND date <= '${format(
+            to,
+            'yyyy-MM-dd'
+          )}'`
+        : '';
+
+    try {
+      const queryRaw = `SELECT * FROM "MarketData" WHERE "symbol" IN ('${aSymbols.join(
+        `','`
+      )}') ${granularityQuery} ${rangeQuery} ORDER BY date;`;
+
+      const marketDataByGranularity: MarketData[] = await this.prisma.$queryRaw(
+        queryRaw
+      );
+
+      response = marketDataByGranularity.reduce((r, marketData) => {
+        const { date, marketPrice, symbol } = marketData;
+
+        r[symbol] = {
+          ...(r[symbol] || {}),
+          [format(new Date(date), 'yyyy-MM-dd')]: { marketPrice }
+        };
+
+        return r;
+      }, {});
+    } catch (error) {
+      console.error(error);
+    } finally {
+      return response;
+    }
+  }
+
+  public async getHistoricalRaw(
+    aSymbols: string[],
+    from: Date,
+    to: Date
+  ): Promise<{
+    [symbol: string]: { [date: string]: IDataProviderHistoricalResponse };
+  }> {
+    const dataOfYahoo = await this.yahooFinanceService.getHistorical(
+      aSymbols,
+      undefined,
+      from,
+      to
+    );
+
+    if (aSymbols.length === 1) {
+      const symbol = aSymbols[0];
+
+      if (isCrypto(symbol)) {
+        // Merge data from Yahoo with data from Alpha Vantage
+        const dataOfAlphaVantage = await this.alphaVantageService.getHistorical(
+          [symbol],
+          undefined,
+          from,
+          to
+        );
+
+        return {
+          [symbol]: {
+            ...dataOfYahoo[symbol],
+            ...dataOfAlphaVantage[symbol]
+          }
+        };
+      } else if (isRakutenRapidApi(symbol)) {
+        const dataOfRakutenRapidApi = await this.rakutenRapidApiService.getHistorical(
+          [symbol],
+          undefined,
+          from,
+          to
+        );
+
+        return dataOfRakutenRapidApi;
+      }
+    }
+
+    return dataOfYahoo;
+  }
+}

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

@@ -0,0 +1,78 @@
+import { Injectable } from '@nestjs/common';
+import { isAfter, isBefore, parse } from 'date-fns';
+
+import { DataProviderInterface } from '../../interfaces/data-provider.interface';
+import { Granularity } from '../../interfaces/granularity.type';
+import {
+  IDataProviderHistoricalResponse,
+  IDataProviderResponse
+} from '../../interfaces/interfaces';
+import { IAlphaVantageHistoricalResponse } from './interfaces/interfaces';
+
+const alphaVantage = require('alphavantage')({
+  key: process.env.ALPHA_VANTAGE_API_KEY
+});
+
+@Injectable()
+export class AlphaVantageService implements DataProviderInterface {
+  public constructor() {}
+
+  public async get(
+    aSymbols: string[]
+  ): Promise<{ [symbol: string]: IDataProviderResponse }> {
+    return {};
+  }
+
+  public async getHistorical(
+    aSymbols: string[],
+    aGranularity: Granularity = 'day',
+    from: Date,
+    to: Date
+  ): Promise<{
+    [symbol: string]: { [date: string]: IDataProviderHistoricalResponse };
+  }> {
+    if (aSymbols.length <= 0) {
+      return {};
+    }
+
+    const symbol = aSymbols[0];
+
+    try {
+      const historicalData: {
+        [symbol: string]: IAlphaVantageHistoricalResponse[];
+      } = await alphaVantage.crypto.daily(
+        symbol.substring(0, symbol.length - 3).toLowerCase(),
+        'usd'
+      );
+
+      const response: {
+        [symbol: string]: { [date: string]: IDataProviderHistoricalResponse };
+      } = {};
+
+      response[symbol] = {};
+
+      for (const [key, timeSeries] of Object.entries(
+        historicalData['Time Series (Digital Currency Daily)']
+      ).sort()) {
+        if (
+          isAfter(from, parse(key, 'yyyy-MM-dd', new Date())) &&
+          isBefore(to, parse(key, 'yyyy-MM-dd', new Date()))
+        ) {
+          response[symbol][key] = {
+            marketPrice: parseFloat(timeSeries['4a. close (USD)'])
+          };
+        }
+      }
+
+      return response;
+    } catch (error) {
+      console.error(error, symbol);
+
+      return {};
+    }
+  }
+
+  public search(aSymbol: string) {
+    return alphaVantage.data.search(aSymbol);
+  }
+}

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

@@ -0,0 +1 @@
+export interface IAlphaVantageHistoricalResponse {}

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

@@ -0,0 +1 @@
+export interface IRakutenRapidApiResponse {}

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

@@ -0,0 +1,146 @@
+import { Injectable } from '@nestjs/common';
+import * as bent from 'bent';
+import { format, subMonths, subWeeks, subYears } from 'date-fns';
+import { getToday, getYesterday } from 'libs/helper/src';
+
+import { DataProviderInterface } from '../../interfaces/data-provider.interface';
+import { Granularity } from '../../interfaces/granularity.type';
+import {
+  IDataProviderHistoricalResponse,
+  IDataProviderResponse
+} from '../../interfaces/interfaces';
+import { PrismaService } from '../../prisma.service';
+
+@Injectable()
+export class RakutenRapidApiService implements DataProviderInterface {
+  public static FEAR_AND_GREED_INDEX_NAME = 'Fear & Greed Index';
+
+  private prisma: PrismaService;
+
+  public constructor() {}
+
+  public async get(
+    aSymbols: string[]
+  ): Promise<{ [symbol: string]: IDataProviderResponse }> {
+    if (aSymbols.length <= 0) {
+      return {};
+    }
+
+    try {
+      const symbol = aSymbols[0];
+
+      if (symbol === 'GF.FEAR_AND_GREED_INDEX') {
+        const fgi = await this.getFearAndGreedIndex();
+
+        return {
+          'GF.FEAR_AND_GREED_INDEX': {
+            currency: undefined,
+            isMarketOpen: true,
+            marketPrice: fgi.now.value,
+            name: RakutenRapidApiService.FEAR_AND_GREED_INDEX_NAME
+          }
+        };
+      }
+    } catch (error) {
+      console.error(error);
+    }
+
+    return {};
+  }
+
+  public async getHistorical(
+    aSymbols: string[],
+    aGranularity: Granularity = 'day',
+    from: Date,
+    to: Date
+  ): Promise<{
+    [symbol: string]: { [date: string]: IDataProviderHistoricalResponse };
+  }> {
+    if (aSymbols.length <= 0) {
+      return {};
+    }
+
+    try {
+      const symbol = aSymbols[0];
+
+      if (symbol === 'GF.FEAR_AND_GREED_INDEX') {
+        const fgi = await this.getFearAndGreedIndex();
+
+        try {
+          // Rebuild historical data
+          // TODO: can be removed after all data from the last year has been gathered
+          // (introduced on 27.03.2021)
+
+          await this.prisma.marketData.create({
+            data: {
+              symbol,
+              date: subWeeks(getToday(), 1),
+              marketPrice: fgi.oneWeekAgo.value
+            }
+          });
+
+          await this.prisma.marketData.create({
+            data: {
+              symbol,
+              date: subMonths(getToday(), 1),
+              marketPrice: fgi.oneMonthAgo.value
+            }
+          });
+
+          await this.prisma.marketData.create({
+            data: {
+              symbol,
+              date: subYears(getToday(), 1),
+              marketPrice: fgi.oneYearAgo.value
+            }
+          });
+
+          ///////////////////////////////////////////////////////////////////////////
+        } catch {}
+
+        return {
+          'GF.FEAR_AND_GREED_INDEX': {
+            [format(getYesterday(), 'yyyy-MM-dd')]: {
+              marketPrice: fgi.previousClose.value
+            }
+          }
+        };
+      }
+    } catch (error) {}
+
+    return {};
+  }
+
+  private async getFearAndGreedIndex(): Promise<{
+    now: { value: number; valueText: string };
+    previousClose: { value: number; valueText: string };
+    oneWeekAgo: { value: number; valueText: string };
+    oneMonthAgo: { value: number; valueText: string };
+    oneYearAgo: { value: number; valueText: string };
+  }> {
+    try {
+      const get = bent(
+        `https://fear-and-greed-index.p.rapidapi.com/v1/fgi`,
+        'GET',
+        'json',
+        200,
+        {
+          useQueryString: true,
+          'x-rapidapi-host': 'fear-and-greed-index.p.rapidapi.com',
+          'x-rapidapi-key': process.env.RAKUTEN_RAPID_API_KEY
+        }
+      );
+
+      const { fgi } = await get();
+      return fgi;
+    } catch (error) {
+      console.error(error);
+
+      return undefined;
+    }
+  }
+
+  public setPrisma(aPrismaService: PrismaService) {
+    this.prisma = aPrismaService;
+  }
+}

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

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

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

@@ -0,0 +1,24 @@
+/*
+  import { Test } from '@nestjs/testing';
+
+  import { YahooFinanceService } from './yahoo-finance.service';
+
+  describe('AppService', () => {
+    let service: YahooFinanceService;
+
+    beforeAll(async () => {
+      const app = await Test.createTestingModule({
+        imports: [],
+        providers: [YahooFinanceService]
+      }).compile();
+
+      service = app.get<YahooFinanceService>(YahooFinanceService);
+    });
+
+    describe('get', () => {
+      it('should return data for USDCHF', () => {
+        expect(service.get(['USDCHF'])).toEqual('{}');
+      });
+    });
+  });
+*/

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

@@ -0,0 +1,239 @@
+import { Injectable } from '@nestjs/common';
+import { format } from 'date-fns';
+import { isCrypto, isCurrency, parseCurrency } from 'libs/helper/src';
+import * as yahooFinance from 'yahoo-finance';
+
+import { DataProviderInterface } from '../../interfaces/data-provider.interface';
+import { Granularity } from '../../interfaces/granularity.type';
+import {
+  IDataProviderHistoricalResponse,
+  IDataProviderResponse,
+  Industry,
+  Sector,
+  Type
+} from '../../interfaces/interfaces';
+import {
+  IYahooFinanceHistoricalResponse,
+  IYahooFinanceQuoteResponse
+} from './interfaces/interfaces';
+
+@Injectable()
+export class YahooFinanceService implements DataProviderInterface {
+  public constructor() {}
+
+  public async get(
+    aSymbols: string[]
+  ): Promise<{ [symbol: string]: IDataProviderResponse }> {
+    if (aSymbols.length <= 0) {
+      return {};
+    }
+
+    const yahooSymbols = aSymbols.map((symbol) => {
+      return this.convertToYahooSymbol(symbol);
+    });
+
+    try {
+      const response: { [symbol: string]: IDataProviderResponse } = {};
+
+      const data: {
+        [symbol: string]: IYahooFinanceQuoteResponse;
+      } = await yahooFinance.quote({
+        modules: ['price', 'summaryProfile'],
+        symbols: yahooSymbols
+      });
+
+      for (const [yahooSymbol, value] of Object.entries(data)) {
+        // Convert symbols back
+        const symbol = convertFromYahooSymbol(yahooSymbol);
+
+        response[symbol] = {
+          currency: parseCurrency(value.price?.currency),
+          exchange: this.parseExchange(value.price?.exchangeName),
+          isMarketOpen:
+            value.price?.marketState === 'REGULAR' || isCrypto(symbol),
+          marketPrice: value.price?.regularMarketPrice || 0,
+          name: value.price?.longName || value.price?.shortName || symbol,
+          type: this.parseType(this.getType(symbol, value))
+        };
+
+        const industry = this.parseIndustry(value.summaryProfile?.industry);
+        if (industry) {
+          response[symbol].industry = industry;
+        }
+
+        const sector = this.parseSector(value.summaryProfile?.sector);
+        if (sector) {
+          response[symbol].sector = sector;
+        }
+
+        const url = value.summaryProfile?.website;
+        if (url) {
+          response[symbol].url = url;
+        }
+      }
+
+      return response;
+    } catch (error) {
+      console.error(error);
+
+      return {};
+    }
+  }
+
+  public async getHistorical(
+    aSymbols: string[],
+    aGranularity: Granularity = 'day',
+    from: Date,
+    to: Date
+  ): Promise<{
+    [symbol: string]: { [date: string]: IDataProviderHistoricalResponse };
+  }> {
+    if (aSymbols.length <= 0) {
+      return {};
+    }
+
+    const yahooSymbols = aSymbols.map((symbol) => {
+      return this.convertToYahooSymbol(symbol);
+    });
+
+    try {
+      const historicalData: {
+        [symbol: string]: IYahooFinanceHistoricalResponse[];
+      } = await yahooFinance.historical({
+        symbols: yahooSymbols,
+        from: format(from, 'yyyy-MM-dd'),
+        to: format(to, 'yyyy-MM-dd')
+      });
+
+      const response: {
+        [symbol: string]: { [date: string]: IDataProviderHistoricalResponse };
+      } = {};
+
+      for (const [yahooSymbol, timeSeries] of Object.entries(historicalData)) {
+        // Convert symbols back
+        const symbol = convertFromYahooSymbol(yahooSymbol);
+        response[symbol] = {};
+
+        timeSeries.forEach((timeSerie) => {
+          response[symbol][format(timeSerie.date, 'yyyy-MM-dd')] = {
+            marketPrice: timeSerie.close,
+            performance: timeSerie.open - timeSerie.close
+          };
+        });
+      }
+
+      return response;
+    } catch (error) {
+      console.error(error);
+
+      return {};
+    }
+  }
+
+  /**
+   * Converts a symbol to a Yahoo symbol
+   *
+   * Currency:        USDCHF=X
+   * Cryptocurrency:  BTC-USD
+   */
+  private convertToYahooSymbol(aSymbol: string) {
+    if (isCurrency(aSymbol)) {
+      if (isCrypto(aSymbol)) {
+        // Add a dash before the last three characters
+        // BTCUSD  -> BTC-USD
+        // DOGEUSD -> DOGE-USD
+        return `${aSymbol.substring(0, aSymbol.length - 3)}-${aSymbol.substring(
+          aSymbol.length - 3
+        )}`;
+      }
+
+      return `${aSymbol}=X`;
+    }
+
+    return aSymbol;
+  }
+
+  private getType(aSymbol: string, aValue: IYahooFinanceQuoteResponse): Type {
+    if (isCrypto(aSymbol)) {
+      return Type.Cryptocurrency;
+    } else if (aValue.price?.quoteType.toLowerCase() === 'equity') {
+      return Type.Stock;
+    }
+
+    return aValue.price?.quoteType.toLowerCase();
+  }
+
+  private parseExchange(aString: string): string {
+    if (aString?.toLowerCase() === 'ccc') {
+      return 'Other';
+    }
+
+    return aString;
+  }
+
+  private parseIndustry(aString: string): Industry {
+    if (aString === undefined) {
+      return undefined;
+    }
+
+    if (aString?.toLowerCase() === 'auto manufacturers') {
+      return Industry.Automotive;
+    } else if (aString?.toLowerCase() === 'biotechnology') {
+      return Industry.Biotechnology;
+    } else if (
+      aString?.toLowerCase() === 'drug manufacturers—specialty & generic'
+    ) {
+      return Industry.Pharmaceutical;
+    } else if (
+      aString?.toLowerCase() === 'internet content & information' ||
+      aString?.toLowerCase() === 'internet retail'
+    ) {
+      return Industry.Internet;
+    } else if (aString?.toLowerCase() === 'packaged foods') {
+      return Industry.Food;
+    } else if (aString?.toLowerCase() === 'software—application') {
+      return Industry.Software;
+    }
+
+    return Industry.Other;
+  }
+
+  private parseSector(aString: string): Sector {
+    if (aString === undefined) {
+      return undefined;
+    }
+
+    if (
+      aString?.toLowerCase() === 'consumer cyclical' ||
+      aString?.toLowerCase() === 'consumer defensive'
+    ) {
+      return Sector.Consumer;
+    } else if (aString?.toLowerCase() === 'healthcare') {
+      return Sector.Healthcare;
+    } else if (
+      aString?.toLowerCase() === 'communication services' ||
+      aString?.toLowerCase() === 'technology'
+    ) {
+      return Sector.Technology;
+    }
+
+    return Sector.Other;
+  }
+
+  private parseType(aString: string): Type {
+    if (aString?.toLowerCase() === 'cryptocurrency') {
+      return Type.Cryptocurrency;
+    } else if (aString?.toLowerCase() === 'etf') {
+      return Type.ETF;
+    } else if (aString?.toLowerCase() === 'stock') {
+      return Type.Stock;
+    }
+
+    return Type.Other;
+  }
+}
+
+export const convertFromYahooSymbol = (aSymbol: string) => {
+  let symbol = aSymbol.replace('-', '');
+  return symbol.replace('=X', '');
+};

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

@@ -0,0 +1,71 @@
+import { Injectable } from '@nestjs/common';
+import { Currency } from '@prisma/client';
+import { format } from 'date-fns';
+import { getYesterday } from 'libs/helper/src';
+
+import { DataProviderService } from './data-provider.service';
+
+@Injectable()
+export class ExchangeRateDataService {
+  private currencies = {};
+  private pairs: string[] = [];
+
+  public constructor(private dataProviderService: DataProviderService) {
+    this.initialize();
+  }
+
+  public async initialize() {
+    this.addPairs(Currency.CHF, Currency.EUR);
+    this.addPairs(Currency.CHF, Currency.GBP);
+    this.addPairs(Currency.CHF, Currency.USD);
+    this.addPairs(Currency.EUR, Currency.GBP);
+    this.addPairs(Currency.EUR, Currency.USD);
+    this.addPairs(Currency.GBP, Currency.USD);
+
+    await this.loadCurrencies();
+  }
+
+  private addPairs(aCurrency1: Currency, aCurrency2: Currency) {
+    this.pairs.push(`${aCurrency1}${aCurrency2}`);
+    this.pairs.push(`${aCurrency2}${aCurrency1}`);
+  }
+
+  public async loadCurrencies() {
+    const result = await this.dataProviderService.getHistorical(
+      this.pairs,
+      'day',
+      getYesterday(),
+      getYesterday()
+    );
+
+    this.pairs.forEach((pair) => {
+      this.currencies[pair] =
+        result[pair]?.[format(getYesterday(), 'yyyy-MM-dd')]?.marketPrice || 1;
+
+      if (this.currencies[pair] === 1) {
+        // Calculate the other direction
+        const [currency1, currency2] = pair.match(/.{1,3}/g);
+
+        this.currencies[pair] =
+          1 /
+          result[`${currency2}${currency1}`]?.[
+            format(getYesterday(), 'yyyy-MM-dd')
+          ]?.marketPrice;
+      }
+    });
+  }
+
+  public toCurrency(
+    aValue: number,
+    aFromCurrency: Currency,
+    aToCurrency: Currency
+  ) {
+    let factor = 1;
+
+    if (aFromCurrency !== aToCurrency) {
+      factor = this.currencies[`${aFromCurrency}${aToCurrency}`];
+    }
+
+    return factor * aValue;
+  }
+}

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

@@ -0,0 +1,16 @@
+import { Injectable } from '@nestjs/common';
+
+import { PrismaService } from './prisma.service';
+
+@Injectable()
+export class ImpersonationService {
+  public constructor(private prisma: PrismaService) {}
+
+  public async validateImpersonationId(aId = '', aUserId: string) {
+    const accessObject = await this.prisma.access.findFirst({
+      where: { GranteeUser: { id: aUserId }, id: aId }
+    });
+
+    return accessObject?.userId;
+  }
+}

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

@@ -0,0 +1,18 @@
+import { Granularity } from './granularity.type';
+import {
+  IDataProviderHistoricalResponse,
+  IDataProviderResponse
+} from './interfaces';
+
+export interface DataProviderInterface {
+  get(aSymbols: string[]): Promise<{ [symbol: string]: IDataProviderResponse }>;
+
+  getHistorical(
+    aSymbols: string[],
+    aGranularity: Granularity,
+    from: Date,
+    to: Date
+  ): Promise<{
+    [symbol: string]: { [date: string]: IDataProviderHistoricalResponse };
+  }>;
+}

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

@@ -0,0 +1 @@
+export type Granularity = 'day' | 'month';

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

@@ -0,0 +1,64 @@
+import { Currency, Platform } from '@prisma/client';
+
+import { OrderType } from '../../models/order-type';
+
+export const Industry = {
+  Automotive: 'Automotive',
+  Biotechnology: 'Biotechnology',
+  Food: 'Food',
+  Internet: 'Internet',
+  Other: 'Other',
+  Pharmaceutical: 'Pharmaceutical',
+  Software: 'Software'
+};
+
+export const Sector = {
+  Consumer: 'Consumer',
+  Healthcare: 'Healthcare',
+  Other: 'Other',
+  Technology: 'Technology'
+};
+
+export const Type = {
+  Cryptocurrency: 'Cryptocurrency',
+  ETF: 'ETF',
+  Other: 'Other',
+  Stock: 'Stock'
+};
+
+export interface IOrder {
+  currency: Currency;
+  date: string;
+  fee: number;
+  id?: string;
+  platform: Platform;
+  quantity: number;
+  symbol: string;
+  type: OrderType;
+  unitPrice: number;
+}
+
+export interface IDataProviderHistoricalResponse {
+  marketPrice: number;
+  performance?: number;
+}
+
+export interface IDataProviderResponse {
+  currency: Currency;
+  exchange?: string;
+  industry?: Industry;
+  isMarketOpen: boolean;
+  marketChange?: number;
+  marketChangePercent?: number;
+  marketPrice: number;
+  name: string;
+  sector?: Sector;
+  type?: Type;
+  url?: string;
+}
+
+export type Industry = typeof Industry[keyof typeof Industry];
+
+export type Sector = typeof Sector[keyof typeof Sector];
+
+export type Type = typeof Type[keyof typeof Type];

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

@@ -0,0 +1,14 @@
+import { Injectable, OnModuleDestroy, OnModuleInit } from '@nestjs/common';
+import { PrismaClient } from '@prisma/client';
+
+@Injectable()
+export class PrismaService extends PrismaClient
+  implements OnModuleInit, OnModuleDestroy {
+  async onModuleInit() {
+    await this.$connect();
+  }
+
+  async onModuleDestroy() {
+    await this.$disconnect();
+  }
+}

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

@@ -0,0 +1,78 @@
+import { Injectable } from '@nestjs/common';
+
+import { Portfolio } from '../models/portfolio';
+import { Rule } from '../models/rule';
+import { CurrencyClusterRiskBaseCurrencyCurrentInvestment } from '../models/rules/currency-cluster-risk/base-currency-current-investment';
+import { CurrencyClusterRiskBaseCurrencyInitialInvestment } from '../models/rules/currency-cluster-risk/base-currency-initial-investment';
+import { CurrencyClusterRiskCurrentInvestment } from '../models/rules/currency-cluster-risk/current-investment';
+import { CurrencyClusterRiskInitialInvestment } from '../models/rules/currency-cluster-risk/initial-investment';
+import { FeeRatioInitialInvestment } from '../models/rules/fees/fee-ratio-initial-investment';
+import { PlatformClusterRiskCurrentInvestment } from '../models/rules/platform-cluster-risk/current-investment';
+import { PlatformClusterRiskInitialInvestment } from '../models/rules/platform-cluster-risk/initial-investment';
+import { PlatformClusterRiskSinglePlatform } from '../models/rules/platform-cluster-risk/single-platform';
+
+@Injectable()
+export class RulesService {
+  public constructor() {}
+
+  public async evaluate(
+    aPortfolio: Portfolio,
+    aRules: Rule[],
+    aUserSettings: { baseCurrency: string }
+  ) {
+    const defaultSettings = this.getDefaultRuleSettings(aUserSettings);
+    const details = await aPortfolio.getDetails();
+
+    return aRules
+      .filter((rule) => {
+        return defaultSettings[rule.constructor.name]?.isActive;
+      })
+      .map((rule) => {
+        const evaluationResult = rule.evaluate(
+          details,
+          aPortfolio.getFees(),
+          defaultSettings
+        );
+        return { ...evaluationResult, name: rule.getName() };
+      });
+  }
+
+  private getDefaultRuleSettings(aUserSettings: { baseCurrency: string }) {
+    return {
+      [CurrencyClusterRiskBaseCurrencyInitialInvestment.name]: {
+        baseCurrency: aUserSettings.baseCurrency,
+        isActive: true
+      },
+      [CurrencyClusterRiskBaseCurrencyCurrentInvestment.name]: {
+        baseCurrency: aUserSettings.baseCurrency,
+        isActive: true
+      },
+      [CurrencyClusterRiskCurrentInvestment.name]: {
+        baseCurrency: aUserSettings.baseCurrency,
+        isActive: true,
+        threshold: 0.5
+      },
+      [CurrencyClusterRiskInitialInvestment.name]: {
+        baseCurrency: aUserSettings.baseCurrency,
+        isActive: true,
+        threshold: 0.5
+      },
+      [FeeRatioInitialInvestment.name]: {
+        baseCurrency: aUserSettings.baseCurrency,
+        isActive: true,
+        threshold: 0.01
+      },
+      [PlatformClusterRiskCurrentInvestment.name]: {
+        baseCurrency: aUserSettings.baseCurrency,
+        isActive: true,
+        threshold: 0.5
+      },
+      [PlatformClusterRiskInitialInvestment.name]: {
+        baseCurrency: aUserSettings.baseCurrency,
+        isActive: true,
+        threshold: 0.5
+      },
+      [PlatformClusterRiskSinglePlatform.name]: { isActive: true }
+    };
+  }
+}