rez_core 2.1.154 → 2.1.157

package/package.json

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

package/src/module/filter/service/filter.service.ts

@@ -196,10 +196,12 @@ export class FilterService {
     const layoutPreference = await this.dataSource.query(
       `SELECT layout_json
       FROM cr_layout_preference
-      WHERE user_id = ? AND mapped_entity_type = ?`,
-      [user_id, entity_type],
+      WHERE user_id = ? AND mapped_entity_type = ? AND mapped_level_id = ? AND mapped_level_type = ?`,
+      [user_id, entity_type, level_id, level_type],
     );
 
+    console.log('found layoutPreference', layoutPreference);
+
     // Extract layout preference
     const layout = layoutPreference?.[0]?.layout_json?.quick_tab || {};
 

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

@@ -42,7 +42,7 @@ export class ActionController {
     return result;
   }
 
-  @Post('/getActions')
+  @Post('/getactions')
   @HttpCode(HttpStatus.OK)
   async getActions(
     @Req() req: Request & { user: any },
@@ -52,4 +52,22 @@ export class ActionController {
     const result = this.actionService.getActions(loggedInUser, stage_id);
     return result;
   }
+
+  @Post('/getaction')
+  @HttpCode(HttpStatus.OK)
+  async getAction(
+    @Req() req: Request & { user: any },
+    @Body('stage_id') stage_id: number,
+    @Body('mapped_entity_id') mapped_entity_id: number,
+    @Body('mapped_entity_type') mapped_entity_type: string,
+  ) {
+    const loggedInUser = req.user.userData;
+    const result = this.actionService.getAction(
+      loggedInUser,
+      stage_id,
+      mapped_entity_id,
+      mapped_entity_type,
+    );
+    return result;
+  }
 }

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

@@ -19,15 +19,16 @@ export class TaskController {
     private readonly taskService: TaskService,
   ) {}
 
-  @Post('/getTasksbyUserAndStage')
+  @Post('/by-user-and-stage')
   @HttpCode(HttpStatus.OK)
   async getTasksbyUserAndStage(
     @Req() req: Request & { user: any },
     @Body()
     body: {
-      mapped_entity_type: string;
-      mapped_entity_id: number;
       stage_id: number;
+      mapped_entity_type?: string;
+      mapped_entity_id?: number;
+      user_id?: number;
     },
   ) {
     const loggedInUser = req.user.userData;
@@ -37,4 +38,20 @@ export class TaskController {
     );
     return result;
   }
+
+  @Post('/move-task')
+  async moveTask(
+    @Req() req: Request & { user: any },
+    @Body()
+    body: {
+      mapped_entity_type: string;
+      mapped_entity_id: number;
+      stage_id: number;
+      action_id: number;
+    },
+  ) {
+    const loggedInUser = req.user.userData;
+    const result = this.taskService.moveTask(loggedInUser, body);
+    return result;
+  }
 }

package/src/module/workflow/repository/action-data.repository.ts

@@ -0,0 +1,93 @@
+import { BadRequestException, Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { ActionDataEntity } from '../entity/action-data.entity';
+import { DataSource, Repository } from 'typeorm';
+import { UserData } from 'src/module/user/entity/user.entity';
+
+@Injectable()
+export class ActionDataRepository {
+  constructor(
+    @InjectRepository(ActionDataEntity)
+    private readonly actionDataRepo: Repository<ActionDataEntity>,
+    private readonly dataSource: DataSource,
+  ) {}
+
+  async saveActionData(
+    action: any,
+    loggedInUser: UserData,
+    mapped_entity_id,
+    mapped_entity_type,
+  ): Promise<any> {
+    if (!action?.length) return;
+
+    // Find the action with the lowest sequence
+    const minSequence = Math.min(...action.map((a) => a.sequence));
+
+    if (action.length > 0) {
+      for (const act of action) {
+        const isFirst = act.sequence == minSequence;
+        const actionData = this.actionDataRepo.create({
+          stage_id: act.stage_id,
+          user_id: loggedInUser.id,
+          action_id: act.id,
+          sequence: act.sequence,
+          mapped_entity_id,
+          mapped_entity_type,
+          is_current: isFirst ? 'Y' : null,
+          start_time: isFirst ? new Date() : null,
+        } as ActionDataEntity);
+        await this.actionDataRepo.save(actionData);
+      }
+    }
+  }
+
+  async updateActionStatus(
+    loggedInUser: UserData,
+    mapped_entity_type: string,
+    mapped_entity_id: number,
+    stage_id: number,
+    action_id: number,
+  ): Promise<any> {
+    const actionData = await this.actionDataRepo.findOne({
+      where: {
+        mapped_entity_type,
+        mapped_entity_id,
+        stage_id,
+        action_id,
+      },
+    });
+
+    if (!actionData) return;
+
+    actionData.end_time = new Date();
+    actionData.modified_by = loggedInUser.id;
+    actionData.modified_date = new Date();
+    actionData.is_done = true;
+    actionData.is_current = 'N'; // Mark as not current
+
+    // Save the updated action
+    await this.actionDataRepo.update(actionData.id, actionData);
+
+    // NOW, ACTIVATE THE NEXT ACTION (moveNextActionData logic here)
+    // Find next sequence action for the same entity/stage
+    const allActionData = await this.actionDataRepo.find({
+      where: { mapped_entity_type, mapped_entity_id, stage_id },
+      order: { sequence: 'ASC' },
+    });
+
+    // Find the action with the next higher sequence number
+    const nextAction = allActionData.find(
+      (a) => a.sequence > actionData.sequence,
+    );
+    if (nextAction && nextAction.is_current !== 'Y') {
+      nextAction.is_current = 'Y';
+      nextAction.start_time = new Date();
+      nextAction.modified_by = loggedInUser.id;
+      nextAction.modified_date = new Date();
+      await this.actionDataRepo.update(nextAction.id, nextAction);
+    }
+
+    // Optionally return both for audit
+    return { finished: actionData, activated: nextAction ?? null };
+  }
+}

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

@@ -0,0 +1,104 @@
+import {
+  BadRequestException,
+  Inject,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { DataSource, Repository } from 'typeorm';
+import { ActionEntity } from '../entity/action.entity';
+import { UserData } from 'src/module/user/entity/user.entity';
+
+@Injectable()
+export class ActionRepository {
+  constructor(
+    @InjectRepository(ActionEntity)
+    private readonly actionRepository: Repository<ActionEntity>,
+    private readonly dataSource: DataSource,
+  ) {}
+
+  async getAction(
+    organization_id: number,
+    stage_id: number,
+    mapped_entity_id: number,
+    mapped_entity_type: string,
+  ) {
+    // Step 1: Get all action mappings for the stage
+    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);
+
+    // Step 2: Fetch all actions from cr_wf_action
+    const actions = await this.dataSource
+      .createQueryBuilder()
+      .select([
+        'a.id AS action_id',
+        'a.name AS action_name',
+        'ac.modalName AS modalName',
+        'ac.logo AS logo',
+        'ac.name AS action_category_name',
+      ])
+      .from('cr_wf_action', 'a')
+      .leftJoin('cr_wf_action_category', 'ac', 'ac.id = a.action_category')
+      .where('a.organization_id = :orgId', { orgId: organization_id })
+      .andWhere('a.id IN (:...actionIds)', { actionIds })
+      .getRawMany();
+
+    // Step 3: Fetch action_data for the matched stage and entity
+    const actionData = await this.dataSource
+      .createQueryBuilder()
+      .select([
+        'ad.action_id AS action_id',
+        'ad.is_current AS is_current',
+        'ad.is_mandatory AS is_mandatory',
+        'ad.is_done AS is_done',
+      ])
+      .from('cr_wf_action_data', 'ad')
+      .where('ad.stage_id = :stageId', { stageId: stage_id })
+      .andWhere('ad.action_id IN (:...actionIds)', { actionIds })
+      .andWhere('ad.mapped_entity_id = :mapped_entity_id', {
+        mapped_entity_id,
+      })
+      .andWhere('ad.mapped_entity_type = :mapped_entity_type', {
+        mapped_entity_type,
+      })
+      .getRawMany();
+
+    // Step 4: Build map of action_id to data
+    const actionIdToData = actionData.reduce((acc, row) => {
+      acc[row.action_id] = {
+        is_current: row.is_current === 'Y',
+        is_mandatory: row.is_mandatory === 1,
+        is_done: row.is_done === 1,
+      };
+      return acc;
+    }, {});
+
+    // Step 5: Enrich actions and set default current = false (N)
+    const enrichedResult = actions.map((row) => {
+      const data = actionIdToData[row.action_id];
+      return {
+        value: row.action_id,
+        label: row.action_name,
+        modalName: row.modalName,
+        logo: row.logo,
+        name: row.action_category_name,
+        is_current: data?.is_current ?? false,
+        is_done: data?.is_done ?? false,
+        is_mandatory: data?.is_mandatory ?? false,
+      };
+    });
+
+    enrichedResult.push({
+      value: 0,
+      label: 'Generic',
+    } as any);
+
+    return enrichedResult;
+  }
+}

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

@@ -46,18 +46,15 @@ export class CommTemplateRepository {
 
   async getTemplateByCode(
     entity_type: string,
-    code: string,
+    id: number,
     loggedInUser,
   ): Promise<any | null> {
     const template = await this.commTemplateRepository.findOne({
-      where: {
-        entity_type,
-        code,
-      },
+      where: { entity_type, id },
     });
 
     if (!template) {
-      throw new NotFoundException(`Template with code ${code} not found`);
+      throw new NotFoundException(`Template with id ${id} not found`);
     }
 
     if (template.format_type === 'markup') {
@@ -65,30 +62,41 @@ export class CommTemplateRepository {
         template.markup_id,
         loggedInUser,
       );
-
-      console.log(media);
+      template.markup_id = media as any;
     }
 
     if (template.format_type === 'richtext') {
       return template;
     }
 
-    // Get only attachment IDs
+    // Get attachments for this template
     const attachments = await this.templateAttachEntity.find({
       select: ['media_id'],
       where: {
-        entity_type: entity_type,
+        entity_type,
         template_id: template.id,
       },
     });
 
-    const media = await this.mediaDataService.getMediaDownloadUrl(
-      1,
-      loggedInUser,
-    );
-
-    console.log(media);
+    // If there are attachments, return array of media JSONs
+    let attachmentsMedia: any[] = [];
+    if (attachments.length > 0) {
+      attachmentsMedia = await Promise.all(
+        attachments.map(async (att) => {
+          // Fetch media details for each media_id
+          const media = await this.mediaDataService.getMediaDownloadUrl(
+            att.media_id,
+            loggedInUser,
+          );
+          return media; // return full media info (e.g., { id, url, ... })
+        }),
+      );
+    }
 
-    return { ...template, attachments: attachments.map((att) => att.media_id) };
+    // Return template with attachments array
+    return {
+      ...template,
+      attachments: attachmentsMedia, // [] or array of media JSONs
+    };
   }
 }

package/src/module/workflow/repository/stage-movement.repository.ts

@@ -180,11 +180,15 @@ export class StageMovementRepository {
     return nextStageGroupFirstStage || null;
   }
 
-  async getAllActionByStageId(stageId: number): Promise<any[]> {
-    return this.dataSource.query(
-      `SELECT * FROM cr_wf_stage_action_mapping WHERE stage_id = ?`,
+  async getAllActionByStageId(stageId: number): Promise<any> {
+    const result = await this.dataSource.query(
+      `SELECT a.*, m.stage_id
+     FROM cr_wf_action a
+     INNER JOIN cr_wf_stage_action_mapping m ON a.id = m.action_id
+     WHERE m.stage_id = ?`,
       [stageId],
     );
+    return result;
   }
 
   async saveActionData(action: any, loggedInUser: UserData): Promise<any> {

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

@@ -1,30 +1,85 @@
 import { BadRequestException, Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { TaskDataEntity } from '../entity/task-data.entity';
-import { Repository } from 'typeorm';
+import { DataSource, Repository } from 'typeorm';
 
 @Injectable()
 export class TaskRepository {
   constructor(
     @InjectRepository(TaskDataEntity)
     private readonly TaskRepository: Repository<TaskDataEntity>,
+    private readonly dataSource: DataSource,
   ) {}
 
-  async getAllTaskByUserIdAndStageId(
-    userId,
-    stageId,
-    mapped_entity_type,
-    mapped_entity_id,
-  ) {
+  async getAllTaskByUserIdAndStageId(condition) {
     const result = await this.TaskRepository.find({
       where: {
-        user_id: userId,
-        stage_id: stageId,
-        mapped_entity_type,
-        mapped_entity_id,
+        ...condition,
       },
     });
 
     return result;
   }
+
+  async saveActionDataInTask(
+    action: any,
+    loggedInUser,
+    mapped_entity_id: number,
+    mapped_entity_type: string,
+  ): Promise<any> {
+    if (!action?.length) return;
+
+    const todoListMasterItemId = await this.dataSource.query(
+      `SELECT id FROM cr_list_master_items WHERE code = 'todo' and organization_id = ? and listtype = 'TKST' LIMIT 1;`,
+      [loggedInUser.organization_id],
+    );
+
+    // Find the action with the lowest sequence
+
+    if (action.length > 0) {
+      for (const act of action) {
+        const taskData = this.TaskRepository.create({
+          stage_id: act.stage_id,
+          user_id: loggedInUser.id,
+          action_id: act.id,
+          sequence: act.sequence,
+          mapped_entity_id,
+          mapped_entity_type,
+          is_system: true,
+          task_status: todoListMasterItemId[0]?.id,
+        } as TaskDataEntity);
+        await this.TaskRepository.save(taskData);
+      }
+    }
+  }
+
+  // update task status
+  async updateTaskStatus(
+    loggedInUser,
+    mapped_entity_type,
+    mapped_entity_id,
+    stage_id,
+    action_id,
+  ): Promise<any> {
+    const task = await this.TaskRepository.findOneBy({
+      action_id,
+      mapped_entity_type,
+      mapped_entity_id,
+      stage_id,
+    });
+
+    if (!task) return;
+
+    const completedListMasterItemId = await this.dataSource.query(
+      `SELECT id FROM cr_list_master_items WHERE code = 'completed' and organization_id = ? and listtype = 'TKST' LIMIT 1;`,
+      [loggedInUser.organization_id],
+    );
+
+    task.modified_by = loggedInUser.id;
+    task.modified_date = new Date();
+    task.is_done = true;
+    task.task_status = completedListMasterItemId[0]?.id;
+
+    await this.TaskRepository.update(task.id, task);
+  }
 }

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

@@ -0,0 +1,45 @@
+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';
+import { ActionDataRepository } from '../repository/action-data.repository';
+
+@Injectable()
+export class ActionDataService extends EntityServiceImpl {
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly actionDataRepo: ActionDataRepository,
+  ) {
+    super();
+  }
+
+  async saveActionData(
+    action: any,
+    loggedInUser: UserData,
+    mapped_entity_id,
+    mapped_entity_type,
+  ): Promise<any> {
+    return this.actionDataRepo.saveActionData(
+      action,
+      loggedInUser,
+      mapped_entity_id,
+      mapped_entity_type,
+    );
+  }
+
+  async updateActionStatus(
+    loggedInUser: UserData,
+    mapped_entity_type: string,
+    mapped_entity_id: number,
+    stage_id: number,
+    action_id: number,
+  ): Promise<any> {
+    return this.actionDataRepo.updateActionStatus(
+      loggedInUser,
+      mapped_entity_type,
+      mapped_entity_id,
+      stage_id,
+      action_id,
+    );
+  }
+}

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

@@ -2,12 +2,16 @@ import { BadRequestException, 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 { UserData } from 'src/module/user/entity/user.entity';
-import { DataSource, EntityManager } from 'typeorm';
+import { DataSource, EntityManager, Repository } from 'typeorm';
+import { ActionRepository } from '../repository/action.repository';
 import { ActionEntity } from '../entity/action.entity';
 
 @Injectable()
 export class ActionService extends EntityServiceImpl {
-  constructor(private readonly dataSource: DataSource) {
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly actionRepository: ActionRepository,
+  ) {
     super();
   }
 
@@ -60,6 +64,7 @@ export class ActionService extends EntityServiceImpl {
       appcode,
     );
 
+    // template mapping
     if (Array.isArray(actionData.template) && actionData.template.length > 0) {
       const templates = actionData.template;
 
@@ -98,7 +103,7 @@ export class ActionService extends EntityServiceImpl {
     };
 
     // Pass only actionData (without template) to super.updateEntity
-    let action = await super.updateEntity(actionData, loggedInUser);
+    let action = await super.updateEntity({ ...actionData }, loggedInUser);
 
     if (!action) {
       throw new Error('Action not found or could not be updated');
@@ -122,17 +127,17 @@ export class ActionService extends EntityServiceImpl {
       loggedInUser,
     );
 
+    // delete existing template mappings for this action
+    await this.dataSource.query(
+      `DELETE FROM cr_wf_action_template_mapping WHERE stg_act_mapping_id = ?`,
+      [stageActionMappingData.id],
+    );
+
     // Handle template mapping (using the extracted template)
     if (Array.isArray(template) && template.length > 0) {
       for (let i = 0; i < template.length; i++) {
         const templateCode = template[i];
 
-        // delete existing template mappings for this action
-        await this.dataSource.query(
-          `DELETE FROM cr_wf_action_template_mapping WHERE stg_act_mapping_id = ? AND template_code = ?`,
-          [stageActionMappingData.id, templateCode],
-        );
-
         // Create Action-Template Mapping
         const actionTemplateMapping = {
           stg_act_mapping_id: stageActionMappingData.id,
@@ -287,8 +292,7 @@ export class ActionService extends EntityServiceImpl {
     const actionResults = await this.dataSource
       .createQueryBuilder()
       .select([
-        'a.id AS id',
-        'a.name AS name',
+        'a.*',
         'ac.name AS action_category',
         'ar.name AS action_requirement',
       ])
@@ -318,4 +322,19 @@ export class ActionService extends EntityServiceImpl {
 
     return enrichedResult;
   }
+
+  async getAction(
+    loggedInUser: UserData,
+    stage_id: number,
+    mapped_entity_id: number,
+    mapped_entity_type: string,
+  ) {
+    const { organization_id } = loggedInUser;
+    return this.actionRepository.getAction(
+      organization_id,
+      stage_id,
+      mapped_entity_id,
+      mapped_entity_type,
+    );
+  }
 }

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

@@ -70,7 +70,7 @@ export class CommTemplateService extends EntityServiceImpl {
 
     const getTemplate = await this.commTemplateRepository.getTemplateByCode(
       entityType,
-      id.toString(),
+      id,
       loggedInUser,
     );