Support migrating asset profile to MANUAL data source

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

@@ -19,8 +19,7 @@ import {
   AdminData,
   AdminUserResponse,
   AdminUsersResponse,
-  AssetProfileIdentifier,
+  AssetProfileIdentifier
-  Holding
 } from '@ghostfolio/common/interfaces';
 import { PropertyKey } from '@ghostfolio/common/types';
 
@@ -40,6 +39,7 @@ import {
 } from '@prisma/client';
 import { differenceInDays } from 'date-fns';
 import { StatusCodes, getReasonPhrase } from 'http-status-codes';
+import { randomUUID } from 'node:crypto';
 
 @Injectable()
 export class AdminService {
@@ -241,16 +241,26 @@ export class AdminService {
       url
     }: Prisma.SymbolProfileUpdateInput
   ) {
+    const isConversionToManualDataSource =
+      newDataSource === DataSource.MANUAL && dataSource !== DataSource.MANUAL;
+
+    if (isConversionToManualDataSource && !newSymbol) {
+      // The generated symbol avoids collisions in the MANUAL namespace
+      newSymbol = randomUUID();
+    }
+
     if (
       newDataSource &&
       newSymbol &&
       (newDataSource !== dataSource || newSymbol !== symbol)
     ) {
-      const [assetProfile] = await this.symbolProfileService.getSymbolProfiles([
+      const newAssetProfileIdentifier: AssetProfileIdentifier = {
-        {
+        dataSource: newDataSource as DataSource,
-          dataSource: DataSource[newDataSource.toString()],
         symbol: newSymbol as string
-        }
+      };
+
+      const [assetProfile] = await this.symbolProfileService.getSymbolProfiles([
+        newAssetProfileIdentifier
       ]);
 
       if (assetProfile) {
@@ -260,74 +270,86 @@ export class AdminService {
         );
       }
 
-      try {
+      const operations: Prisma.PrismaPromise<unknown>[] = [
-        await Promise.all([
         this.symbolProfileService.updateAssetProfileIdentifier(
           {
             dataSource,
             symbol
           },
-            {
+          newAssetProfileIdentifier
-              dataSource: DataSource[newDataSource.toString()],
-              symbol: newSymbol as string
-            }
         ),
         this.marketDataService.updateAssetProfileIdentifier(
           {
             dataSource,
             symbol
           },
+          newAssetProfileIdentifier
+        )
+      ];
+
+      if (isConversionToManualDataSource) {
+        const [currentAssetProfile] =
+          await this.symbolProfileService.getSymbolProfiles([
             {
-              dataSource: DataSource[newDataSource.toString()],
+              dataSource,
-              symbol: newSymbol as string
+              symbol
             }
-          )
           ]);
 
-        if (DataSource[newDataSource.toString()] === DataSource.MANUAL) {
+        if (!currentAssetProfile) {
-          await Promise.all([
+          throw new HttpException(
-            this.symbolProfileService.deleteAssetProfileOverrides({
+            getReasonPhrase(StatusCodes.NOT_FOUND),
-              dataSource: DataSource.MANUAL,
+            StatusCodes.NOT_FOUND
-              symbol: newSymbol as string
+          );
-            }),
+        }
+
+        operations.push(
+          // The overrides are not read for MANUAL asset profiles
+          this.symbolProfileService.deleteAssetProfileOverrides(
+            newAssetProfileIdentifier
+          ),
+          // Persist the current values, merged with the overrides
           this.symbolProfileService.updateSymbolProfile(
+            newAssetProfileIdentifier,
             {
-                dataSource: DataSource.MANUAL,
+              assetClass: currentAssetProfile.assetClass,
-                symbol: newSymbol as string
+              assetSubClass: currentAssetProfile.assetSubClass,
-              },
+              countries: currentAssetProfile.countries?.map(
-              {
+                ({ code, weight }) => {
-                assetClass,
+                  return { code, weight };
-                assetSubClass,
+                }
-                countries,
+              ),
-                name,
+              holdings: currentAssetProfile.holdings?.map((holding) => {
-                sectors,
-                url,
-                holdings: (holdings as unknown as Holding[])?.map((holding) => {
                 return {
                   name: holding.name,
                   weight: holding.allocationInPercentage
                 };
-                })
+              }),
+              name: currentAssetProfile.name,
+              sectors: currentAssetProfile.sectors?.map((sector) => {
+                return { name: sector.name, weight: sector.weight };
+              }),
+              url: currentAssetProfile.url
             }
           )
-          ]);
+        );
-        }
-
-        const [updatedAssetProfile] =
-          await this.symbolProfileService.getSymbolProfiles([
-            {
-              dataSource: DataSource[newDataSource.toString()],
-              symbol: newSymbol as string
       }
-          ]);
 
-        return updatedAssetProfile;
+      try {
+        await this.prismaService.$transaction(operations);
       } catch {
         throw new HttpException(
           getReasonPhrase(StatusCodes.BAD_REQUEST),
           StatusCodes.BAD_REQUEST
         );
       }
+
+      const [updatedAssetProfile] =
+        await this.symbolProfileService.getSymbolProfiles([
+          newAssetProfileIdentifier
+        ]);
+
+      return updatedAssetProfile;
     } else {
       const assetProfileOverrides = {
         assetClass: assetClass as AssetClass,

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

@@ -204,7 +204,7 @@ export class MarketDataService {
     );
   }
 
-  public async updateAssetProfileIdentifier(
+  public updateAssetProfileIdentifier(
     oldAssetProfileIdentifier: AssetProfileIdentifier,
     newAssetProfileIdentifier: AssetProfileIdentifier
   ) {

apps/api/src/services/symbol-profile/symbol-profile.service.ts

@@ -35,7 +35,7 @@ export class SymbolProfileService {
     });
   }
 
-  public async deleteAssetProfileOverrides({
+  public deleteAssetProfileOverrides({
     dataSource,
     symbol
   }: AssetProfileIdentifier) {

apps/client/src/app/components/admin-market-data/asset-profile-dialog/asset-profile-dialog.component.ts

@@ -473,62 +473,15 @@ export class GfAssetProfileDialogComponent implements OnInit {
   }
 
   protected onConvertToManualDataSource() {
-    this.notificationService.confirm({
+    this.patchAssetProfileIdentifier({
-      confirmFn: () => {
+      getErrorMessage: () => {
-        const newAssetProfileIdentifier: AssetProfileIdentifier = {
+        return (
-          dataSource: DataSource.MANUAL,
-          symbol: crypto.randomUUID()
-        };
-
-        const convertedAssetProfile: UpdateAssetProfileDto = {
-          assetClass: this.assetProfile?.assetClass ?? undefined,
-          assetSubClass: this.assetProfile?.assetSubClass ?? undefined,
-          countries: this.assetProfile?.countries?.map(({ code, weight }) => {
-            return { code, weight };
-          }),
-          dataSource: newAssetProfileIdentifier.dataSource,
-          holdings: this.assetProfile?.holdings?.map(
-            ({ allocationInPercentage, name }) => {
-              return { allocationInPercentage, name };
-            }
-          ),
-          name: this.assetProfile?.name ?? undefined,
-          sectors: this.assetProfile?.sectors?.map(({ name, weight }) => {
-            return { name, weight };
-          }),
-          symbol: newAssetProfileIdentifier.symbol,
-          url: this.assetProfile?.url ?? undefined
-        };
-
-        this.adminService
-          .patchAssetProfile(
-            {
-              dataSource: this.data.dataSource,
-              symbol: this.data.symbol
-            },
-            convertedAssetProfile
-          )
-          .pipe(
-            catchError(() => {
-              this.snackBar.open(
           '😞 ' +
-                  $localize`An error occurred while converting the asset profile to ${DataSource.MANUAL}.`,
+          $localize`An error occurred while converting the asset profile to ${DataSource.MANUAL}.`
-                undefined,
-                {
-                  duration: ms('3 seconds')
-                }
         );
-
-              return EMPTY;
-            }),
-            takeUntilDestroyed(this.destroyRef)
-          )
-          .subscribe(() => {
-            this.dialogRef.close(newAssetProfileIdentifier);
-          });
       },
-      confirmType: ConfirmationDialogType.Primary,
+      title: $localize`Do you really want to convert this asset profile to ${DataSource.MANUAL} data source?`,
-      title: $localize`Do you really want to convert this asset profile to ${DataSource.MANUAL} data source?`
+      updateAssetProfileDto: { dataSource: DataSource.MANUAL }
     });
   }
 
@@ -755,48 +708,18 @@ export class GfAssetProfileDialogComponent implements OnInit {
       return;
     }
 
-    this.notificationService.confirm({
+    this.patchAssetProfileIdentifier({
-      confirmFn: () => {
+      getErrorMessage: (error) => {
-        this.adminService
-          .patchAssetProfile(
-            {
-              dataSource: this.data.dataSource,
-              symbol: this.data.symbol
-            },
-            assetProfileIdentifier
-          )
-          .pipe(
-            catchError((error: HttpErrorResponse) => {
         if (error.status === StatusCodes.CONFLICT) {
           // TODO: Ask if the user wants to merge the two asset profiles
 
-                this.snackBar.open(
+          return $localize`${assetProfileIdentifier.symbol} (${assetProfileIdentifier.dataSource}) is already in use.`;
-                  $localize`${assetProfileIdentifier.symbol} (${assetProfileIdentifier.dataSource}) is already in use.`,
-                  undefined,
-                  {
-                    duration: ms('3 seconds')
-                  }
-                );
-              } else {
-                this.snackBar.open(
-                  $localize`An error occurred while updating to ${assetProfileIdentifier.symbol} (${assetProfileIdentifier.dataSource}).`,
-                  undefined,
-                  {
-                    duration: ms('3 seconds')
-                  }
-                );
         }
 
-              return EMPTY;
+        return $localize`An error occurred while updating to ${assetProfileIdentifier.symbol} (${assetProfileIdentifier.dataSource}).`;
-            }),
-            takeUntilDestroyed(this.destroyRef)
-          )
-          .subscribe(() => {
-            this.dialogRef.close(newAssetProfileIdentifier);
-          });
       },
-      confirmType: ConfirmationDialogType.Primary,
+      title: $localize`Do you really want to convert this asset profile to ${newAssetProfileIdentifier.symbol} (${newAssetProfileIdentifier.dataSource})?`,
-      title: $localize`Do you really want to convert this asset profile to ${newAssetProfileIdentifier.symbol} (${newAssetProfileIdentifier.dataSource})?`
+      updateAssetProfileDto: assetProfileIdentifier
     });
   }
 
@@ -895,4 +818,42 @@ export class GfAssetProfileDialogComponent implements OnInit {
 
     return null;
   }
+
+  private patchAssetProfileIdentifier({
+    getErrorMessage,
+    title,
+    updateAssetProfileDto
+  }: {
+    getErrorMessage: (error: HttpErrorResponse) => string;
+    title: string;
+    updateAssetProfileDto: UpdateAssetProfileDto;
+  }) {
+    this.notificationService.confirm({
+      title,
+      confirmFn: () => {
+        this.adminService
+          .patchAssetProfile(
+            {
+              dataSource: this.data.dataSource,
+              symbol: this.data.symbol
+            },
+            updateAssetProfileDto
+          )
+          .pipe(
+            catchError((error: HttpErrorResponse) => {
+              this.snackBar.open(getErrorMessage(error), undefined, {
+                duration: ms('3 seconds')
+              });
+
+              return EMPTY;
+            }),
+            takeUntilDestroyed(this.destroyRef)
+          )
+          .subscribe(({ dataSource, symbol }) => {
+            this.dialogRef.close({ dataSource, symbol });
+          });
+      },
+      confirmType: ConfirmationDialogType.Primary
+    });
+  }
 }