rez_core 2.2.149 → 2.2.151

package/package.json

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

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

@@ -26,4 +26,7 @@ export class ActionCategory extends BaseEntity {
 
   @Column({ type: 'boolean', nullable: true })
   is_form: boolean;
+
+  @Column({ type: 'boolean', nullable: true })
+  is_assignment: boolean;
 }

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}).`;
     }
 
@@ -266,13 +281,6 @@ export class WorkflowMetaService extends EntityServiceImpl {
     let assignmentType = await this.dataSource.query(
       `SELECT value FROM cr_list_master_items WHERE id = ${Number(firstAction.assignment_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);
-    }
 
     // save in action data
     await this.actionDataService.saveActionData(
@@ -295,30 +303,160 @@ export class WorkflowMetaService extends EntityServiceImpl {
       assignmentType[0]?.value == 'round_robin'
     ) {
       console.log('Auto-assigning owner based on round-robin assignment type');
-      await this.assignLead(loggedInUser);
-      // move task
-      await this.taskService.moveTask(loggedInUser, {
-        mapped_entity_type,
+      await this.assignLead(
+        loggedInUser,
         mapped_entity_id,
+        mapped_entity_type,
         stage_id,
-        action_id: firstAction.id,
-      });
+        actions,
+      );
+    }
+  }
 
-      // 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,
+  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): Promise<number> {
+  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)
@@ -384,6 +522,41 @@ export class WorkflowMetaService extends EntityServiceImpl {
     );
 
     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;
   }
 }

package/.vscode/extensions.json

@@ -1,5 +0,0 @@
-{
-    "recommendations": [
-        "dbaeumer.vscode-eslint"
-    ]
-}