Move 'pending' flow category as shortcut

src/domain-services/flows/flow-search-service.ts

@@ -19,7 +19,7 @@ import { ReportDetailService } from '../report-details/report-detail-service';
 import { type UsageYear } from '../usage-years/grpahql/types';
 import { UsageYearService } from '../usage-years/usage-year-service';
 import {
-  type FlowCategoryFilters,
+  type FlowCategory,
   type FlowObjectFilters,
   type SearchFlowsArgs,
   type SearchFlowsArgsNonPaginated,
@@ -62,8 +62,14 @@ export class FlowSearchService {
     models: Database,
     filters: SearchFlowsArgs
   ): Promise<FlowSearchResult> {
-    const { limit, nextPageCursor, prevPageCursor, sortField, sortOrder } =
-      filters;
+    const {
+      limit,
+      nextPageCursor,
+      prevPageCursor,
+      sortField,
+      sortOrder,
+      pending: isPendingFlows,
+    } = filters;
 
     const orderBy: FlowOrderBy = this.buildOrderBy(sortField, sortOrder);
 
@@ -79,7 +85,8 @@ export class FlowSearchService {
     const { strategy, conditions } = this.determineStrategy(
       flowFilters,
       flowObjectFilters,
-      flowCategoryFilters
+      flowCategoryFilters,
+      isPendingFlows
     );
 
     // Fetch one more item to check for hasNextPage
@@ -91,7 +98,8 @@ export class FlowSearchService {
       models,
       orderBy,
       limitComputed,
-      cursorCondition
+      cursorCondition,
+      isPendingFlows
     );
 
     // Remove the extra item used to check hasNextPage
@@ -432,29 +440,39 @@ export class FlowSearchService {
   determineStrategy(
     flowFilters: SearchFlowsFilters,
     flowObjectFilters: FlowObjectFilters[],
-    flowCategoryFilters: FlowCategoryFilters
+    flowCategoryFilters: FlowCategory[],
+    isFilterByPendingFlows: boolean
   ): { strategy: FlowSearchStrategy; conditions: any } {
     const isFlowFilterDefined = flowFilters !== undefined;
     const isFlowObjectFilterDefined = flowObjectFilters !== undefined;
     const isFlowObjectFiltersNotEmpty =
       isFlowObjectFilterDefined && flowObjectFilters.length !== 0;
 
     const isFlowCategoryFilterDefined = flowCategoryFilters !== undefined;
+    const isFlowCategoryFilterNotEmpty =
+      isFlowCategoryFilterDefined && flowCategoryFilters.length !== 0;
 
+    const isFilterByPendingFlowsDefined = isFilterByPendingFlows !== undefined;
     if (
       (!isFlowFilterDefined &&
         (!isFlowObjectFilterDefined || !isFlowObjectFiltersNotEmpty) &&
-        !isFlowCategoryFilterDefined) ||
+        !isFlowCategoryFilterNotEmpty &&
+        !isFilterByPendingFlowsDefined) ||
       (isFlowFilterDefined &&
         (!isFlowObjectFilterDefined || !isFlowObjectFiltersNotEmpty) &&
-        !isFlowCategoryFilterDefined)
+        !isFlowCategoryFilterNotEmpty &&
+        !isFilterByPendingFlowsDefined)
     ) {
       const flowConditions = this.prepareFlowConditions(flowFilters);
       return {
         strategy: this.onlyFlowFiltersStrategy,
         conditions: flowConditions,
       };
-    } else if (isFlowObjectFiltersNotEmpty || isFlowCategoryFilterDefined) {
+    } else if (
+      isFlowObjectFiltersNotEmpty ||
+      isFlowCategoryFilterNotEmpty ||
+      isFilterByPendingFlowsDefined
+    ) {
       const flowConditions = this.prepareFlowConditions(flowFilters);
       const flowObjectConditions =
         this.prepareFlowObjectConditions(flowObjectFilters);
@@ -632,15 +650,28 @@ export class FlowSearchService {
     models: Database,
     args: SearchFlowsArgsNonPaginated
   ): Promise<FlowSearchTotalAmountResult> {
-    const { flowFilters, flowObjectFilters, flowCategoryFilters } = args;
+    const {
+      flowFilters,
+      flowObjectFilters,
+      flowCategoryFilters,
+      pending: isPendingFlows,
+    } = args;
 
     const { strategy, conditions } = this.determineStrategy(
       flowFilters,
       flowObjectFilters,
-      flowCategoryFilters
+      flowCategoryFilters,
+      isPendingFlows
     );
 
-    const { flows, count } = await strategy.search(conditions, models);
+    const { flows, count } = await strategy.search(
+      conditions,
+      models,
+      undefined,
+      undefined,
+      undefined,
+      isPendingFlows
+    );
 
     const flowsAmountUSD: Array<string | number> = flows.map(
       (flow) => flow.amountUSD

src/domain-services/flows/graphql/args.ts

@@ -31,9 +31,6 @@ export class SearchFlowsFilters {
 
 @InputType()
 export class FlowCategoryFilters {
-  @Field({ nullable: true })
-  pending: boolean;
-
   @Field(() => [FlowCategory], { nullable: true })
   categoryFilters: FlowCategory[];
 }
@@ -81,8 +78,11 @@ export class SearchFlowsArgs extends PaginationArgs<FlowSortField> {
   @Field({ nullable: true })
   includeChildrenOfParkedFlows: boolean;
 
+  @Field(() => [FlowCategory], { nullable: true })
+  flowCategoryFilters: FlowCategory[];
+
   @Field({ nullable: true })
-  flowCategoryFilters: FlowCategoryFilters;
+  pending: boolean;
 }
 
 @ArgsType()
@@ -96,6 +96,9 @@ export class SearchFlowsArgsNonPaginated {
   @Field({ nullable: true })
   includeChildrenOfParkedFlows: boolean;
 
+  @Field(() => [FlowCategory], { nullable: true })
+  flowCategoryFilters: FlowCategory[];
+
   @Field({ nullable: true })
-  flowCategoryFilters: FlowCategoryFilters;
+  pending: boolean;
 }

src/domain-services/flows/strategy/flow-search-strategy.ts

@@ -14,6 +14,7 @@ export interface FlowSearchStrategy {
     models: Database,
     orderBy?: any,
     limit?: number,
-    cursorCondition?: any
+    cursorCondition?: any,
+    filterByPendingFlows?: boolean
   ): Promise<FlowSearchStrategyResponse>;
 }

src/domain-services/flows/strategy/flowID-search-strategy.ts

@@ -1,6 +1,6 @@
 import { type Database } from '@unocha/hpc-api-core/src/db';
 import { type FlowId } from '@unocha/hpc-api-core/src/db/models/flow';
-import { type FlowCategoryFilters } from '../graphql/args';
+import { type FlowCategory } from '../graphql/args';
 
 export interface FlowIdSearchStrategyResponse {
   flowIDs: FlowId[];
@@ -10,8 +10,13 @@ export interface FlowIDSearchStrategy {
   search(
     models: Database,
     flowObjectsConditions: Map<string, Map<string, number[]>>,
-    flowCategoryConditions: FlowCategoryFilters
+    flowCategoryConditions: FlowCategory[],
+    filterByPendingFlows?: boolean
   ): Promise<FlowIdSearchStrategyResponse>;
 
-  generateWhereClause(flowIds: FlowId[], conditions: any): any;
+  generateWhereClause(
+    flowIds: FlowId[],
+    conditions: any,
+    filterByPendingFlows?: boolean
+  ): any;
 }

src/domain-services/flows/strategy/impl/flow-object-conditions-strategy-impl.ts

@@ -2,7 +2,7 @@ import { type Database } from '@unocha/hpc-api-core/src/db';
 import { Cond } from '@unocha/hpc-api-core/src/db/util/conditions';
 import { Service } from 'typedi';
 import { FlowService } from '../../flow-service';
-import { type FlowCategoryFilters } from '../../graphql/args';
+import { type FlowCategory } from '../../graphql/args';
 import {
   type FlowSearchStrategy,
   type FlowSearchStrategyResponse,
@@ -27,12 +27,13 @@ export class FlowObjectFiltersStrategy implements FlowSearchStrategy {
   async search(
     flowConditions: {
       conditionsMap: Map<string, any>;
-      flowCategoryFilters: FlowCategoryFilters;
+      flowCategoryFilters: FlowCategory[];
     },
     models: Database,
     orderBy?: any,
     limit?: number,
-    cursorCondition?: any
+    cursorCondition?: any,
+    filterByPendingFlows?: boolean
   ): Promise<FlowSearchStrategyResponse> {
     const flowConditionsMap = flowConditions.conditionsMap;
     // Obtain flowObjects conditions
@@ -45,41 +46,40 @@ export class FlowObjectFiltersStrategy implements FlowSearchStrategy {
     const flowEntityConditions = flowConditionsMap.get('flow') ?? new Map();
 
     // Obtain flowCategory conditions
-    const flowCategoryConditions = flowConditions.flowCategoryFilters ?? {};
+    const flowCategoryConditions = flowConditions.flowCategoryFilters ?? [];
 
+    console.log('filterByPendingFlows', filterByPendingFlows);
     const searchFlowIdsStrategy: FlowIDSearchStrategy = this.determineStrategy(
       flowObjectsConditions,
-      flowCategoryConditions
+      flowCategoryConditions,
+      filterByPendingFlows
     );
 
     const { flowIDs: flowIdsToFilter }: FlowIdSearchStrategyResponse =
       await searchFlowIdsStrategy.search(
         models,
         flowObjectsConditions,
-        flowCategoryConditions
+        flowCategoryConditions,
+        filterByPendingFlows
       );
 
+    const whereClauseFromStrategy = searchFlowIdsStrategy.generateWhereClause(
+      flowIdsToFilter,
+      flowCategoryConditions,
+      filterByPendingFlows
+    );
+
     // Combine conditions from flowObjects FlowIDs and flow conditions
     const countConditions = {
-      [Cond.AND]: [
-        flowEntityConditions ?? {},
-
-        searchFlowIdsStrategy.generateWhereClause(
-          flowIdsToFilter,
-          flowCategoryConditions
-        ),
-      ],
+      [Cond.AND]: [flowEntityConditions ?? {}, whereClauseFromStrategy ?? {}],
     };
 
     // Combine cursor condition with flow conditions
     const searchConditions = {
       [Cond.AND]: [
         flowEntityConditions ?? {},
         cursorCondition ?? {},
-        searchFlowIdsStrategy.generateWhereClause(
-          flowIdsToFilter,
-          flowCategoryConditions
-        ),
+        whereClauseFromStrategy ?? {},
       ],
     };
 
@@ -111,24 +111,33 @@ export class FlowObjectFiltersStrategy implements FlowSearchStrategy {
   // otherwise keep all flowIDs from the one that is not empty
   determineStrategy(
     flowObjectsConditions: Map<string, Map<string, number[]>>,
-    flowCategoryConditions: any
+    flowCategoryConditions: any,
+    filterByPendingFlows?: boolean
   ): any {
     const isFlowObjectsConditionsIsDefined =
       flowObjectsConditions !== undefined;
     const isFlowCategoryConditionsIsDefined =
       flowCategoryConditions !== undefined;
+    const isFilterByPendingFlowsIsDefined = filterByPendingFlows !== undefined;
 
+    console.log('filterByPendingFlows', filterByPendingFlows);
     const flowObjectsConditionsIsNotEmpty =
       isFlowObjectsConditionsIsDefined && flowObjectsConditions.size;
-    const flowCategoryConditionsIsNotEmpty =
-      isFlowCategoryConditionsIsDefined &&
-      Object.keys(flowCategoryConditions).length;
-
-    if (flowObjectsConditionsIsNotEmpty && flowCategoryConditionsIsNotEmpty) {
+    const isFlowCategoryConditionsIsNotEmpty =
+      isFlowCategoryConditionsIsDefined && flowCategoryConditions.length !== 0;
+
+    console.log('pending flows', isFilterByPendingFlowsIsDefined);
+    if (
+      flowObjectsConditionsIsNotEmpty &&
+      (isFlowCategoryConditionsIsNotEmpty || isFilterByPendingFlowsIsDefined)
+    ) {
       return this.getFlowIdsFromMixedConditions;
     } else if (flowObjectsConditionsIsNotEmpty) {
       return this.getFlowIdsFromObjectConditions;
-    } else if (flowCategoryConditionsIsNotEmpty) {
+    } else if (
+      isFlowCategoryConditionsIsNotEmpty ||
+      isFilterByPendingFlowsIsDefined
+    ) {
       return this.getFlowIdsFromCategoryConditions;
     }
     throw new Error(

src/domain-services/flows/strategy/impl/get-flowIds-flow-category-conditions-strategy-impl.ts

@@ -5,7 +5,7 @@ import { Op } from '@unocha/hpc-api-core/src/db/util/conditions';
 import { createBrandedValue } from '@unocha/hpc-api-core/src/util/types';
 import { Service } from 'typedi';
 import { CategoryService } from '../../../categories/category-service';
-import { type FlowCategoryFilters } from '../../graphql/args';
+import { type FlowCategory } from '../../graphql/args';
 import {
   type FlowIDSearchStrategy,
   type FlowIdSearchStrategyResponse,
@@ -21,9 +21,11 @@ export class GetFlowIdsFromCategoryConditionsStrategyImpl
   async search(
     models: Database,
     _flowObjectsConditions: Map<string, Map<string, number[]>>,
-    flowCategoryConditions: FlowCategoryFilters
+    flowCategoryConditions: FlowCategory[],
+    filterByPendingFlows: boolean
   ): Promise<FlowIdSearchStrategyResponse> {
     const whereClause = mapFlowCategoryConditionsToWhereClause(
+      filterByPendingFlows,
       flowCategoryConditions
     );
 
@@ -55,9 +57,10 @@ export class GetFlowIdsFromCategoryConditionsStrategyImpl
 
   generateWhereClause(
     flowIds: FlowId[],
-    flowCategoryConditions: FlowCategoryFilters
+    _conditions: any,
+    filterByPendingFlows: boolean
   ) {
-    const operation = flowCategoryConditions.pending ? Op.IN : Op.NOT_IN;
+    const operation = filterByPendingFlows === true ? Op.IN : Op.NOT_IN;
     return {
       id: {
         [operation]: flowIds,

src/domain-services/flows/strategy/impl/get-flowIds-flow-mixed-conditions-strategy-impl.ts

@@ -2,7 +2,7 @@ import { type Database } from '@unocha/hpc-api-core/src/db';
 import { type FlowId } from '@unocha/hpc-api-core/src/db/models/flow';
 import { Op } from '@unocha/hpc-api-core/src/db/util/conditions';
 import { Service } from 'typedi';
-import { type FlowCategoryFilters } from '../../graphql/args';
+import { type FlowCategory } from '../../graphql/args';
 import {
   type FlowIDSearchStrategy,
   type FlowIdSearchStrategyResponse,
@@ -23,7 +23,8 @@ export class GetFlowIdsFromMixedConditionsStrategyImpl
   async search(
     models: Database,
     flowObjectsConditions: Map<string, Map<string, number[]>>,
-    flowCategoryConditions: FlowCategoryFilters
+    flowCategoryConditions: FlowCategory[],
+    filterByPendingFlows: boolean
   ): Promise<FlowIdSearchStrategyResponse> {
     const { flowIDs: flowIdsFromFlowObjects }: FlowIdSearchStrategyResponse =
       await this.getFlowIdsFromObjectConditionsStrategy.search(
@@ -35,7 +36,8 @@ export class GetFlowIdsFromMixedConditionsStrategyImpl
       await this.getFlowIdsFromCategoryConditionsStrategy.search(
         models,
         flowObjectsConditions,
-        flowCategoryConditions
+        flowCategoryConditions,
+        filterByPendingFlows
       );
 
     const mergeFlowIDs: FlowId[] =