rez_core 2.2.148 → 2.2.150

package/package.json

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

package/src/module/meta/controller/view-master.controller.ts

@@ -1,3 +1,4 @@
+import { log } from 'console';
 import {
   Controller,
   Get,
@@ -24,7 +25,10 @@ export class ViewMasterController {
     @Query('entity_type') entityType: string,
     @Query('type') type: string,
     @Res() res: Response,
+    @Req() req: Request & { user: any },
   ) {
+    const loggedInUser = req.user.userData;
+
     try {
       if (!entityType || !type) {
         return res.status(HttpStatus.BAD_REQUEST).json({

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

@@ -32,4 +32,7 @@ export class ActionEntity extends BaseEntity {
 
   @Column({ nullable: true })
   user_id: number;
+
+  @Column({ type: 'varchar', nullable: true })
+  assignment_type: string;
 }

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

@@ -189,7 +189,7 @@ export class StageMovementRepository {
       ac.code AS action_category_code,
       arm.form_id
     FROM cr_wf_action a
-    INNER JOIN cr_wf_stage_action_mapping m ON a.id = m.action_id
+    LEFT JOIN cr_wf_stage_action_mapping m ON a.id = m.action_id
     LEFT JOIN cr_wf_action_category ac ON a.action_category = ac.id
     LEFT JOIN cr_wf_action_resources_mapping arm ON m.id = arm.stg_act_mapping_id
     WHERE m.stage_id = ?

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

@@ -341,11 +341,11 @@ export class TaskService extends EntityServiceImpl {
       body.action_id,
     );
 
-    if (body.reason_code && body.remark) {
+    if (body.reason_code || body.remark) {
       await this.createSystemNote(
         {
-          reason_code: body.reason_code,
-          remark: body.remark,
+          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,

package/src/module/workflow/service/workflow-meta.service.ts

@@ -10,6 +10,7 @@ import { ActionDataService } from './action-data.service';
 import { TaskService } from './task.service';
 import { ACTIVITY_CATEGORIES } from '../repository/activity-log.repository';
 import { ActivityLogService } from './activity-log.service';
+import { EntityModificationService } from './entity-modification.service';
 
 @Injectable()
 export class WorkflowMetaService extends EntityServiceImpl {
@@ -23,6 +24,8 @@ export class WorkflowMetaService extends EntityServiceImpl {
     private readonly taskService: TaskService,
     @Inject('ActivityLogService')
     private readonly activityLogService: ActivityLogService,
+    @Inject('EntityModificationService')
+    private readonly modificationService: EntityModificationService,
   ) {
     super();
   }
@@ -151,6 +154,18 @@ export class WorkflowMetaService extends EntityServiceImpl {
         mapped_entity_type,
       );
 
+      await this.taskService.createSystemNote(
+        {
+          reason_code: firstStage.reason_code,
+          remark: firstStage.remark,
+          mapped_entity_id,
+          stage_id: firstStage.id,
+          action_id: firstStage.id,
+          stage_group_id: stageGroup.id,
+        },
+        loggedInUser,
+      );
+
       return `Initialized workflow with first stage (Stage ID: ${firstStage.id}).`;
     }
 
@@ -257,6 +272,16 @@ export class WorkflowMetaService extends EntityServiceImpl {
       return 'No actions found for this stage.';
     }
 
+    // check whether first action's action_category is owner_assignment and assignment_type is AUTO_ASSIGN
+    const firstAction = actions[0];
+    let actionCategory = await this.dataSource.query(
+      `SELECT code FROM cr_wf_action_category WHERE id = ${Number(firstAction.action_category)}`,
+    );
+
+    let assignmentType = await this.dataSource.query(
+      `SELECT value FROM cr_list_master_items WHERE id = ${Number(firstAction.assignment_type)}`,
+    );
+
     // save in action data
     await this.actionDataService.saveActionData(
       actions,
@@ -272,5 +297,266 @@ export class WorkflowMetaService extends EntityServiceImpl {
       mapped_entity_id,
       mapped_entity_type,
     );
+
+    if (
+      actionCategory[0]?.code == 'OWAS' &&
+      assignmentType[0]?.value == 'round_robin'
+    ) {
+      console.log('Auto-assigning owner based on round-robin assignment type');
+      await this.assignLead(
+        loggedInUser,
+        mapped_entity_id,
+        mapped_entity_type,
+        stage_id,
+        actions,
+      );
+    }
+  }
+
+  async updateLeadOwner(entityData, loggedInUser) {
+    let { lead_id, lead_owner, stage_id, entity_type } = entityData;
+    let updatedData = {
+      id: lead_id,
+      lead_owner: lead_owner,
+      entity_type: entity_type,
+    };
+    entityData = updatedData;
+
+    this.modificationService.logModification(
+      {
+        entity_type: 'ENMD',
+        mapped_entity_type: entity_type,
+        mapped_entity_id: lead_id,
+        attribute_key: 'lead_owner',
+        new_value: lead_owner,
+        old_value: entityData.lead_owner,
+        remarks: entityData.remarks,
+        reason_code: entityData.reason_code,
+        stage_id: stage_id,
+        action_id: entityData.action_id,
+      },
+      loggedInUser,
+    );
+
+    const leadData: any = await this.getEntityData(
+      'LEAD',
+      lead_id,
+      loggedInUser,
+    );
+
+    const unassignedListMasterItemData = await this.dataSource.query(
+      `SELECT name, id 
+   FROM cr_list_master_items 
+   WHERE listtype = "LEST" AND organization_id = ? 
+     AND value IN (?, ?)`,
+      [loggedInUser.organization_id, 'unassigned', 'active'],
+    );
+
+    // Find the IDs explicitly
+    const unassignedId = unassignedListMasterItemData.find(
+      (item) => item.name.toLowerCase() === 'unassigned',
+    )?.id;
+
+    const activeId = unassignedListMasterItemData.find(
+      (item) => item.name.toLowerCase() === 'active',
+    )?.id;
+
+    // Use unassignedId for comparison
+    if (leadData?.lead_status === unassignedId) {
+      leadData.lead_status = activeId;
+    }
+
+    const result = await super.updateEntity(
+      {
+        ...entityData,
+        status: leadData?.lead_status,
+        lead_status: leadData?.lead_status,
+      },
+      loggedInUser,
+    );
+
+    await this.dataSource.query(
+      `UPDATE cr_wf_action_data SET user_id =? 
+      WHERE mapped_entity_id=?
+      AND mapped_entity_type = ?
+      AND stage_id = ?
+      AND (is_current = 'Y' OR is_current IS NULL)
+      `,
+      [lead_owner, lead_id, entity_type, stage_id],
+    );
+
+    await this.dataSource.query(
+      `UPDATE cr_lead_meeting SET user_id=?
+      WHERE stage_id = ? 
+      AND lead_id = ? 
+      AND (status='scheduled' OR status='rescheduled')
+      `,
+      [lead_owner, stage_id, lead_id],
+    );
+
+    const taskRows = await this.dataSource.query(
+      `SELECT id,status FROM cr_wf_task_data
+      WHERE mapped_entity_id = ?
+      AND mapped_entity_type = ?
+      AND stage_id = ?`,
+      [lead_id, entity_type, stage_id],
+    );
+
+    for (const task of taskRows) {
+      const statusRows = await this.dataSource.query(
+        `SELECT value FROM cr_list_master_items
+        WHERE id = ? AND organization_id = ?`,
+        [task.status, loggedInUser.organization_id],
+      );
+
+      const statusName = statusRows[0]?.value?.toLowerCase() || '';
+      if (
+        ['todo', 'in_progress'].includes(statusName) ||
+        statusName === 'todo'
+      ) {
+        await this.dataSource.query(
+          `UPDATE cr_wf_task_data SET user_id = ?, task_owner = ? WHERE id  = ?`,
+          [lead_owner, lead_owner, task.id],
+        );
+      }
+    }
+
+    const leadOwnerName = await this.dataSource.query(
+      `SELECT name FROM cr_user WHERE id = ?`,
+      [entityData?.lead_owner],
+    );
+
+    try {
+      const logData = {
+        mapped_entity_id: lead_id,
+        mapped_entity_type: 'LEAD',
+        title: 'Owner Assigned',
+        description: leadData?.lead_owner
+          ? `${leadOwnerName[0]?.name} reassigned as Lead owner.`
+          : `${leadOwnerName[0]?.name} assigned as Lead owner.`,
+        action: 'assign',
+        category: ACTIVITY_CATEGORIES.ASSIGN,
+        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
+    }
+    return result;
+  }
+
+  async assignLead(
+    loggedInUser: UserData,
+    mapped_entity_id: number,
+    mapped_entity_type: string,
+    stage_id: number,
+    actions: any[],
+  ): Promise<number> {
+    const { organization_id, level_id, level_type } = loggedInUser;
+
+    // 1) Get eligible owners (distinct + stable ordering)
+    const owners: Array<{ id: number }> = await this.dataSource.query(
+      `
+    SELECT DISTINCT u.id
+    FROM cr_user u
+    JOIN cr_user_role_mapping urm   ON u.id = urm.user_id
+    JOIN cr_role r                  ON urm.role_id = r.id
+    JOIN cr_module_access ma        ON ma.role_code = r.code
+    WHERE urm.organization_id = ?
+      AND urm.level_id = ?
+      AND urm.level_type = ?
+      AND urm.appcode = 'CRM'
+      AND ma.appcode = 'CRM'
+      AND ma.module_code = 'lead_crm_sch'
+      AND ma.access_flag = 1
+      AND ma.action_type = 'LEAD_OWNER'
+    ORDER BY u.id ASC
+    `,
+      [organization_id, Number(level_id), level_type],
+    );
+
+    if (!owners?.length) throw new Error('No eligible users found');
+    const userIds = owners.map((o) => Number(o.id)); // normalize to numbers
+
+    // 2) Find the last assigned *eligible* owner (use IN (...))
+    const placeholders = userIds.map(() => '?').join(',');
+    const lastRow: Array<{ lead_owner: number }> = await this.dataSource.query(
+      `
+    SELECT lead_owner
+    FROM crm_lead
+    WHERE organization_id = ?
+      AND level_id = ?
+      AND level_type = ?
+      AND lead_owner IN (${placeholders})
+    ORDER BY created_date DESC
+    LIMIT 1
+    `,
+      [organization_id, Number(level_id), level_type, ...userIds],
+    );
+
+    const lastAssigned = lastRow.length ? Number(lastRow[0].lead_owner) : null;
+
+    // 3) Compute next user in round-robin
+    const lastIdx = lastAssigned != null ? userIds.indexOf(lastAssigned) : -1;
+    const nextIdx = (lastIdx + 1) % userIds.length;
+    const nextUser = userIds[nextIdx];
+
+    //4) Update lead owner in the lead table
+    await this.dataSource.query(
+      `
+    UPDATE crm_lead
+    SET lead_owner = ?
+    WHERE organization_id = ?
+      AND level_id = ?
+      AND level_type = ?
+      AND lead_owner IS NULL
+    ORDER BY created_date ASC
+    LIMIT 1
+    `,
+      [nextUser, organization_id, Number(level_id), level_type],
+    );
+
+    console.log(`Assigning lead to user ID: ${nextUser}`);
+
+    const firstAction = actions[0];
+
+    // move task
+    await this.taskService.moveTask(loggedInUser, {
+      mapped_entity_type,
+      mapped_entity_id,
+      stage_id,
+      action_id: firstAction.id,
+    });
+
+    // if it has only one action then move next stage
+    if (actions.length == 1) {
+      console.log(
+        'Only one action present and it is owner assignment. Moving to next stage.',
+      );
+      await this.moveToNextStage(
+        mapped_entity_type,
+        mapped_entity_id,
+        loggedInUser,
+      );
+    }
+
+    // update lead owner status
+    await this.updateLeadOwner(
+      {
+        lead_id: mapped_entity_id,
+        lead_owner: nextUser,
+        stage_id: stage_id,
+        entity_type: mapped_entity_type,
+        action_id: firstAction.id,
+      },
+      loggedInUser,
+    );
+
+    return nextUser;
   }
 }