rez_core 4.0.199 → 4.0.200

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

@@ -1,569 +1,569 @@
-import { Inject, 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';
-import { DataSource, EntityManager } from 'typeorm';
-import { ActivityLogService } from './activity-log.service';
-import { ACTIVITY_CATEGORIES } from '../repository/activity-log.repository';
-import { MediaDataService } from 'src/module/meta/service/media-data.service';
-import { ActionHandler } from 'src/module/workflow-automation/interface/action.decorator';
-import * as moment from 'moment';
-import { ConfigService } from '@nestjs/config';
-import axios from 'axios';
-import { ChecksumAlgorithm } from '@aws-sdk/client-s3';
-
-@Injectable()
-@ActionHandler('add_task')
-export class TaskService extends EntityServiceImpl {
-  constructor(
-    private readonly taskRepository: TaskRepository,
-    private readonly actionDataService: ActionDataService,
-    private readonly dataSource: DataSource,
-    @Inject('ActivityLogService')
-    private readonly activityLogService: ActivityLogService,
-    private readonly mediaDataService: MediaDataService,
-    private readonly configService: ConfigService,
-  ) {
-    super();
-  }
-  name: string = 'add_task';
-
-  async execute(payload: any): Promise<any> {
-    let { entity, user, config } = payload;
-
-    const { organization_id, level_id, level_type } = entity;
-
-    if (entity.entity_type !== 'LEAD') {
-      entity = await this.getEntityData('LEAD', entity.parent_id, user);
-    }
-
-    // 3. Build entityData
-    const entityData = {
-      mapped_entity_id: entity.id,
-      mapped_entity_type: entity.entity_type,
-      task_owner: entity.lead_owner,
-      stage_id: entity.stageId,
-      status: config.status,
-      due_date: Date.now() + 2,
-      due_time: Date.now(),
-      description: config.description,
-      is_mandatory: config.is_mandatory,
-      name: config.name,
-      entity_type: 'TASK',
-    };
-
-    return await this.createEntity(entityData, user);
-  }
-
-  async createEntity(
-    entityData: any,
-    loggedInUser: any,
-    manager?: EntityManager | null,
-    appcode?: string,
-  ): Promise<any> {
-    if (entityData && typeof entityData['is_mandatory'] === 'string') {
-      entityData['is_mandatory'] = entityData['is_mandatory'] === '1';
-    }
-
-    // handling the date string for due_date and reminder_date
-    if (entityData?.due_date) {
-      // Interpret input 'YYYY-MM-DD' as local midnight (IST)
-      entityData.due_date = moment(entityData.due_date, 'YYYY-MM-DD')
-        .startOf('day') // 00:00 local time
-        .toDate(); // Convert to JS Date object for TypeORM
-    }
-
-    if (entityData?.reminder_date) {
-      entityData.reminder_date = moment(entityData.reminder_date, 'YYYY-MM-DD')
-        .startOf('day')
-        .toDate();
-    }
-
-    const createdEntity = await super.createEntity(
-      entityData,
-      loggedInUser,
-      manager,
-      appcode,
-    );
-
-    try {
-      const logData = {
-        mapped_entity_id: createdEntity.mapped_entity_id,
-        mapped_entity_type: createdEntity.mapped_entity_type,
-        title: `Task added`,
-        description: `A new task ${createdEntity.name} was added`,
-        category: ACTIVITY_CATEGORIES.TASK,
-        action: 'add',
-        appcode: loggedInUser.appcode,
-      };
-
-      await this.activityLogService.logActivity(logData, loggedInUser);
-    } catch (error) {
-      console.error(
-        'Failed to log activity for meeting:',
-        error?.message || error,
-      );
-      // Logging should not block main flow
-    }
-
-    let relationData = await this.dataSource.query(
-      `SELECT * FROM frm_entity_relation WHERE source_entity_type = ?  AND target_entity_type = ?`,
-      [createdEntity.mapped_entity_type, createdEntity.entity_type],
-    );
-
-    if (relationData) {
-      await this.dataSource.query(
-        `INSERT INTO frm_entity_relation_data (organization_id, source_entity_id, source_entity_type, target_entity_id, target_entity_type, relation_type) VALUES (?, ?, ?, ?, ? , ?)`,
-        [
-          loggedInUser.organization_id,
-          createdEntity.mapped_entity_id,
-          createdEntity.mapped_entity_type,
-          createdEntity.id,
-          createdEntity.entity_type,
-          relationData[0]?.relation_type,
-        ],
-      );
-    }
-
-    return createdEntity;
-  }
-
-  async updateEntity(
-    entityData,
-    loggedInUser: UserData,
-    appcode?: string,
-  ): Promise<any> {
-    const taskStatusQuery = `
-    SELECT name 
-    FROM frm_list_master_items 
-    WHERE id = ? 
-      AND organization_id = ? 
-      AND listtype = 'TKST'
-    LIMIT 1;
-  `;
-
-    const statusRows = await this.dataSource.query(taskStatusQuery, [
-      entityData.status,
-      loggedInUser.organization_id,
-    ]);
-
-    const oldStatusQuery = `
-    SELECT * 
-    FROM frm_wf_task_data
-    WHERE id = ? 
-      AND organization_id = ?
-    LIMIT 1;
-  `;
-
-    const [oldRow] = await this.dataSource.query(oldStatusQuery, [
-      entityData.id,
-      loggedInUser.organization_id,
-    ]);
-
-    const oldStatusRows = await this.dataSource.query(taskStatusQuery, [
-      oldRow.status,
-      loggedInUser.organization_id,
-    ]);
-
-    const isStatusChanged =
-      statusRows.length > 0 &&
-      oldStatusRows.length > 0 &&
-      statusRows[0].name !== oldStatusRows[0].name;
-
-    const isCompletedStatus =
-      statusRows.length > 0 &&
-      statusRows[0].name?.toLowerCase() === 'completed';
-
-    // Sync flags based on status
-    entityData.is_completed = isCompletedStatus;
-    entityData.is_done = isCompletedStatus;
-
-    const isMandatory =
-      String(entityData.is_mandatory).toLowerCase() === 'true' ||
-      entityData.is_mandatory === true ||
-      entityData.is_mandatory === 1 ||
-      entityData.is_mandatory === '1';
-
-    const updatedEntity = await super.updateEntity(
-      {
-        ...entityData,
-        is_mandatory: isMandatory,
-      },
-      loggedInUser,
-      appcode,
-    );
-
-    // Convert boolean back to "1" / "0" for response
-    if (updatedEntity && typeof updatedEntity['is_mandatory'] === 'boolean') {
-      updatedEntity['is_mandatory'] = updatedEntity['is_mandatory'] ? '1' : '0';
-    }
-
-    try {
-      if (isCompletedStatus && isStatusChanged) {
-        const completedLogData = {
-          mapped_entity_id: updatedEntity.mapped_entity_id,
-          mapped_entity_type: updatedEntity.mapped_entity_type,
-          title: `Task completed`,
-          description: `${updatedEntity.code} was marked as completed`,
-          category: ACTIVITY_CATEGORIES.TASK,
-          action: 'completed',
-          appcode: loggedInUser.appcode,
-        };
-
-        await this.activityLogService.logActivity(
-          completedLogData,
-          loggedInUser,
-        );
-      } else {
-        const editLogData = {
-          mapped_entity_id: updatedEntity.mapped_entity_id,
-          mapped_entity_type: updatedEntity.mapped_entity_type,
-          title: `Task edited`,
-          description: `${updatedEntity.code} was edited`,
-          category: ACTIVITY_CATEGORIES.TASK,
-          action: 'edit',
-          appcode: loggedInUser.appcode,
-        };
-
-        await this.activityLogService.logActivity(editLogData, loggedInUser);
-      }
-    } catch (error) {
-      console.error(
-        'Failed to log activity for task:',
-        error?.message || error,
-      );
-      // Don't block main flow
-    }
-
-    return updatedEntity;
-  }
-
-  async getAllTaskByUserIdandStageId(
-    loggedInUser: UserData,
-    data,
-  ): Promise<any> {
-    const taskData = await this.taskRepository.getAllTaskByUserIdAndStageId({
-      user_id: data.user_id,
-      stage_id: data.stage_id,
-      mapped_entity_type: data.mapped_entity_type,
-      mapped_entity_id: 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 getAllTask(
-    loggedInUser: UserData,
-    data: {
-      mapped_entity_type: string;
-      mapped_entity_id: number;
-      status?: string;
-      mandatory?: boolean;
-      overdue?: boolean;
-    },
-  ): Promise<any[]> {
-    const { mapped_entity_type, mapped_entity_id, status, mandatory, overdue } =
-      data;
-
-    // Build dynamic WHERE clauses
-    const whereClauses = [`t.mapped_entity_type = ?`, `t.mapped_entity_id = ?`];
-    const params: any[] = [mapped_entity_type, mapped_entity_id];
-
-    if (status) {
-      whereClauses.push(`t.status = ?`);
-      params.push(status);
-    }
-    if (mandatory) {
-      whereClauses.push(`t.is_mandatory = ?`);
-      params.push(mandatory ? 1 : 0);
-    }
-    if (overdue) {
-      whereClauses.push(
-        `(t.due_date < CURDATE() OR (t.due_date = CURDATE() AND t.due_time < CURTIME()))`,
-      );
-      // exclude tasks that are already completed
-      whereClauses.push(`t.is_done = ?`);
-      params.push(0); // Only include tasks that are not done
-    }
-
-    const sql = `
-    SELECT
-      t.*,
-      sg.name AS stage_group_name,
-      s.name AS stage_name,
-      a.name AS action_name
-    FROM frm_wf_task_data t
-    LEFT JOIN frm_wf_stage s ON t.stage_id = s.id
-    LEFT JOIN frm_wf_stage_group sg ON s.stage_group_id = sg.id
-    LEFT JOIN frm_wf_action a ON t.action_id = a.id
-    WHERE ${whereClauses.join(' AND ')}
-    ORDER BY t.created_date DESC
-  `;
-
-    const taskData = await this.dataSource.query(sql, params);
-
-    if (taskData) {
-      let user: any = null;
-      for (const param of taskData as any) {
-        try {
-          const baseUrl = this.configService.get<string>('REDIRECT_BE_URL');
-
-          // Prepare the query string
-          const queryParams = new URLSearchParams({
-            loggedInUser: JSON.stringify(loggedInUser),
-          }).toString();
-
-          // Make the GET request with query parameters
-          const response = await axios.get(
-            `${baseUrl}/users/profile-image-url/${param?.task_owner}?entity_type=USR&${queryParams}`,
-            {
-              headers: {
-                'Content-Type': 'application/json',
-              },
-            },
-          );
-
-          user = response.data;
-          param.created_by_name = user.name;
-          param.task_owner_name = user.name;
-          param.task_owner_profile = user.profile_image;
-        } catch (error) {
-          console.error('⚠️ Internal Entity API call failed:', error.message);
-        }
-      }
-    }
-
-    if (taskData.length === 0) {
-      return [];
-    }
-
-    //  Fetch all TKST statuses in a single query
-    const taskStatusQuery = `
-  SELECT id, name 
-  FROM frm_list_master_items 
-  WHERE organization_id = ? 
-    AND listtype = 'TKST'
-`;
-    const taskAllStatus = await this.dataSource.query(taskStatusQuery, [
-      loggedInUser.organization_id,
-    ]);
-
-    //  Build a hash map { id → name }
-    const statusMap = new Map(
-      taskAllStatus.map((row) => [String(row.id), row.name]),
-    );
-
-    //  Assign task_status using the map
-
-    const mediaCache = new Map<number, any>();
-
-    for (const task of taskData) {
-      // Map status name
-      task.task_status = task.status
-        ? statusMap.get(String(task.status)) || null
-        : null;
-
-      // Fix action_name for generic tasks
-      task.action_name =
-        task.action_id === '0' || task.action_id === 0
-          ? 'Generic'
-          : task.action_name;
-
-      // Profile media (with caching like notes)
-      // if (task.task_owner_profile) {
-      //   if (!mediaCache.has(task.task_owner_profile)) {
-      //     const url = await this.mediaDataService.getMediaDownloadUrl(
-      //       Number(task.task_owner_profile),
-      //       loggedInUser,
-      //     );
-      //     mediaCache.set(task.task_owner_profile, url);
-      //   }
-      //   task.task_owner_profile = mediaCache.get(task.task_owner_profile);
-      // } else {
-      //   task.task_owner_profile = null;
-      // }
-    }
-
-    // Normalize is_mandatory to '0'/'1' as string
-    return taskData.map((task) => ({
-      ...task,
-      is_mandatory: task.is_mandatory ? '1' : '0',
-    }));
-  }
-
-  async getEntityData(entityType: string, id: number, loggedInUser: any) {
-    const taskData = await super.getEntityData(entityType, id, loggedInUser);
-
-    if (taskData?.due_date) {
-      taskData.due_date = moment(taskData.due_date)
-        .local() // convert from UTC to local
-        .format('YYYY-MM-DD'); // return just the date string
-    }
-
-    if (taskData?.reminder_date) {
-      taskData.reminder_date = moment(taskData.reminder_date)
-        .local()
-        .format('YYYY-MM-DD');
-    }
-
-    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;
-      reason_code?: string | number;
-      remark?: string;
-      stage_group_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,
-    );
-
-    if (body.reason_code || body.remark) {
-      await this.createSystemNote(
-        {
-          reason_code: body.reason_code!,
-          remark: body.remark || '',
-          mapped_entity_id: body.mapped_entity_id,
-          stage_id: body.stage_id,
-          action_id: body.action_id,
-          stage_group_id: body.stage_group_id,
-        },
-        loggedInUser,
-      );
-    }
-
-    return 'Task moved successfully';
-  }
-
-  async deleteEntity(
-    entity_type: string,
-    taskId: number,
-    loggedInUser: UserData,
-  ): Promise<any> {
-    // Fetch the task before deleting
-    const task: any = await super.getEntityData(
-      entity_type,
-      taskId,
-      loggedInUser,
-    );
-
-    if (!task) {
-      throw new Error('Task not found');
-    }
-
-    // Check if the task is system-generated
-    if (task.is_system) {
-      throw new Error('Cannot delete system-generated tasks');
-    }
-
-    // Perform the deletion
-    await super.deleteEntity(entity_type, taskId, loggedInUser);
-
-    // Try to log the delete activity
-    try {
-      const logData = {
-        mapped_entity_id: task.mapped_entity_id,
-        mapped_entity_type: task.mapped_entity_type,
-        title: `Task deleted`,
-        description: `${task.name} was deleted`,
-        category: ACTIVITY_CATEGORIES.TASK,
-        action: 'delete',
-        appcode: loggedInUser.appcode,
-      };
-
-      await this.activityLogService.logActivity(logData, loggedInUser);
-    } catch (error) {
-      console.error(
-        'Failed to log activity for task deletion:',
-        error?.message || error,
-      );
-    }
-
-    return { message: 'Task deleted successfully' };
-  }
-
-  async createSystemNote(
-    entity: {
-      reason_code: string | number;
-      remark: string;
-      mapped_entity_id: number;
-      stage_id: number;
-      action_id: number;
-      stage_group_id?: number;
-    },
-    loggedInUser: any,
-  ) {
-    if (!entity || !entity.mapped_entity_id || !entity.reason_code) return null;
-
-    const [reason] = await this.dataSource.query(
-      `SELECT name FROM frm_list_master_items WHERE id = ? AND organization_id = ?`,
-      [entity.reason_code, loggedInUser.organization_id],
-    );
-
-    const notePayload = {
-      note_title: reason ? reason.name : entity.reason_code,
-      note: entity.remark,
-      is_system: true,
-      mapped_entity_type: 'LEAD',
-      entity_type: 'NOTE',
-      mapped_entity_id: entity.mapped_entity_id,
-      stage_id: entity.stage_id,
-      action_id: entity.action_id,
-      stage_group_id: entity.stage_group_id,
-    } as any;
-
-    return await super.createEntity(notePayload, loggedInUser);
-  }
-}
+import { Inject, 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';
+import { DataSource, EntityManager } from 'typeorm';
+import { ActivityLogService } from './activity-log.service';
+import { ACTIVITY_CATEGORIES } from '../repository/activity-log.repository';
+import { MediaDataService } from 'src/module/meta/service/media-data.service';
+import { ActionHandler } from 'src/module/workflow-automation/interface/action.decorator';
+import * as moment from 'moment';
+import { ConfigService } from '@nestjs/config';
+import axios from 'axios';
+import { ChecksumAlgorithm } from '@aws-sdk/client-s3';
+
+@Injectable()
+@ActionHandler('add_task')
+export class TaskService extends EntityServiceImpl {
+  constructor(
+    private readonly taskRepository: TaskRepository,
+    private readonly actionDataService: ActionDataService,
+    private readonly dataSource: DataSource,
+    @Inject('ActivityLogService')
+    private readonly activityLogService: ActivityLogService,
+    private readonly mediaDataService: MediaDataService,
+    private readonly configService: ConfigService,
+  ) {
+    super();
+  }
+  name: string = 'add_task';
+
+  async execute(payload: any): Promise<any> {
+    let { entity, user, config } = payload;
+
+    const { organization_id, level_id, level_type } = entity;
+
+    if (entity.entity_type !== 'LEAD') {
+      entity = await this.getEntityData('LEAD', entity.parent_id, user);
+    }
+
+    // 3. Build entityData
+    const entityData = {
+      mapped_entity_id: entity.id,
+      mapped_entity_type: entity.entity_type,
+      task_owner: entity.lead_owner,
+      stage_id: entity.stageId,
+      status: config.status,
+      due_date: Date.now() + 2,
+      due_time: Date.now(),
+      description: config.description,
+      is_mandatory: config.is_mandatory,
+      name: config.name,
+      entity_type: 'TASK',
+    };
+
+    return await this.createEntity(entityData, user);
+  }
+
+  async createEntity(
+    entityData: any,
+    loggedInUser: any,
+    manager?: EntityManager | null,
+    appcode?: string,
+  ): Promise<any> {
+    if (entityData && typeof entityData['is_mandatory'] === 'string') {
+      entityData['is_mandatory'] = entityData['is_mandatory'] === '1';
+    }
+
+    // handling the date string for due_date and reminder_date
+    if (entityData?.due_date) {
+      // Interpret input 'YYYY-MM-DD' as local midnight (IST)
+      entityData.due_date = moment(entityData.due_date, 'YYYY-MM-DD')
+        .startOf('day') // 00:00 local time
+        .toDate(); // Convert to JS Date object for TypeORM
+    }
+
+    if (entityData?.reminder_date) {
+      entityData.reminder_date = moment(entityData.reminder_date, 'YYYY-MM-DD')
+        .startOf('day')
+        .toDate();
+    }
+
+    const createdEntity = await super.createEntity(
+      entityData,
+      loggedInUser,
+      manager,
+      appcode,
+    );
+
+    try {
+      const logData = {
+        mapped_entity_id: createdEntity.mapped_entity_id,
+        mapped_entity_type: createdEntity.mapped_entity_type,
+        title: `Task added`,
+        description: `A new task ${createdEntity.name} was added`,
+        category: ACTIVITY_CATEGORIES.TASK,
+        action: 'add',
+        appcode: loggedInUser.appcode,
+      };
+
+      await this.activityLogService.logActivity(logData, loggedInUser);
+    } catch (error) {
+      console.error(
+        'Failed to log activity for meeting:',
+        error?.message || error,
+      );
+      // Logging should not block main flow
+    }
+
+    let relationData = await this.dataSource.query(
+      `SELECT * FROM frm_entity_relation WHERE source_entity_type = $1  AND target_entity_type = $2`,
+      [createdEntity.mapped_entity_type, createdEntity.entity_type],
+    );
+
+    if (relationData) {
+      await this.dataSource.query(
+        `INSERT INTO frm_entity_relation_data (organization_id, source_entity_id, source_entity_type, target_entity_id, target_entity_type, relation_type) VALUES ($1, $2, $3, $4, $5 , $6)`,
+        [
+          loggedInUser.organization_id,
+          createdEntity.mapped_entity_id,
+          createdEntity.mapped_entity_type,
+          createdEntity.id,
+          createdEntity.entity_type,
+          relationData[0]?.relation_type,
+        ],
+      );
+    }
+
+    return createdEntity;
+  }
+
+  async updateEntity(
+    entityData,
+    loggedInUser: UserData,
+    appcode?: string,
+  ): Promise<any> {
+    const taskStatusQuery = `
+    SELECT name 
+    FROM frm_list_master_items 
+    WHERE id = $1 
+      AND organization_id = $2 
+      AND listtype = 'TKST'
+    LIMIT 1;
+  `;
+
+    const statusRows = await this.dataSource.query(taskStatusQuery, [
+      entityData.status,
+      loggedInUser.organization_id,
+    ]);
+
+    const oldStatusQuery = `
+    SELECT * 
+    FROM frm_wf_task_data
+    WHERE id = $1
+      AND organization_id = $2
+    LIMIT 1;
+  `;
+
+    const [oldRow] = await this.dataSource.query(oldStatusQuery, [
+      entityData.id,
+      loggedInUser.organization_id,
+    ]);
+
+    const oldStatusRows = await this.dataSource.query(taskStatusQuery, [
+      oldRow.status,
+      loggedInUser.organization_id,
+    ]);
+
+    const isStatusChanged =
+      statusRows.length > 0 &&
+      oldStatusRows.length > 0 &&
+      statusRows[0].name !== oldStatusRows[0].name;
+
+    const isCompletedStatus =
+      statusRows.length > 0 &&
+      statusRows[0].name?.toLowerCase() === 'completed';
+
+    // Sync flags based on status
+    entityData.is_completed = isCompletedStatus;
+    entityData.is_done = isCompletedStatus;
+
+    const isMandatory =
+      String(entityData.is_mandatory).toLowerCase() === 'true' ||
+      entityData.is_mandatory === true ||
+      entityData.is_mandatory === 1 ||
+      entityData.is_mandatory === '1';
+
+    const updatedEntity = await super.updateEntity(
+      {
+        ...entityData,
+        is_mandatory: isMandatory,
+      },
+      loggedInUser,
+      appcode,
+    );
+
+    // Convert boolean back to "1" / "0" for response
+    if (updatedEntity && typeof updatedEntity['is_mandatory'] === 'boolean') {
+      updatedEntity['is_mandatory'] = updatedEntity['is_mandatory'] ? '1' : '0';
+    }
+
+    try {
+      if (isCompletedStatus && isStatusChanged) {
+        const completedLogData = {
+          mapped_entity_id: updatedEntity.mapped_entity_id,
+          mapped_entity_type: updatedEntity.mapped_entity_type,
+          title: `Task completed`,
+          description: `${updatedEntity.code} was marked as completed`,
+          category: ACTIVITY_CATEGORIES.TASK,
+          action: 'completed',
+          appcode: loggedInUser.appcode,
+        };
+
+        await this.activityLogService.logActivity(
+          completedLogData,
+          loggedInUser,
+        );
+      } else {
+        const editLogData = {
+          mapped_entity_id: updatedEntity.mapped_entity_id,
+          mapped_entity_type: updatedEntity.mapped_entity_type,
+          title: `Task edited`,
+          description: `${updatedEntity.code} was edited`,
+          category: ACTIVITY_CATEGORIES.TASK,
+          action: 'edit',
+          appcode: loggedInUser.appcode,
+        };
+
+        await this.activityLogService.logActivity(editLogData, loggedInUser);
+      }
+    } catch (error) {
+      console.error(
+        'Failed to log activity for task:',
+        error?.message || error,
+      );
+      // Don't block main flow
+    }
+
+    return updatedEntity;
+  }
+
+  async getAllTaskByUserIdandStageId(
+    loggedInUser: UserData,
+    data,
+  ): Promise<any> {
+    const taskData = await this.taskRepository.getAllTaskByUserIdAndStageId({
+      user_id: data.user_id,
+      stage_id: data.stage_id,
+      mapped_entity_type: data.mapped_entity_type,
+      mapped_entity_id: 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 getAllTask(
+    loggedInUser: UserData,
+    data: {
+      mapped_entity_type: string;
+      mapped_entity_id: number;
+      status?: string;
+      mandatory?: boolean;
+      overdue?: boolean;
+    },
+  ): Promise<any[]> {
+    const { mapped_entity_type, mapped_entity_id, status, mandatory, overdue } =
+      data;
+
+    // Build dynamic WHERE clauses
+    const whereClauses = [`t.mapped_entity_type = ?`, `t.mapped_entity_id = ?`];
+    const params: any[] = [mapped_entity_type, mapped_entity_id];
+
+    if (status) {
+      whereClauses.push(`t.status = ?`);
+      params.push(status);
+    }
+    if (mandatory) {
+      whereClauses.push(`t.is_mandatory = ?`);
+      params.push(mandatory ? 1 : 0);
+    }
+    if (overdue) {
+      whereClauses.push(
+        `(t.due_date < CURDATE() OR (t.due_date = CURDATE() AND t.due_time < CURTIME()))`,
+      );
+      // exclude tasks that are already completed
+      whereClauses.push(`t.is_done = ?`);
+      params.push(0); // Only include tasks that are not done
+    }
+
+    const sql = `
+    SELECT
+      t.*,
+      sg.name AS stage_group_name,
+      s.name AS stage_name,
+      a.name AS action_name
+    FROM frm_wf_task_data t
+    LEFT JOIN frm_wf_stage s ON t.stage_id = s.id
+    LEFT JOIN frm_wf_stage_group sg ON s.stage_group_id = sg.id
+    LEFT JOIN frm_wf_action a ON t.action_id = a.id
+    WHERE ${whereClauses.join(' AND ')}
+    ORDER BY t.created_date DESC
+  `;
+
+    const taskData = await this.dataSource.query(sql, params);
+
+    if (taskData) {
+      let user: any = null;
+      for (const param of taskData as any) {
+        try {
+          const baseUrl = this.configService.get<string>('REDIRECT_BE_URL');
+
+          // Prepare the query string
+          const queryParams = new URLSearchParams({
+            loggedInUser: JSON.stringify(loggedInUser),
+          }).toString();
+
+          // Make the GET request with query parameters
+          const response = await axios.get(
+            `${baseUrl}/users/profile-image-url/${param?.task_owner}?entity_type=USR&${queryParams}`,
+            {
+              headers: {
+                'Content-Type': 'application/json',
+              },
+            },
+          );
+
+          user = response.data;
+          param.created_by_name = user.name;
+          param.task_owner_name = user.name;
+          param.task_owner_profile = user.profile_image;
+        } catch (error) {
+          console.error('⚠️ Internal Entity API call failed:', error.message);
+        }
+      }
+    }
+
+    if (taskData.length === 0) {
+      return [];
+    }
+
+    //  Fetch all TKST statuses in a single query
+    const taskStatusQuery = `
+  SELECT id, name 
+  FROM frm_list_master_items 
+  WHERE organization_id = $1 
+    AND listtype = 'TKST'
+`;
+    const taskAllStatus = await this.dataSource.query(taskStatusQuery, [
+      loggedInUser.organization_id,
+    ]);
+
+    //  Build a hash map { id → name }
+    const statusMap = new Map(
+      taskAllStatus.map((row) => [String(row.id), row.name]),
+    );
+
+    //  Assign task_status using the map
+
+    const mediaCache = new Map<number, any>();
+
+    for (const task of taskData) {
+      // Map status name
+      task.task_status = task.status
+        ? statusMap.get(String(task.status)) || null
+        : null;
+
+      // Fix action_name for generic tasks
+      task.action_name =
+        task.action_id === '0' || task.action_id === 0
+          ? 'Generic'
+          : task.action_name;
+
+      // Profile media (with caching like notes)
+      // if (task.task_owner_profile) {
+      //   if (!mediaCache.has(task.task_owner_profile)) {
+      //     const url = await this.mediaDataService.getMediaDownloadUrl(
+      //       Number(task.task_owner_profile),
+      //       loggedInUser,
+      //     );
+      //     mediaCache.set(task.task_owner_profile, url);
+      //   }
+      //   task.task_owner_profile = mediaCache.get(task.task_owner_profile);
+      // } else {
+      //   task.task_owner_profile = null;
+      // }
+    }
+
+    // Normalize is_mandatory to '0'/'1' as string
+    return taskData.map((task) => ({
+      ...task,
+      is_mandatory: task.is_mandatory ? '1' : '0',
+    }));
+  }
+
+  async getEntityData(entityType: string, id: number, loggedInUser: any) {
+    const taskData = await super.getEntityData(entityType, id, loggedInUser);
+
+    if (taskData?.due_date) {
+      taskData.due_date = moment(taskData.due_date)
+        .local() // convert from UTC to local
+        .format('YYYY-MM-DD'); // return just the date string
+    }
+
+    if (taskData?.reminder_date) {
+      taskData.reminder_date = moment(taskData.reminder_date)
+        .local()
+        .format('YYYY-MM-DD');
+    }
+
+    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;
+      reason_code?: string | number;
+      remark?: string;
+      stage_group_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,
+    );
+
+    if (body.reason_code || body.remark) {
+      await this.createSystemNote(
+        {
+          reason_code: body.reason_code!,
+          remark: body.remark || '',
+          mapped_entity_id: body.mapped_entity_id,
+          stage_id: body.stage_id,
+          action_id: body.action_id,
+          stage_group_id: body.stage_group_id,
+        },
+        loggedInUser,
+      );
+    }
+
+    return 'Task moved successfully';
+  }
+
+  async deleteEntity(
+    entity_type: string,
+    taskId: number,
+    loggedInUser: UserData,
+  ): Promise<any> {
+    // Fetch the task before deleting
+    const task: any = await super.getEntityData(
+      entity_type,
+      taskId,
+      loggedInUser,
+    );
+
+    if (!task) {
+      throw new Error('Task not found');
+    }
+
+    // Check if the task is system-generated
+    if (task.is_system) {
+      throw new Error('Cannot delete system-generated tasks');
+    }
+
+    // Perform the deletion
+    await super.deleteEntity(entity_type, taskId, loggedInUser);
+
+    // Try to log the delete activity
+    try {
+      const logData = {
+        mapped_entity_id: task.mapped_entity_id,
+        mapped_entity_type: task.mapped_entity_type,
+        title: `Task deleted`,
+        description: `${task.name} was deleted`,
+        category: ACTIVITY_CATEGORIES.TASK,
+        action: 'delete',
+        appcode: loggedInUser.appcode,
+      };
+
+      await this.activityLogService.logActivity(logData, loggedInUser);
+    } catch (error) {
+      console.error(
+        'Failed to log activity for task deletion:',
+        error?.message || error,
+      );
+    }
+
+    return { message: 'Task deleted successfully' };
+  }
+
+  async createSystemNote(
+    entity: {
+      reason_code: string | number;
+      remark: string;
+      mapped_entity_id: number;
+      stage_id: number;
+      action_id: number;
+      stage_group_id?: number;
+    },
+    loggedInUser: any,
+  ) {
+    if (!entity || !entity.mapped_entity_id || !entity.reason_code) return null;
+
+    const [reason] = await this.dataSource.query(
+      `SELECT name FROM frm_list_master_items WHERE id = $1 AND organization_id = $2`,
+      [entity.reason_code, loggedInUser.organization_id],
+    );
+
+    const notePayload = {
+      note_title: reason ? reason.name : entity.reason_code,
+      note: entity.remark,
+      is_system: true,
+      mapped_entity_type: 'LEAD',
+      entity_type: 'NOTE',
+      mapped_entity_id: entity.mapped_entity_id,
+      stage_id: entity.stage_id,
+      action_id: entity.action_id,
+      stage_group_id: entity.stage_group_id,
+    } as any;
+
+    return await super.createEntity(notePayload, loggedInUser);
+  }
+}