rez_core 2.1.138 → 2.1.140

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

@@ -1,5 +1,38 @@
-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';
 
 @Injectable()
-export class StageGroupService extends EntityServiceImpl {}
+export class StageGroupService extends EntityServiceImpl {
+  constructor(private readonly stageGroupRepository: StageGroupRepository) {
+    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);
+  }
+}

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

@@ -1,47 +1,38 @@
 import { Injectable } from '@nestjs/common';
-import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
 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';
 
 @Injectable()
 export class StageService extends EntityServiceImpl {
-  constructor(private readonly dataSource: DataSource) {
+  constructor(private readonly stageRepository: StageRepository) {
     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> {
-    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;
-      }
-    }
-
-    if (stageGroupName && stageData.name) {
-      stageData.full_name = `${stageGroupName}-${stageData.name}`;
-    }
-
-    const savedStage = await super.createEntity(
-      stageData,
-      loggedInUser,
-      manager,
-      appcode,
-    );
+    return await super.updateEntity(entityData, loggedInUser);
+  }
 
-    return savedStage;
+  async getEntityData(
+    entityType: string,
+    id: number,
+    loggedInUser?: UserData,
+  ): Promise<BaseEntity | null> {
+    return await super.getEntityData(entityType, id, loggedInUser);
   }
 }

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

@@ -1,29 +1,34 @@
-import { BadRequestException, Injectable } from '@nestjs/common';
+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, Entity } 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';
 
 @Injectable()
 export class WorkflowService extends EntityServiceImpl {
-  constructor(private readonly dataSource: DataSource) {
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly workflowRepository: WorkflowRepository,
+    @Inject('ListMasterService')
+    private readonly listMasterService: ListMasterService,
+  ) {
     super();
   }
 
-  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],
+  async getAllWorkflows(
+    entity_type: string,
+    level_id: string,
+    level_type: string,
+  ) {
+    return this.workflowRepository.getAllWorkflowsByFilters(
+      entity_type,
+      level_id,
+      level_type,
     );
-
-    return workflows; // array of rows (each row is already in JSON format)
   }
 
   async getWorkflowById(id: number) {
@@ -34,45 +39,93 @@ export class WorkflowService extends EntityServiceImpl {
     return result[0] || null;
   }
 
-  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],
+  //update entity
+  async updateEntity(
+    entityData: BaseEntity,
+    loggedInUser: UserData,
+  ): 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 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
+    if ((entityData as Workflow).is_default == true) {
+      await this.dataSource
+        .createQueryBuilder()
+        .update(Workflow)
+        .set({ is_default: 0 })
+        .where('is_default = :isDefault', { isDefault: 1 })
+        .execute();
+    }
+    // Final update
+    return super.updateEntity(entityData, loggedInUser);
+  }
+
+  async deleteWorkflowById(id: number) {
+    return this.workflowRepository.deleteWorkflowById(id);
+  }
+
+  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;
       }
-      if (data.mother_email) {
-        response.push({ label: 'Mother', value: data.mother_email });
+
+      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 });
       }
-    } else {
-      throw new BadRequestException('Invalid mode');
     }
-
-    return response;
+    return { updated: results.filter((r) => r.success).length, results };
   }
 }

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

@@ -16,17 +16,26 @@ import { StageService } from './service/stage.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 { 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 { ListMasterService } from '../listmaster/service/list-master.service';
+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';
 
 @Module({
   imports: [
     TypeOrmModule.forFeature([
       Workflow,
-      Action,
+      ActionEntity,
       ActionCategory,
       Stage,
       StageGroup,
@@ -35,6 +44,7 @@ import { WorkflowController } from './controller/workflow.controller';
       StageActionMapping,
     ]),
     EntityModule,
+    ListMasterModule,
   ],
   providers: [
     { provide: 'ActionCategoryService', useClass: ActionCategoryService },
@@ -49,6 +59,11 @@ import { WorkflowController } from './controller/workflow.controller';
     { provide: 'WorkflowService', useClass: WorkflowService },
     WorkflowListMasterService,
     ActionTemplateMappingService,
+    WorkflowRepository,
+    CommTemplateService,
+    CommTemplateRepository,
+    StageGroupRepository,
+    StageRepository,
   ],
   exports: [
     'ActionCategoryService',
@@ -57,11 +72,17 @@ import { WorkflowController } from './controller/workflow.controller';
     'ActionService',
     'StageService',
     'StageGroupService',
+    WorkflowRepository,
+    StageGroupRepository,
+    StageRepository,
   ],
   controllers: [
     WorkflowListMasterController,
     ActionTemplateMappingController,
     WorkflowController,
+    CommTemplateController,
+    StageGroupController,
+    StageController,
   ],
 })
 export class WorkflowModule {}