Temp wip

refactor GQL types

package.json

@@ -16,7 +16,7 @@
     "lint": "yarn lint-prettier && yarn lint-eslint"
   },
   "dependencies": {
-    "@unocha/hpc-api-core": "^6.0.0",
+    "@unocha/hpc-api-core": "https://github.com/UN-OCHA/hpc-api-core.git#7443efb9039a0eab7833ee9fa8393038e1c286a6",
     "apollo-server-hapi": "^3.12.0",
     "bunyan": "^1.8.15",
     "class-validator": "^0.14.0",

src/domain-services/categories/category-service.ts

@@ -1,40 +1,46 @@
 import { Database } from '@unocha/hpc-api-core/src/db';
-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 { FlowCategory } from '../flows/graphql/types';
+import { Category } from './graphql/types';
 import { InstanceDataOfModel } from '@unocha/hpc-api-core/src/db/util/raw-model';
+import { Op } from '@unocha/hpc-api-core/src/db/util/conditions';
 
 // TODO: add proper type for flowLinks
 @Service()
 export class CategoryService {
   async getCategoriesForFlows(
-    flowLinks: Map<number, any[]>,
+    flowLinks: Map<number, InstanceDataOfModel<Database['flowLink']>[]>,
     models: Database
-  ): Promise<Map<number, FlowCategory[]>> {
+  ): Promise<Map<number, Category[]>> {
     const flowLinksBrandedIds = [];
     for (const flowLink of flowLinks.keys()) {
       flowLinksBrandedIds.push(createBrandedValue(flowLink));
     }
 
-    const categoriesRef = await models.categoryRef.find({
-      where: {
-        objectID: {
-          [Op.IN]: flowLinksBrandedIds,
-        },
-      },
-    });
+    // Group categories by flow ID for easy mapping
+    const categoriesMap = new Map<number, Category[]>();
 
-    const categories = await models.category.find({
-      where: {
-        id: {
-          [Op.IN]: categoriesRef.map((catRef) => catRef.categoryID),
+    if (flowLinksBrandedIds.length === 0) {
+      return categoriesMap;
+    }
+
+    const categoriesRef: InstanceDataOfModel<Database['categoryRef']>[] =
+      await models.categoryRef.find({
+        where: {
+          objectID: {
+            [Op.IN]: flowLinksBrandedIds,
+          },
         },
-      },
-    });
+      });
 
-    // Group categories by flow ID for easy mapping
-    const categoriesMap = new Map<number, FlowCategory[]>();
+    const categories: InstanceDataOfModel<Database['category']>[] =
+      await models.category.find({
+        where: {
+          id: {
+            [Op.IN]: categoriesRef.map((catRef) => catRef.categoryID),
+          },
+        },
+      });
 
     // Populate the map with categories for each flow
     categoriesRef.forEach((catRef) => {
@@ -61,13 +67,13 @@ export class CategoryService {
   private mapCategoryToFlowCategory(
     category: InstanceDataOfModel<Database['category']>,
     categoryRef: InstanceDataOfModel<Database['categoryRef']>
-  ): FlowCategory {
+  ): Category {
     return {
       id: category.id,
       name: category.name,
       group: category.group,
-      createdAt: category.createdAt.toISOString(),
-      updatedAt: category.updatedAt.toISOString(),
+      createdAt: category.createdAt,
+      updatedAt: category.updatedAt,
       description: category.description ?? '',
       parentID: category.parentID ? category.parentID.valueOf() : 0,
       code: category.code ?? '',
@@ -77,8 +83,8 @@ export class CategoryService {
         versionID: categoryRef.versionID,
         objectType: categoryRef.objectType,
         categoryID: category.id.valueOf(),
-        createdAt: categoryRef.createdAt.toISOString(),
-        updatedAt: categoryRef.updatedAt.toISOString(),
+        createdAt: categoryRef.createdAt,
+        updatedAt: categoryRef.updatedAt,
       },
     };
   }

src/domain-services/categories/graphql/types.ts

@@ -0,0 +1,44 @@
+import { Field, ObjectType } from 'type-graphql';
+import { BaseType } from '../../../utils/graphql/base-types';
+
+@ObjectType()
+export class CategoryRef extends BaseType {
+  @Field({ nullable: false })
+  objectID: number;
+
+  @Field({ nullable: false })
+  versionID: number;
+
+  @Field({ nullable: false })
+  objectType: string;
+
+  @Field({ nullable: false })
+  categoryID: number;
+}
+
+@ObjectType()
+export class Category extends BaseType {
+  @Field({ nullable: true })
+  id: number;
+
+  @Field({ nullable: false })
+  name: string;
+
+  @Field({ nullable: false })
+  group: string;
+
+  @Field({ nullable: true })
+  description: string;
+
+  @Field({ nullable: true })
+  parentID: number;
+
+  @Field({ nullable: true })
+  code: string;
+
+  @Field({ nullable: true })
+  includeTotals: boolean;
+
+  @Field(() => CategoryRef, { nullable: true })
+  categoryRef: CategoryRef;
+}

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

@@ -1,5 +1,9 @@
 import { Service } from 'typedi';
-import { FlowSearchResult, FlowSortField } from './graphql/types';
+import {
+  FlowParkedParentSource,
+  FlowSearchResult,
+  FlowSortField,
+} from './graphql/types';
 import { Database } from '@unocha/hpc-api-core/src/db/type';
 import { createBrandedValue } from '@unocha/hpc-api-core/src/util/types';
 import { OrganizationService } from '../organizations/organization-service';
@@ -84,7 +88,7 @@ export class FlowSearchService {
 
     const count = countRes[0] as { count: number };
 
-    const flowIds = flows.map((flow) => flow.id);
+    const flowIds: FlowId[] = flows.map((flow) => flow.id);
 
     const organizationsFO: any[] = [];
     const locationsFO: any[] = [];
@@ -131,6 +135,7 @@ export class FlowSearchService {
     ]);
 
     const items = flows.map((flow) => {
+      const flowLink = flowLinksMap.get(flow.id) || [];
       const categories = categoriesMap.get(flow.id) || [];
       const organizations = organizationsMap.get(flow.id) || [];
       const locations = locationsMap.get(flow.id) || [];
@@ -139,9 +144,14 @@ export class FlowSearchService {
       const externalReferences = externalReferencesMap.get(flow.id) || [];
       const reportDetails = reportDetailsMap.get(flow.id) || [];
 
-      const childIDs: number[] = (flowLinksMap.get(flow.id) || []).map(
-        (flowLink) => flowLink.childID.valueOf()
-      ) as number[];
+      const parkedParentSource: FlowParkedParentSource[] = [];
+      if (flow.activeStatus && flowLink.length > 0) {
+        this.getParketParents(flow, flowLink, models, parkedParentSource);
+      }
+
+      const childIDs: number[] = flowLinksMap
+        .get(flow.id)
+        ?.map((flowLink) => flowLink.childID.valueOf()) as number[];
 
       const parentIDs: number[] = flowLinksMap
         .get(flow.id)
@@ -167,7 +177,7 @@ export class FlowSearchService {
         origCurrency: flow.origCurrency ? flow.origCurrency.toString() : '',
         externalReferences,
         reportDetails,
-        parkedParentSource: 'placeholder',
+        parkedParentSource,
         // Paged item field
         cursor: flow.id.valueOf(),
       };
@@ -214,4 +224,46 @@ export class FlowSearchService {
       }
     });
   }
+
+  private async getParketParents(
+    flow: any,
+    flowLink: any[],
+    models: Database,
+    parkedParentSource: FlowParkedParentSource[]
+  ): Promise<any> {
+    const flowLinksDepth0 = flowLink.filter((flowLink) => flowLink.depth === 0);
+
+    const flowLinksParent = flowLinksDepth0.filter(
+      (flowLink) => flowLink.parentID === flow.id
+    );
+
+    const parentFlowIds = flowLinksParent.map((flowLink) =>
+      flowLink.parentID.valueOf()
+    );
+
+    const categories = await models.category.find({
+      where: {
+        group: 'flowType',
+        name: 'parked',
+      },
+    });
+
+    const categoriesIDs = categories.map((category) => category.id);
+
+    const categoryRef = await models.categoryRef.find({
+      where: {
+        categoryID: {
+          [Op.IN]: categoriesIDs,
+        },
+        versionID: flow.versionID,
+      },
+    });
+
+    const parentFlows = flowLinksParent.filter((flowLink) => {
+      return categoryRef.some(
+        (categoryRef) =>
+          categoryRef.objectID.valueOf() === flowLink.parentID.valueOf()
+      );
+    });
+  }
 }

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

@@ -1,4 +1,4 @@
-import Flow, { FlowSearchResult, FlowSortField } from './types';
+import { FlowPaged, FlowSearchResult, FlowSortField } from './types';
 import { Service } from 'typedi';
 import { Arg, Args, Ctx, Query, Resolver } from 'type-graphql';
 import { FlowSearchService } from '../flow-search-service';
@@ -7,7 +7,7 @@ import { SearchFlowsFilters } from './args';
 import { PaginationArgs } from '../../../utils/graphql/pagination';
 
 @Service()
-@Resolver(Flow)
+@Resolver(FlowPaged)
 export default class FlowResolver {
   constructor(private flowSearchService: FlowSearchService) {}