rez_core 2.1.145 → 2.1.147

package/package.json

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

package/src/module/layout_preference/controller/layout_preference.controller.ts

@@ -15,11 +15,13 @@ export class LayoutPreferenceController {
     @Query('entity_type') entity_type: string,
     @Req() req: Request & { user: any },
   ) {
-    const userId = req.user.userData.id;
+    const userDat = req.user.userData;
 
     return this.layoutPreferenceService.getLayoutPreferenceByUserID(
-      userId,
+      userDat.id,
       entity_type,
+      userDat.level_id,
+      userDat.level_type,
     );
   }
 

package/src/module/layout_preference/entity/layout_preference.entity.ts

@@ -14,4 +14,15 @@ export class LayoutPreference extends BaseEntity {
 
   @Column({ nullable: true, type: 'json' })
   navigation_tabs_json: any;
+
+  @Column({
+    name: 'mapped_level_id',
+    type: 'varchar',
+    length: 100,
+    nullable: true,
+  })
+  mapped_level_id: string;
+
+  @Column({ name: 'mapped_level_type', type: 'varchar', nullable: true })
+  mapped_level_type: string;
 }

package/src/module/layout_preference/repository/layout_preference.repository.ts

@@ -11,13 +11,17 @@ export class LayoutPreferenceRepository {
   ) {}
 
   async findByEntityUserId(
-    entity_type: string,
+    mapped_entity_type: string,
+    mapped_level_id: string,
+    mapped_level_type: string,
     userId: number,
   ): Promise<LayoutPreference | null> {
     return this.layoutPreferenceRepo.findOne({
       where: {
         user_id: userId.toString(),
-        mapped_entity_type: entity_type,
+        mapped_entity_type: mapped_entity_type,
+        mapped_level_id: mapped_level_id,
+        mapped_level_type: mapped_level_type,
       },
     });
   }

package/src/module/layout_preference/service/layout_preference.service.ts

@@ -27,6 +27,8 @@ export class LayoutPreferenceService extends EntityServiceImpl {
     const existingLayoutPreference =
       await this.layoutPreferenceRepository.findByEntityUserId(
         mapped_entity_type,
+        loggedInUser.level_id,
+        loggedInUser.level_type,
         userId,
       );
 
@@ -38,16 +40,31 @@ export class LayoutPreferenceService extends EntityServiceImpl {
     }
 
     return await super.createEntity(
-      { ...entityData, user_id: userId } as any,
+      {
+        ...entityData,
+        user_id: userId,
+        mapped_level_id: loggedInUser.level_id,
+        mapped_level_type: loggedInUser.level_type,
+      } as any,
       loggedInUser,
     );
   }
 
