rez_core 2.2.8 → 2.2.10

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/stage-group.service.ts

@@ -1,5 +1,70 @@
-import { Injectable } from '@nestjs/common';
+import { Inject, Injectable } from '@nestjs/common';
 import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+import { StageGroupRepository } from '../repository/stage-group.repository';
+import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
+import { UserData } from 'src/module/user/entity/user.entity';
+import { StageService } from './stage.service';
+import { DataSource } from 'typeorm';
 
 @Injectable()
-export class StageGroupService extends EntityServiceImpl {}
+export class StageGroupService extends EntityServiceImpl {
+  constructor(
+    private readonly stageGroupRepository: StageGroupRepository,
+    @Inject('StageService')
+    private readonly stageService: StageService,
+    private readonly dataSource: DataSource,
+  ) {
+    super();
+  }
+  async getAllStageGroup(
+    workflow_id: number,
+    level_id: string,
+    level_type: string,
+  ) {
+    return await this.stageGroupRepository.getAllStageGroup(
+      workflow_id,
+      level_id,
+      level_type,
+    );
+  }
+
+  async updateEntity(
+    entityData: BaseEntity,
+    loggedInUser: UserData,
+  ): Promise<any> {
+    return await super.updateEntity(entityData, loggedInUser);
+  }
+
+  async getEntityData(
+    entityType: string,
+    id: number,
+    loggedInUser?: UserData,
+  ): Promise<BaseEntity | null> {
+    return await super.getEntityData(entityType, id, loggedInUser);
+  }
+
+  async deleteEntity(
+    entityType: string,
+    id: number,
+    loggedInUser: UserData,
+  ): Promise<any> {
+    const getAllStage = await this.dataSource.query(
+      `SELECT id FROM cr_wf_stage WHERE stage_group_id = ? AND level_id =? AND level_type = ?`,
+      [id, loggedInUser.level_id, loggedInUser.level_type],
+    );
+
+    if (getAllStage.length > 0) {
+      for (const stage of getAllStage) {
+        await this.stageService.deleteEntity('STG', stage.id, loggedInUser);
+      }
+    }
+
+    const deleteStageGroup = await super.deleteEntity(
+      entityType,
+      id,
+      loggedInUser,
+    );
+
+    return deleteStageGroup;
+  }
+}

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

