rez_core 2.2.31 → 2.2.33

package/package.json

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

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

@@ -21,22 +21,14 @@ export class ActionCategoryController {
 
   @Post('/getActionsCategory')
   @HttpCode(HttpStatus.OK)
-  async getActionsCat(
-    @Req() req: Request & { user: any },
-    @Body('entity_type') entity_type: string,
-  ) {
-    const loggedInUser = req.user.userData;
-    const result = this.actionCategoryService.getActionsCat(
-      loggedInUser,
-      entity_type,
-    );
+  async getActionsCat(@Body('entity_type') entity_type: string) {
+    const result = this.actionCategoryService.getActionsCat(entity_type);
     return result;
   }
 
   @Post('/getreasoncode')
   @HttpCode(HttpStatus.OK)
   async getReasonCodeByActionCategoryId(
-    @Req() req: Request & { user: any },
     @Body('action_cat_code') action_cat_code: string,
   ) {
     const result =
@@ -48,15 +40,8 @@ export class ActionCategoryController {
 
   @Post('/getactioncategorydata')
   @HttpCode(HttpStatus.OK)
-  async getActionCategory(
-    @Req() req: Request & { user: any },
-    @Body('action_cat_id') action_cat_id: number,
-  ) {
-    const loggedInUser = req.user.userData;
-    const result = this.actionCategoryService.getActionCategory(
-      loggedInUser,
-      action_cat_id,
-    );
+  async getActionCategory(@Body('action_cat_id') action_cat_id: number) {
+    const result = this.actionCategoryService.getActionCategory(action_cat_id);
     return result;
   }
 }

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

@@ -54,4 +54,22 @@ export class TaskController {
     const result = this.taskService.moveTask(loggedInUser, body);
     return result;
   }
+
+  @Post('/listing')
+  @HttpCode(HttpStatus.OK)
+  async getAllTask(
+    @Req() req: Request & { user: any },
+    @Body()
+    body: {
+      mapped_entity_type: string;
+      mapped_entity_id: number;
+      status?: string;
+      mandatory?: boolean;
+      overdue?: boolean;
+    },
+  ) {
+    const loggedInUser = req.user.userData;
+    const result = this.taskService.getAllTask(loggedInUser, body);
+    return result;
+  }
 }

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

@@ -53,7 +53,7 @@ export class TaskDataEntity extends BaseEntity {
   @Column({ nullable: true })
   task_owner: string;
 
-  @Column({ nullable: true, type: 'varchar' })
+  @Column({ nullable: true })
   due_date: Date;
 
   @Column({ nullable: true, type: 'varchar' })

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

@@ -0,0 +1,56 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { ActionCategory } from '../entity/action-category.entity';
+import { UserData } from 'src/module/user/entity/user.entity';
+
+@Injectable()
+export class ActionCategoryRepository {
+  constructor(
+    @InjectRepository(ActionCategory)
+    private readonly actionCategoryRepository: Repository<ActionCategory>,
+  ) {}
+
+  async getActionsCat(entity_type: string) {
+    const result = await this.actionCategoryRepository
+      .createQueryBuilder('ac')
+      .select(['ac.id', 'ac.name'])
+      .where('ac.mapped_entity_type = :entityType', { entityType: entity_type })
+      .getRawMany();
+
+    return result.map((row) => ({
+      label: row.ac_name,
+      value: String(row.ac_id),
+    }));
+  }
+
+  async getReasonCodeByActionCategoryId(action_cat_code: string) {
+    const result = await this.actionCategoryRepository
+      .createQueryBuilder('ac')
+      .select(['ac.id', 'ac.reason_code'])
+      .where('ac.code = :code', { code: action_cat_code })
+      .getOne();
+
+    if (!result || !result.reason_code) {
+      return {
+        success: false,
+        value: null,
+      };
+    }
+
+    return {
+      success: true,
+      value: result.reason_code,
+    };
+  }
+
+  async getActionCategory(action_cat_id: number) {
+    const result = await this.actionCategoryRepository
+      .createQueryBuilder('ac')
+      .select(['ac.*'])
+      .where('ac.id = :id', { id: action_cat_id })
+      .getRawMany();
+
+    return result;
+  }
+}

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

@@ -7,6 +7,7 @@ import {
 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 {
@@ -16,6 +17,156 @@ export class ActionRepository {
     private readonly dataSource: DataSource,
   ) {}
 
+  async getReasonCode(loggedInUser: UserData): Promise<any> {
+    const { organization_id } = loggedInUser;
+    const result = await this.dataSource.query(
+      `
+       SELECT name, type
+       FROM cr_list_master
+       WHERE organization_id = ? AND source = 'master'
+       `,
+      [organization_id],
+    );
+
+    const formatted = result.map((item: any) => ({
+      label: item.name,
+      value: item.type,
+    }));
+
+    return formatted;
+  }
+
+  async defaultReasonCode(list_type: string, loggedInUser: UserData) {
+    const { organization_id } = loggedInUser;
+    if (!list_type) {
+      throw new BadRequestException('list_type is required');
+    }
+    const result = await this.dataSource.query(
+      `
+    SELECT name, id 
+    FROM cr_list_master_items 
+    WHERE listtype = ? AND organization_id = ?
+    `,
+      [list_type, organization_id],
+    );
+
+    // Format as array of key-value pairs
+    return result.map((row: any) => ({
+      label: row.name,
+      value: row.id,
+    }));
+  }
+
+  async getActions(loggedInUser: UserData, stage_id: number) {
+    const { organization_id } = loggedInUser;
+
+    // Step 1: Get all action_ids for the provided stage_id
+    const stageActions = await this.dataSource.query(
+      `
+    SELECT id, action_id 
+    FROM cr_wf_stage_action_mapping 
+    WHERE stage_id = ?
+    `,
+      [stage_id],
+    );
+
+    if (!stageActions?.length) return [];
+
+    const actionIds = stageActions.map((sa) => sa.action_id);
+    const mappingIds = stageActions.map((sa) => sa.id);
+
+    // Step 2: Get template codes with mapping IDs
+    const templateMappings = await this.dataSource.query(
+      `
+    SELECT stg_act_mapping_id, template_code 
+    FROM cr_wf_action_template_mapping 
+    WHERE stg_act_mapping_id IN (${mappingIds.map(() => '?').join(',')})
+    `,
+      mappingIds,
+    );
+
+    const templateCodes = templateMappings.map((tm) => tm.template_code);
+
+    // Step 3: Fetch template names from cr_wf_comm_template
+    const templateCodeToName: Record<string, string> = {};
+
+    if (templateCodes.length > 0) {
+      const templates = await this.dataSource
+        .createQueryBuilder()
+        .select(['t.code AS code', 't.name AS name'])
+        .from('cr_wf_comm_template', 't')
+        .where('t.code IN (:...codes)', { codes: templateCodes })
+        .andWhere('t.organization_id = :orgId', { orgId: organization_id })
+        .getRawMany();
+
+      templates.forEach((tpl) => {
+        templateCodeToName[tpl.code] = tpl.name;
+      });
+    }
+
+    // Step 4: Build map of mapping_id → template names
+    const mappingIdToTemplates: Record<number, string[]> = {};
+
+    for (const tm of templateMappings) {
+      const mappingId = tm.stg_act_mapping_id;
+      const name = templateCodeToName[tm.template_code];
+      if (name) {
+        if (!mappingIdToTemplates[mappingId]) {
+          mappingIdToTemplates[mappingId] = [];
+        }
+        mappingIdToTemplates[mappingId].push(name);
+      }
+    }
+
+    // Step 5: Build action_id → template names using mappingIdToTemplates + stageActions
+    const actionIdToTemplates: Record<number, string[]> = {};
+
+    for (const sa of stageActions) {
+      const mappingId = sa.id;
+      const templates = mappingIdToTemplates[mappingId];
+      if (templates?.length) {
+        if (!actionIdToTemplates[sa.action_id]) {
+          actionIdToTemplates[sa.action_id] = [];
+        }
+        actionIdToTemplates[sa.action_id].push(...templates);
+      }
+    }
+
+    // Step 6: Fetch action details
+    const actionResults = await this.dataSource
+      .createQueryBuilder()
+      .select([
+        'a.*',
+        'ac.name AS action_category',
+        'ar.name AS action_requirement',
+      ])
+      .from('cr_wf_action', 'a')
+      .leftJoin('cr_wf_action_category', 'ac', 'ac.id = a.action_category')
+      .leftJoin(
+        'cr_list_master_items',
+        'ar',
+        `ar.id = a.action_requirement AND ar.listtype = 'ACRQ' AND ar.organization_id = :orgId`,
+        { orgId: organization_id },
+      )
+      .where('a.organization_id = :orgId', { orgId: organization_id })
+      .andWhere('a.id IN (:...actionIds)', { actionIds })
+      .getRawMany();
+
+    // Step 7: Enrich result with template field
+    const enrichedResult = actionResults.map((row) => {
+      const actionId = Number(row.id); // Ensure numeric ID match
+      const templates = actionIdToTemplates[actionId] || [];
+      const uniqueTemplates = [...new Set(templates)]; // remove duplicates
+
+      return {
+        ...row,
+        template: uniqueTemplates.join(', '),
+      };
+    });
+
+    return enrichedResult;
+  }
+
   async getAction(
     organization_id: number,
     stage_id: number,

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

@@ -2,59 +2,28 @@ 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 { ActionCategoryRepository } from '../repository/action-category.repository';
 
 @Injectable()
 export class ActionCategoryService extends EntityServiceImpl {
-  constructor(private readonly dataSource: DataSource) {
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly actionCategoryRepository: ActionCategoryRepository,
+  ) {
     super();
   }
 
-  async getActionsCat(loggedInUser: UserData, entity_type: string) {
-    const { organization_id } = loggedInUser;
-
-    console.log(entity_type, 'entity_type in action category service');
-
-    const result = await this.dataSource.query(
-      `
-    SELECT id, name 
-    FROM cr_wf_action_category 
-    WHERE mapped_entity_type = ?`,
-      [entity_type],
-    );
-
-    return result.map((row: any) => ({
-      label: row.name,
-      value: row.id,
-    }));
+  async getActionsCat(entity_type: string) {
+    return this.actionCategoryRepository.getActionsCat(entity_type);
   }
 
   async getReasonCodeByActionCategoryId(action_cat_code: string) {
-    const result = await this.dataSource.query(
-      `
-      SELECT id, reason_code
-      FROM cr_wf_action_category
-      WHERE code = ?
-      `,
-      [action_cat_code],
+    return this.actionCategoryRepository.getReasonCodeByActionCategoryId(
+      action_cat_code,
     );
-
-    return {
-      success: true,
-      value: result?.[0]?.reason_code || null,
-    };
   }
 
-  async getActionCategory(loggedInUser: UserData, action_cat_id: number) {
-    const { organization_id } = loggedInUser;
-    const result = await this.dataSource.query(
-      `
-      SELECT *
-      FROM cr_wf_action_category
-      WHERE id = ?
-      `,
-      [action_cat_id],
-    );
-
-    return result;
+  async getActionCategory(action_cat_id: number) {
+    return this.actionCategoryRepository.getActionCategory(action_cat_id);
   }
 }

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

@@ -215,153 +215,15 @@ export class ActionService extends EntityServiceImpl {
   }
 
   async getReasonCode(loggedInUser: UserData): Promise<any> {
-    const { organization_id } = loggedInUser;
-    const result = await this.dataSource.query(
-      `
-      SELECT name, type
-      FROM cr_list_master
-      WHERE organization_id = ? AND source = 'master'
-      `,
-      [organization_id],
-    );
-
-    const formatted = result.map((item: any) => ({
-      label: item.name,
-      value: item.type,
-    }));
-
-    return formatted;
+    return this.actionRepository.getReasonCode(loggedInUser);
   }
 
   async defaultReasonCode(list_type: string, loggedInUser: UserData) {
-    const { organization_id } = loggedInUser;
-    if (!list_type) {
-      throw new BadRequestException('list_type is required');
-    }
-    const result = await this.dataSource.query(
-      `
-    SELECT name, id 
-    FROM cr_list_master_items 
-    WHERE listtype = ? AND organization_id = ?
-    `,
-      [list_type, organization_id],
-    );
-
-    // Format as array of key-value pairs
-    return result.map((row: any) => ({
-      label: row.name,
-      value: row.id,
-    }));
+    return this.actionRepository.defaultReasonCode(list_type, loggedInUser);
   }
 
   async getActions(loggedInUser: UserData, stage_id: number) {
-    const { organization_id } = loggedInUser;
-
-    // Step 1: Get all action_ids for the provided stage_id
-    const stageActions = await this.dataSource.query(
-      `
-    SELECT id, action_id 
-    FROM cr_wf_stage_action_mapping 
-    WHERE stage_id = ?
-    `,
-      [stage_id],
-    );
-
-    if (!stageActions?.length) return [];
-
-    const actionIds = stageActions.map((sa) => sa.action_id);
-    const mappingIds = stageActions.map((sa) => sa.id);
-
-    // Step 2: Get template codes with mapping IDs
-    const templateMappings = await this.dataSource.query(
-      `
-    SELECT stg_act_mapping_id, template_code 
-    FROM cr_wf_action_template_mapping 
-    WHERE stg_act_mapping_id IN (${mappingIds.map(() => '?').join(',')})
-    `,
-      mappingIds,
-    );
-
-    const templateCodes = templateMappings.map((tm) => tm.template_code);
-
-    // Step 3: Fetch template names from cr_wf_comm_template
-    const templateCodeToName: Record<string, string> = {};
-
-    if (templateCodes.length > 0) {
-      const templates = await this.dataSource
-        .createQueryBuilder()
-        .select(['t.code AS code', 't.name AS name'])
-        .from('cr_wf_comm_template', 't')
-        .where('t.code IN (:...codes)', { codes: templateCodes })
-        .andWhere('t.organization_id = :orgId', { orgId: organization_id })
-        .getRawMany();
-
-      templates.forEach((tpl) => {
-        templateCodeToName[tpl.code] = tpl.name;
-      });
-    }
-
-    // Step 4: Build map of mapping_id → template names
-    const mappingIdToTemplates: Record<number, string[]> = {};
-
-    for (const tm of templateMappings) {
-      const mappingId = tm.stg_act_mapping_id;
-      const name = templateCodeToName[tm.template_code];
-      if (name) {
-        if (!mappingIdToTemplates[mappingId]) {
-          mappingIdToTemplates[mappingId] = [];
-        }
-        mappingIdToTemplates[mappingId].push(name);
-      }
-    }
-
-    // Step 5: Build action_id → template names using mappingIdToTemplates + stageActions
-    const actionIdToTemplates: Record<number, string[]> = {};
-
-    for (const sa of stageActions) {
-      const mappingId = sa.id;
-      const templates = mappingIdToTemplates[mappingId];
-      if (templates?.length) {
-        if (!actionIdToTemplates[sa.action_id]) {
-          actionIdToTemplates[sa.action_id] = [];
-        }
-        actionIdToTemplates[sa.action_id].push(...templates);
-      }
-    }
-
-    // Step 6: Fetch action details
-    const actionResults = await this.dataSource
-      .createQueryBuilder()
-      .select([
-        'a.*',
-        'ac.name AS action_category',
-        'ar.name AS action_requirement',
-      ])
-      .from('cr_wf_action', 'a')
-      .leftJoin('cr_wf_action_category', 'ac', 'ac.id = a.action_category')
-      .leftJoin(
-        'cr_list_master_items',
-        'ar',
-        `ar.id = a.action_requirement AND ar.listtype = 'ACRQ' AND ar.organization_id = :orgId`,
-        { orgId: organization_id },
-      )
-      .where('a.organization_id = :orgId', { orgId: organization_id })
-      .andWhere('a.id IN (:...actionIds)', { actionIds })
-      .getRawMany();
-
-    // Step 7: Enrich result with template field
-    const enrichedResult = actionResults.map((row) => {
-      const actionId = Number(row.id); // Ensure numeric ID match
-      const templates = actionIdToTemplates[actionId] || [];
-      const uniqueTemplates = [...new Set(templates)]; // remove duplicates
-
-      return {
-        ...row,
-        template: uniqueTemplates.join(', '),
-      };
-    });
-
-    return enrichedResult;
+    return this.actionRepository.getActions(loggedInUser, stage_id);
   }
 
   async getAction(

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

@@ -3,12 +3,14 @@ import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.s
 import { UserData } from 'src/module/user/entity/user.entity';
 import { TaskRepository } from '../repository/task.repository';
 import { ActionDataService } from './action-data.service';
+import { DataSource } from 'typeorm';
 
 @Injectable()
 export class TaskService extends EntityServiceImpl {
   constructor(
     private readonly taskRepository: TaskRepository,
     private readonly actionDataService: ActionDataService,
+    private readonly dataSource: DataSource,
   ) {
     super();
   }
@@ -40,6 +42,60 @@ export class TaskService extends EntityServiceImpl {
     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 cr_wf_task_data t
+    LEFT JOIN cr_wf_stage s ON t.stage_id = s.id
+    LEFT JOIN cr_wf_stage_group sg ON s.stage_group_id = sg.id
+    LEFT JOIN cr_wf_action a ON t.action_id = a.id
+    WHERE ${whereClauses.join(' AND ')}
+    ORDER BY t.due_date ASC, t.due_time ASC
+  `;
+
+    const taskData = await this.dataSource.query(sql, params);
+
+    return taskData;
+  }
+
   async getEntityData(entityType: string, id: number, loggedInUser: any) {
     const taskData = await super.getEntityData(entityType, id, loggedInUser);
 
@@ -92,4 +148,28 @@ export class TaskService extends EntityServiceImpl {
 
     return 'Task moved successfully';
   }
+
+  async deleteEntity(
+    entity_type: string,
+    taskId,
+    loggedInUser: UserData,
+  ): Promise<any> {
+    // Logic to delete a task by its ID
+    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 using is_system flag
+    if (task.is_system) {
+      throw new Error('Cannot delete system-generated tasks');
+    }
+
+    // Perform the deletion
+    await super.deleteEntity(entity_type, taskId, loggedInUser);
+  }
 }

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

@@ -56,6 +56,7 @@ import { FormMasterRepository } from './repository/form-master.repository';
 import { ActionResourcesMapping } from './entity/action-resources-mapping.entity';
 import { ActionResourcesMappingService } from './service/action-resources-mapping.service';
 import { ActionResourcesMappingController } from './controller/action-resource-mapping.controller';
+import { ActionCategoryRepository } from './repository/action-category.repository';
 
 @Module({
   imports: [
@@ -117,6 +118,7 @@ import { ActionResourcesMappingController } from './controller/action-resource-m
     ActionDataRepository,
     ActionDataService,
     FormMasterRepository,
+    ActionCategoryRepository,
   ],
   exports: [
     'ActionCategoryService',
@@ -128,11 +130,13 @@ import { ActionResourcesMappingController } from './controller/action-resource-m
     'EntityModificationService',
     'FormMasterService',
     'ActionResourcesMappingService',
+    'TaskService',
     WorkflowRepository,
     StageGroupRepository,
     StageRepository,
     WorkflowMetaService,
     PopulateWorkflowService,
+    ActionCategoryRepository,
   ],
   controllers: [
     WorkflowListMasterController,