rez_core 2.2.17 → 2.2.20

package/package.json

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

package/src/module/workflow/entity/action-resources-mapping.entity.ts

@@ -20,4 +20,7 @@ export class ActionResourcesMapping extends BaseEntity {
 
   @Column({ type: 'varchar', nullable: true })
   form_id: string;
+
+  @Column({ type: 'int', nullable: true })
+  stg_act_mapping_id: number;
 }

package/src/module/workflow/service/action.service.ts

@@ -26,13 +26,23 @@ export class ActionService extends EntityServiceImpl {
       return null;
     }
 
-    const template = await this.dataSource.query(
-      `SELECT template_code FROM cr_wf_action_template_mapping WHERE stg_act_mapping_id =
+    const result = await this.dataSource.query(
+      `SELECT template_code, form_id FROM cr_wf_action_resources_mapping WHERE stg_act_mapping_id =
         (SELECT id FROM cr_wf_stage_action_mapping WHERE action_id = ? AND entity_type = 'STGM')`,
       [actionData.id],
     );
 
-    return { ...actionData, template: template.map((t) => t.template_code) };
+    const templates = result
+      .filter((t) => t.template_code !== null)
+      .map((t) => t.template_code);
+
+    const form = result.find((f) => f.form_id !== null);
+
+    return {
+      ...actionData,
+      template: templates,
+      form: form?.form_id ?? null,
+    };
   }
 
   async createEntity(
@@ -41,49 +51,49 @@ export class ActionService extends EntityServiceImpl {
     manager?: EntityManager | null,
     appcode?: string,
   ): Promise<any> {
-    let actionData = entityData as any;
+    const actionData = entityData as any;
 
-    let action = await super.createEntity(
-      entityData,
-      loggedInUser,
-      manager,
-      appcode,
-    );
+    // Step 1: Create main action entity
+    const action = await super.createEntity(entityData, loggedInUser);
 
-    // stage mapping
-    let stageActionMapping = {
+    // Step 2: Create stage mapping
+    const stageActionMapping = {
       action_id: action.id,
       stage_id: actionData.stage_id,
       entity_type: 'STGM',
     } as any;
 
-    let stageActionMappingData = await super.createEntity(
+    const stageActionMappingData = await super.createEntity(
       stageActionMapping,
       loggedInUser,
-      manager,
-      appcode,
     );
 
-    // template mapping
+    // Step 3: Template mapping (existing)
     if (Array.isArray(actionData.template) && actionData.template.length > 0) {
-      const templates = actionData.template;
+      for (const templateCode of actionData.template) {
+        // ➕ Step 4: Resource mapping for template
+        const resourceMapping = {
+          stg_act_mapping_id: stageActionMappingData.id,
+          template_code: templateCode,
+          type: 'template',
+          entity_type: 'ARMS',
+        } as any;
 
-      for (let i = 0; i < templates.length; i++) {
-        const templateCode = templates[i];
+        await super.createEntity(resourceMapping, loggedInUser);
+      }
+    }
 
-        // Create Action-Template Mapping
-        const actionTemplateMapping = {
+    // ➕ Step 5: Resource mapping for form (if form is sent)
+    if (actionData.form && actionData.form.length > 0) {
+      for (const formId of actionData.form) {
+        const resourceMapping = {
           stg_act_mapping_id: stageActionMappingData.id,
-          template_code: templateCode,
-          entity_type: 'ATMP',
+          form_id: formId,
+          type: 'form',
+          entity_type: 'ARMS',
         } as any;
 
-        await super.createEntity(
-          actionTemplateMapping,
-          loggedInUser,
-          manager,
-          appcode,
-        );
+        await super.createEntity(resourceMapping, loggedInUser);
       }
     }
 
@@ -97,10 +107,12 @@ export class ActionService extends EntityServiceImpl {
     console.log('entityData', entityData);
 
     // Extract template from entityData, keep the rest for ActionEntity
-    const { template, stage_id, ...actionData } = entityData as ActionEntity & {
-      template?: number[];
-      stage_id?: string;
-    };
+    const { template, stage_id, form, ...actionData } =
+      entityData as ActionEntity & {
+        template?: number[];
+        stage_id?: string;
+        form?: number;
+      };
 
     // Pass only actionData (without template) to super.updateEntity
     let action = await super.updateEntity({ ...actionData }, loggedInUser);
@@ -139,16 +151,27 @@ export class ActionService extends EntityServiceImpl {
         const templateCode = template[i];
 
         // Create Action-Template Mapping
-        const actionTemplateMapping = {
+        const resourceMapping = {
           stg_act_mapping_id: stageActionMappingData.id,
           template_code: templateCode,
-          entity_type: 'ATMP',
+          type: 'template',
+          entity_type: 'ARMS',
         } as any;
 
-        await super.createEntity(actionTemplateMapping, loggedInUser);
+        await super.createEntity(resourceMapping, loggedInUser);
       }
     }
 
+    if (form) {
+      const resourceMapping = {
+        stg_act_mapping_id: stageActionMappingData.id,
+        form_id: form,
+        type: 'form',
+        entity_type: 'ARMS',
+      } as any;
+
+      await super.createEntity(resourceMapping, loggedInUser);
+    }
     return action; // Return the action entity instead of actionData
   }
 

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

@@ -1,3 +1,4 @@
+import { ActionCategory } from './../entity/action-category.entity';
 import { DataSource } from 'typeorm';
 import { PopulateMetaService } from './../../meta/service/populate-meta.service';
 import { Inject, Injectable } from '@nestjs/common';
@@ -80,6 +81,29 @@ export class PopulateWorkflowService extends EntityServiceImpl {
   //   }
 
   async populateWorkflowData(organization_id: number, loggedInUser: UserData) {
+    const defaultEntity = await this.dataSource.query(
+      `SELECT * FROM eth_entity WHERE organization_id = -1 AND level_type = 'ORG' AND level_id = -1 AND entity_type = 'ENT'`,
+    );
+
+    const defaultEntityData = defaultEntity[0];
+
+    defaultEntityData.organization_id = organization_id;
+    defaultEntityData.level_id = organization_id;
+
+    await this.dataSource.query(
+      `INSERT INTO eth_entity (entity_type, name, status, code, enterprise_id, organization_id, level_id, level_type) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        defaultEntityData.entity_type,
+        defaultEntityData.name,
+        defaultEntityData.status,
+        defaultEntityData.code,
+        defaultEntityData.enterprise_id,
+        organization_id,
+        organization_id,
+        defaultEntityData.level_type,
+      ],
+    );
+
     const workflowTables = [
       { table: 'cr_workflow', entityType: 'WRFW', service: 'workflowService' },
       {
@@ -99,7 +123,7 @@ export class PopulateWorkflowService extends EntityServiceImpl {
     const factoryData = await Promise.all(
       workflowTables.map(getAllFactoryData),
     );
-    const [workflows, stageGroups, stages, actions] = factoryData;
+    const [workflows, stageGroups, stages] = factoryData;
 
     // === 1. Workflow mapping
     const workflowIdMap: Record<number, number> = {};
@@ -114,6 +138,13 @@ export class PopulateWorkflowService extends EntityServiceImpl {
         },
         loggedInUser,
       );
+
+      // adding new entry for workflow level mapping
+      await this.dataSource.query(
+        `INSERT INTO cr_workflow_level_mapping (workflow_id, mapped_level_id, mapped_level_type) VALUES (?, ?, ?)`,
+        [newWf.id, organization_id, 'ORG'],
+      );
+
       workflowIdMap[id] = newWf.id;
     }
 
@@ -157,28 +188,80 @@ export class PopulateWorkflowService extends EntityServiceImpl {
       );
       stageIdMap[id] = newStage.id;
       stageToStageGroupMap[id] = stage_group_id; // maintain
-    }
 
