rez_core 2.2.108 → 2.2.110

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

@@ -6,11 +6,18 @@ export class EntityDynamicService {
   constructor(private readonly dataSource: DataSource) {}
 
   // -----------------------------
-  async createEntity(entityType: string, data: Record<string, any>, loggedInUser: any): Promise<any> {
+  async createEntity(
+    entityType: string,
+    data: Record<string, any>,
+    loggedInUser: any,
+  ): Promise<any> {
     const organizationId = loggedInUser.organization_id;
 
-    const tableName = await this.getTableName(entityType);
-    const validAttributes = await this.getAttributeCodes(entityType, organizationId);
+    const tableName = await this.getTableName(entityType, organizationId);
+    const validAttributes = await this.getAttributeCodes(
+      entityType,
+      organizationId,
+    );
 
     const columns: string[] = [];
     const values: any[] = [];
@@ -28,45 +35,412 @@ export class EntityDynamicService {
     return result;
   }
 
+  // ----------------------------- get 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;
+
+    // Process related entities
+    const relationResults: any[] = [];
+
+    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;
+
+        // Check if we have data for this target entity type
+        if (mappedEntities[targetEntityType]) {
+          const entityData = mappedEntities[targetEntityType];
+
+          // resolve from list_master_items
+          const relationTypeResult = await this.dataSource.query(
+            `SELECT * FROM cr_list_master_items WHERE organization_id = ? AND id = ?`,
+            [organizationId, relationId],
+          );
+
+          if (
+            relationTypeResult[0]?.value == 'ONE_TO_MANY' ||
+            relationTypeResult[0]?.value == 'MANY_TO_ONE'
+          ) {
+            // Expect array of objects
+            if (Array.isArray(entityData)) {
+              for (const item of entityData) {
+                // Add foreign key reference to main entity
+                const itemWithRef = {
+                  ...item,
+                  entity_type: targetEntityType,
+                };
+
+                const createdRelatedEntity = await this.createEntity(
+                  targetEntityType,
+                  itemWithRef,
+                  loggedInUser,
+                );
+
+                // SAVE ENTRY IN cr_entity_relation_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,
+                    targetEntityType,
+                    relationType,
+                  ],
+                );
+              }
+            } else {
+              throw new Error(
+                `Expected array for ONE_TO_MANY relationship with ${targetEntityType}`,
+              );
+            }
+          } else if (
+            relationTypeResult[0]?.value == 'ONE_TO_ONE' ||
+            relationTypeResult[0]?.value == 'MANY_TO_ONE'
+          ) {
+            // Expect single object
+            if (!Array.isArray(entityData)) {
+              // Add foreign key reference to main entity
+              const entityWithRef = {
+                ...entityData,
+                entity_type: targetEntityType,
+              };
+
+              const createdRelatedEntity = await this.createEntity(
+                targetEntityType,
+                entityWithRef,
+                loggedInUser,
+              );
+
+              // SAVE ENTRY IN cr_entity_relation_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,
+                  targetEntityType,
+                  relationType,
+                ],
+              );
+            } else {
+              throw new Error(
+                `Expected single object for ONE_TO_ONE relationship with ${targetEntityType}`,
+              );
+            }
+          }
+        }
+      }
+    }
+
+    return {
+      mainEntity: {
+        id: mainID,
+        entityType: entityType,
+        data: createdEntityData,
+      },
+      relatedEntities: relationResults,
+    };
+  }
+
+  // ----------------------------- get entity with relations
+  async getEntityWithRelation(
+    entityType: string,
+    id: number | string,
+    loggedInUser: any,
+  ): Promise<any> {
+    const mainEntity = await this.getEntity(entityType, id, loggedInUser);
+
+    const relatedEntities = await this.dataSource.query(
+      `SELECT * FROM cr_entity_relation_data WHERE  source_entity_id = ? AND target_entity_type IN (
+      SELECT target_entity_type FROM cr_entity_relation WHERE source_entity_type = ?)`,
+      [id, entityType],
+    );
+
+    // Format response to match create entity structure
+    const response: any = {
+      entity_type: entityType,
+      ...mainEntity,
+    };
+
+    if (relatedEntities.length > 0) {
+      response.mappedEntities = await this.formatMappedEntities(
+        relatedEntities,
+        loggedInUser,
+      );
+    }
+
+    return response;
+  }
+
+  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;
+      const relationType = relation.relation_type;
+
+      // Get the actual entity data
+      const entityData = await this.getEntity(
+        targetEntityType,
+        targetEntityId,
+        loggedInUser,
+      );
+
+      if (!mappedEntities[targetEntityType]) {
+        // Initialize based on relation type
+        if (relationType === 'ONE_TO_MANY') {
+          mappedEntities[targetEntityType] = [];
+        } else if (
+          relationType === 'ONE_TO_ONE' ||
+          relationType === 'MANY_TO_ONE'
+        ) {
+          mappedEntities[targetEntityType] = null;
+        }
+      }
+
+      if (relationType === 'ONE_TO_MANY') {
+        mappedEntities[targetEntityType].push(entityData);
+      } else if (
+        relationType === 'ONE_TO_ONE' ||
+        relationType === 'MANY_TO_ONE'
+      ) {
+        mappedEntities[targetEntityType] = entityData;
+      }
+    }
+
+    return mappedEntities;
+  }
+
+  // ----------------------------- update 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 the main entity (excluding mappedEntities)
+    await this.updateEntity(entityType, id, mainData, loggedInUser);
+
+    // Handle related entities if mappedEntities is provided
+    if (mappedEntities) {
+      // Get existing relations
+      const existingRelations = await this.dataSource.query(
+        `SELECT * FROM cr_entity_relation_data WHERE source_entity_type = ? AND source_entity_id = ?`,
+        [entityType, id],
+      );
+
+      // Get relation definitions
+      const getRelationDefs = await this.dataSource.query(
+        `SELECT * FROM cr_entity_relation WHERE organization_id = ? AND source_entity_type = ?`,
+        [organizationId, entityType],
+      );
+
+      // Process each target entity type in mappedEntities
+      for (const [targetEntityType, entityData] of Object.entries(
+        mappedEntities,
+      )) {
+        const relationDef = getRelationDefs.find(
+          (r) => r.target_entity_type === targetEntityType,
+        );
+
+        if (!relationDef) {
+          console.warn(
+            `No relation definition found for ${entityType} -> ${targetEntityType}`,
+          );
+          continue;
+        }
+
+        const relationType = relationDef.relation_type;
+        const existingRelationsForType = existingRelations.filter(
+          (r) => r.target_entity_type === targetEntityType,
+        );
+
+        if (relationType === 'ONE_TO_MANY') {
+          // Handle array of entities
+          if (Array.isArray(entityData)) {
+            // Delete existing relations for this type
+
+            for (const existingRel of existingRelationsForType) {
+              await this.dataSource.query(
+                `DELETE FROM cr_entity_relation_data WHERE id = ?`,
+                [existingRel.id],
+              );
+            }
+
+            // Create new relations
+            for (const item of entityData) {
+              let targetEntityId;
+
+              if (item.id) {
+                // Update existing entity
+                await this.updateEntity(
+                  targetEntityType,
+                  item.id,
+                  item,
+                  loggedInUser,
+                );
+                targetEntityId = item.id;
+              } else {
+                // Create new entity
+                const createdEntity = await this.createEntity(
+                  targetEntityType,
+                  item,
+                  loggedInUser,
+                );
+                targetEntityId = createdEntity.insertId || createdEntity.id;
+              }
+
+              // Create relation entry
+              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,
+                ],
+              );
+            }
+          } else {
+            throw new Error(
+              `Expected array for ONE_TO_MANY relationship with ${targetEntityType}`,
+            );
+          }
+        } else if (
+          relationType === 'ONE_TO_ONE' ||
+          relationType === 'MANY_TO_ONE'
+        ) {
+          // Handle single entity
+          if (!Array.isArray(entityData)) {
+            const singleEntityData = entityData as Record<string, any>;
+            let targetEntityId;
+
+            if (singleEntityData.id) {
+              // Update existing entity
+              await this.updateEntity(
+                targetEntityType,
+                singleEntityData.id,
+                singleEntityData,
+                loggedInUser,
+              );
+              targetEntityId = singleEntityData.id;
+            } else {
+              // Create new entity
+              const createdEntity = await this.createEntity(
+                targetEntityType,
+                singleEntityData,
+                loggedInUser,
+              );
+              targetEntityId = createdEntity.insertId || createdEntity.id;
+
+              // Create relation entry if it doesn't exist
+              const existingRel = existingRelationsForType[0];
+              if (!existingRel) {
+                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,
+                  ],
+                );
+              }
+            }
+          } else {
+            throw new Error(
+              `Expected single object for ONE_TO_ONE relationship with ${targetEntityType}`,
+            );
+          }
+        }
+      }
+    }
+
+    return { success: true };
+  }
+
   // -----------------------------
   async updateEntity(
     entityType: string,
     id: number | string,
     data: Record<string, any>,
-    loggedInUser: any
+    loggedInUser: any,
   ): Promise<any> {
     const organizationId = loggedInUser.organization_id;
-  
-    const tableName = await this.getTableName(entityType);
-    const validAttributes = await this.getAttributeCodes(entityType, organizationId);
-  
+
+    const tableName = await this.getTableName(entityType, organizationId);
+    const validAttributes = await this.getAttributeCodes(
+      entityType,
+      organizationId,
+    );
+
     const updates: string[] = [];
     const values: any[] = [];
-  
+
     for (const key of Object.keys(data)) {
       if (validAttributes.includes(key)) {
         updates.push(`\`${key}\` = ?`);
         values.push(data[key]);
       }
     }
-  
+
     if (updates.length === 0) {
       throw new Error('No valid attributes to update.');
     }
-  
+
     const updateQuery = `UPDATE \`${tableName}\` SET ${updates.join(', ')} WHERE id = ?`;
     values.push(id); // Add id for WHERE clause
-  
+
     const result = await this.dataSource.query(updateQuery, values);
     return result;
   }
 
   // -----------------------------
