rez_core 3.1.83 → 3.1.84

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "3.1.83",
+  "version": "3.1.84",
   "description": "",
   "author": "",
   "private": false,

package/src/module/filter/service/filter.service.ts

@@ -10,6 +10,7 @@ import { SavedFilterService } from './saved-filter.service';
 import * as moment from 'moment';
 import { EntityRelationService } from 'src/module/meta/service/entity-relation.service';
 import { ResolverService } from 'src/module/meta/service/resolver.service';
+import { LoggingService } from 'src/utils/service/loggingUtil.service';
 
 @Injectable()
 export class FilterService {
@@ -22,6 +23,7 @@ export class FilterService {
     @Inject('EntityRelationService')
     private readonly entityRelationService: EntityRelationService,
     private readonly resolverService: ResolverService,
+    @Inject() protected readonly loggingService: LoggingService,
   ) {}
   private readonly skipAppCodeFilterEntities = ['ORGP'];
   private readonly skipOrgFilterEntities = ['ORGP'];
@@ -80,9 +82,16 @@ export class FilterService {
       quickFilter = [],
       savedFilterCode,
       attributeFilter = [],
+      loggedInUser,
     } = dto;
 
-    console.log(dto,"APPLY FILTER WRAPPER DTO");
+    await this.loggingService.log(
+      'info',
+      'FilterService',
+      'applyFilterWrapper',
+      'Started applyFilterWrapper',
+      [dto],
+    );
 
     // 🔹 Step 1: Collect all filters (from body + savedFilter)
     const savedFilters = await this.getSavedFilters(
@@ -94,6 +103,14 @@ export class FilterService {
       ...savedFilters,
     ].filter((f) => f.filter_value !== '');
 
+    await this.loggingService.log(
+      'debug',
+      'FilterService',
+      'applyFilterWrapper',
+      'Collected all filters',
+      [allFilters],
+    );
+
     // 🔹 Step 2: Group filters by filter_entity_type
     const grouped = allFilters.reduce(
       (acc, f) => {
@@ -104,6 +121,14 @@ export class FilterService {
       {} as Record<string, any[]>,
     );
 
+    await this.loggingService.log(
+      'debug',
+      'FilterService',
+      'applyFilterWrapper',
+      'Grouped filters by entity type',
+      [grouped],
+    );
+
     // 🔹 Step 3: Handle sub-entities first
     let intersectionIds: number[] | null = null;
     for (const [subEntityType, filters] of Object.entries(grouped)) {
@@ -121,10 +146,23 @@ export class FilterService {
 
       const subResult = await this.applyFilter(subDto);
 
-      // ✅ new way (fetch source entity IDs via relation mapping)
       const subEntityIds = subResult.data.entity_list.map((row) => row.id);
 
+      await this.loggingService.log(
+        'debug',
+        'FilterService',
+        'applyFilterWrapper',
+        `Sub-entity ${subEntityType} returned IDs`,
+        [subEntityIds],
+      );
+
       if (!subEntityIds.length) {
+        await this.loggingService.log(
+          'info',
+          'FilterService',
+          'applyFilterWrapper',
+          `No records found for sub-entity ${subEntityType}, returning empty result`,
+        );
         return {
           success: true,
           data: { entity_tabs: [], entity_list: [], pagination: {} },
@@ -138,14 +176,26 @@ export class FilterService {
         dto.loggedInUser.organization_id,
       );
 
-      // keep intersection
       intersectionIds =
         intersectionIds === null
           ? relatedIds
           : intersectionIds.filter((id) => relatedIds.includes(id));
 
-      // early exit if no intersection
+      await this.loggingService.log(
+        'debug',
+        'FilterService',
+        'applyFilterWrapper',
+        `Related IDs for sub-entity ${subEntityType}`,
+        [relatedIds, intersectionIds],
+      );
+
       if (intersectionIds.length === 0) {
+        await this.loggingService.log(
+          'info',
+          'FilterService',
+          'applyFilterWrapper',
+          'No intersection IDs left, returning empty result',
+        );
         return {
           success: true,
           data: { entity_tabs: [], entity_list: [], pagination: {} },
@@ -157,12 +207,11 @@ export class FilterService {
     const mainFilters = grouped[entity_type] || [];
     const mainDto: FilterRequestDto = {
       ...dto,
-      quickFilter: [...mainFilters], // this guarantees it's an array
+      quickFilter: [...mainFilters],
       savedFilterCode: null,
       attributeFilter: [],
     };
 
-    // pass intersection ids as an extra constraint
     if (intersectionIds && intersectionIds.length > 0) {
       (mainDto.quickFilter ??= []).push({
         filter_attribute: 'id',
@@ -172,6 +221,14 @@ export class FilterService {
       });
     }
 
+    await this.loggingService.log(
+      'info',
+      'FilterService',
+      'applyFilterWrapper',
+      'Calling applyFilter for main entity',
+      [mainDto],
+    );
+
     return this.applyFilter(mainDto);
   }
 
@@ -199,6 +256,14 @@ export class FilterService {
       organization_id,
     } = loggedInUser || {};
 
+    await this.loggingService.log(
+      'info',
+      'FilterService',
+      'applyFilter',
+      'Started applyFilter',
+      [dto],
+    );
+
     // Fetch meta from entity table service
     const entityMeta = await this.entityMasterService.getEntityData(
       entity_type,
@@ -207,6 +272,12 @@ export class FilterService {
     const tableName = entityMeta?.data_source; // data_souce is the table name
 
     if (!tableName) {
+      await this.loggingService.log(
+        'error',
+        'FilterService',
+        'applyFilter',
+        `Invalid entity_type: ${entity_type}`,
+      );
       throw new BadRequestException(`Invalid entity_type: ${entity_type}`);
     }
 
@@ -263,6 +334,14 @@ export class FilterService {
 
     console.log(baseFilters, 'STEP 1B: BASE FILTERS FOR MAIN ENTITY');
 
+    await this.loggingService.log(
+      'debug',
+      'FilterService',
+      'applyFilter',
+      'Collected base filters',
+      [baseFilters],
+    );
+
     // Build where clauses
     const baseWhere = this.buildWhereClauses(baseFilters, attributeMetaMap);
 
@@ -332,6 +411,14 @@ export class FilterService {
     //   });
     // }
 
+    await this.loggingService.log(
+      'debug',
+      'FilterService',
+      'applyFilter',
+      'Constructed baseWhere clauses',
+      [baseWhere],
+    );
+
     // layout preference query
     const layoutPreference = await this.dataSource.query(
       `SELECT mapped_json 
@@ -360,6 +447,14 @@ export class FilterService {
       );
     }
 
+    await this.loggingService.log(
+      'debug',
+      'FilterService',
+      'applyFilter',
+      'Tab counts retrieved',
+      [allTabs],
+    );
+
     let filteredTabs;
 
     if (showList?.length > 0) {
@@ -441,6 +536,14 @@ export class FilterService {
       filteredTabs = allTabs;
     }
 
+    await this.loggingService.log(
+      'debug',
+      'FilterService',
+      'applyFilter',
+      'Filtered tabs prepared',
+      [filteredTabs],
+    );
+
     const dataWhere = [...baseWhere];
 
     console.log(dataWhere, 'dataWhere');
@@ -557,6 +660,14 @@ export class FilterService {
 
     const entity_list = await qb.getRawMany();
 
+    await this.loggingService.log(
+      'debug',
+      'FilterService',
+      'applyFilter',
+      'Fetched entity_list',
+      [entity_list.length, entity_list.slice(0, 5)], // log first 5 rows for brevity
+    );
+
     // 1. Extract all date-type attribute keys
     const dateAttributes = Object.entries(attributeMetaMap)
       .filter(([_, attr]) => attr.data_type === 'date')
@@ -590,6 +701,14 @@ export class FilterService {
       ),
     );
 
+    await this.loggingService.log(
+      'debug',
+      'FilterService',
+      'applyFilter',
+      'Resolved entity data',
+      [resolvedEntityList.length],
+    );
+
     // 6. Resolve tab values (tab_value field)
     const resolvedTabs = await Promise.all(
       filteredTabs.map(async (tab) => {
@@ -618,6 +737,14 @@ export class FilterService {
       }),
     );
 
+    await this.loggingService.log(
+      'debug',
+      'FilterService',
+      'applyFilter',
+      'Resolved tab values',
+      [resolvedTabs],
+    );
+
     // Count query (without pagination)
     const countQb = this.dataSource
       .createQueryBuilder()
@@ -629,6 +756,13 @@ export class FilterService {
     const countResult = await countQb.getRawOne();
     const total = parseInt(countResult.count, 10);
 
+    await this.loggingService.log(
+      'info',
+      'FilterService',
+      'applyFilter',
+      'Returning final result',
+    );
+
     return {
       success: true,
       data: {

package/src/module/workflow/service/action-template-mapping.service.ts

@@ -26,7 +26,7 @@ export class ActionTemplateMappingService extends EntityServiceImpl {
 
     const templates = await this.dataSource.query(
       `
-      SELECT template_code FROM cr_wf_action_template_mapping
+      SELECT template_code FROM cr_wf_action_resources_mapping
       WHERE stg_act_mapping_id = ? 
       `,
       [stgActMappingId],

package/src/module/workflow-automation/service/workflow-automation-engine.service.ts

@@ -4,6 +4,7 @@ import { WorkflowAutomationService } from './workflow-automation.service';
 import { FilterEvaluatorService } from '../../filter/service/filter-evaluator.service';
 import { Action } from '../interface/action.interface';
 import { DataSource } from 'typeorm';
+import { LoggingService } from 'src/utils/service/loggingUtil.service';
 
 @Injectable()
 export class WorkflowAutomationEngineService {
@@ -14,10 +15,17 @@ export class WorkflowAutomationEngineService {
     private readonly wfService: WorkflowAutomationService,
     private readonly filterEvaluator: FilterEvaluatorService,
     private readonly dataSource: DataSource,
+    @Inject() protected readonly loggingService: LoggingService,
   ) {}
 
   registerAction(actionName: string, actionInstance: Action) {
     this.actions.set(actionName, actionInstance);
+    this.loggingService.log(
+      'info',
+      'WorkflowAutomationEngine',
+      'registerAction',
+      `Registered action ${actionName}`,
+    );
   }
 
   /**
@@ -31,10 +39,18 @@ export class WorkflowAutomationEngineService {
     user: any,
     preUpdateStates?: Record<number, boolean> | null,
   ) {
+    this.loggingService.log(
+      'info',
+      'WorkflowAutomationEngine',
+      'handleEntityEvent',
+      `Handling entity event: ${eventType} for entityType: ${entityType}`,
+      [newEntity?.id, preUpdateStates],
+    );
+
     const workflows = await this.wfService.getActiveRules(
       entityType,
       eventType,
-      user
+      user,
     );
 
     for (const wf of workflows) {
@@ -43,7 +59,7 @@ export class WorkflowAutomationEngineService {
 
       if (eventType === 'CREATE') {
         triggerMatched = await this.filterEvaluator.evaluateCriteria(
-          entityType,
+          wf.applicable_entity_type,
           wf.condition_filter_code,
           newEntity.id,
           user,
@@ -51,7 +67,7 @@ export class WorkflowAutomationEngineService {
       } else if (eventType === 'UPDATE' && preUpdateStates) {
         const before = preUpdateStates[wf.id] ?? false;
         const after = await this.filterEvaluator.evaluateCriteria(
-          entityType,
+          wf.applicable_entity_type,
           wf.condition_filter_code,
           newEntity.id,
           user,
@@ -60,25 +76,37 @@ export class WorkflowAutomationEngineService {
       }
 
       // 🔍 Log Step 1 result
-      console.log(
-        `[Workflow:${wf.id}] Step 1 - Trigger matched:`,
-        triggerMatched,
+      this.loggingService.log(
+        'debug',
+        'WorkflowAutomationEngine',
+        'handleEntityEvent',
+        `Step 1 - Trigger matched`,
+        [wf.id, triggerMatched],
       );
 
       if (!triggerMatched) continue;
 
       // Step 2️⃣ Final criteria evaluation
+
+      const entityIdToUse =
+      wf.mapped_entity_type === wf.applicable_entity_type
+    ? newEntity.id
+    : newEntity.parent_id;
+
       const criteriaMatched = await this.filterEvaluator.evaluateCriteria(
-        entityType,
+        wf.mapped_entity_type,
         wf.criteria_filter_code,
-        newEntity.id,
+        entityIdToUse,
         user,
       );
 
       // 🔍 Log Step 2 result
-      console.log(
-        `[Workflow:${wf.id}] Step 2 - Criteria matched:`,
-        criteriaMatched,
+      this.loggingService.log(
+        'debug',
+        'WorkflowAutomationEngine',
+        'handleEntityEvent',
+        `Step 2 - Criteria matched`,
+        [wf.id, criteriaMatched],
       );
 
       if (!criteriaMatched) continue;
@@ -99,7 +127,12 @@ export class WorkflowAutomationEngineService {
     );
 
     if (!actions.length) {
-      console.log(`No actions found for workflow ${workflow_automation_id}`);
+      this.loggingService.log(
+        'warn',
+        'WorkflowAutomationEngine',
+        'executeActions',
+        `No actions found for workflow ${workflow_automation_id}`,
+      );
       return;
     }
 
@@ -112,7 +145,10 @@ export class WorkflowAutomationEngineService {
         );
 
         if (!category?.action_decorator) {
-          console.warn(
+          this.loggingService.log(
+            'warn',
+            'WorkflowAutomationEngine',
+            'executeActions',
             `No action_decorator found for category_id=${action.action_category_id}`,
           );
           continue;
@@ -124,11 +160,22 @@ export class WorkflowAutomationEngineService {
         const impl = this.actions.get(decorator);
 
         if (!impl) {
-          console.warn(` No implementation found for action: ${decorator}`);
+          this.loggingService.log(
+            'warn',
+            'WorkflowAutomationEngine',
+            'executeActions',
+            `No implementation found for action: ${decorator}`,
+          );
           continue;
         }
 
-        console.log(`Executing action ${decorator} for entity ${entity.id}`);
+        this.loggingService.log(
+          'info',
+          'WorkflowAutomationEngine',
+          'executeActions',
+          `Executing action ${decorator} for entity ${entity.id}`,
+          [workflow_automation_id],
+        );
 
         // 4️ Execute action with required context
         await impl.execute({
@@ -137,11 +184,20 @@ export class WorkflowAutomationEngineService {
           config: action.payload, // from cr_wf_action table
         });
 
-        console.log(`Action ${decorator} executed successfully`);
+        this.loggingService.log(
+          'info',
+          'WorkflowAutomationEngine',
+          'executeActions',
+          `Action ${decorator} executed successfully`,
+          [workflow_automation_id],
+        );
       } catch (err) {
-        console.error(
-          `Error executing action (category_id=${action.action_category_id}):`,
-          err,
+        this.loggingService.log(
+          'error',
+          'WorkflowAutomationEngine',
+          'executeActions',
+          `Error executing action (category_id=${action.action_category_id})`,
+          [err],
         );
       }
     }

package/.vscode/extensions.json

@@ -1,5 +0,0 @@
-{
-    "recommendations": [
-        "dbaeumer.vscode-eslint"
-    ]
-}