rez_core 2.1.145 → 2.1.148

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

@@ -37,8 +37,6 @@ export class ActionService extends EntityServiceImpl {
     manager?: EntityManager | null,
     appcode?: string,
   ): Promise<any> {
-    console.log('entityData', entityData);
-
     let actionData = entityData as any;
 
     let action = await super.createEntity(
@@ -196,7 +194,7 @@ export class ActionService extends EntityServiceImpl {
     }
     const result = await this.dataSource.query(
       `
-    SELECT name, value 
+    SELECT name, id 
     FROM cr_list_master_items 
     WHERE listtype = ? AND organization_id = ?
     `,
@@ -205,38 +203,119 @@ export class ActionService extends EntityServiceImpl {
 
     // Format as array of key-value pairs
     return result.map((row: any) => ({
-      label: row.value,
-      value: row.name,
+      label: row.name,
+      value: row.id,
     }));
   }
 
-  async getActions(loggedInUser: UserData, workflow_id: number) {
+  async getActions(loggedInUser: UserData, stage_id: number) {
     const { organization_id } = loggedInUser;
 
-    const result = await this.dataSource.query(
+    // Step 1: Get all action_ids for the provided stage_id
+    const stageActions = await this.dataSource.query(
       `
-    SELECT 
-      a.name AS action_name,
-      ac.name AS action_category,
-      ar.name AS action_requirement,
-      'Email Template' AS template
-
-    FROM cr_wf_action a
+    SELECT id, action_id 
+    FROM cr_wf_stage_action_mapping 
+    WHERE stage_id = ?
+    `,
+      [stage_id],
+    );
 
-    LEFT JOIN cr_wf_action_category ac 
-      ON ac.id = a.action_cat_id
+    if (!stageActions?.length) return [];
 
-    LEFT JOIN cr_list_master_items ar 
-      ON ar.id = a.action_requirement
-      AND ar.listtype = 'ACRQ'
-      AND ar.organization_id = ?
+    const actionIds = stageActions.map((sa) => sa.action_id);
+    const mappingIds = stageActions.map((sa) => sa.id);
 
-    WHERE a.organization_id = ?
-    AND a.workflow_id = ?
+    // Step 2: Get template codes with mapping IDs
+    const templateMappings = await this.dataSource.query(
+      `
+    SELECT stg_act_mapping_id, template_code 
+    FROM cr_wf_action_template_mapping 
+    WHERE stg_act_mapping_id IN (${mappingIds.map(() => '?').join(',')})
     `,
-      [organization_id, organization_id, workflow_id],
+      mappingIds,
     );
 
-    return result;
+    const templateCodes = templateMappings.map((tm) => tm.template_code);
+
+    // Step 3: Fetch template names from cr_wf_comm_template
+    const templateCodeToName: Record<string, string> = {};
+
+    if (templateCodes.length > 0) {
+      const templates = await this.dataSource
+        .createQueryBuilder()
+        .select(['t.code AS code', 't.name AS name'])
+        .from('cr_wf_comm_template', 't')
+        .where('t.code IN (:...codes)', { codes: templateCodes })
+        .andWhere('t.organization_id = :orgId', { orgId: organization_id })
+        .getRawMany();
+
+      templates.forEach((tpl) => {
+        templateCodeToName[tpl.code] = tpl.name;
+      });
+    }
+
+    // Step 4: Build map of mapping_id → template names
+    const mappingIdToTemplates: Record<number, string[]> = {};
+
+    for (const tm of templateMappings) {
+      const mappingId = tm.stg_act_mapping_id;
+      const name = templateCodeToName[tm.template_code];
+      if (name) {
+        if (!mappingIdToTemplates[mappingId]) {
+          mappingIdToTemplates[mappingId] = [];
+        }
+        mappingIdToTemplates[mappingId].push(name);
+      }
+    }
+
+    // Step 5: Build action_id → template names using mappingIdToTemplates + stageActions
+    const actionIdToTemplates: Record<number, string[]> = {};
+
+    for (const sa of stageActions) {
+      const mappingId = sa.id;
+      const templates = mappingIdToTemplates[mappingId];
+      if (templates?.length) {
+        if (!actionIdToTemplates[sa.action_id]) {
+          actionIdToTemplates[sa.action_id] = [];
+        }
+        actionIdToTemplates[sa.action_id].push(...templates);
+      }
+    }
+
+    // Step 6: Fetch action details
+    const actionResults = await this.dataSource
+      .createQueryBuilder()
+      .select([
+        'a.id AS id',
+        'a.name AS action_name',
+        'ac.name AS action_category',
+        'ar.name AS action_requirement',
+      ])
+      .from('cr_wf_action', 'a')
+      .leftJoin('cr_wf_action_category', 'ac', 'ac.id = a.action_cat_id')
+      .leftJoin(
+        'cr_list_master_items',
+        'ar',
+        `ar.id = a.action_requirement AND ar.listtype = 'ACRQ' AND ar.organization_id = :orgId`,
+        { orgId: organization_id },
+      )
+      .where('a.organization_id = :orgId', { orgId: organization_id })
+      .andWhere('a.id IN (:...actionIds)', { actionIds })
+      .getRawMany();
+
+    // Step 7: Enrich result with template field
+    const enrichedResult = actionResults.map((row) => {
+      const actionId = Number(row.id); // Ensure numeric ID match
+      const templates = actionIdToTemplates[actionId] || [];
+      const uniqueTemplates = [...new Set(templates)]; // remove duplicates
+
+      return {
+        ...row,
+        template: uniqueTemplates.join(', '),
+      };
+    });
+
+    return enrichedResult;
   }
 }

package/src/module/workflow/service/comm-template.service.ts

@@ -1,6 +1,8 @@
 import { Injectable } from '@nestjs/common';
 import { CommTemplateRepository } from '../repository/comm-template.repository';
 import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
+import { UserData } from 'src/module/user/entity/user.entity';
 
 @Injectable()
 export class CommTemplateService extends EntityServiceImpl {
@@ -8,6 +10,57 @@ export class CommTemplateService extends EntityServiceImpl {
     super();
   }
 
+  async createEntity(entityData: any, loggedInUser: any): Promise<any> {
+    const { attachments, ...templateData } = entityData;
+
+    const tempData = await super.createEntity(templateData, loggedInUser);
+
+    // attachment mapper create and update
+    if (attachments && attachments.length > 0) {
+      const attachmentEntities = attachments.map((attachment) => ({
+        entity_type: templateData.entity_type,
+        template_id: tempData.id,
+        media_id: attachment,
+        organization_id: loggedInUser.organization_id,
+        appcode: loggedInUser.appcode,
+        level_id: loggedInUser.level_id,
+        level_type: loggedInUser.level_type,
+      }));
+
+      await this.commTemplateRepository.save(attachmentEntities);
+    }
+
+    return tempData;
+  }
+
+  async updateEntity(entityData: any, loggedInUser: UserData): Promise<any> {
+    const { attachments, ...templateData } = entityData;
+
+    const tempData = await super.updateEntity(templateData, loggedInUser);
+
+    // delete existing mapper
+    await this.commTemplateRepository.delete({
+      template_id: tempData.id,
+    });
+
+    // attachment mapper create and update
+    if (attachments && attachments.length > 0) {
+      const attachmentEntities = attachments.map((attachment) => ({
+        entity_type: templateData.entity_type,
+        template_id: tempData.id,
+        media_id: attachment,
+        organization_id: loggedInUser.organization_id,
+        appcode: loggedInUser.appcode,
+        level_id: loggedInUser.level_id,
+        level_type: loggedInUser.level_type,
+      }));
+
+      await this.commTemplateRepository.save(attachmentEntities);
+    }
+
+    return tempData;
+  }
+
   async getEntityData(
     entityType: string,
     id: number,
@@ -32,8 +85,8 @@ export class CommTemplateService extends EntityServiceImpl {
       );
 
     const response = commTemplateData.map((item) => ({
-      label: item.name,
       value: item.code,
+      name: item.name,
     }));
 
     return response;

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

@@ -0,0 +1,189 @@
+import { DataSource } from 'typeorm';
+import { PopulateMetaService } from './../../meta/service/populate-meta.service';
+import { Inject, Injectable } from '@nestjs/common';
+import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+import { WorkflowService } from './workflow.service';
+import { UserData } from 'src/module/user/entity/user.entity';
+import { StageGroupService } from './stage-group.service';
+import { StageService } from './stage.service';
+import { ActionService } from './action.service';
+
+@Injectable()
+export class PopulateWorkflowService extends EntityServiceImpl {
+  constructor(
+    private readonly populateMetaService: PopulateMetaService,
+    private readonly dataSource: DataSource,
+    @Inject('WorkflowService')
+    private readonly workflowService: WorkflowService,
+    @Inject('StageGroupService')
+    private readonly stageGroupService: StageGroupService,
+    @Inject('StageService')
+    private readonly stageService: StageService,
+    @Inject('ActionService')
+    private readonly actionService: ActionService,
+  ) {
+    super();
+  }
+
+  //   async populateWorkflowData(organization_id: number, loggedInUser: UserData) {
+  //     // Define workflow tables
+  //     const workflowTables = [
+  //       { table: 'cr_workflow', entityType: 'WRFW', service: 'workflowService' },
+  //       {
+  //         table: 'cr_wf_stage_group',
+  //         entityType: 'STGP',
+  //         service: 'stageGroupService',
+  //       },
+  //       { table: 'cr_wf_stage', entityType: 'STG', service: 'stageService' },
+  //       { table: 'cr_wf_action', entityType: 'ACTN', service: 'actionService' },
+  //     ];
+
+  //     const getAllFactoryData = async (table: { table: string }) => {
+  //       return this.dataSource.query(
+  //         `SELECT * FROM ${table.table} WHERE organization_id = -1 AND level_type = 'ORG' AND level_id = -1`,
+  //       );
+  //     };
+
+  //     const factoryData = await Promise.all(
+  //       workflowTables.map((table) => getAllFactoryData(table)),
+  //     );
+
+  //     // Step 1: Insert workflow metadata
+  //     for (let i = 0; i < workflowTables.length; i++) {
+  //       const table = workflowTables[i];
+  //       const data = factoryData[i];
+
+  //       if (!data.length) continue;
+
+  //       // Clean and transform data for insertion
+  //       const transformedData = data.map((row) => {
+  //         const { id, created_date, modified_date, ...rest } = row;
+  //         return {
+  //           ...rest,
+  //           organization_id: organization_id,
+  //           level_id: organization_id,
+  //           entity_type: table.entityType,
+  //         };
+  //       });
+
+  //       const service = this[table.service];
+
+  //       for (const record of transformedData) {
+  //         await service.createEntity(record, loggedInUser);
+  //       }
+  //     }
+
+  //     return {
+  //       message: 'Workflow data populated successfully',
+  //       status: 'success',
+  //     };
+  //   }
+
+  async populateWorkflowData(organization_id: number, loggedInUser: UserData) {
+    const workflowTables = [
+      { table: 'cr_workflow', entityType: 'WRFW', service: 'workflowService' },
+      {
+        table: 'cr_wf_stage_group',
+        entityType: 'STGP',
+        service: 'stageGroupService',
+      },
+      { table: 'cr_wf_stage', entityType: 'STG', service: 'stageService' },
+      { table: 'cr_wf_action', entityType: 'ACTN', service: 'actionService' },
+    ];
+
+    // Fetch all base data
+    const getAllFactoryData = async (table: { table: string }) =>
+      this.dataSource.query(
+        `SELECT * FROM ${table.table} WHERE organization_id = -1 AND level_type = 'ORG' AND level_id = -1`,
+      );
+    const factoryData = await Promise.all(
+      workflowTables.map(getAllFactoryData),
+    );
+    const [workflows, stageGroups, stages, actions] = factoryData;
+
+    // === 1. Workflow mapping
+    const workflowIdMap: Record<number, number> = {};
+    for (const row of workflows) {
+      const { id, ...rest } = row;
+      const newWf = await this.workflowService.createEntity(
+        {
+          ...rest,
+          organization_id,
+          level_id: organization_id,
+          entity_type: 'WRFW',
+        },
+        loggedInUser,
+      );
+      workflowIdMap[id] = newWf.id;
+    }
+
+    // === 2. StageGroup mapping (and save workflow ref from template data!)
+    const stageGroupIdMap: Record<number, number> = {};
+    // Include mapping from old stageGroupId to old workflowId to help with stage->workflow logic later:
+    const stageGroupToWorkflowMap: Record<number, number> = {};
+    for (const row of stageGroups) {
+      const { id, workflow_id, ...rest } = row;
+      const newSg = await this.stageGroupService.createEntity(
+        {
+          ...rest,
+          workflow_id: workflowIdMap[workflow_id],
+          organization_id,
+          level_id: organization_id,
+          entity_type: 'STGP',
+        },
+        loggedInUser,
+      );
+      stageGroupIdMap[id] = newSg.id;
+      stageGroupToWorkflowMap[id] = workflow_id;
+    }
+
+    // === 3. Stage mapping — point to stageGroup and workflow
+    const stageIdMap: Record<number, number> = {};
+    const stageToStageGroupMap: Record<number, number> = {};
+    for (const row of stages) {
+      const { id, stage_group_id, ...rest } = row;
+      // Find the original parent workflow_id using the stageGroupToWorkflowMap
+      const originalWorkflowId = stageGroupToWorkflowMap[stage_group_id];
+      const newStage = await this.stageService.createEntity(
+        {
+          ...rest,
+          stage_group_id: stageGroupIdMap[stage_group_id],
+          workflow_id: workflowIdMap[originalWorkflowId], // New workflow id!
+          organization_id,
+          level_id: organization_id,
+          entity_type: 'STG',
+        },
+        loggedInUser,
+      );
+      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;
+
+      const newStageId = stageIdMap[stage_id];
+      const oldStageGroupId = stageToStageGroupMap[stage_id];
+      const oldWorkflowId = stageGroupToWorkflowMap[oldStageGroupId];
+      const newWorkflowId = workflowIdMap[oldWorkflowId];
+
+      await this.actionService.createEntity(
+        {
+          ...rest,
+          stage_id: newStageId,
+          workflow_id: newWorkflowId,
+          organization_id,
+          level_id: organization_id,
+          entity_type: 'ACTN',
+        },
+        loggedInUser,
+      );
+    }
+
+    return {
+      message: 'Workflow data populated successfully',
+      status: 'success',
+    };
+  }
+}

package/src/module/workflow/service/workflow-list-master.service.ts

@@ -12,8 +12,8 @@ export class WorkflowListMasterService extends EntityServiceImpl {
     const results = await this.dataSource.query(
       `
       SELECT 
-        ac.logo AS logo,
-        ac.name AS name,
+      ac.name AS name,
+      ac.logo AS logo,
         ac.modalName AS modalName,
         a.action_requirement AS actionRequirement
       FROM cr_wf_stage_action_mapping sam
@@ -26,8 +26,8 @@ export class WorkflowListMasterService extends EntityServiceImpl {
 
     // Add actionStatus and return formatted output
     return results.map((item: any) => ({
-      logo: item.logo,
       name: item.name,
+      logo: item.logo,
       modalName: item.modalName,
       actionRequirement: item.actionRequirement,
       actionStatus: 'Done',

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

@@ -0,0 +1,98 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { StageMovementData } from '../entity/stage-movement-data.entity';
+
+@Injectable()
+export class WorkflowMetaService {
+  constructor(
+    @InjectRepository(StageMovementData)
+    private readonly stageMovementRepo: Repository<StageMovementData>,
+  ) {}
+
+  /**
+   * Get the current active stage for a given mapped entity
+   */
+  async getCurrentStage(
+    mapped_entity_type: string,
+    mapped_entity_id: number,
+  ): Promise<StageMovementData | null> {
+    return this.stageMovementRepo.findOne({
+      where: {
+        mapped_entity_type,
+        mapped_entity_id,
+        is_current: 'Y',
+      },
+    });
+  }
+
+  /**
+   * Get next stage ID based on current stage
+   * (Stub logic – replace with real stage transition resolution)
+   */
+  async getNextStage(currentStage: StageMovementData): Promise<number | null> {
+    // TODO: Replace with actual logic based on mapping table
+    const nextStageId = currentStage.stage_action_mapping_id + 1;
+    const hasNext = true;
+
+    return hasNext ? nextStageId : null;
+  }
+
+  /**
+   * Move mapped entity to the next stage in the workflow
+   */
+  async moveToNextStage(
+    mapped_entity_type: string,
+    mapped_entity_id: number,
+    current_user_id: number,
+  ): Promise<string> {
+    const now = new Date();
+    const currentStage = await this.getCurrentStage(mapped_entity_type, mapped_entity_id);
+
+    // Case 1: First stage – initialize
+    if (!currentStage) {
+      const firstStageId = 1; // TODO: Replace with actual logic to fetch first stage
+
+      await this.stageMovementRepo.save({
+        mapped_entity_type,
+        mapped_entity_id,
+        current_user_id,
+        stage_action_mapping_id: firstStageId,
+        start_date: now,
+        is_current: 'Y',
+      });
+
+      return 'Workflow started with the first stage.';
+    }
+
+    // Case 2: Has next stage – move forward
+    const nextStageId = await this.getNextStage(currentStage);
+
+    if (nextStageId) {
+      // Close current stage
+      currentStage.end_date = now;
+      currentStage.is_current = 'N';
+      await this.stageMovementRepo.save(currentStage);
+
+      // Insert next stage
+      await this.stageMovementRepo.save({
+        entity_type: 'STAGE_MOVEMENT_DATA',
+        mapped_entity_type,
+        mapped_entity_id,
+        current_user_id,
+        stage_action_mapping_id: nextStageId,
+        start_date: now,
+        is_current: 'Y',
+      });
+
+      return `Moved to next stage (Stage ID: ${nextStageId}).`;
+    }
+
+    // Case 3: No next stage – mark workflow as done
+    currentStage.end_date = now;
+    currentStage.is_current = 'N';
+    await this.stageMovementRepo.save(currentStage);
+
+    return 'Workflow completed. No next stage available.';
+  }
+}

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

@@ -1,39 +1,44 @@
 import { Module } from '@nestjs/common';
-import { Workflow } from './entity/workflow.entity';
-import { WorkflowService } from './service/workflow.service';
-import { StageGroup } from './entity/stage-group.entity';
-import { Stage } from './entity/stage.entity';
-import { ActionCategory } from './entity/action-category.entity';
-import { CommTemplate } from './entity/comm-template.entity';
-import { ActionTemplateMapping } from './entity/action-template-mapping.entity';
-import { StageActionMapping } from './entity/stage-action-mapping.entity';
-import { ActionCategoryService } from './service/action-category.service';
-import { CommTemplateService } from './service/comm-template.service';
-import { StageActionMappingService } from './service/stage-action-mapping.service';
-import { ActionTemplateMappingService } from './service/action-template-mapping.service';
-import { ActionService } from './service/action.service';
-import { StageService } from './service/stage.service';
-import { StageGroupService } from './service/stage-group.service';
 import { TypeOrmModule } from '@nestjs/typeorm';
+import { ListMasterModule } from '../listmaster/listmaster.module';
 import { EntityModule } from '../meta/entity.module';
-import { WorkflowListMasterService } from './service/workflow-list-master.service';
-import { WorkflowListMasterController } from './controller/workflow-list-master.controller';
 import { ActionTemplateMappingController } from './controller/action-template-mapping.controller';
-import { WorkflowController } from './controller/workflow.controller';
-import { WorkflowRepository } from './repository/workflow.repository';
-import { ListMasterModule } from '../listmaster/listmaster.module';
+import { ActionController } from './controller/action.controller';
 import { CommTemplateController } from './controller/comm-template.controller';
-import { CommTemplateRepository } from './repository/comm-template.repository';
-import { ActionEntity } from './entity/action.entity';
-import { StageGroupRepository } from './repository/stage-group.repository';
+import { EntityModificationController } from './controller/entity-modification.controller';
 import { StageGroupController } from './controller/stage-group.controller';
 import { StageController } from './controller/stage.controller';
+import { WorkflowListMasterController } from './controller/workflow-list-master.controller';
+import { WorkflowMetaController } from './controller/workflow-meta.controller';
+import { WorkflowController } from './controller/workflow.controller';
+import { ActionCategory } from './entity/action-category.entity';
+import { ActionTemplateMapping } from './entity/action-template-mapping.entity';
+import { ActionEntity } from './entity/action.entity';
+import { CommTemplate } from './entity/comm-template.entity';
+import { EntityModification } from './entity/entity-modification.entity';
+import { StageActionMapping } from './entity/stage-action-mapping.entity';
+import { StageGroup } from './entity/stage-group.entity';
+import { StageMovementData } from './entity/stage-movement-data.entity';
+import { Stage } from './entity/stage.entity';
+import { TemplateAttach } from './entity/template-attach-mapper.entity';
+import { Workflow } from './entity/workflow.entity';
+import { CommTemplateRepository } from './repository/comm-template.repository';
+import { StageGroupRepository } from './repository/stage-group.repository';
 import { StageRepository } from './repository/stage.repository';
-import { ActionController } from './controller/action.controller';
-import { EntityController } from '../meta/controller/entity.controller';
+import { WorkflowRepository } from './repository/workflow.repository';
+import { ActionCategoryService } from './service/action-category.service';
+import { ActionTemplateMappingService } from './service/action-template-mapping.service';
+import { ActionService } from './service/action.service';
+import { CommTemplateService } from './service/comm-template.service';
 import { EntityModificationService } from './service/entity-modification.service';
-import { EntityModification } from './entity/entity-modification.entity';
-import { EntityModificationController } from './controller/entity-modification.controller';
+import { PopulateWorkflowService } from './service/populate-workflow.service';
+import { StageActionMappingService } from './service/stage-action-mapping.service';
+import { StageGroupService } from './service/stage-group.service';
+import { StageService } from './service/stage.service';
+import { WorkflowListMasterService } from './service/workflow-list-master.service';
+import { WorkflowMetaService } from './service/workflow-meta.service';
+import { WorkflowService } from './service/workflow.service';
+import { ActionCategoryController } from './controller/action-category.controller';
 
 @Module({
   imports: [
@@ -46,7 +51,9 @@ import { EntityModificationController } from './controller/entity-modification.c
       CommTemplate,
       ActionTemplateMapping,
       StageActionMapping,
+      StageMovementData,
       EntityModification,
+      TemplateAttach,
     ]),
     EntityModule,
     ListMasterModule,
@@ -73,6 +80,9 @@ import { EntityModificationController } from './controller/entity-modification.c
     CommTemplateRepository,
     StageGroupRepository,
     StageRepository,
+    WorkflowService,
+    WorkflowMetaService,
+    PopulateWorkflowService,
   ],
   exports: [
     'ActionCategoryService',
@@ -85,6 +95,8 @@ import { EntityModificationController } from './controller/entity-modification.c
     WorkflowRepository,
     StageGroupRepository,
     StageRepository,
+    WorkflowMetaService,
+    PopulateWorkflowService,
   ],
   controllers: [
     WorkflowListMasterController,
@@ -94,7 +106,9 @@ import { EntityModificationController } from './controller/entity-modification.c
     StageGroupController,
     StageController,
     ActionController,
+    WorkflowMetaController,
     EntityModificationController,
+    ActionCategoryController,
   ],
 })
 export class WorkflowModule {}