Task/harmonize validation for create activity endpoint with existing import activity logic (#6349)

* Harmonize validation

* Update changelog

CHANGELOG.md

@@ -14,6 +14,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+- Harmonized the validation for the create activity endpoint with the existing import activity logic
 - Upgraded `marked` from version `17.0.1` to `17.0.2`
 - Upgraded `ngx-markdown` from version `21.0.1` to `21.1.0`
 

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

@@ -3,7 +3,6 @@ import { OrderService } from '@ghostfolio/api/app/order/order.service';
 import { PlatformService } from '@ghostfolio/api/app/platform/platform.service';
 import { PortfolioService } from '@ghostfolio/api/app/portfolio/portfolio.service';
 import { ApiService } from '@ghostfolio/api/services/api/api.service';
-import { ConfigurationService } from '@ghostfolio/api/services/configuration/configuration.service';
 import { DataProviderService } from '@ghostfolio/api/services/data-provider/data-provider.service';
 import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data/exchange-rate-data.service';
 import { MarketDataService } from '@ghostfolio/api/services/market-data/market-data.service';
@@ -33,7 +32,7 @@ import {
 } from '@ghostfolio/common/types';
 
 import { Injectable } from '@nestjs/common';
-import { DataSource, Prisma, SymbolProfile } from '@prisma/client';
+import { DataSource, Prisma } from '@prisma/client';
 import { Big } from 'big.js';
 import { endOfToday, isAfter, isSameSecond, parseISO } from 'date-fns';
 import { omit, uniqBy } from 'lodash';
@@ -46,7 +45,6 @@ export class ImportService {
   public constructor(
     private readonly accountService: AccountService,
     private readonly apiService: ApiService,
-    private readonly configurationService: ConfigurationService,
     private readonly dataGatheringService: DataGatheringService,
     private readonly dataProviderService: DataProviderService,
     private readonly exchangeRateDataService: ExchangeRateDataService,
@@ -395,7 +393,7 @@ export class ImportService {
       }
     }
 
-    const assetProfiles = await this.validateActivities({
+    const assetProfiles = await this.dataProviderService.validateActivities({
       activitiesDto,
       assetProfilesWithMarketDataDto,
       maxActivitiesToImport,
@@ -729,132 +727,4 @@ export class ImportService {
 
     return uniqueAccountIds.size === 1;
   }
-
-  private async validateActivities({
-    activitiesDto,
-    assetProfilesWithMarketDataDto,
-    maxActivitiesToImport,
-    user
-  }: {
-    activitiesDto: Partial<CreateOrderDto>[];
-    assetProfilesWithMarketDataDto: ImportDataDto['assetProfiles'];
-    maxActivitiesToImport: number;
-    user: UserWithSettings;
-  }) {
-    if (activitiesDto?.length > maxActivitiesToImport) {
-      throw new Error(`Too many activities (${maxActivitiesToImport} at most)`);
-    }
-
-    const assetProfiles: {
-      [assetProfileIdentifier: string]: Partial<SymbolProfile>;
-    } = {};
-    const dataSources = await this.dataProviderService.getDataSources();
-
-    for (const [
-      index,
-      { currency, dataSource, symbol, type }
-    ] of activitiesDto.entries()) {
-      if (!dataSources.includes(dataSource)) {
-        throw new Error(
-          `activities.${index}.dataSource ("${dataSource}") is not valid`
-        );
-      }
-
-      if (
-        this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION') &&
-        user.subscription.type === 'Basic'
-      ) {
-        const dataProvider = this.dataProviderService.getDataProvider(
-          DataSource[dataSource]
-        );
-
-        if (dataProvider.getDataProviderInfo().isPremium) {
-          throw new Error(
-            `activities.${index}.dataSource ("${dataSource}") is not valid`
-          );
-        }
-      }
-
-      if (!assetProfiles[getAssetProfileIdentifier({ dataSource, symbol })]) {
-        if (['FEE', 'INTEREST', 'LIABILITY'].includes(type)) {
-          // Skip asset profile validation for FEE, INTEREST, and LIABILITY
-          // as these activity types don't require asset profiles
-          const assetProfileInImport = assetProfilesWithMarketDataDto?.find(
-            (profile) => {
-              return (
-                profile.dataSource === dataSource && profile.symbol === symbol
-              );
-            }
-          );
-
-          assetProfiles[getAssetProfileIdentifier({ dataSource, symbol })] = {
-            currency,
-            dataSource,
-            symbol,
-            name: assetProfileInImport?.name
-          };
-
-          continue;
-        }
-
-        let assetProfile: Partial<SymbolProfile> = { currency };
-
-        try {
-          assetProfile = (
-            await this.dataProviderService.getAssetProfiles([
-              { dataSource, symbol }
-            ])
-          )?.[symbol];
-        } catch {}
-
-        if (!assetProfile?.name) {
-          const assetProfileInImport = assetProfilesWithMarketDataDto?.find(
-            (profile) => {
-              return (
-                profile.dataSource === dataSource && profile.symbol === symbol
-              );
-            }
-          );
-
-          if (assetProfileInImport) {
-            // Merge all fields of custom asset profiles into the validation object
-            Object.assign(assetProfile, {
-              assetClass: assetProfileInImport.assetClass,
-              assetSubClass: assetProfileInImport.assetSubClass,
-              comment: assetProfileInImport.comment,
-              countries: assetProfileInImport.countries,
-              currency: assetProfileInImport.currency,
-              cusip: assetProfileInImport.cusip,
-              dataSource: assetProfileInImport.dataSource,
-              figi: assetProfileInImport.figi,
-              figiComposite: assetProfileInImport.figiComposite,
-              figiShareClass: assetProfileInImport.figiShareClass,
-              holdings: assetProfileInImport.holdings,
-              isActive: assetProfileInImport.isActive,
-              isin: assetProfileInImport.isin,
-              name: assetProfileInImport.name,
-              scraperConfiguration: assetProfileInImport.scraperConfiguration,
-              sectors: assetProfileInImport.sectors,
-              symbol: assetProfileInImport.symbol,
-              symbolMapping: assetProfileInImport.symbolMapping,
-              url: assetProfileInImport.url
-            });
-          }
-        }
-
-        if (!['FEE', 'INTEREST', 'LIABILITY'].includes(type)) {
-          if (!assetProfile?.name) {
-            throw new Error(
-              `activities.${index}.symbol ("${symbol}") is not valid for the specified data source ("${dataSource}")`
-            );
-          }
-        }
-
-        assetProfiles[getAssetProfileIdentifier({ dataSource, symbol })] =
-          assetProfile;
-      }
-    }
-
-    return assetProfiles;
-  }
 }

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

@@ -4,6 +4,7 @@ import { RedactValuesInResponseInterceptor } from '@ghostfolio/api/interceptors/
 import { TransformDataSourceInRequestInterceptor } from '@ghostfolio/api/interceptors/transform-data-source-in-request/transform-data-source-in-request.interceptor';
 import { TransformDataSourceInResponseInterceptor } from '@ghostfolio/api/interceptors/transform-data-source-in-response/transform-data-source-in-response.interceptor';
 import { ApiService } from '@ghostfolio/api/services/api/api.service';
+import { DataProviderService } from '@ghostfolio/api/services/data-provider/data-provider.service';
 import { ImpersonationService } from '@ghostfolio/api/services/impersonation/impersonation.service';
 import { DataGatheringService } from '@ghostfolio/api/services/queues/data-gathering/data-gathering.service';
 import { getIntervalFromDateRange } from '@ghostfolio/common/calculation-helper';
@@ -46,6 +47,7 @@ import { OrderService } from './order.service';
 export class OrderController {
   public constructor(
     private readonly apiService: ApiService,
+    private readonly dataProviderService: DataProviderService,
     private readonly dataGatheringService: DataGatheringService,
     private readonly impersonationService: ImpersonationService,
     private readonly orderService: OrderService,
@@ -190,6 +192,29 @@ export class OrderController {
   @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
   @UseInterceptors(TransformDataSourceInRequestInterceptor)
   public async createOrder(@Body() data: CreateOrderDto): Promise<OrderModel> {
+    try {
+      await this.dataProviderService.validateActivities({
+        activitiesDto: [
+          {
+            currency: data.currency,
+            dataSource: data.dataSource,
+            symbol: data.symbol,
+            type: data.type
+          }
+        ],
+        maxActivitiesToImport: 1,
+        user: this.request.user
+      });
+    } catch (error) {
+      throw new HttpException(
+        {
+          error: getReasonPhrase(StatusCodes.BAD_REQUEST),
+          message: [error.message]
+        },
+        StatusCodes.BAD_REQUEST
+      );
+    }
+
     const currency = data.currency;
     const customCurrency = data.customCurrency;
     const dataSource = data.dataSource;

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

@@ -1,3 +1,4 @@
+import { ImportDataDto } from '@ghostfolio/api/app/import/import-data.dto';
 import { RedisCacheService } from '@ghostfolio/api/app/redis-cache/redis-cache.service';
 import { ConfigurationService } from '@ghostfolio/api/services/configuration/configuration.service';
 import { DataProviderInterface } from '@ghostfolio/api/services/data-provider/interfaces/data-provider.interface';
@@ -10,8 +11,10 @@ import {
   PROPERTY_API_KEY_GHOSTFOLIO,
   PROPERTY_DATA_SOURCE_MAPPING
 } from '@ghostfolio/common/config';
+import { CreateOrderDto } from '@ghostfolio/common/dtos';
 import {
   DATE_FORMAT,
+  getAssetProfileIdentifier,
   getCurrencyFromSymbol,
   getStartOfUtcDate,
   isCurrency,
@@ -185,6 +188,121 @@ export class DataProviderService implements OnModuleInit {
     return dataSources.sort();
   }
 
+  public async validateActivities({
+    activitiesDto,
+    assetProfilesWithMarketDataDto,
+    maxActivitiesToImport,
+    user
+  }: {
+    activitiesDto: Pick<
+      Partial<CreateOrderDto>,
+      'currency' | 'dataSource' | 'symbol' | 'type'
+    >[];
+    assetProfilesWithMarketDataDto?: ImportDataDto['assetProfiles'];
+    maxActivitiesToImport: number;
+    user: UserWithSettings;
+  }) {
+    if (activitiesDto?.length > maxActivitiesToImport) {
+      throw new Error(`Too many activities (${maxActivitiesToImport} at most)`);
+    }
+
+    const assetProfiles: {
+      [assetProfileIdentifier: string]: Partial<SymbolProfile>;
+    } = {};
+
+    const dataSources = await this.getDataSources();
+
+    for (const [
+      index,
+      { currency, dataSource, symbol, type }
+    ] of activitiesDto.entries()) {
+      const activityPath =
+        maxActivitiesToImport === 1 ? 'activity' : `activities.${index}`;
+
+      if (!dataSources.includes(dataSource)) {
+        throw new Error(
+          `${activityPath}.dataSource ("${dataSource}") is not valid`
+        );
+      }
+
+      if (
+        this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION') &&
+        user.subscription.type === 'Basic'
+      ) {
+        const dataProvider = this.getDataProvider(DataSource[dataSource]);
+
+        if (dataProvider.getDataProviderInfo().isPremium) {
+          throw new Error(
+            `${activityPath}.dataSource ("${dataSource}") is not valid`
+          );
+        }
+      }
+
+      const assetProfileIdentifier = getAssetProfileIdentifier({
+        dataSource,
+        symbol
+      });
+
+      if (!assetProfiles[assetProfileIdentifier]) {
+        if (['FEE', 'INTEREST', 'LIABILITY'].includes(type)) {
+          const assetProfileInImport = assetProfilesWithMarketDataDto?.find(
+            (profile) => {
+              return (
+                profile.dataSource === dataSource && profile.symbol === symbol
+              );
+            }
+          );
+
+          assetProfiles[assetProfileIdentifier] = {
+            currency,
+            dataSource,
+            symbol,
+            name: assetProfileInImport?.name
+          };
+
+          continue;
+        }
+
+        let assetProfile: Partial<SymbolProfile> = { currency };
+
+        try {
+          assetProfile = (
+            await this.getAssetProfiles([
+              {
+                dataSource,
+                symbol
+              }
+            ])
+          )?.[symbol];
+        } catch {}
+
+        if (!assetProfile?.name) {
+          const assetProfileInImport = assetProfilesWithMarketDataDto?.find(
+            (profile) => {
+              return (
+                profile.dataSource === dataSource && profile.symbol === symbol
+              );
+            }
+          );
+
+          if (assetProfileInImport) {
+            Object.assign(assetProfile, assetProfileInImport);
+          }
+        }
+
+        if (!assetProfile?.name) {
+          throw new Error(
+            `activities.${index}.symbol ("${symbol}") is not valid for the specified data source ("${dataSource}")`
+          );
+        }
+
+        assetProfiles[assetProfileIdentifier] = assetProfile;
+      }
+    }
+
+    return assetProfiles;
+  }
+
   public async getDividends({
     dataSource,
     from,