-  async getLayoutPreferenceByUserID(user_id, mapped_entity_type) {
-    return await this.layoutPreferenceRepository.findByEntityUserId(
-      mapped_entity_type,
-      user_id,
-    );
+  async getLayoutPreferenceByUserID(
+    user_id,
+    mapped_entity_type,
+    mapped_level_id,
+    mapped_level_type,
+  ) {
+    const layoutPreference =
+      await this.layoutPreferenceRepository.findByEntityUserId(
+        mapped_entity_type,
+        mapped_level_id,
+        mapped_level_type,
+        user_id,
+      );
+
+    return layoutPreference;
   }
 
   async getColumnValue(
@@ -65,6 +82,7 @@ export class LayoutPreferenceService extends EntityServiceImpl {
       );
 
     const tableName = getTableMeta?.data_source;
+
     if (!tableName) {
       throw new Error('Invalid or missing table name in metadata');
     }

package/src/module/meta/controller/media.controller.ts

@@ -1,19 +1,17 @@
 import {
   Body,
   Controller,
+  Get,
   HttpStatus,
+  Param,
   Post,
+  Req,
   Res,
-  Get,
-  Param,
   UseGuards,
-  Req,
 } from '@nestjs/common';
-import { MediaDataService } from '../service/media-data.service';
+import { Response } from 'express';
 import { JwtAuthGuard } from '../../auth/guards/jwt.guard';
-import e, { Response } from 'express';
-import { ENTITYTYPE_MEDIA } from 'src/constant/global.constant';
-import { MediaData } from '../entity/media-data.entity';
+import { MediaDataService } from '../service/media-data.service';
 
 @Controller('media')
 @UseGuards(JwtAuthGuard)

package/src/module/workflow/controller/action-category.controller.ts

@@ -0,0 +1,35 @@
+import {
+  Body,
+  Controller,
+  HttpCode,
+  HttpStatus,
+  Inject,
+  Post,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+import { ActionCategoryService } from '../service/action-category.service';
+
+@Controller('/actionCategory')
+@UseGuards(JwtAuthGuard)
+export class ActionCategoryController {
+  constructor(
+    @Inject('ActionCategoryService')
+    private readonly actionCategoryService: ActionCategoryService,
+  ) {}
+
+  @Post('/getActionsCategory')
+  @HttpCode(HttpStatus.OK)
+  async getActionsCat(
+    @Req() req: Request & { user: any },
+    @Body('entity_type') entity_type: string,
+  ) {
+    const loggedInUser = req.user.userData;
+    const result = this.actionCategoryService.getActionsCat(
+      loggedInUser,
+      entity_type,
+    );
+    return result;
+  }
+}

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

@@ -46,10 +46,10 @@ export class ActionController {
   @HttpCode(HttpStatus.OK)
   async getActions(
     @Req() req: Request & { user: any },
-    @Body('workflow_id') workflow_id: number,
+    @Body('stage_id') stage_id: number,
   ) {
     const loggedInUser = req.user.userData;
-    const result = this.actionService.getActions(loggedInUser, workflow_id);
+    const result = this.actionService.getActions(loggedInUser, stage_id);
     return result;
   }
 }

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

@@ -1,8 +1,9 @@
 import {
+  Body,
   Controller,
-  Get,
   HttpCode,
   HttpStatus,
+  Post,
   Query,
   Req,
   UseGuards,
@@ -15,15 +16,15 @@ import { CommTemplateService } from '../service/comm-template.service';
 export class CommTemplateController {
   constructor(private readonly commTemplateService: CommTemplateService) {}
 
-  @Get('/get-comm-template')
+  @Post('/getTemplates')
   @HttpCode(HttpStatus.OK)
   async getTemplate(
     @Req() req: Request & { user: any },
-    @Query('entity_type') entityType?: string,
+    @Body('entity_type') entity_type: string,
   ) {
     const loggedInUser = req.user.userData;
     const result = this.commTemplateService.getAllCommTemplate(
-      entityType || '',
+      entity_type || '',
       loggedInUser,
     );
     return result;

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

@@ -0,0 +1,52 @@
+import { Controller, Get, Query, Post, Body } from '@nestjs/common';
+import { WorkflowMetaService } from '../service/workflow-meta.service';
+import { StageMovementData } from '../entity/stage-movement-data.entity';
+
+@Controller('workflow-meta')
+export class WorkflowMetaController {
+  constructor(private readonly workflowMetaService: WorkflowMetaService) {}
+
+  /**
+   * GET /meta/current-stage?entityType=...&entityId=...
+   */
+  @Get('current-stage')
+  async getCurrentStage(
+    @Query('entityType') mapped_entity_type: string,
+    @Query('entityId') mapped_entity_id: number,
+  ): Promise<StageMovementData | null> {
+    return this.workflowMetaService.getCurrentStage(mapped_entity_type, Number(mapped_entity_id));
+  }
+
+  /**
+   * GET /meta/next-stage?entityType=...&entityId=...
+   */
+  @Get('next-stage')
+  async getNextStage(
+    @Query('entityType') mapped_entity_type: string,
+    @Query('entityId') mapped_entity_id: number,
+  ): Promise<number | null> {
+    const current = await this.workflowMetaService.getCurrentStage(mapped_entity_type, Number(mapped_entity_id));
+    return current ? this.workflowMetaService.getNextStage(current) : null;
+  }
+
+  /**
+   * POST /meta/move-next-stage
+   * {
+   *   "entityType": "lead",
+   *   "entityId": 101,
+   *   "currentUserId": 5
+   * }
+   */
+  @Post('move-next-stage')
+  async moveToNextStage(
+    @Body('entityType') mapped_entity_type: string,
+    @Body('entityId') mapped_entity_id: number,
+    @Body('currentUserId') current_user_id: number,
+  ): Promise<string> {
+    return this.workflowMetaService.moveToNextStage(
+      mapped_entity_type,
+      Number(mapped_entity_id),
+      current_user_id,
+    );
+  }
+}

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

@@ -14,6 +14,7 @@ import {
 } from '@nestjs/common';
 import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
 import { WorkflowService } from '../service/workflow.service';
+import { PopulateWorkflowService } from '../service/populate-workflow.service';
 
 @Controller('/workflow')
 @UseGuards(JwtAuthGuard)
@@ -21,6 +22,7 @@ export class WorkflowController {
   constructor(
     @Inject('WorkflowService')
     private readonly workflowService: WorkflowService,
+    private readonly populateWorkflowService: PopulateWorkflowService,
   ) {}
 
   @Post('/getAllWorkflows')
@@ -50,4 +52,16 @@ export class WorkflowController {
     const loggedInUser = req.user?.userData;
     return this.workflowService.updateSequence(body, loggedInUser);
   }
+
+  @Post('/populateWorkflow')
+  async populateWorkflow(
+    @Body() body: any,
+    @Req() req: Request & { user: any },
+  ) {
+    const loggedInUser = req.user?.userData;
+    return this.populateWorkflowService.populateWorkflowData(
+      body.organization_id,
+      loggedInUser,
+    );
+  }
 }

package/src/module/workflow/entity/action-category.entity.ts

@@ -14,4 +14,7 @@ export class ActionCategory extends BaseEntity {
 
   @Column({ type: 'varchar', nullable: true })
   modalName: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  mapped_entity_type: string;
 }

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

@@ -19,7 +19,7 @@ export class ActionEntity extends BaseEntity {
   action_requirement: string;
 
   @Column({ type: 'varchar', nullable: true })
-  template: string;
+  sequence: string;
 
   @Column({ type: 'varchar', nullable: true })
   reason_code: string;

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

@@ -9,6 +9,23 @@ export class CommTemplate extends BaseEntity {
     this.entity_type = COMM_TEMPLATE;
   }
 
-  @Column({ type: 'varchar', nullable: true })
+  @Column({ nullable: true })
   mode: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  mapped_entity_type: string;
+
+  @Column({ nullable: true })
+  subject: string;
+
+  @Column({ nullable: true })
+  format_type: string;
+
+  // if format_type is 'richtext', this field will be used
+  @Column({ type: 'longtext', nullable: true })
+  rich_text: string;
+
+  // if format_type is 'markup', this field will be used
+  @Column({ nullable: true })
+  markup_id: number;
 }

package/src/module/workflow/entity/stage-movement-data.entity.ts

@@ -23,4 +23,10 @@ export class StageMovementData extends BaseEntity {
 
   @Column({ type: 'varchar', nullable: true })
   is_current: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  mapped_entity_type: string;
+
+  @Column({ type: 'int', nullable: true })
+  mapped_entity_id: number;
 }

package/src/module/workflow/entity/template-attach-mapper.entity.ts

@@ -0,0 +1,30 @@
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity({ name: 'cr_wf_tem_attach_mapper' })
+export class TemplateAttach {
+  constructor() {}
+
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({})
+  entity_type: string;
+
+  @Column({ nullable: true })
+  template_id: number;
+
+  @Column({ nullable: true })
+  media_id: number;
+
+  @Column({ nullable: true })
+  organization_id: number;
+
+  @Column({ nullable: true })
+  appcode: string;
+
+  @Column({ nullable: true })
+  level_id: string;
+
+  @Column({ nullable: true })
+  level_type: string;
+}

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

@@ -3,32 +3,56 @@ import { InjectRepository } from '@nestjs/typeorm';
 import { Workflow } from '../entity/workflow.entity';
 import { Repository } from 'typeorm';
 import { CommTemplate } from '../entity/comm-template.entity';
+import { TemplateAttach } from '../entity/template-attach-mapper.entity';
+import { MediaDataService } from 'src/module/meta/service/media-data.service';
 
 @Injectable()
 export class CommTemplateRepository {
   constructor(
     @InjectRepository(CommTemplate)
     private readonly commTemplateRepository: Repository<CommTemplate>,
+    @InjectRepository(TemplateAttach)
+    private readonly templateAttachEntity: Repository<TemplateAttach>,
+    private readonly mediaDataService: MediaDataService,
   ) {}
 
   async getAllCommTemplate(entity_type: string, loggedInUser) {
+    const { organization_id } = loggedInUser;
     return this.commTemplateRepository.find({
       select: ['name', 'code'],
       where: {
-        entity_type: entity_type,
+        mapped_entity_type: entity_type,
+        organization_id: organization_id,
       },
     });
   }
 
+  async save(commTemplate: any): Promise<any> {
+    // // delete existing mapper
+    // for (const attachment of commTemplate || []) {
+    //   await this.templateAttachEntity.delete({
+    //     entity_type: attachment.entity_type,
+    //     template_id: attachment.template_id,
+    //   });
+    // }
+
+    return this.templateAttachEntity.save(commTemplate);
+  }
+
+  async delete(id: any): Promise<any> {
+    // delete existing mapper
+    return await this.templateAttachEntity.delete(id);
+  }
+
   async getTemplateByCode(
     entity_type: string,
     code: string,
     loggedInUser,
-  ): Promise<CommTemplate | null> {
+  ): Promise<any | null> {
     const template = await this.commTemplateRepository.findOne({
       where: {
-        entity_type: entity_type,
-        code: code,
+        entity_type,
+        code,
       },
     });
 
@@ -36,6 +60,35 @@ export class CommTemplateRepository {
       throw new NotFoundException(`Template with code ${code} not found`);
     }
 
-    return template;
+    if (template.format_type === 'markup') {
+      const media = await this.mediaDataService.getMediaDownloadUrl(
+        template.markup_id,
+        loggedInUser,
+      );
+
+      console.log(media);
+    }
+
+    if (template.format_type === 'richtext') {
+      return template;
+    }
+
+    // Get only attachment IDs
+    const attachments = await this.templateAttachEntity.find({
+      select: ['media_id'],
+      where: {
+        entity_type: entity_type,
+        template_id: template.id,
+      },
+    });
+
+    const media = await this.mediaDataService.getMediaDownloadUrl(
+      1,
+      loggedInUser,
+    );
+
+    console.log(media);
+
+    return { ...template, attachments: attachments.map((att) => att.media_id) };
   }
 }

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

@@ -1,5 +1,27 @@
 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 { DataSource } from 'typeorm';
 
 @Injectable()
-export class ActionCategoryService extends EntityServiceImpl {}
+export class ActionCategoryService extends EntityServiceImpl {
+  constructor(private readonly dataSource: DataSource) {
+    super();
+  }
+
+  async getActionsCat(loggedInUser: UserData, entity_type: string) {
+    const { organization_id } = loggedInUser;
+
+    const result = await this.dataSource.query(
+      `
+    SELECT id, name 
+    FROM cr_wf_action_category 
+    WHERE mapped_entity_type = ? 
+      AND organization_id = ?
+    `,
+      [entity_type, organization_id],
+    );
+
+    return result;
+  }
+}

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

@@ -36,7 +36,7 @@ export class ActionTemplateMappingService extends EntityServiceImpl {
       [mode],
     );
 
-    if (!listMasterItemData?.length) return []; // 🛑 No mode found
+    if (!listMasterItemData?.length) return [];
 
     const templateCodes = templates.map((t) => t.template_code);
     if (!templateCodes.length) return [];

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

@@ -210,33 +210,109 @@ export class ActionService extends EntityServiceImpl {
     }));
   }
 
-  async getActions(loggedInUser: UserData, workflow_id: number) {
+  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,
-      'Email Template' AS template
-
+      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.workflow_id = ?
+      AND a.id IN (?)
     `,
-      [organization_id, organization_id, workflow_id],
+      [organization_id, organization_id, actionIds],
     );
 
-    return result;
+    // 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;
   }
 }