-    // === 4. Action mapping — point to stage, stageGroup, workflow correctly
-    for (const row of actions) {
-      const { id, stage_id, created_date, modified_date, ...rest } = row;
+      // step 1 find old stage_id in stage_action_mapper and get all actions_ids
+      // step 2 search action in cr_wf_action table with those action_ids
+      // step 3 create new action with new stage_id and new workflow_id
+      // step 4 save new action
 
-      const newStageId = stageIdMap[stage_id];
-      const oldStageGroupId = stageToStageGroupMap[stage_id];
-      const oldWorkflowId = stageGroupToWorkflowMap[oldStageGroupId];
-      const newWorkflowId = workflowIdMap[oldWorkflowId];
+      const stageIds = await this.dataSource.query(
+        `SELECT action_id FROM cr_wf_stage_action_mapping WHERE stage_id = ?`,
+        [id],
+      );
 
-      await this.actionService.createEntity(
-        {
-          ...rest,
-          stage_id: newStageId,
-          workflow_id: newWorkflowId,
-          organization_id,
-          level_id: organization_id,
-          entity_type: 'ACTN',
-        },
-        loggedInUser,
+      const actionIds = stageIds.map((item) => item.action_id);
+
+      let actions = [];
+      if (actionIds.length > 0) {
+        actions = await this.dataSource.query(
+          `SELECT * FROM cr_wf_action WHERE id IN (?)`,
+          [actionIds],
+        );
+      } else {
+        // No actions to query
+        actions = [];
+      }
+
+      console.log(
+        `Found ${actions.length} actions for stage ${id} in workflow ${originalWorkflowId}`,
       );
+
+      // === 4. Action mapping — point to stage, stageGroup, workflow correctly
+      for (const row of actions as any[]) {
+        const { id, created_date, modified_date, workflow_id, ...rest } = row;
+
+        const newWorkflowId = workflowIdMap[workflow_id];
+
+        // Step 1: Get the code of the old is_mandatory field
+        const [oldIsMandatory] = await this.dataSource.query(
+          `SELECT code FROM cr_list_master_items WHERE id = ?`,
+          [rest.action_requirement],
+        );
+
+        // Step 2: Get all new 'ACRQ' list master items for the organization
+        const newIsMandatoryList = await this.dataSource.query(
+          `SELECT id, code FROM cr_list_master_items WHERE organization_id = ? AND listtype = 'ACRQ'`,
+          [organization_id],
+        );
+
+        console.log(
+          `Populating action for stage ${newStage.id} in workflow ${newWorkflowId}`,
+        );
+
+        console.log(`Old is_mandatory code: ${oldIsMandatory?.code}`);
+        console.log(`New is_mandatory list:`, newIsMandatoryList);
+
+        // Step 3: Find the matching new item with the same code
+        const matchedNewMandatory = newIsMandatoryList.find(
+          (item) => item.code === oldIsMandatory?.code,
+        );
+
+        console.log(`Matched new mandatory item:`, matchedNewMandatory);
+
+        // Step 4: Use the matched new item's id (if found)
+        await this.actionService.createEntity(
+          {
+            ...rest,
+            stage_id: newStage.id,
+            workflow_id: newWorkflowId,
+            organization_id,
+            action_requirement: matchedNewMandatory?.id ?? null,
+            level_id: organization_id,
+            entity_type: 'ACTN',
+          },
+          loggedInUser,
+        );
+      }
     }
 
     return {

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

@@ -86,38 +86,32 @@ export class WorkflowService extends EntityServiceImpl {
       }
     }
 
+    const isDefault = [true, 1, 'true'].includes(
+      (entityData as any).is_default,
+    );
     // Handle is_default uniqueness logic within same level
-    if ((entityData as Workflow).is_default == true) {
-      // Step 1: Get previous default workflow for same level_id and level_type
-      const oldDefault = await this.dataSource.query(
-        `
-      SELECT id FROM cr_workflow
-      WHERE level_id = ? AND level_type = ?
-      `,
-        [level_id, level_type],
+    if (isDefault) {
+      await this.dataSource
+        .createQueryBuilder()
+        .update(Workflow)
+        .set({ is_default: 0 })
+        .where(
+          'level_id = :level_id AND level_type = :level_type AND id != :currentId',
+          {
+            level_id,
+            level_type,
+            currentId: workflowId,
+          },
+        )
+        .execute();
+
+      // Update cr_workflow_level_mapping to point to the new workflow
+      await this.dataSource.query(
+        `UPDATE cr_workflow_level_mapping
+     SET workflow_id = ?
+     WHERE mapped_level_id = ? AND mapped_level_type = ?`,
+        [workflowId, level_id, level_type],
       );
-
-      if (oldDefault?.length) {
-        const oldWorkflowId = oldDefault[0].id;
-
-        // Step 2: Update old workflow to is_default = 0
-        await this.dataSource
-          .createQueryBuilder()
-          .update(Workflow)
-          .set({ is_default: 0 })
-          .where('id = :id', { id: oldWorkflowId })
-          .execute();
-
-        // Step 3: Update cr_workflow_level_mapping to point to new workflowId
-        await this.dataSource.query(
-          `
-        UPDATE cr_workflow_level_mapping
-        SET workflow_id = ?
-        WHERE mapped_level_id = ? AND mapped_level_type = ?
-        `,
-          [workflowId, level_id, level_type],
-        );
-      }
     }
 
     // Final update

package/src/module/workflow/workflow.module.ts

@@ -53,6 +53,9 @@ import { FormMasterDataEntity } from './entity/form-master.entity';
 import { FormMasterController } from './controller/form-master.controller';
 import { FormMasterService } from './service/form-master.service';
 import { FormMasterRepository } from './repository/form-master.repository';
+import { ActionResourcesMapping } from './entity/action-resources-mapping.entity';
+import { ActionResourcesMappingService } from './service/action-resources-mapping.service';
+import { ActionResourcesMappingController } from './controller/action-resource-mapping.controller';
 
 @Module({
   imports: [
@@ -72,6 +75,7 @@ import { FormMasterRepository } from './repository/form-master.repository';
       TaskDataEntity,
       ActionDataEntity,
       FormMasterDataEntity,
+      ActionResourcesMapping,
     ]),
     EntityModule,
     ListMasterModule,
@@ -93,6 +97,10 @@ import { FormMasterRepository } from './repository/form-master.repository';
       useClass: EntityModificationService,
     },
     { provide: 'FormMasterService', useClass: FormMasterService },
+    {
+      provide: 'ActionResourcesMappingService',
+      useClass: ActionResourcesMappingService,
+    },
     WorkflowListMasterService,
     ActionTemplateMappingService,
     WorkflowRepository,
@@ -119,6 +127,7 @@ import { FormMasterRepository } from './repository/form-master.repository';
     'StageGroupService',
     'EntityModificationService',
     'FormMasterService',
+    'ActionResourcesMappingService',
     WorkflowRepository,
     StageGroupRepository,
     StageRepository,
@@ -138,6 +147,7 @@ import { FormMasterRepository } from './repository/form-master.repository';
     ActionCategoryController,
     TaskController,
     FormMasterController,
+    ActionResourcesMappingController,
   ],
 })
 export class WorkflowModule {}