rez_core 6.1.4 → 6.1.6

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

@@ -1,551 +1,551 @@
-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 { ActionHandler } from 'src/module/workflow-automation/interface/action.decorator';
-import * as moment from 'moment';
-import { ConfigService } from '@nestjs/config';
-import axios from 'axios';
-
-@Injectable()
-@ActionHandler('add_task')
-export class TaskService extends EntityServiceImpl {
-  constructor(
-    private readonly taskRepository: TaskRepository,
-    private readonly actionDataService: ActionDataService,
-    @Inject('ActivityLogService')
-    private readonly activityLogService: ActivityLogService,
-    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
-    }
-
-    const entityRelationRepo =
-      this.reflectionHelper.getRepoService('EntityRelationData');
-
-    let relationData = await entityRelationRepo.findOne({
-      where: {
-        source_entity_type: createdEntity.mapped_entity_type,
-        target_entity_type: createdEntity.entity_type,
-      },
-    });
-
-    if (relationData) {
-      await entityRelationRepo.save({
-        organization_id: loggedInUser.organization_id,
-        enterprise_id: loggedInUser.enterprise_id,
-        source_entity_id: createdEntity.mapped_entity_id,
-        source_entity_type: createdEntity.mapped_entity_type,
-        target_entity_id: createdEntity.id,
-        target_entity_type: createdEntity.entity_type,
-        relation_type: relationData?.relation_type,
-      });
-    }
-
-    return createdEntity;
-  }
-
-  async updateEntity(
-    entityData,
-    loggedInUser: UserData,
-    appcode?: string,
-  ): Promise<any> {
-    const listRepo = this.reflectionHelper.getRepoService('ListMasterItems');
-    const taskRepo = this.reflectionHelper.getRepoService('TaskDataEntity');
-
-    const statusRows = await listRepo.find({
-      where: {
-        id: entityData.status,
-        enterprise_id: loggedInUser.enterprise_id,
-        listtype: 'TKST',
-      },
-      take: 1,
-    });
-
-    const oldRow = await taskRepo.findOne({
-      where: {
-        id: entityData.id,
-        enterprise_id: loggedInUser.enterprise_id,
-      },
-    });
-
-    const oldStatusRows = oldRow
-      ? await listRepo.find({
-          where: {
-            id: oldRow.status,
-            enterprise_id: loggedInUser.enterprise_id,
-            listtype: 'TKST',
-          },
-          take: 1,
-        })
-      : [];
-
-    const isStatusChanged =
-      statusRows.length > 0 &&
-      oldStatusRows.length > 0 &&
-      statusRows[0].name !== oldStatusRows[0].name;
-
-    const isCompletedStatus =
-      statusRows.length > 0 &&
-      statusRows[0].name?.toLowerCase() === 'completed';
-
-    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 → "1"/"0"
-    if (updatedEntity && typeof updatedEntity['is_mandatory'] === 'boolean') {
-      updatedEntity['is_mandatory'] = updatedEntity['is_mandatory'] ? '1' : '0';
-    }
-
-    // -------------------------------
-    // Logging Activity
-    // -------------------------------
-    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,
-      );
-    }
-
-    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;
-    const taskRepo = this.reflectionHelper.getRepoService('TaskDataEntity');
-
-    const qb = taskRepo
-      .createQueryBuilder('t')
-      .select('t.*')
-      .addSelect('sg.name', 'stage_group_name')
-      .addSelect('s.name', 'stage_name')
-      .addSelect('a.name', 'action_name')
-      .leftJoin('frm_wf_stage', 's', 't.stage_id::text = s.id::text')
-      .leftJoin('frm_wf_stage_group', 'sg', 's.stage_group_id = sg.id')
-      .leftJoin('frm_wf_action', 'a', 't.action_id::text = a.id::text')
-      .where('t.mapped_entity_type = :mapped_entity_type', {
-        mapped_entity_type,
-      })
-      .andWhere('t.mapped_entity_id::text = :mapped_entity_id', {
-        mapped_entity_id: String(mapped_entity_id),
-      });
-
-    // ---------------------------
-    // OPTIONAL FILTERS
-    // ---------------------------
-
-    if (status) {
-      qb.andWhere('t.status::text = :status', { status: String(status) });
-    }
-
-    if (mandatory !== undefined) {
-      qb.andWhere('t.is_mandatory = :mandatory', {
-        mandatory: mandatory,
-      });
-    }
-
-    if (overdue) {
-      qb.andWhere(
-        `
-      (
-        t.due_date < CURRENT_DATE
-        OR (
-          t.due_date = CURRENT_DATE 
-          AND t.due_time::time < CURRENT_TIME
-        )
-      )
-    `,
-      ).andWhere('t.is_done = :is_done', { is_done: false });
-    }
-
-    qb.orderBy('t.created_date', 'DESC');
-
-    const taskData = await qb.getRawMany();
-
-    // ------------------------------------------------
-    // PROFILE IMAGE LOGIC (same as your code)
-    // ------------------------------------------------
-
-    if (taskData?.length) {
-      for (const task of taskData) {
-        try {
-          const baseUrl = this.configService.get<string>('REDIRECT_BE_URL');
-          const queryParams = new URLSearchParams({
-            loggedInUser: JSON.stringify(loggedInUser),
-          }).toString();
-
-          const response = await axios.get(
-            `${baseUrl}/users/profile-image-url/${task.task_owner}?entity_type=USR&${queryParams}`,
-            { headers: { 'Content-Type': 'application/json' } },
-          );
-
-          task.created_by_name = response.data.name;
-          task.task_owner_name = response.data.name;
-          task.task_owner_profile = response.data.profile_image;
-        } catch (err) {
-          console.error('⚠ Error fetching profile:', err.message);
-        }
-      }
-    }
-
-    if (!taskData.length) return [];
-
-    // ------------------------------------------------
-    // STATUS LOOKUP
-    // ------------------------------------------------
-    const listMasterRepo =
-      this.reflectionHelper.getRepoService('ListMasterItems');
-
-    const statuses = await listMasterRepo.find({
-      where: {
-        enterprise_id: loggedInUser.enterprise_id,
-        listtype: 'TKST',
-      },
-      select: ['id', 'name'],
-    });
-
-    const statusMap = new Map(
-      statuses.map((row) => [String(row.id), row.name]),
-    );
-
-    return taskData.map((task) => ({
-      ...task,
-      task_status: statusMap.get(String(task.status)) || null,
-      action_name:
-        task.action_id === '0' || task.action_id === 0
-          ? 'Generic'
-          : task.action_name,
-      is_mandatory: task.is_mandatory,
-    }));
-  }
-
-  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
-    await 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 listMasterItemRepo =
-      this.reflectionHelper.getRepoService('ListMasterItems');
-    const reason = await listMasterItemRepo.findOne({
-      where: {
-        id: entity.reason_code,
-        enterprise_id: loggedInUser.enterprise_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 { ActionHandler } from 'src/module/workflow-automation/interface/action.decorator';
+import * as moment from 'moment';
+import { ConfigService } from '@nestjs/config';
+import axios from 'axios';
+
+@Injectable()
+@ActionHandler('add_task')
+export class TaskService extends EntityServiceImpl {
+  constructor(
+    private readonly taskRepository: TaskRepository,
+    private readonly actionDataService: ActionDataService,
+    @Inject('ActivityLogService')
+    private readonly activityLogService: ActivityLogService,
+    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
+    }
+
+    const entityRelationRepo =
+      this.reflectionHelper.getRepoService('EntityRelationData');
+
+    let relationData = await entityRelationRepo.findOne({
+      where: {
+        source_entity_type: createdEntity.mapped_entity_type,
+        target_entity_type: createdEntity.entity_type,
+      },
+    });
+
+    if (relationData) {
+      await entityRelationRepo.save({
+        organization_id: loggedInUser.organization_id,
+        enterprise_id: loggedInUser.enterprise_id,
+        source_entity_id: createdEntity.mapped_entity_id,
+        source_entity_type: createdEntity.mapped_entity_type,
+        target_entity_id: createdEntity.id,
+        target_entity_type: createdEntity.entity_type,
+        relation_type: relationData?.relation_type,
+      });
+    }
+
+    return createdEntity;
+  }
+
+  async updateEntity(
+    entityData,
+    loggedInUser: UserData,
+    appcode?: string,
+  ): Promise<any> {
+    const listRepo = this.reflectionHelper.getRepoService('ListMasterItems');
+    const taskRepo = this.reflectionHelper.getRepoService('TaskDataEntity');
+
+    const statusRows = await listRepo.find({
+      where: {
+        id: entityData.status,
+        enterprise_id: loggedInUser.enterprise_id,
+        listtype: 'TKST',
+      },
+      take: 1,
+    });
+
+    const oldRow = await taskRepo.findOne({
+      where: {
+        id: entityData.id,
+        enterprise_id: loggedInUser.enterprise_id,
+      },
+    });
+
+    const oldStatusRows = oldRow
+      ? await listRepo.find({
+          where: {
+            id: oldRow.status,
+            enterprise_id: loggedInUser.enterprise_id,
+            listtype: 'TKST',
+          },
+          take: 1,
+        })
+      : [];
+
+    const isStatusChanged =
+      statusRows.length > 0 &&
+      oldStatusRows.length > 0 &&
+      statusRows[0].name !== oldStatusRows[0].name;
+
+    const isCompletedStatus =
+      statusRows.length > 0 &&
+      statusRows[0].name?.toLowerCase() === 'completed';
+
+    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 → "1"/"0"
+    if (updatedEntity && typeof updatedEntity['is_mandatory'] === 'boolean') {
+      updatedEntity['is_mandatory'] = updatedEntity['is_mandatory'] ? '1' : '0';
+    }
+
+    // -------------------------------
+    // Logging Activity
+    // -------------------------------
+    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,
+      );
+    }
+
+    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;
+    const taskRepo = this.reflectionHelper.getRepoService('TaskDataEntity');
+
+    const qb = taskRepo
+      .createQueryBuilder('t')
+      .select('t.*')
+      .addSelect('sg.name', 'stage_group_name')
+      .addSelect('s.name', 'stage_name')
+      .addSelect('a.name', 'action_name')
+      .leftJoin('frm_wf_stage', 's', 't.stage_id::text = s.id::text')
+      .leftJoin('frm_wf_stage_group', 'sg', 's.stage_group_id = sg.id')
+      .leftJoin('frm_wf_action', 'a', 't.action_id::text = a.id::text')
+      .where('t.mapped_entity_type = :mapped_entity_type', {
+        mapped_entity_type,
+      })
+      .andWhere('t.mapped_entity_id::text = :mapped_entity_id', {
+        mapped_entity_id: String(mapped_entity_id),
+      });
+
+    // ---------------------------
+    // OPTIONAL FILTERS
+    // ---------------------------
+
+    if (status) {
+      qb.andWhere('t.status::text = :status', { status: String(status) });
+    }
+
+    if (mandatory !== undefined) {
+      qb.andWhere('t.is_mandatory = :mandatory', {
+        mandatory: mandatory,
+      });
+    }
+
+    if (overdue) {
+      qb.andWhere(
+        `
+      (
+        t.due_date < CURRENT_DATE
+        OR (
+          t.due_date = CURRENT_DATE 
+          AND t.due_time::time < CURRENT_TIME
+        )
+      )
+    `,
+      ).andWhere('t.is_done = :is_done', { is_done: false });
+    }
+
+    qb.orderBy('t.created_date', 'DESC');
+
+    const taskData = await qb.getRawMany();
+
+    // ------------------------------------------------
+    // PROFILE IMAGE LOGIC (same as your code)
+    // ------------------------------------------------
+
+    if (taskData?.length) {
+      for (const task of taskData) {
+        try {
+          const baseUrl = this.configService.get<string>('REDIRECT_BE_URL');
+          const queryParams = new URLSearchParams({
+            loggedInUser: JSON.stringify(loggedInUser),
+          }).toString();
+
+          const response = await axios.get(
+            `${baseUrl}/users/profile-image-url/${task.task_owner}?entity_type=USR&${queryParams}`,
+            { headers: { 'Content-Type': 'application/json' } },
+          );
+
+          task.created_by_name = response.data.name;
+          task.task_owner_name = response.data.name;
+          task.task_owner_profile = response.data.profile_image;
+        } catch (err) {
+          console.error('⚠ Error fetching profile:', err.message);
+        }
+      }
+    }
+
+    if (!taskData.length) return [];
+
+    // ------------------------------------------------
+    // STATUS LOOKUP
+    // ------------------------------------------------
+    const listMasterRepo =
+      this.reflectionHelper.getRepoService('ListMasterItems');
+
+    const statuses = await listMasterRepo.find({
+      where: {
+        enterprise_id: loggedInUser.enterprise_id,
+        listtype: 'TKST',
+      },
+      select: ['id', 'name'],
+    });
+
+    const statusMap = new Map(
+      statuses.map((row) => [String(row.id), row.name]),
+    );
+
+    return taskData.map((task) => ({
+      ...task,
+      task_status: statusMap.get(String(task.status)) || null,
+      action_name:
+        task.action_id === '0' || task.action_id === 0
+          ? 'Generic'
+          : task.action_name,
+      is_mandatory: task.is_mandatory,
+    }));
+  }
+
+  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
+    await 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 listMasterItemRepo =
+      this.reflectionHelper.getRepoService('ListMasterItems');
+    const reason = await listMasterItemRepo.findOne({
+      where: {
+        id: entity.reason_code,
+        enterprise_id: loggedInUser.enterprise_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);
+  }
+}