@@ -1,47 +1,123 @@
-import { Injectable } from '@nestjs/common';
-import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
+import { ActionService } from './action.service';
+import {
+  BadRequestException,
+  Inject,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
 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';
-import { DataSource, EntityManager } from 'typeorm';
+import { StageRepository } from '../repository/stage.repository';
+import { DataSource } from 'typeorm';
+import { StageGroupRepository } from '../repository/stage-group.repository';
 
 @Injectable()
 export class StageService extends EntityServiceImpl {
-  constructor(private readonly dataSource: DataSource) {
+  constructor(
+    private readonly stageRepository: StageRepository,
+    private readonly stageGroupRepository: StageGroupRepository,
+    private readonly dataSource: DataSource,
+    @Inject('ActionService')
+    private readonly actionService: ActionService,
+  ) {
     super();
   }
+  async getAllStage(
+    stage_group_id: number,
+    level_id: string,
+    level_type: string,
+  ) {
+    return await this.stageRepository.getAllStage(
+      stage_group_id,
+      level_id,
+      level_type,
+    );
+  }
 
-  async createEntity(
+  async updateEntity(
     entityData: BaseEntity,
-    loggedInUser: UserData | null,
-    manager?: EntityManager | null,
-    appcode?: string,
+    loggedInUser: UserData,
+  ): Promise<any> {
+    return await super.updateEntity(entityData, loggedInUser);
+  }
+
+  async getEntityData(
+    entityType: string,
+    id: number,
+    loggedInUser?: UserData,
+  ): Promise<BaseEntity | null> {
+    return await super.getEntityData(entityType, id, loggedInUser);
+  }
+
+  async deleteEntity(
+    entityType: string,
+    id: number,
+    loggedInUser: UserData,
   ): Promise<any> {
-    const stageData = entityData as any;
-
-    // Step 1: Get the stage_group name using stage_group_id
-    let stageGroupName = '';
-    if (stageData.stage_group_id) {
-      const result = await this.dataSource.query(
-        `SELECT name FROM cr_wf_stage_group WHERE id = ?`,
-        [stageData.stage_group_id],
-      );
-
-      if (result.length > 0) {
-        stageGroupName = result[0].name;
+    const getAllStageAction = await this.dataSource.query(
+      `SELECT action_id FROM cr_wf_stage_action_mapping WHERE stage_id = ? AND entity_type = 'STGM'`,
+      [id],
+    );
+
+    if (getAllStageAction.length > 0) {
+      for (const action of getAllStageAction) {
+        await this.actionService.deleteEntity(
+          'ACTN',
+          action.action_id,
+          loggedInUser,
+        );
       }
     }
 
-    if (stageGroupName && stageData.name) {
-      stageData.full_name = `${stageGroupName}-${stageData.name}`;
+    const deleteStage = await super.deleteEntity(entityType, id, loggedInUser);
+
+    return deleteStage;
+  }
+
+  async getStagesWithGroupName(
+    workflow_id: number,
+    level_id: string,
+    level_type: string,
+  ) {
+    if (!workflow_id) {
+      throw new BadRequestException('workflow_id is required');
     }
 
-    const savedStage = await super.createEntity(
-      stageData,
-      loggedInUser,
-      manager,
-      appcode,
+    const stageGroups = await this.stageGroupRepository.getAllStageGroup(
+      workflow_id,
+      level_id,
+      level_type,
     );
 
-    return savedStage;
+    const stageGroupIds = stageGroups.map((group) => group.id);
+    const groupNameMap = new Map<number, string>(
+      stageGroups.map((group) => [Number(group.id), group.name]),
+    );
+
+    // Get all stages for all stageGroups
+    const allStages: any = [];
+    for (const groupId of stageGroupIds) {
+      try {
+        const stages = await this.stageRepository.getAllStage(
+          groupId,
+          level_id,
+          level_type,
+        );
+        allStages.push(...stages);
+      } catch (err) {
+        if (err instanceof NotFoundException) {
+          console.warn(`No stages for group ID ${groupId}`);
+          continue;
+        }
+        throw err;
+      }
+    }
+
+    const result = allStages.map((stage) => ({
+      stage_id: stage.id,
+      full_name: `${groupNameMap.get(stage.stage_group_id)} - ${stage.name}`,
+    }));
+    return result;
   }
 }

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

@@ -0,0 +1,95 @@
+import { Injectable } from '@nestjs/common';
+import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+import { UserData } from 'src/module/user/entity/user.entity';
+import { TaskRepository } from '../repository/task.repository';
+import { ActionDataService } from './action-data.service';
+
+@Injectable()
+export class TaskService extends EntityServiceImpl {
+  constructor(
+    private readonly taskRepository: TaskRepository,
+    private readonly actionDataService: ActionDataService,
+  ) {
+    super();
+  }
+
+  async getAllTaskByUserIdandStageId(
+    loggedInUser: UserData,
+    data,
+  ): Promise<any> {
+    const taskData = await this.taskRepository.getAllTaskByUserIdAndStageId({
+      user_id: data.user_id,
+      stage_id: data.stage_id,
+      mapped_entity_type: data.mapped_entity_type,
+      mapped_entity_id: data.mapped_entity_id,
+    });
+
+    const grouped: { mandatory: any[]; non_mandatory: any[] } = {
+      mandatory: [],
+      non_mandatory: [],
+    };
+
+    for (const task of taskData) {
+      if (task && task.is_mandatory) {
+        grouped.mandatory.push(task);
+      } else {
+        grouped.non_mandatory.push(task);
+      }
+    }
+
+    return grouped;
+  }
+
+  async getEntityData(entityType: string, id: number, loggedInUser: any) {
+    const taskData = await super.getEntityData(entityType, id, loggedInUser);
+
+    return taskData;
+  }
+
+  async saveActionData(
+    action: any,
+    loggedInUser: UserData,
+    mapped_entity_id: number,
+    mapped_entity_type: string,
+  ): Promise<any> {
+    await this.taskRepository.saveActionDataInTask(
+      action,
+      loggedInUser,
+      mapped_entity_id,
+      mapped_entity_type,
+    );
+  }
+
+  async moveTask(
+    loggedInUser: UserData,
+    body: {
+      mapped_entity_type: string;
+      mapped_entity_id: number;
+      stage_id: number;
+      action_id: number;
+    },
+  ): Promise<any> {
+    // Logic to move task based on the provided body parameters
+    // This could involve updating the task's stage, action, etc.
+
+    // update task status
+    this.taskRepository.updateTaskStatus(
+      loggedInUser,
+      body.mapped_entity_type,
+      body.mapped_entity_id,
+      body.stage_id,
+      body.action_id,
+    );
+
+    // update action status
+    await this.actionDataService.updateActionStatus(
+      loggedInUser,
+      body.mapped_entity_type,
+      body.mapped_entity_id,
+      body.stage_id,
+      body.action_id,
+    );
+
+    return 'Task moved successfully';
+  }
+}

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

@@ -12,13 +12,13 @@ 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
       JOIN cr_wf_action a ON sam.action_id = a.id
-      JOIN cr_wf_action_category ac ON a.action_cat_id = ac.id
+      JOIN cr_wf_action_category ac ON a.action_category = ac.id
       WHERE sam.stage_id = ?
       `,
       [stageId],
@@ -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',