rez_core 2.2.253 → 2.2.255

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

@@ -1,14 +1,16 @@
-import { Inject, Injectable } from '@nestjs/common';
+import { Inject, Injectable, Logger, NotFoundException } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
+import { DataSource, Repository } from 'typeorm';
 import { WorkflowAutomation } from '../entity/workflow-automation.entity';
 import { WorkflowAutomationActionEntity } from '../entity/workflow-automation-action.entity';
 import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
 import { UserData } from 'src/module/user/entity/user.entity';
 import { SavedFilterService } from 'src/module/filter/service/saved-filter.service';
+import { ENTITYTYPE_SAVEDFILTERMASTER } from 'src/constant/global.constant';
 
 @Injectable()
 export class WorkflowAutomationService extends EntityServiceImpl {
+  private readonly logger = new Logger(WorkflowAutomationService.name);
   constructor(
     @InjectRepository(WorkflowAutomation)
     private readonly wfRepo: Repository<WorkflowAutomation>,
@@ -16,6 +18,7 @@ export class WorkflowAutomationService extends EntityServiceImpl {
     private readonly actionRepo: Repository<WorkflowAutomationActionEntity>,
     @Inject('SavedFilterService')
     private readonly savedFilterService: SavedFilterService,
+    private readonly dataSource: DataSource,
   ) {
     super();
   }
@@ -64,66 +67,261 @@ export class WorkflowAutomationService extends EntityServiceImpl {
   }
 
   async updateEntity(entityData: any, loggedInUser: UserData) {
-    // 1. Extract "core" workflow fields
+    this.logger.debug(
+      `Updating WorkflowAutomation with data: ${JSON.stringify(entityData)}`,
+    );
+
     const { event, criteria, action, ...workflowData } = entityData;
 
-    // 2. Update only valid workflow columns
+    // 1. Update core workflow columns first
+    this.logger.log(`Updating core workflow fields for workflow...`);
     let workflow = await super.updateEntity(workflowData, loggedInUser);
+    this.logger.debug(`Workflow updated (id=${workflow.id})`);
 
-    // 3. EVENT
+    // 2. EVENT FILTER
     if (event?.eventFilterJson || event?.triggerType || event?.event) {
+      this.logger.log(`Processing EVENT filter for workflow ${workflow.id}`);
+
       const eventFilterMaster = {
         entity_type: 'SFM',
         name: `Event_Filter_${workflow.id}`,
         filterDetails: event?.eventFilterJson ?? [],
         filter_scope: 'RULE',
+        organization_id: loggedInUser.organization_id,
+        enterprise_id: loggedInUser.enterprise_id,
       };
 
-      const savedEvent = await this.savedFilterService.createEntity(
-        eventFilterMaster,
-        loggedInUser,
-      );
+      if (workflow.condition_filter_code) {
+        this.logger.debug(
+          `Existing event filter found: ${workflow.condition_filter_code}`,
+        );
+        const existing = await this.savedFilterService.getEntityDataByCode(
+          ENTITYTYPE_SAVEDFILTERMASTER,
+          workflow.condition_filter_code,
+          loggedInUser,
+        );
+
+        if (existing) {
+          eventFilterMaster['id'] = existing.id;
+          const updatedEvent = await this.savedFilterService.updateEntity(
+            eventFilterMaster as any,
+            loggedInUser,
+          );
+          workflow.condition_filter_code = updatedEvent.code;
+          this.logger.log(
+            `Updated existing event filter: ${updatedEvent.code}`,
+          );
+        }
+      } else {
+        const savedEvent = await this.savedFilterService.createEntity(
+          eventFilterMaster,
+          loggedInUser,
+        );
+        workflow.condition_filter_code = savedEvent.code;
+        this.logger.log(`Created new event filter: ${savedEvent.code}`);
+      }
 
       workflow.trigger_type = event?.triggerType ?? null;
       workflow.trigger_event = event?.event ?? null;
-      workflow.condition_filter_code = savedEvent.code;
     }
 
-    // 4. CRITERIA
+    // 3. CRITERIA FILTER
     if (criteria?.criteriaFilterJson?.length) {
+      this.logger.log(`Processing CRITERIA filter for workflow ${workflow.id}`);
+
       const criteriaFilterMaster = {
         entity_type: 'SFM',
         name: `Criteria_Filter_${workflow.id}`,
         filterDetails: criteria?.criteriaFilterJson ?? [],
         filter_scope: 'RULE',
+        organization_id: loggedInUser.organization_id,
+        enterprise_id: loggedInUser.enterprise_id,
       };
 
-      const savedCriteria = await this.savedFilterService.createEntity(
-        criteriaFilterMaster,
-        loggedInUser,
-      );
+      if (workflow.criteria_filter_code) {
+        this.logger.debug(
+          `Existing criteria filter found: ${workflow.criteria_filter_code}`,
+        );
+        const existing = await this.savedFilterService.getEntityDataByCode(
+          ENTITYTYPE_SAVEDFILTERMASTER,
+          workflow.criteria_filter_code,
+          loggedInUser,
+        );
 
-      workflow.criteria_filter_code = savedCriteria.code;
+        if (existing) {
+          criteriaFilterMaster['id'] = existing.id;
+          const updatedCriteria = await this.savedFilterService.updateEntity(
+            criteriaFilterMaster as any,
+            loggedInUser,
+          );
+          workflow.criteria_filter_code = updatedCriteria.code;
+          this.logger.log(
+            `Updated existing criteria filter: ${updatedCriteria.code}`,
+          );
+        }
+      } else {
+        const savedCriteria = await this.savedFilterService.createEntity(
+          criteriaFilterMaster,
+          loggedInUser,
+        );
+        workflow.criteria_filter_code = savedCriteria.code;
+        this.logger.log(`Created new criteria filter: ${savedCriteria.code}`);
+      }
     }
 
-    // 5. ACTIONS
+    // 4. ACTIONS
     if (Array.isArray(action) && action.length) {
+      this.logger.log(
+        `Processing ${action.length} actions for workflow ${workflow.id}`,
+      );
+
+      const existingActions = await this.dataSource
+        .getRepository(WorkflowAutomationActionEntity)
+        .find({
+          where: { workflow_automation_id: workflow.id },
+        });
+
+      const existingMap = new Map(
+        existingActions.map((a) => [a.entity_method, a]),
+      );
+
+      // 2. Upsert actions
       for (const a of action) {
-        if (!a?.actionCategory) continue; // skip invalid
+        if (!a?.actionCategory) {
+          this.logger.warn(
+            `Skipping action without category: ${JSON.stringify(a)}`,
+          );
+          continue;
+        }
+
+        const existing = existingMap.get(a.actionCategory);
 
-        const actionEntity = new WorkflowAutomationActionEntity();
-        actionEntity.entity_type = 'WFAA';
-        actionEntity.workflow_automation_id = workflow.id;
-        actionEntity.entity_method = a.actionCategory;
-        actionEntity.payload = a.actionPayload ?? {};
+        if (existing) {
+          // update
+          existing.payload = a.actionPayload ?? {};
+          await this.dataSource
+            .getRepository(WorkflowAutomationActionEntity)
+            .save(existing);
+          this.logger.log(`Updated action: ${a.actionCategory}`);
+        } else {
+          // insert
+          const actionEntity = new WorkflowAutomationActionEntity();
+          actionEntity.entity_type = 'WFAA';
+          actionEntity.workflow_automation_id = workflow.id;
+          actionEntity.entity_method = a.actionCategory;
+          actionEntity.payload = a.actionPayload ?? {};
 
-        await super.createEntity(actionEntity, loggedInUser);
+          await this.dataSource
+            .getRepository(WorkflowAutomationActionEntity)
+            .save(actionEntity);
+          this.logger.log(`Created new action: ${a.actionCategory}`);
+        }
+      }
+      const incomingCategories = action.map((a) => a.actionCategory);
+      const toDelete = existingActions.filter(
+        (a) => !incomingCategories.includes(a.entity_method),
+      );
+
+      if (toDelete.length) {
+        await this.dataSource
+          .getRepository(WorkflowAutomationActionEntity)
+          .remove(toDelete);
+        this.logger.log(
+          `Deleted ${toDelete.length} actions not present in request.`,
+        );
       }
     }
 
-    // 6. Save workflow with updated trigger/criteria codes
+    // 5. Save workflow again with updated codes
     workflow = await super.updateEntity(workflow, loggedInUser);
+    this.logger.debug(`Final workflow updated (id=${workflow.id})`);
 
     return workflow;
   }
+
+  async getEntityData(entity_type: string, id: number, loggedInUser: UserData) {
+    this.logger.log(`Fetching WorkflowAutomation by id=${id}`);
+
+    // 1. Get workflow automation entity
+    const workflowAutomation = await this.dataSource
+      .getRepository(WorkflowAutomation)
+      .findOne({
+        where: { id },
+      });
+
+    if (!workflowAutomation) {
+      throw new NotFoundException(`WorkflowAutomation not found with id=${id}`);
+    }
+
+    // 2. EVENT FILTER
+    let event: any = null;
+    if (workflowAutomation.condition_filter_code) {
+      const eventFilterMaster: any =
+        await this.savedFilterService.getEntityDataByCode(
+          ENTITYTYPE_SAVEDFILTERMASTER,
+          workflowAutomation.condition_filter_code,
+          loggedInUser,
+        );
+
+      if (eventFilterMaster) {
+        // 🔑 fetch filter details using mapped_filter_code
+        const eventFilterDetails =
+          await this.savedFilterService.getDetailsByCode(
+            eventFilterMaster.code,
+          );
+
+        event = {
+          eventFilterJson: eventFilterDetails ?? [],
+          triggerType: workflowAutomation.trigger_type,
+          event: workflowAutomation.trigger_event,
+        };
+      }
+    }
+
+    // 3. CRITERIA FILTER
+    let criteria: any = null;
+    if (workflowAutomation.criteria_filter_code) {
+      const criteriaFilterMaster: any =
+        await this.savedFilterService.getEntityDataByCode(
+          ENTITYTYPE_SAVEDFILTERMASTER,
+          workflowAutomation.criteria_filter_code,
+          loggedInUser,
+        );
+
+      if (criteriaFilterMaster) {
+        // 🔑 fetch filter details using mapped_filter_code
+        const criteriaFilterDetails =
+          await this.savedFilterService.getDetailsByCode(
+            criteriaFilterMaster.code,
+          );
+
+        criteria = {
+          criteriaFilterJson: criteriaFilterDetails ?? [],
+        };
+      }
+    }
+
+    // 4. ACTIONS
+    const actions = await this.dataSource
+      .getRepository(WorkflowAutomationActionEntity)
+      .find({
+        where: { workflow_automation_id: workflowAutomation.id },
+      });
+
+    const action = actions.map((a) => ({
+      actionCategory: a.entity_method,
+      actionPayload: a.payload,
+    }));
+
+    // 5. Final response
+    const response = {
+      ...workflowAutomation,
+      event,
+      criteria,
+      action,
+    };
+
+    this.logger.debug(`Fetched WorkflowAutomation (id=${id}) with relations`);
+    return response;
+  }
 }