rez_core 2.1.144 → 2.1.147

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

@@ -209,4 +209,110 @@ export class ActionService extends EntityServiceImpl {
       value: row.name,
     }));
   }
+
+  async getActions(loggedInUser: UserData, stage_id: number) {
+    const { organization_id } = loggedInUser;
+
+    // Step 1: Get all action_ids for the provided stage_id
+    const stageActions = await this.dataSource.query(
+      `
+    SELECT id, action_id 
+    FROM cr_wf_stage_action_mapping 
+    WHERE stage_id = ?
+    `,
+      [stage_id],
+    );
+
+    if (!stageActions?.length) return [];
+
+    const actionIds = stageActions.map((sa) => sa.action_id);
+    const mappingIds = stageActions.map((sa) => sa.id);
+
+    const templateMappings = await this.dataSource.query(
+      `
+    SELECT template_code 
+    FROM cr_wf_action_template_mapping 
+    WHERE stg_act_mapping_id IN (?)
+    `,
+      [mappingIds],
+    );
+
+    const templateCodes = templateMappings.map((tm) => tm.template_code);
+
+    // Step 3: Fetch template names from cr_wf_comm_template
+    let templateNameMap: Record<number, string> = {};
+
+    if (templateCodes.length > 0) {
+      const templates = await this.dataSource.query(
+        `
+      SELECT code, name 
+      FROM cr_wf_comm_template 
+      WHERE code IN (?)
+        AND organization_id = ?
+      `,
+        [templateCodes, organization_id],
+      );
+
+      // Map template_code to name
+      const codeToNameMap = templates.reduce((acc, curr) => {
+        acc[curr.code] = curr.name;
+        return acc;
+      }, {});
+
+      // Group template names by mapping_id
+      templateMappings.forEach((tm) => {
+        const mappingId = tm.stg_act_mapping_id;
+        const name = codeToNameMap[tm.template_code];
+        if (name) {
+          if (!templateNameMap[mappingId]) {
+            templateNameMap[mappingId] = name;
+          } else {
+            templateNameMap[mappingId] += `, ${name}`;
+          }
+        }
+      });
+    }
+
+    // Step 2: Fetch action details based on those action_ids
+    // Step 4: Fetch action details
+    const result = await this.dataSource.query(
+      `
+    SELECT 
+      a.id,
+      a.name AS action_name,
+      ac.name AS action_category,
+      ar.name AS action_requirement
+    FROM cr_wf_action a
+    LEFT JOIN cr_wf_action_category ac 
+      ON ac.id = a.action_cat_id
+    LEFT JOIN cr_list_master_items ar 
+      ON ar.id = a.action_requirement
+      AND ar.listtype = 'ACRQ'
+      AND ar.organization_id = ?
+    WHERE a.organization_id = ?
+      AND a.id IN (?)
+    `,
+      [organization_id, organization_id, actionIds],
+    );
+
+    // Step 5: Attach templates (comma-separated) to each result row
+    const enrichedResult = result.map((row) => {
+      // Find all mapping_ids where action_id == current row.id
+      const relatedMappingIds = stageActions
+        .filter((sa) => sa.action_id === row.id)
+        .map((sa) => sa.id);
+
+      // Collect all template names across those mapping ids
+      const allNames = relatedMappingIds
+        .map((mid) => templateNameMap[mid])
+        .filter(Boolean);
+
+      return {
+        ...row,
+        template: allNames.length ? allNames.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/entity-modification.service.ts

@@ -0,0 +1,67 @@
+import {
+  BadRequestException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+import { UserData } from 'src/module/user/entity/user.entity';
+import { DataSource } from 'typeorm';
+
+@Injectable()
+export class EntityModificationService extends EntityServiceImpl {
+  constructor(private readonly dataSource: DataSource) {
+    super();
+  }
+  async logModification(modificationData: any, loggedInUser: UserData) {
+    const { mapped_entity_type, mapped_entity_id, attribute_key } =
+      modificationData;
+    const { organization_id } = loggedInUser;
+
+    if (!mapped_entity_type || !mapped_entity_id || !attribute_key) {
+      throw new BadRequestException(
+        'Missing required modification data: mapped_entity_type, mapped_entity_id, or attribute_key',
+      );
+    }
+
+    // Step 1: Fetch db_table_name from cr_entity_master
+    const [entityMeta] = await this.dataSource.query(
+      `
+    SELECT db_table_name 
+    FROM cr_entity_master 
+    WHERE mapped_entity_type = ? AND organization_id = ?
+    `,
+      [mapped_entity_type, organization_id],
+    );
+
+    if (!entityMeta || !entityMeta.db_table_name) {
+      throw new NotFoundException(
+        'Entity metadata not found in cr_entity_master',
+      );
+    }
+
+    const tableName = entityMeta.db_table_name;
+
+    // Step 2: Get the row from the target table using mapped_entity_id
+    const [entityRow] = await this.dataSource.query(
+      `
+    SELECT * FROM ${tableName} WHERE id = ?
+    `,
+      [mapped_entity_id],
+    );
+
+    if (!entityRow) {
+      throw new NotFoundException(
+        `No record found in ${tableName} with ID ${mapped_entity_id}`,
+      );
+    }
+
+    // Step 3: Extract current value from the target column
+    const currentAttributeValue = entityRow[attribute_key];
+
+    // Step 4: Set current_value in modificationData
+    modificationData.current_value = currentAttributeValue;
+
+    // Step 5: Call super.createEntity with updated modificationData
+    return await super.createEntity(modificationData, loggedInUser);
+  }
+}

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,35 +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 { TypeOrmModule } from '@nestjs/typeorm';
+import { ListMasterModule } from '../listmaster/listmaster.module';
+import { EntityModule } from '../meta/entity.module';
+import { ActionTemplateMappingController } from './controller/action-template-mapping.controller';
+import { ActionController } from './controller/action.controller';
+import { CommTemplateController } from './controller/comm-template.controller';
+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 { CommTemplate } from './entity/comm-template.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 { WorkflowRepository } from './repository/workflow.repository';
 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 { CommTemplateService } from './service/comm-template.service';
+import { EntityModificationService } from './service/entity-modification.service';
+import { PopulateWorkflowService } from './service/populate-workflow.service';
+import { StageActionMappingService } from './service/stage-action-mapping.service';
 import { StageGroupService } from './service/stage-group.service';
-import { TypeOrmModule } from '@nestjs/typeorm';
-import { EntityModule } from '../meta/entity.module';
+import { StageService } from './service/stage.service';
 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 { 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 { StageGroupController } from './controller/stage-group.controller';
-import { StageController } from './controller/stage.controller';
-import { StageRepository } from './repository/stage.repository';
-import { ActionController } from './controller/action.controller';
+import { WorkflowMetaService } from './service/workflow-meta.service';
+import { WorkflowService } from './service/workflow.service';
+import { ActionCategoryController } from './controller/action-category.controller';
 
 @Module({
   imports: [
@@ -42,6 +51,9 @@ import { ActionController } from './controller/action.controller';
       CommTemplate,
       ActionTemplateMapping,
       StageActionMapping,
+      StageMovementData,
+      EntityModification,
+      TemplateAttach,
     ]),
     EntityModule,
     ListMasterModule,
@@ -57,6 +69,10 @@ import { ActionController } from './controller/action.controller';
     { provide: 'StageService', useClass: StageService },
     { provide: 'StageGroupService', useClass: StageGroupService },
     { provide: 'WorkflowService', useClass: WorkflowService },
+    {
+      provide: 'EntityModificationService',
+      useClass: EntityModificationService,
+    },
     WorkflowListMasterService,
     ActionTemplateMappingService,
     WorkflowRepository,
@@ -64,6 +80,9 @@ import { ActionController } from './controller/action.controller';
     CommTemplateRepository,
     StageGroupRepository,
     StageRepository,
+    WorkflowService,
+    WorkflowMetaService,
+    PopulateWorkflowService,
   ],
   exports: [
     'ActionCategoryService',
@@ -72,9 +91,12 @@ import { ActionController } from './controller/action.controller';
     'ActionService',
     'StageService',
     'StageGroupService',
+    'EntityModificationService',
     WorkflowRepository,
     StageGroupRepository,
     StageRepository,
+    WorkflowMetaService,
+    PopulateWorkflowService,
   ],
   controllers: [
     WorkflowListMasterController,
@@ -84,6 +106,9 @@ import { ActionController } from './controller/action.controller';
     StageGroupController,
     StageController,
     ActionController,
+    WorkflowMetaController,
+    EntityModificationController,
+    ActionCategoryController,
   ],
 })
 export class WorkflowModule {}