rez_core 2.1.127 → 2.1.129

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "2.1.127",
+  "version": "2.1.129",
   "description": "",
   "author": "",
   "private": false,

package/src/module/listmaster/entity/list-master-items.entity.ts

@@ -18,6 +18,9 @@ export class ListMasterItems extends BaseEntity {
   @Column()
   name: string;
 
+  @Column()
+  parent_code: string;
+
   @Column()
   value: string;
 

package/src/module/listmaster/repository/list-master-items.repository.ts

@@ -25,21 +25,26 @@ export class ListMasterItemsRepository {
     sort_by?,
     inactiveIdsArray?: number[],
     organizationId?: number,
+    params?: Record<string, string>,
   ) {
-    let orderBy: Record<string, 'ASC' | 'DESC'> = {}; // no default sort unless specified
+    let orderBy: Record<string, 'ASC' | 'DESC'> = {};
 
-    // Only sort if sort_by is provided
+    // Initial where clause
+    const whereClause: any = {
+      listtype: type,
+      organization_id: organizationId,
+      status: 'ACTIVE',
+    };
+
+    // Sorting logic
     if (sort_by) {
-      const listMasterItem = await this.repo.find({
+      const listMasterItem = await this.repo.findOne({
         where: { id: sort_by },
       });
-
-      const sortValue = listMasterItem?.[0]?.value;
+      const sortValue = listMasterItem?.value?.toLowerCase();
 
       if (sortValue) {
-        const listMasterSortBy = String(sortValue).toLowerCase();
-
-        switch (listMasterSortBy) {
+        switch (sortValue) {
           case 'az':
             orderBy = { name: 'ASC' };
             break;
@@ -53,18 +58,26 @@ export class ListMasterItemsRepository {
       }
     }
 
+    // Handle parent_code logic
+    if (params?.parent) {
+      const parentItem = await this.repo.findOne({
+        where: { id: parseInt(params.parent) },
+      });
+
+      if (parentItem?.parent_code) {
+        whereClause.parent_code = parentItem.parent_code;
+      }
+    }
+
+    // Fetch active items
     const items = await this.repo.find({
-      where: {
-        listtype: type,
-        organization_id: organizationId,
-        status: 'ACTIVE',
-      },
+      where: whereClause,
       order: orderBy,
     });
 
     let result = items.map((i) => ({ label: i.name, value: i.id }));
 
-    // If inactive IDs are passed, fetch them
+    // Handle inactive items if specified
     if (inactiveIdsArray?.length) {
       const inactiveItems = await this.repo.find({
         where: {

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

@@ -75,6 +75,7 @@ export class ListMasterService {
           config.sort_by,
           inactiveIdsArray,
           loggedInUser?.organization_id,
+          params,
         );
 
       case 'operator':

package/src/module/workflow/controller/action-template-mapping.controller.ts

@@ -0,0 +1,35 @@
+import {
+  Body,
+  Controller,
+  HttpCode,
+  HttpStatus,
+  Post,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+import { ActionTemplateMappingService } from '../service/action-template-mapping.service';
+
+@Controller('/action-template-mapping')
+@UseGuards(JwtAuthGuard)
+export class ActionTemplateMappingController {
+  constructor(
+    private readonly actionTemplateMappingService: ActionTemplateMappingService,
+  ) {}
+
+  @Post('/get-template')
+  @HttpCode(HttpStatus.OK)
+  async getTemplate(
+    @Body() body: { stage_id: number; action_id: number; mode: number },
+    @Req() req: Request & { user: any },
+  ) {
+    const loggedInUser = req.user.userData;
+    const result = this.actionTemplateMappingService.getTemplateByMode(
+      body.stage_id,
+      body.action_id,
+      body.mode,
+      loggedInUser,
+    );
+    return result;
+  }
+}

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

@@ -5,10 +5,14 @@ import {
   HttpCode,
   HttpStatus,
   Get,
+  Req,
+  UseGuards,
 } from '@nestjs/common';
 import { WorkflowListMasterService } from '../service/workflow-list-master.service';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
 
 @Controller('/workflow-list')
+@UseGuards(JwtAuthGuard)
 export class WorkflowListMasterController {
   constructor(private readonly workflowService: WorkflowListMasterService) {}
 
@@ -32,8 +36,9 @@ export class WorkflowListMasterController {
 
   @Get('/getModes')
   @HttpCode(HttpStatus.OK)
-  async getModes() {
-    const result = await this.workflowService.getModes();
+  async getModes(@Req() req: Request & { user: any }) {
+    const loggedInUser = req.user.userData;
+    const result = await this.workflowService.getModes(loggedInUser);
     return result;
   }
 }

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

@@ -1,6 +1,6 @@
 import { COMM_TEMPLATE } from 'src/constant/global.constant';
 import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
-import { Entity } from 'typeorm';
+import { Column, Entity } from 'typeorm';
 
 @Entity({ name: 'cr_wf_comm_template' })
 export class CommTemplate extends BaseEntity {
@@ -8,4 +8,7 @@ export class CommTemplate extends BaseEntity {
     super();
     this.entity_type = COMM_TEMPLATE;
   }
+
+  @Column({ type: 'varchar', nullable: true })
+  mode: string;
 }

package/src/module/workflow/service/action-template-mapping.service.ts

@@ -1,5 +1,52 @@
 import { Injectable } from '@nestjs/common';
 import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+import { DataSource } from 'typeorm';
 
 @Injectable()
-export class ActionTemplateMappingService extends EntityServiceImpl {}
+export class ActionTemplateMappingService extends EntityServiceImpl {
+  constructor(private readonly dataSource: DataSource) {
+    super();
+  }
+  async getTemplateByMode(
+    stage_id: number,
+    action_id: number,
+    mode: number,
+    loggedInUser,
+  ) {
+    const stageAction = await this.dataSource.query(
+      `
+      SELECT id FROM cr_wf_stage_action_mapping
+      WHERE stage_id = ? AND action_id = ?
+      `,
+      [stage_id, action_id],
+    );
+    if (!stageAction?.length) return [];
+
+    const stgActMappingId = stageAction[0].id;
+
+    const templates = await this.dataSource.query(
+      `
+      SELECT template_code FROM cr_wf_action_template_mapping
+      WHERE stg_act_mapping_id = ? 
+      `,
+      [stgActMappingId],
+    );
+    const listMasterItemData = await this.dataSource.query(
+      `SELECT code FROM cr_list_master_items WHERE id = ?`,
+      [mode],
+    );
+
+    const templateCodes = templates.map((t) => t.template_code);
+    if (!templateCodes.length) return [];
+
+    const commTemplates = await this.dataSource.query(
+      `
+      SELECT id, name
+      FROM cr_wf_comm_template
+      WHERE code IN (?) AND mode = ? AND organization_id = ?
+      `,
+      [templateCodes, listMasterItemData[0].code, loggedInUser.organization_id],
+    );
+    return commTemplates.map((t) => ({ id: t.id, name: t.name }));
+  }
+}

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

@@ -42,24 +42,17 @@ export class WorkflowListMasterService extends EntityServiceImpl {
     return results;
   }
 
-  async getModes(): Promise<any[]> {
-    // Step 1: Get all list masters with type 'MOD'
-    const modeLists = await this.dataSource.query(
-      `SELECT id FROM cr_list_master WHERE type = 'MOD'`,
-    );
-
-    if (modeLists.length === 0) return [];
-
-    const listIds = modeLists.map((item) => item.id);
+  async getModes(loggedInUser): Promise<any[]> {
+    const { organization_id } = loggedInUser;
 
-    // Step 2: Get all list items where list_id is in the MOD list IDs
     const modes = await this.dataSource.query(
       `
     SELECT id, name
     FROM cr_list_master_items
-    WHERE list_id IN (${listIds.map(() => '?').join(',')})
+    WHERE listtype = 'MOD'
+      AND organization_id = ?
     `,
-      listIds,
+      [organization_id],
     );
 
     return modes;

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

@@ -19,6 +19,7 @@ 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';
 
 @Module({
   imports: [
@@ -38,10 +39,6 @@ import { WorkflowListMasterController } from './controller/workflow-list-master.
     { provide: 'WorkflowService', useClass: WorkflowService },
     { provide: 'ActionCategoryService', useClass: ActionCategoryService },
     { provide: 'CommTemplateService', useClass: CommTemplateService },
-    {
-      provide: 'ActionTemplateMappingService',
-      useClass: ActionTemplateMappingService,
-    },
     {
       provide: 'StageActionMappingService',
       useClass: StageActionMappingService,
@@ -50,17 +47,17 @@ import { WorkflowListMasterController } from './controller/workflow-list-master.
     { provide: 'StageService', useClass: StageService },
     { provide: 'StageGroupService', useClass: StageGroupService },
     WorkflowListMasterService,
+    ActionTemplateMappingService,
   ],
   exports: [
     'WorkflowService',
     'ActionCategoryService',
     'CommTemplateService',
-    'ActionTemplateMappingService',
     'StageActionMappingService',
     'ActionService',
     'StageService',
     'StageGroupService',
   ],
-  controllers: [WorkflowListMasterController],
+  controllers: [WorkflowListMasterController, ActionTemplateMappingController],
 })
 export class WorkflowModule {}