rez_core 2.2.146 → 2.2.147

package/package.json

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

package/src/module/meta/service/entity-dynamic.service.ts

@@ -17,7 +17,6 @@ export class EntityDynamicService {
     entityData: Record<string, any>,
     loggedInUser: any,
   ): Promise<any> {
-    
     const organizationId = loggedInUser.organization_id;
 
     const tableName = await this.getTableName(entityType, organizationId);
@@ -42,7 +41,7 @@ export class EntityDynamicService {
         entityData.level_type = loggedInUser.level_type;
       if (!entityData.level_id) entityData.level_id = loggedInUser.level_id;
       if (!entityData.status) entityData.status = statusList[0].id;
-      if( !entityData.entity_type ) entityData.entity_type = entityType;
+      if (!entityData.entity_type) entityData.entity_type = entityType;
     }
 
     if (!entityData.code && loggedInUser) {
@@ -92,76 +91,76 @@ export class EntityDynamicService {
 
   // ----------------------------- get entity with relations
 
-// ----------------------------- create entity with relations
-async createEntityWithRelation(
-  entityType: string,
-  data: Record<string, any>,
-  loggedInUser: any,
-): Promise<any> {
-  const organizationId = loggedInUser.organization_id;
-
-  const getRelation = await this.dataSource.query(
-    `SELECT * FROM cr_entity_relation WHERE organization_id = ? AND source_entity_type = ?`,
-    [organizationId, entityType],
-  );
-
-  const { mappedEntities, ...mainData } = data;
-
-  // create main entity
-  const createdEntityData = await this.createEntity(
-    entityType,
-    mainData,
-    loggedInUser,
-  );
-  const mainID = createdEntityData.insertId || createdEntityData.id;
-
-  if (mappedEntities && getRelation.length > 0) {
-    for (const relation of getRelation) {
-      const targetEntityType = relation.target_entity_type;
-      const relationType = relation.relation_type;
-      const relationId = relation.relation_id;
-
-      if (!mappedEntities[targetEntityType]) continue;
-
-      // normalize: always array
-      const entityDataArray = Array.isArray(mappedEntities[targetEntityType])
-        ? mappedEntities[targetEntityType]
-        : [mappedEntities[targetEntityType]];
-
-      for (const item of entityDataArray) {
-        const itemWithRef = {
-          ...item,
-          entity_type: targetEntityType,
-        };
-
-        const createdRelatedEntity = await this.createEntity(
-          targetEntityType,
-          itemWithRef,
-          loggedInUser,
-        );
+  // ----------------------------- create entity with relations
+  async createEntityWithRelation(
+    entityType: string,
+    data: Record<string, any>,
+    loggedInUser: any,
+  ): Promise<any> {
+    const organizationId = loggedInUser.organization_id;
+
+    const getRelation = await this.dataSource.query(
+      `SELECT * FROM cr_entity_relation WHERE organization_id = ? AND source_entity_type = ?`,
+      [organizationId, entityType],
+    );
+
+    const { mappedEntities, ...mainData } = data;
 
-        await this.dataSource.query(
-          `INSERT INTO cr_entity_relation_data (source_entity_id, source_entity_type, target_entity_id, target_entity_type, relation_type) VALUES (?, ?, ?, ?, ?)`,
-          [
-            mainID,
-            entityType,
-            createdRelatedEntity.insertId,
+    // create main entity
+    const createdEntityData = await this.createEntity(
+      entityType,
+      mainData,
+      loggedInUser,
+    );
+    const mainID = createdEntityData.insertId || createdEntityData.id;
+
+    if (mappedEntities && getRelation.length > 0) {
+      for (const relation of getRelation) {
+        const targetEntityType = relation.target_entity_type;
+        const relationType = relation.relation_type;
+        const relationId = relation.relation_id;
+
+        if (!mappedEntities[targetEntityType]) continue;
+
+        // normalize: always array
+        const entityDataArray = Array.isArray(mappedEntities[targetEntityType])
+          ? mappedEntities[targetEntityType]
+          : [mappedEntities[targetEntityType]];
+
+        for (const item of entityDataArray) {
+          const itemWithRef = {
+            ...item,
+            entity_type: targetEntityType,
+          };
+
+          const createdRelatedEntity = await this.createEntity(
             targetEntityType,
-            relationType,
-          ],
-        );
+            itemWithRef,
+            loggedInUser,
+          );
+
+          await this.dataSource.query(
+            `INSERT INTO cr_entity_relation_data (source_entity_id, source_entity_type, target_entity_id, target_entity_type, relation_type) VALUES (?, ?, ?, ?, ?)`,
+            [
+              mainID,
+              entityType,
+              createdRelatedEntity.insertId,
+              targetEntityType,
+              relationType,
+            ],
+          );
+        }
       }
     }
-  }
 
-  return {
-    mainEntity: {
-      id: mainID,
-      entityType,
-      data: createdEntityData,
-    },
-  };
-}
+    return {
+      mainEntity: {
+        id: mainID,
+        entityType,
+        data: createdEntityData,
+      },
+    };
+  }
 
   // ----------------------------- get entity with relations
   async getEntityWithRelation(
@@ -193,132 +192,164 @@ async createEntityWithRelation(
     return response;
   }
 
-// ----------------------------- formatMappedEntities
-async formatMappedEntities(
-  relatedEntities: any[],
-  loggedInUser: any,
-): Promise<any> {
-  const mappedEntities: any = {};
+  // ----------------------------- formatMappedEntities
+  async formatMappedEntities(
+    relatedEntities: any[],
+    loggedInUser: any,
+  ): Promise<any> {
+    const mappedEntities: any = {};
 
-  for (const relation of relatedEntities) {
-    const targetEntityType = relation.target_entity_type;
-    const targetEntityId = relation.target_entity_id;
+    for (const relation of relatedEntities) {
+      const targetEntityType = relation.target_entity_type;
+      const targetEntityId = relation.target_entity_id;
 
-    const entityData = await this.getEntity(
-      targetEntityType,
-      targetEntityId,
-      loggedInUser,
-    );
+      const entityData = await this.getEntity(
+        targetEntityType,
+        targetEntityId,
+        loggedInUser,
+      );
+
+      if (!mappedEntities[targetEntityType]) {
+        mappedEntities[targetEntityType] = [];
+      }
 
-    if (!mappedEntities[targetEntityType]) {
-      mappedEntities[targetEntityType] = [];
+      mappedEntities[targetEntityType].push(entityData);
     }
 
-    mappedEntities[targetEntityType].push(entityData);
+    return mappedEntities;
   }
 
-  return mappedEntities;
-}
-
   // ----------------------------- update with relations
 
-// ----------------------------- update entity with relations
-async updateEntityWithRelations(
-  entityType: string,
-  id: number | string,
-  data: Record<string, any>,
-  loggedInUser: any,
-): Promise<any> {
-  const organizationId = loggedInUser.organization_id;
-  const { mappedEntities, ...mainData } = data;
-
-  // Update main entity
-  const updatedMainEntity = await this.updateEntity(entityType, id, mainData, loggedInUser);
-
-  const updatedRelations: Record<string, any> = {};
+  // ----------------------------- update entity with relations
+  async updateEntityWithRelations(
+    entityType: string,
+    id: number | string,
+    data: Record<string, any>,
+    loggedInUser: any,
+  ): Promise<any> {
+    const organizationId = loggedInUser.organization_id;
+    const { mappedEntities, ...mainData } = data;
 
-  if (mappedEntities) {
-    const getRelationDefs = await this.dataSource.query(
-      `SELECT * FROM cr_entity_relation WHERE organization_id = ? AND source_entity_type = ?`,
-      [organizationId, entityType],
+    // Update main entity
+    const updatedMainEntity = await this.updateEntity(
+      entityType,
+      id,
+      mainData,
+      loggedInUser,
     );
 
-    for (const [targetEntityType, rawEntityData] of Object.entries(mappedEntities)) {
-      const relationDef = getRelationDefs.find(
-        (r) => r.target_entity_type === targetEntityType,
-      );
-      if (!relationDef) continue;
-
-      const relationType = relationDef.relation_type;
-      const entityArray = Array.isArray(rawEntityData) ? rawEntityData : [rawEntityData];
+    const updatedRelations: Record<string, any> = {};
 
-      // Delete previous relations and related entities
-      const existingRelationsForType = await this.dataSource.query(
-        `SELECT * FROM cr_entity_relation_data WHERE source_entity_type = ? AND source_entity_id = ? AND target_entity_type = ?`,
-        [entityType, id, targetEntityType],
+    if (mappedEntities) {
+      const getRelationDefs = await this.dataSource.query(
+        `SELECT * FROM cr_entity_relation WHERE organization_id = ? AND source_entity_type = ?`,
+        [organizationId, entityType],
       );
 
-      for (const existingRel of existingRelationsForType) {
-        // Delete the related entity
-        await this.deleteEntity(existingRel.target_entity_type, existingRel.target_entity_id, loggedInUser);
+      for (const [targetEntityType, rawEntityData] of Object.entries(
+        mappedEntities,
+      )) {
+        const relationDef = getRelationDefs.find(
+          (r) => r.target_entity_type === targetEntityType,
+        );
+        if (!relationDef) continue;
+
+        const relationType = relationDef.relation_type;
+        const entityArray = Array.isArray(rawEntityData)
+          ? rawEntityData
+          : [rawEntityData];
 
-        // Delete the relation row
-        await this.dataSource.query(
-          `DELETE FROM cr_entity_relation_data WHERE id = ?`,
-          [existingRel.id],
+        // Delete previous relations and related entities
+        const existingRelationsForType = await this.dataSource.query(
+          `SELECT * FROM cr_entity_relation_data WHERE source_entity_type = ? AND source_entity_id = ? AND target_entity_type = ?`,
+          [entityType, id, targetEntityType],
         );
-      }
 
-      // Create/update new entities & relations
-      const updatedEntities: any[] = [];
-
-      for (const item of entityArray) {
-        let targetEntityId;
-        let entityData;
-
-        if (item.id) {
-          // Update existing entity
-          await this.updateEntity(targetEntityType, item.id, item, loggedInUser);
-          targetEntityId = item.id;
-          entityData = await this.getEntity(targetEntityType, targetEntityId, loggedInUser);
-        } else {
-          // Create new entity
-          const createdEntity = await this.createEntity(targetEntityType, item, loggedInUser);
-          targetEntityId = createdEntity.insertId || createdEntity.id;
-          entityData = await this.getEntity(targetEntityType, targetEntityId, loggedInUser);
+        for (const existingRel of existingRelationsForType) {
+          // Delete the related entity
+          await this.deleteEntity(
+            existingRel.target_entity_type,
+            existingRel.target_entity_id,
+            loggedInUser,
+          );
+
+          // Delete the relation row
+          await this.dataSource.query(
+            `DELETE FROM cr_entity_relation_data WHERE id = ?`,
+            [existingRel.id],
+          );
         }
 
-        // Insert relation
-        await this.dataSource.query(
-          `INSERT INTO cr_entity_relation_data 
+        // Create/update new entities & relations
+        const updatedEntities: any[] = [];
+
+        for (const item of entityArray) {
+          let targetEntityId;
+          let entityData;
+
+          if (item.id) {
+            // Update existing entity
+            await this.updateEntity(
+              targetEntityType,
+              item.id,
+              item,
+              loggedInUser,
+            );
+            targetEntityId = item.id;
+            entityData = await this.getEntity(
+              targetEntityType,
+              targetEntityId,
+              loggedInUser,
+            );
+          } else {
+            // Create new entity
+            const createdEntity = await this.createEntity(
+              targetEntityType,
+              item,
+              loggedInUser,
+            );
+            targetEntityId = createdEntity.insertId || createdEntity.id;
+            entityData = await this.getEntity(
+              targetEntityType,
+              targetEntityId,
+              loggedInUser,
+            );
+          }
+
+          // Insert relation
+          await this.dataSource.query(
+            `INSERT INTO cr_entity_relation_data 
           (source_entity_id, source_entity_type, target_entity_id, target_entity_type, relation_type) 
           VALUES (?, ?, ?, ?, ?)`,
-          [id, entityType, targetEntityId, targetEntityType, relationType],
-        );
-
-        if (relationType === 'ONE_TO_MANY') {
-          updatedEntities.push(entityData);
-        } else if (relationType === 'ONE_TO_ONE' || relationType === 'MANY_TO_ONE') {
-          updatedEntities[0] = entityData; // single object
+            [id, entityType, targetEntityId, targetEntityType, relationType],
+          );
+
+          if (relationType === 'ONE_TO_MANY') {
+            updatedEntities.push(entityData);
+          } else if (
+            relationType === 'ONE_TO_ONE' ||
+            relationType === 'MANY_TO_ONE'
+          ) {
+            updatedEntities[0] = entityData; // single object
+          }
         }
-      }
 
-      // Assign to response mappedEntities
-      updatedRelations[targetEntityType] =
-        relationType === 'ONE_TO_MANY' ? updatedEntities : updatedEntities[0];
+        // Assign to response mappedEntities
+        updatedRelations[targetEntityType] =
+          relationType === 'ONE_TO_MANY' ? updatedEntities : updatedEntities[0];
+      }
     }
-  }
-
-  return {
-    mainEntity: {
-      id,
-      entityType,
-      data: updatedMainEntity,
-    },
-    relatedEntities: updatedRelations,
-  };
-}
 
+    return {
+      mainEntity: {
+        id,
+        entityType,
+        data: updatedMainEntity,
+      },
+      relatedEntities: updatedRelations,
+    };
+  }
 
   // -----------------------------
   async updateEntity(
@@ -485,4 +516,41 @@ async updateEntityWithRelations(
     const dropdown = await this.dataSource.query(query, params);
     return dropdown;
   }
+
+  async getCode(entityType: string, loggedInUser: any): Promise<string> {
+    const organizationId = loggedInUser.organization_id;
+
+    // 1. Get db_table_name from entity master
+    const result = await this.dataSource.query(
+      `SELECT db_table_name 
+     FROM cr_entity_master 
+     WHERE mapped_entity_type = ? AND organization_id = ?`,
+      [entityType, organizationId],
+    );
+
+    if (!result.length) {
+      throw new Error(
+        `Entity type '${entityType}' not found in cr_entity_master for org '${organizationId}'`,
+      );
+    }
+
+    const tableName = result[0].db_table_name;
+
+    // 2. Get current max sequence number from that table
+    const seqResult = await this.dataSource.query(
+      `SELECT MAX(CAST(SUBSTRING(code, LENGTH(entity_type) + 1) AS UNSIGNED)) AS max_seq_no
+     FROM \`${tableName}\`
+     WHERE entity_type = ?`,
+      [entityType],
+    );
+
+    let maxSeqNo = seqResult?.[0]?.max_seq_no
+      ? Number(seqResult[0].max_seq_no)
+      : 0;
+
+    maxSeqNo += 1;
+
+    // 3. Return generated code
+    return `${entityType}${maxSeqNo}`;
+  }
 }

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

@@ -317,6 +317,7 @@ export class TaskService extends EntityServiceImpl {
       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
@@ -346,6 +347,9 @@ export class TaskService extends EntityServiceImpl {
           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,
       );
@@ -406,6 +410,9 @@ export class TaskService extends EntityServiceImpl {
       reason_code: string | number;
       remark: string;
       mapped_entity_id: number;
+      stage_id: number;
+      action_id: number;
+      stage_group_id?: number;
     },
     loggedInUser: any,
   ) {
@@ -423,6 +430,9 @@ export class TaskService extends EntityServiceImpl {
       mapped_entity_type: 'LEAD',
       entity_type: 'LNO',
       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);