rez_core 2.1.153 → 2.1.156

package/package.json

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

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

@@ -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,7 +19,7 @@ export class TaskController {
     private readonly taskService: TaskService,
   ) {}
 
-  @Post('/getTasksbyUserAndStage')
+  @Post('/by-user-and-stage')
   @HttpCode(HttpStatus.OK)
   async getTasksbyUserAndStage(
     @Req() req: Request & { user: any },
@@ -37,4 +37,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/entity/action-data.entity.ts

@@ -31,4 +31,13 @@ export class ActionDataEntity extends BaseEntity {
 
   @Column({ nullable: true })
   mapped_entity_type: string;
+
+  @Column({ nullable: true })
+  sequence: number;
+
+  @Column({ default: 0 })
+  is_done: boolean;
+
+  @Column({ type: 'varchar', nullable: true })
+  is_current: string;
 }

package/src/module/workflow/entity/task-data.entity.ts

@@ -5,20 +5,20 @@ import { Column, Entity } from 'typeorm';
 export class TaskDataEntity extends BaseEntity {
   constructor() {
     super();
-    this.entity_type = 'TASK_DATA';
+    this.entity_type = 'TASK';
   }
 
   @Column({ nullable: true })
-  task_id: number;
+  task_id: string;
 
   @Column({ nullable: true })
-  user_id: number;
+  user_id: string;
 
   @Column({ nullable: true })
-  stage_id: number;
+  stage_id: string;
 
   @Column({ nullable: true })
-  action_id: number;
+  action_id: string;
 
   @Column({ nullable: true })
   start_time: Date;
@@ -40,4 +40,28 @@ export class TaskDataEntity extends BaseEntity {
 
   @Column({ nullable: true })
   mapped_entity_type: string;
+
+  @Column({ nullable: true })
+  sequence: number;
+
+  @Column({ default: 0 })
+  is_done: boolean;
+
+  @Column({ nullable: true })
+  task_status: string;
+
+  @Column({ nullable: true })
+  task_name: string;
+
+  @Column({ nullable: true, type: 'varchar', length: 1000 })
+  description: string;
+
+  @Column({ nullable: true })
+  task_owner: string;
+
+  @Column({ nullable: true, type: 'varchar' })
+  due_date: Date;
+
+  @Column({ nullable: true, type: 'varchar' })
+  due_time: string;
 }

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,99 @@
+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,
+      };
+    });
+
+    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,20 +1,21 @@
 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: number,
-    stageId: number,
-    mapped_entity_type: string,
-    mapped_entity_id: number,
+    userId,
+    stageId,
+    mapped_entity_type,
+    mapped_entity_id,
   ) {
     const result = await this.TaskRepository.find({
       where: {
@@ -27,4 +28,66 @@ export class TaskRepository {
 
     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();
   }
 
@@ -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,
     );
 

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

@@ -2,10 +2,14 @@ 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 { TaskRepository } from '../repository/task.repository';
+import { ActionDataService } from './action-data.service';
 
 @Injectable()
 export class TaskService extends EntityServiceImpl {
-  constructor(private readonly taskRepository: TaskRepository) {
+  constructor(
+    private readonly taskRepository: TaskRepository,
+    private readonly actionDataService: ActionDataService,
+  ) {
     super();
   }
 
@@ -20,6 +24,72 @@ export class TaskService extends EntityServiceImpl {
       data.mapped_entity_id,
     );
 
+    const grouped: { mandatory: any[]; non_mandatory: any[] } = {
+      mandatory: [],
+      non_mandatory: [],
+    };
+
+    for (const task of taskData) {
+      if (task && task.is_mandatory) {
+        grouped.mandatory.push(task);
+      } else {
+        grouped.non_mandatory.push(task);
+      }
+    }
+
+    return grouped;
+  }
+
+  async getEntityData(entityType: string, id: number, loggedInUser: any) {
+    const taskData = await super.getEntityData(entityType, id, loggedInUser);
+
     return taskData;
   }
+
+  async saveActionData(
+    action: any,
+    loggedInUser: UserData,
+    mapped_entity_id: number,
+    mapped_entity_type: string,
+  ): Promise<any> {
+    await this.taskRepository.saveActionDataInTask(
+      action,
+      loggedInUser,
+      mapped_entity_id,
+      mapped_entity_type,
+    );
+  }
+
+  async moveTask(
+    loggedInUser: UserData,
+    body: {
+      mapped_entity_type: string;
+      mapped_entity_id: number;
+      stage_id: number;
+      action_id: number;
+    },
+  ): Promise<any> {
+    // Logic to move task based on the provided body parameters
+    // This could involve updating the task's stage, action, etc.
+
+    // update task status
+    this.taskRepository.updateTaskStatus(
+      loggedInUser,
+      body.mapped_entity_type,
+      body.mapped_entity_id,
+      body.stage_id,
+      body.action_id,
+    );
+
+    // update action status
+    await this.actionDataService.updateActionStatus(
+      loggedInUser,
+      body.mapped_entity_type,
+      body.mapped_entity_id,
+      body.stage_id,
+      body.action_id,
+    );
+
+    return 'Task moved successfully';
+  }
 }