rez_core 2.2.8 → 2.2.10

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

@@ -0,0 +1,231 @@
+import { log } from 'console';
+import { Inject, Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository, DataSource } from 'typeorm';
+import { StageMovementData } from '../entity/stage-movement-data.entity';
+import { UserData } from 'src/module/user/entity/user.entity';
+import { StageMovementRepository } from '../repository/stage-movement.repository';
+import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+import { ActionDataService } from './action-data.service';
+import { TaskService } from './task.service';
+
+@Injectable()
+export class WorkflowMetaService extends EntityServiceImpl {
+  constructor(
+    @InjectRepository(StageMovementData)
+    private readonly stageMovementRepo: Repository<StageMovementData>,
+    private readonly stageMovementRepository: StageMovementRepository,
+    private readonly dataSource: DataSource,
+    private readonly actionDataService: ActionDataService,
+    @Inject('TaskService')
+    private readonly taskService: TaskService,
+  ) {
+    super();
+  }
+
+  // get first stage from stage table
+  async getFirstStage(
+    loggedInUser: UserData,
+    mapped_entity_type: string,
+    mapped_entity_id: number,
+  ): Promise<any | null> {
+    // step1 find in workflow_level_mapping if not found with current level_id and level_type search in for ORG
+    // step2 find in stage_group => workflow_id
+    // step3 find in stage => stage_group_id
+    // step4 get first stage from stage table
+    return this.stageMovementRepository.getFirstStage({
+      loggedInUser,
+      mapped_entity_type,
+      mapped_entity_id,
+    });
+  }
+
+  /**
+   * Get the current active stage for a given mapped entity
+   */
+  async getCurrentStage(
+    mapped_entity_type: string,
+    mapped_entity_id: number,
+    loggedInUser: UserData,
+  ): Promise<any | null> {
+    // Try to find the current stage movement entry
+    let currentStage = await this.stageMovementRepo.findOne({
+      where: {
+        mapped_entity_type,
+        mapped_entity_id,
+        is_current: 'Y',
+      },
+    });
+
+    if (!currentStage) {
+      // If no current stage found, return null
+      return null;
+    }
+
+    // get group name for the current stage
+    const getGroupName = await this.dataSource.query(
+      `SELECT name FROM cr_wf_stage_group WHERE id = ${currentStage?.stage_group_id}`,
+    );
+
+    // Return the found or newly created current stage movement
+    return {
+      ...currentStage,
+      stage_group_name: getGroupName[0]?.name,
+    };
+  }
+
+  /**
+   * Get next stage ID based on current stage
+   * (Stub logic – replace with real stage transition resolution)
+   */
+  async getNextStage(currentStage: any): Promise<any | null> {
+    // get all stage for that stage group
+    const nextStage =
+      await this.stageMovementRepository.getNextStageOrFirstOfNextGroup(
+        currentStage?.stage_group_id,
+        currentStage?.stage_id,
+      );
+
+    if (!nextStage) {
+      return { hasNextStage: false, nextStage: null };
+    }
+
+    const groupName = await this.dataSource.query(
+      `SELECT name FROM cr_wf_stage_group WHERE id = ${nextStage?.stage_group_id}`,
+    );
+
+    return {
+      hasNextStage: !!nextStage,
+      nextStage: { ...nextStage, stage_group_name: groupName[0]?.name },
+    };
+  }
+
+  /**
+   * Move mapped entity to the next stage in the workflow
+   */
+  async moveToNextStage(
+    mapped_entity_type: string,
+    mapped_entity_id: number,
+    loggedInUser: UserData,
+  ): Promise<string> {
+    const now = new Date();
+    let currentStage = await this.getCurrentStage(
+      mapped_entity_type,
+      mapped_entity_id,
+      loggedInUser,
+    );
+
+    // Case 1: First stage – initialize
+    // If no current stage movement found, create one from the first stage
+    if (!currentStage) {
+      const getAllResult = await this.getFirstStage(
+        loggedInUser,
+        mapped_entity_type,
+        mapped_entity_id,
+      );
+
+      const { mappingUsed, stageGroup, firstStage } = getAllResult;
+
+      // Create a new current stage movement record
+      currentStage = await this.stageMovementRepo.save({
+        entity_type: 'STGM',
+        mapped_entity_type,
+        mapped_entity_id,
+        name: firstStage.name,
+        status: firstStage.status,
+        current_user_id: loggedInUser.id,
+        stage_action_mapping_id: firstStage.id,
+        stage_group_id: stageGroup.id,
+        stage_id: firstStage.id,
+        start_date: new Date(),
+        is_current: 'Y',
+      });
+
+      this.populateActionService(
+        currentStage.stage_id,
+        loggedInUser,
+        mapped_entity_id,
+        mapped_entity_type,
+      );
+
+      return `Initialized workflow with first stage (Stage ID: ${firstStage.id}).`;
+    }
+
+    //idhr
+
+    // Case 2: Has next stage – move forward
+    const stageDate = await this.getNextStage(currentStage);
+
+    if (stageDate.hasNextStage) {
+      const { nextStage } = stageDate;
+      // 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: 'STGM',
+        mapped_entity_type,
+        mapped_entity_id,
+        name: nextStage.name,
+        status: nextStage.status,
+        current_user_id: loggedInUser.id,
+        stage_action_mapping_id: nextStage.id,
+        start_date: now,
+        stage_group_id: nextStage?.stage_group_id,
+        stage_id: nextStage.id,
+        is_current: 'Y',
+      });
+
+      this.populateActionService(
+        currentStage.stage_id,
+        loggedInUser,
+        mapped_entity_id,
+        mapped_entity_type,
+      );
+
+      return `Moved to next stage (Stage ID: ${nextStage.id}).`;
+    }
+
+    //idhr
+
+    // 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.';
+  }
+
+  async populateActionService(
+    stage_id: number,
+    loggedInUser: UserData,
+    mapped_entity_id: number,
+    mapped_entity_type: string,
+  ): Promise<any> {
+    const actions =
+      await this.stageMovementRepository.getAllActionByStageId(stage_id);
+    // Populate the action service with the retrieved actions
+
+    if (!actions || actions.length === 0) {
+      return 'No actions found for this stage.';
+    }
+
+    // save in action data
+    await this.actionDataService.saveActionData(
+      actions,
+      loggedInUser,
+      mapped_entity_id,
+      mapped_entity_type,
+    );
+
+    // save in task data
+    await this.taskService.saveActionData(
+      actions,
+      loggedInUser,
+      mapped_entity_id,
+      mapped_entity_type,
+    );
+  }
+}

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