-  async getEntity(entityType: string, id: number | string, loggedInUser: any): Promise<any> {
+  async getEntity(
+    entityType: string,
+    id: number | string,
+    loggedInUser: any,
+  ): Promise<any> {
     const organizationId = loggedInUser.organization_id;
 
-    const tableName = await this.getTableName(entityType);
-    const validAttributes = await this.getAttributeCodes(entityType, organizationId);
+    const tableName = await this.getTableName(entityType, organizationId);
+    const validAttributes = await this.getAttributeCodes(
+      entityType,
+      organizationId,
+    );
 
     const columns = validAttributes.map((attr) => `\`${attr}\``).join(', ');
     const selectQuery = `SELECT ${columns} FROM \`${tableName}\` WHERE id = ?`;
@@ -76,10 +450,13 @@ export class EntityDynamicService {
   }
 
   // -----------------------------
-  private async getTableName(entityType: string): Promise<string> {
+  private async getTableName(
+    entityType: string,
+    organizationId: string,
+  ): Promise<string> {
     const result = await this.dataSource.query(
-      `SELECT db_table_name FROM cr_entity_master WHERE mapped_entity_type = ?`,
-      [entityType]
+      `SELECT db_table_name FROM cr_entity_master WHERE organization_id = ? AND mapped_entity_type = ?`,
+      [organizationId, entityType],
     );
 
     if (!result.length) {
@@ -89,16 +466,35 @@ export class EntityDynamicService {
     return result[0].db_table_name;
   }
 
-  private async getAttributeCodes(entityType: string, organizationId: string): Promise<string[]> {
+  private async getAttributeCodes(
+    entityType: string,
+    organizationId: string,
+  ): Promise<string[]> {
     const result = await this.dataSource.query(
       `SELECT attribute_key FROM cr_attribute_master WHERE mapped_entity_type = ? AND organization_id = ?`,
-      [entityType, organizationId]
+      [entityType, organizationId],
     );
 
     if (!result.length) {
-     console.log(`No attributes found for entity '${entityType}' and org '${organizationId}'`);
+      console.log(
+        `No attributes found for entity '${entityType}' and org '${organizationId}'`,
+      );
     }
 
     return result.map((row) => row.attribute_key);
   }
+
+  private async deleteEntity(
+    entityType: string,
+    id: number | string,
+    loggedInUser: any,
+  ): Promise<any> {
+    const organizationId = loggedInUser.organization_id;
+
+    const tableName = await this.getTableName(entityType, organizationId);
+
+    const deleteQuery = `DELETE FROM \`${tableName}\` WHERE id = ?`;
+    const result = await this.dataSource.query(deleteQuery, [id]);
+    return result;
+  }
 }

package/src/module/meta/service/entity-realation-data.service.ts

@@ -0,0 +1,9 @@
+import { Injectable } from '@nestjs/common';
+import { EntityServiceImpl } from './entity-service-impl.service';
+
+@Injectable()
+export class EntityRelationDataService extends EntityServiceImpl {
+  constructor() {
+    super();
+  }
+}

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

@@ -0,0 +1,22 @@
+import { Injectable } from '@nestjs/common';
+import { EntityServiceImpl } from './entity-service-impl.service';
+import { DataSource } from 'typeorm';
+
+@Injectable()
+export class EntityRelationService extends EntityServiceImpl {
+  constructor(private readonly dataSource: DataSource) {
+    super();
+  }
+
+  async getEntityRelations(
+    entityType: string,
+    loggedInUser: any,
+  ): Promise<any> {
+    const relations = await this.dataSource.query(
+      `SELECT name as label , target_entity_type as value FROM cr_entity_relation WHERE source_entity_type = ? AND organization_id = ?`,
+      [entityType, loggedInUser.organization_id],
+    );
+
+    return relations;
+  }
+}

package/src/module/meta/service/resolver.service.ts

@@ -61,14 +61,14 @@ export class ResolverService {
         } else {
           if (tableName == 'cr_organization') {
             const [item] = await this.dataSource.query(
-              `SELECT * FROM ${tableName} WHERE code = ?`,
+              `SELECT * FROM ${tableName} WHERE id = ?`,
               [codeValue],
             );
             resolvedEntityData[field] =
               item?.[attr.data_source_attribute] ?? codeValue;
           } else {
             const [item] = await this.dataSource.query(
-              `SELECT * FROM ${tableName} WHERE code = ? AND organization_id = ?`,
+              `SELECT * FROM ${tableName} WHERE id = ? AND organization_id = ?`,
               [codeValue, loggedInUser.organization_id],
             );
             resolvedEntityData[field] =