feat: Solved a problem where deleting all activites while having filter applied it deletes all the activites and not the ones that are filtered

\

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

@@ -31,7 +31,7 @@ import {
 } from '@nestjs/common';
 import { REQUEST } from '@nestjs/core';
 import { AuthGuard } from '@nestjs/passport';
-import { Order as OrderModel, Prisma } from '@prisma/client';
+import { AssetClass, Order as OrderModel, Prisma } from '@prisma/client';
 import { parseISO } from 'date-fns';
 import { StatusCodes, getReasonPhrase } from 'http-status-codes';
 
@@ -53,10 +53,19 @@ export class OrderController {
   @Delete()
   @HasPermission(permissions.deleteOrder)
   @UseGuards(AuthGuard('jwt'), HasPermissionGuard)
-  public async deleteOrders(): Promise<number> {
-    return this.orderService.deleteOrders({
-      userId: this.request.user.id
+  public async deleteOrders(
+    @Query('accounts') filterByAccounts?: string,
+    @Query('assetClasses') filterByAssetClasses?: string,
+    @Query('tags') filterByTags?: string
+  ): Promise<number> {
+    const filters = this.apiService.buildFiltersFromQueryParams({
+      filterByAccounts,
+      filterByAssetClasses,
+      filterByTags
     });
+    return this.orderService.deleteOrders({
+      userId: this.request.user.id,
+    }, filters);
   }
 
   @Delete(':id')

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

@@ -194,7 +194,63 @@ export class OrderService {
     return order;
   }
 
-  public async deleteOrders(where: Prisma.OrderWhereInput): Promise<number> {
+  public async deleteOrders(where: Prisma.OrderWhereInput, filters: Filter[]): Promise<number> {
+
+    const {
+      ACCOUNT: filtersByAccount,
+      ASSET_CLASS: filtersByAssetClass,
+      TAG: filtersByTag
+    } = groupBy(filters, (filter) => {
+      return filter.type;
+    });
+
+    if (filtersByAccount?.length > 0) {
+      where.accountId = {
+        in: filtersByAccount.map(({ id }) => {
+          return id;
+        })
+      };
+    }
+
+    if (filtersByAssetClass?.length > 0) {
+      where.SymbolProfile = {
+        OR: [
+          {
+            AND: [
+              {
+                OR: filtersByAssetClass.map(({ id }) => {
+                  return { assetClass: AssetClass[id] };
+                })
+              },
+              {
+                OR: [
+                  { SymbolProfileOverrides: { is: null } },
+                  { SymbolProfileOverrides: { assetClass: null } }
+                ]
+              }
+            ]
+          },
+          {
+            SymbolProfileOverrides: {
+              OR: filtersByAssetClass.map(({ id }) => {
+                return { assetClass: AssetClass[id] };
+              })
+            }
+          }
+        ]
+      };
+    }
+
+    if (filtersByTag?.length > 0) {
+      where.tags = {
+        some: {
+          OR: filtersByTag.map(({ id }) => {
+            return { id };
+          })
+        }
+      };
+    }
+
     const { count } = await this.prismaService.order.deleteMany({
       where
     });

apps/client/src/app/pages/portfolio/activities/activities-page.component.ts

@@ -171,7 +171,9 @@ export class ActivitiesPageComponent implements OnDestroy, OnInit {
 
     if (confirmation) {
       this.dataService
-        .deleteAllOrders()
+        .deleteAllOrders({
+          filters: this.userService.getFilters()
+        })
         .pipe(takeUntil(this.unsubscribeSubject))
         .subscribe({
           next: () => {
@@ -217,8 +219,7 @@ export class ActivitiesPageComponent implements OnDestroy, OnInit {
             data.activities
           ),
           contentType: 'text/calendar',
-          fileName: `ghostfolio-draft${
-            data.activities.length > 1 ? 's' : ''
+          fileName: `ghostfolio-draft${data.activities.length > 1 ? 's' : ''
             }-${format(parseISO(data.meta.date), 'yyyyMMddHHmmss')}.ics`,
           format: 'string'
         });

apps/client/src/app/services/data.service.ts

@@ -256,8 +256,11 @@ export class DataService {
     return this.http.delete<any>(`/api/v1/account-balance/${aId}`);
   }
 
-  public deleteAllOrders() {
-    return this.http.delete<any>(`/api/v1/order/`);
+  public deleteAllOrders({
+    filters
+  }) {
+    let params = this.buildFiltersAsQueryParams({ filters });
+    return this.http.delete<any>(`/api/v1/order`, { params });
   }
 
   public deleteBenchmark({ dataSource, symbol }: UniqueAsset) {