Refactoring

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

@@ -1,9 +1,6 @@
 import { AccountService } from '@ghostfolio/api/app/account/account.service';
 import { CreateAccountDto } from '@ghostfolio/api/app/account/create-account.dto';
-import {
+import { CreateOrderDto } from '@ghostfolio/api/app/order/create-order.dto';
-  CreateOrderDto,
-  OrderResponseDto
-} from '@ghostfolio/api/app/order/create-order.dto';
 import { Activity } from '@ghostfolio/api/app/order/interfaces/activities.interface';
 import { OrderService } from '@ghostfolio/api/app/order/order.service';
 import { PortfolioService } from '@ghostfolio/api/app/portfolio/portfolio.service';
@@ -208,14 +205,14 @@ export class ImportService {
       userId
     });
 
-    const activitiesDtoWithDuplication = await this.markActivitiesAsDuplicates({
+    const activitiesMarkedAsDuplicates = await this.markActivitiesAsDuplicates({
       activitiesDto,
       userId
     });
 
     const accounts = (await this.accountService.getAccounts(userId)).map(
-      (account) => {
+      ({ id, name }) => {
-        return { id: account.id, name: account.name };
+        return { id, name };
       }
     );
 
@@ -230,17 +227,14 @@ export class ImportService {
     for (const {
       accountId,
       comment,
-      currency,
+      date,
-      dataSource,
-      date: dateString,
       fee,
       isDuplicate,
       quantity,
-      symbol,
+      SymbolProfile: assetProfile,
       type,
       unitPrice
-    } of activitiesDtoWithDuplication) {
+    } of activitiesMarkedAsDuplicates) {
-      const date = parseISO(<string>(<unknown>dateString));
       const validatedAccount = accounts.find(({ id }) => {
         return id === accountId;
       });
@@ -266,23 +260,23 @@ export class ImportService {
           id: uuidv4(),
           isDraft: isAfter(date, endOfToday()),
           SymbolProfile: {
-            currency,
+            assetClass: assetProfile.assetClass,
-            dataSource,
+            assetSubClass: assetProfile.assetSubClass,
-            symbol,
+            comment: assetProfile.comment,
-            assetClass: null,
+            countries: assetProfile.countries,
-            assetSubClass: null,
+            createdAt: assetProfile.createdAt,
-            comment: null,
+            currency: assetProfile.currency,
-            countries: null,
+            dataSource: assetProfile.dataSource,
-            createdAt: undefined,
+            id: assetProfile.id,
-            id: undefined,
+            isin: assetProfile.isin,
-            isin: null,
+            name: assetProfile.name,
-            name: null,
+            scraperConfiguration: assetProfile.scraperConfiguration,
-            scraperConfiguration: null,
+            sectors: assetProfile.sectors,
-            sectors: null,
+            symbol: assetProfile.currency,
-            symbolMapping: null,
+            symbolMapping: assetProfile.symbolMapping,
-            updatedAt: undefined,
+            updatedAt: assetProfile.updatedAt,
-            url: null,
+            url: assetProfile.url,
-            ...assetProfiles[symbol]
+            ...assetProfiles[assetProfile.symbol]
           },
           Account: validatedAccount,
           symbolProfileId: undefined,
@@ -305,14 +299,14 @@ export class ImportService {
           SymbolProfile: {
             connectOrCreate: {
               create: {
-                currency,
+                currency: assetProfile.currency,
-                dataSource,
+                dataSource: assetProfile.dataSource,
-                symbol
+                symbol: assetProfile.symbol
               },
               where: {
                 dataSource_symbol: {
-                  dataSource,
+                  dataSource: assetProfile.dataSource,
-                  symbol
+                  symbol: assetProfile.symbol
                 }
               }
             }
@@ -330,12 +324,12 @@ export class ImportService {
         value,
         feeInBaseCurrency: this.exchangeRateDataService.toCurrency(
           fee,
-          currency,
+          assetProfile.currency,
           userCurrency
         ),
         valueInBaseCurrency: this.exchangeRateDataService.toCurrency(
           value,
-          currency,
+          assetProfile.currency,
           userCurrency
         )
       });
@@ -343,70 +337,86 @@ export class ImportService {
     return activities;
   }
 
+  private isUniqueAccount(accounts: AccountWithPlatform[]) {
+    const uniqueAccountIds = new Set<string>();
+
+    for (const account of accounts) {
+      uniqueAccountIds.add(account.id);
+    }
+
+    return uniqueAccountIds.size === 1;
+  }
+
   private async markActivitiesAsDuplicates({
     activitiesDto,
     userId
   }: {
     activitiesDto: Partial<CreateOrderDto>[];
     userId: string;
-  }): Promise<Partial<OrderResponseDto>[]> {
+  }): Promise<Partial<Activity>[]> {
     const existingActivities = await this.orderService.orders({
       include: { SymbolProfile: true },
       orderBy: { date: 'desc' },
       where: { userId }
     });
 
-    const activitiesDtoWithDuplication: Partial<OrderResponseDto>[] = [];
+    return activitiesDto.map(
-
+      ({
-    for (const activitiesDtoEntry of activitiesDto) {
+        accountId,
-      const {
+        comment,
         currency,
         dataSource,
-        date,
+        date: dateString,
         fee,
         quantity,
         symbol,
         type,
         unitPrice
-      } = activitiesDtoEntry;
+      }) => {
-
+        const date = parseISO(<string>(<unknown>dateString));
-      const isDuplicate = existingActivities.find((activity) => {
+        const isDuplicate = existingActivities.some((activity) => {
-        return (
+          return (
-          activity.SymbolProfile.currency === currency &&
+            activity.SymbolProfile.currency === currency &&
-          activity.SymbolProfile.dataSource === dataSource &&
+            activity.SymbolProfile.dataSource === dataSource &&
-          isSameDay(activity.date, parseISO(<string>(<unknown>date))) &&
+            isSameDay(activity.date, date) &&
-          activity.fee === fee &&
+            activity.fee === fee &&
-          activity.quantity === quantity &&
+            activity.quantity === quantity &&
-          activity.SymbolProfile.symbol === symbol &&
+            activity.SymbolProfile.symbol === symbol &&
-          activity.type === type &&
+            activity.type === type &&
-          activity.unitPrice === unitPrice
+            activity.unitPrice === unitPrice
-        );
+          );
-      });
-
-      if (isDuplicate) {
-        activitiesDtoWithDuplication.push({
-          ...activitiesDtoEntry,
-          isDuplicate: true
-        });
-      } else {
-        activitiesDtoWithDuplication.push({
-          ...activitiesDtoEntry,
-          isDuplicate: false
         });
-      }
-    }
-
-    return activitiesDtoWithDuplication;
-  }
 
-  private isUniqueAccount(accounts: AccountWithPlatform[]) {
+        return {
-    const uniqueAccountIds = new Set<string>();
+          accountId,
-
+          comment,
-    for (const account of accounts) {
+          date,
-      uniqueAccountIds.add(account.id);
+          fee,
-    }
+          isDuplicate,
-
+          quantity,
-    return uniqueAccountIds.size === 1;
+          type,
+          unitPrice,
+          SymbolProfile: {
+            currency,
+            dataSource,
+            symbol,
+            assetClass: null,
+            assetSubClass: null,
+            comment: null,
+            countries: null,
+            createdAt: undefined,
+            id: undefined,
+            isin: null,
+            name: null,
+            scraperConfiguration: null,
+            sectors: null,
+            symbolMapping: null,
+            updatedAt: undefined,
+            url: null
+          }
+        };
+      }
+    );
   }
 
   private async validateActivities({

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

@@ -65,7 +65,3 @@ export class CreateOrderDto {
   @IsNumber()
   unitPrice: number;
 }
-
-export class OrderResponseDto extends CreateOrderDto {
-  isDuplicate: boolean;
-}

libs/ui/src/lib/activities-table/activities-table.component.html

@@ -76,7 +76,6 @@
     <ng-container matColumnDef="select">
       <th *matHeaderCellDef class="px-1" mat-header-cell>
         <mat-checkbox
-          class="mt-2"
           color="primary"
           [checked]="selectedRows.hasValue() && areAllRowsSelected()"
           [indeterminate]="selectedRows.hasValue() && !areAllRowsSelected()"
@@ -85,7 +84,6 @@
       </th>
       <td *matCellDef="let element" class="px-1" mat-cell>
         <mat-checkbox
-          class="mt-2"
           color="primary"
           [checked]="
             element.isDuplicate ? false : selectedRows.isSelected(element)