@@ -1,26 +1,41 @@
-import { BadRequestException, Injectable } from '@nestjs/common';
+import { get } from 'http';
+import { BadRequestException, Inject, Injectable } from '@nestjs/common';
+import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+import { DataSource, In } from 'typeorm';
+import { WorkflowRepository } from '../repository/workflow.repository';
+import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
 import { UserData } from 'src/module/user/entity/user.entity';
-import { BaseEntity, DataSource } from 'typeorm';
+import { ListMasterService } from 'src/module/listmaster/service/list-master.service';
+import { STATUS_INACTIVE, WORKFLOW } from 'src/constant/global.constant';
+import { Workflow } from '../entity/workflow.entity';
+
+import { StageGroupRepository } from '../repository/stage-group.repository';
+import { StageGroupService } from './stage-group.service';
 
 @Injectable()
-export class WorkflowService {
-  constructor(private readonly dataSource: DataSource) {}
-
-  async getAllWorkflow(entity_type: string, loggedInUser: any) {
-    const { level_id, level_type } = loggedInUser;
-
-    const workflows = await this.dataSource.query(
-      `
-      SELECT *
-      FROM cr_workflow
-      WHERE mapped_entity_type = ?
-        AND level_id = ?
-        AND level_type = ?
-      `,
-      [entity_type, level_id, level_type],
-    );
+export class WorkflowService extends EntityServiceImpl {
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly workflowRepository: WorkflowRepository,
+    @Inject('ListMasterService')
+    private readonly listMasterService: ListMasterService,
+    @Inject('StageGroupService')
+    private readonly stateGroupService: StageGroupService,
+    private readonly stageGroupRepository: StageGroupRepository,
+  ) {
+    super();
+  }
 
-    return workflows; // array of rows (each row is already in JSON format)
+  async getAllWorkflows(
+    entity_type: string,
+    level_id: string,
+    level_type: string,
+  ) {
+    return this.workflowRepository.getAllWorkflowsByFilters(
+      entity_type,
+      level_id,
+      level_type,
+    );
   }
 
   async getWorkflowById(id: number) {
@@ -31,50 +46,166 @@ export class WorkflowService {
     return result[0] || null;
   }
 
+  //update entity
   async updateEntity(
     entityData: BaseEntity,
     loggedInUser: UserData,
-  ): Promise<any> {}
-
-  async getLeadContactDropdown(leadId: number, mode: string): Promise<any[]> {
-    const lead = await this.dataSource.query(
-      `SELECT phone_number, father_mobile, mother_mobile, email, father_email, mother_email
-     FROM crm_lead
-     WHERE id = ?`,
-      [leadId],
+  ): Promise<any> {
+    const resolveStatus = await this.listMasterService.getResolvedListCode(
+      STATUS_INACTIVE,
+      loggedInUser?.organization_id || 0,
     );
 
-    if (!lead?.length) {
-      throw new BadRequestException('Lead not found');
-    }
+    const workflowId = entityData.id;
+    const { level_id, level_type, organization_id } = loggedInUser;
 
-    const data = lead[0];
-    const response: { label: string; value: any }[] = [];
+    // Handle INACTIVE status validation
+    if (entityData.status == resolveStatus.id) {
+      const existingWorkflow = (await this.getEntityData(
+        WORKFLOW,
+        workflowId,
+        loggedInUser,
+      )) as Workflow;
 
-    if (mode === 'sms' || mode === 'whatsapp') {
-      if (data.phone_number) {
-        response.push({ label: 'Primary', value: data.phone_number });
+      if (!existingWorkflow) {
+        return { success: false, error: 'Workflow not found' };
       }
-      if (data.father_mobile) {
-        response.push({ label: 'Father', value: data.father_mobile });
-      }
-      if (data.mother_mobile) {
-        response.push({ label: 'Mother', value: data.mother_mobile });
+
+      if (existingWorkflow.is_default) {
+        return {
+          success: false,
+          error: 'Cannot inactivate because it is default.',
+        };
       }
-    } else if (mode === 'email') {
-      if (data.email) {
-        response.push({ label: 'Primary', value: data.email });
+
+      if (existingWorkflow.is_factory) {
+        return {
+          success: false,
+          error: 'Cannot inactivate because it is factory.',
+        };
       }
-      if (data.father_email) {
-        response.push({ label: 'Father', value: data.father_email });
+    }
+
+    // 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 (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],
+        );
       }
-      if (data.mother_email) {
-        response.push({ label: 'Mother', value: data.mother_email });
+    }
+
+    // Final update
+    return super.updateEntity(entityData, loggedInUser);
+  }
+
+  async deleteWorkflowById(id: number) {
+    return this.workflowRepository.deleteWorkflowById(id);
+  }
+
+  async deleteEntity(
+    entityType: string,
+    id: number,
+    loggedInUser: UserData,
+  ): Promise<any> {
+    const getWorkflow = await this.getEntityData(entityType, id, loggedInUser);
+
+    if (!getWorkflow) {
+      throw new BadRequestException('Workflow not found');
+    }
+
+    if ((getWorkflow as Workflow).is_default) {
+      throw new BadRequestException(
+        'Cannot delete workflow because it is default.',
+      );
+    }
+
+    if ((getWorkflow as Workflow).is_factory) {
+      throw new BadRequestException(
+        'Cannot delete workflow because it is factory.',
+      );
+    }
+
+    const getAllStageGroup = await this.dataSource.query(
+      `SELECT id FROM cr_wf_stage_group WHERE workflow_id = ? AND level_id = ? AND level_type = ?`,
+      [id, loggedInUser.level_id, loggedInUser.level_type],
+    );
+
+    if (getAllStageGroup.length > 0) {
+      for (const stageGroup of getAllStageGroup) {
+        await this.stateGroupService.deleteEntity(
+          'STGP',
+          stageGroup.id,
+          loggedInUser,
+        );
       }
-    } else {
-      throw new BadRequestException('Invalid mode');
     }
 
-    return response;
+    const deleteWorkflow = await super.deleteEntity(
+      entityType,
+      id,
+      loggedInUser,
+    );
+
+    return deleteWorkflow;
+  }
+
+  async updateSequence(body: any[], loggedInUser: any) {
+    if (!Array.isArray(body) || body.length === 0) {
+      throw new BadRequestException(
+        'Invalid input. Expected a non-empty array.',
+      );
+    }
+
+    const results: {
+      id: any;
+      success: boolean;
+      result?: any;
+      error?: string;
+    }[] = [];
+
+    for (const item of body) {
+      if (!item.id || item.sequence === undefined) {
+        results.push({
+          id: item.id || null,
+          success: false,
+          error: 'Missing id or sequence',
+        });
+        continue;
+      }
+
+      try {
+        const result = await super.updateEntity(item, loggedInUser);
+        results.push({ id: item.id, success: true, result });
+      } catch (err) {
+        results.push({ id: item.id, success: false, error: err.message });
+      }
+    }
+    return { updated: results.filter((r) => r.success).length, results };
   }
 }

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

@@ -1,40 +1,75 @@
 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 { Action } from './entity/action.entity';
+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 { WorkflowMetaService } from './service/workflow-meta.service';
+import { WorkflowService } from './service/workflow.service';
+import { ActionCategoryController } from './controller/action-category.controller';
+import { StageMovementRepository } from './repository/stage-movement.repository';
+import { WorkflowLevelMappingEntity } from './entity/workflow-level-mapping.entity';
+import { TaskDataEntity } from './entity/task-data.entity';
+import { ActionDataEntity } from './entity/action-data.entity';
+import { TaskController } from './controller/task.controller';
+import { TaskService } from './service/task.service';
+import { TaskRepository } from './repository/task.repository';
+import { ActionRepository } from './repository/action.repository';
+import { ActionDataRepository } from './repository/action-data.repository';
+import { ActionDataService } from './service/action-data.service';
 
 @Module({
   imports: [
     TypeOrmModule.forFeature([
       Workflow,
-      Action,
+      ActionEntity,
       ActionCategory,
       Stage,
       StageGroup,
       CommTemplate,
       ActionTemplateMapping,
       StageActionMapping,
+      StageMovementData,
+      EntityModification,
+      TemplateAttach,
+      WorkflowLevelMappingEntity,
+      TaskDataEntity,
+      ActionDataEntity,
     ]),
     EntityModule,
+    ListMasterModule,
   ],
   providers: [
     { provide: 'ActionCategoryService', useClass: ActionCategoryService },
@@ -45,10 +80,28 @@ import { WorkflowController } from './controller/workflow.controller';
     },
     { provide: 'ActionService', useClass: ActionService },
     { provide: 'StageService', useClass: StageService },
+    { provide: 'TaskService', useClass: TaskService },
     { provide: 'StageGroupService', useClass: StageGroupService },
+    { provide: 'WorkflowService', useClass: WorkflowService },
+    {
+      provide: 'EntityModificationService',
+      useClass: EntityModificationService,
+    },
     WorkflowListMasterService,
     ActionTemplateMappingService,
+    WorkflowRepository,
+    CommTemplateService,
+    CommTemplateRepository,
+    StageGroupRepository,
+    StageRepository,
     WorkflowService,
+    WorkflowMetaService,
+    PopulateWorkflowService,
+    StageMovementRepository,
+    TaskRepository,
+    ActionRepository,
+    ActionDataRepository,
+    ActionDataService,
   ],
   exports: [
     'ActionCategoryService',
@@ -57,11 +110,25 @@ import { WorkflowController } from './controller/workflow.controller';
     'ActionService',
     'StageService',
     'StageGroupService',
+    'EntityModificationService',
+    WorkflowRepository,
+    StageGroupRepository,
+    StageRepository,
+    WorkflowMetaService,
+    PopulateWorkflowService,
   ],
   controllers: [
     WorkflowListMasterController,
     ActionTemplateMappingController,
     WorkflowController,
+    CommTemplateController,
+    StageGroupController,
+    StageController,
+    ActionController,
+    WorkflowMetaController,
+    EntityModificationController,
+    ActionCategoryController,
+    TaskController,
   ],
 })
 export class WorkflowModule {}