rez_core 1.0.98 → 1.1.0

package/package.json

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

package/src/module/master/service/master.service.ts

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { BadRequestException, Injectable } from '@nestjs/common';
 import { Brackets, EntityManager } from 'typeorm';
 import { ExcelUtil } from 'src/utils/service/excelUtil.service';
 import { EntityMasterService } from '../../meta/service/entity-master.service';
@@ -6,6 +6,7 @@ import { AttributeMasterService } from 'src/module/meta/service/attribute-master
 import { EntityMaster } from 'src/module/meta/entity/entity-master.entity';
 import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
 import { ReflectionHelper } from 'src/utils/service/reflection-helper.service';
+import { EntityValidationService } from 'src/module/meta/service/entity-validation.service';
 
 @Injectable()
 export class MasterService {
@@ -17,6 +18,7 @@ export class MasterService {
     private reflectionHelper: ReflectionHelper,
 
     private readonly entityServiceImpl: EntityServiceImpl,
+    protected readonly entityValidationService: EntityValidationService,
   ) {}
 
   private readonly metaSheets = [
@@ -197,6 +199,8 @@ export class MasterService {
     loggedInUser,
     duplicateHandling: 'skip_duplicates' | 'overwrite_items',
   ) {
+    const errors: { row: number; errors: any[] }[] = [];
+
     const data = ExcelUtil.readExcel(file.buffer);
     const entityMaster =
       await this.entityMasterService.findByMappedEntityType(entityType);
@@ -214,6 +218,7 @@ export class MasterService {
       await this.attributeMasterService.findAttributesByMappedEntityType(
         entityType,
       );
+
     const uniqueFields = attributes
       .filter((attr) => attr.is_unique)
       .map((attr) => attr.attribute_key);
@@ -222,28 +227,71 @@ export class MasterService {
       throw new Error(`No unique fields found for entityType: ${entityType}`);
     }
 
-    for (const row of sheetData) {
+    for (const [i, row] of sheetData.entries()) {
       if (row.parent_type && row.parent_id) {
         await this.resolveParent(row);
       }
 
       for (const attr of attributes) {
         if (attr.data_source_type === 'entity' && row[attr.attribute_key]) {
-          const refEntity = await this.entityMasterService.getEntityData(
-            attr.datasource_list,
-          );
-          const refData = await this.entityManager.query(
-            `SELECT * FROM ${refEntity.db_table_name} WHERE code = ? LIMIT 1`,
-            [row[attr.attribute_key]],
-          );
-
-          if (!refData.length) {
-            throw new Error(
-              `Reference entity not found for code: ${row[attr.attribute_key]}`,
+          try {
+            const refEntity = await this.entityMasterService.getEntityData(
+              attr.datasource_list,
             );
-          }
 
-          row[attr.attribute_key] = refData[0].id;
+            const refData = await this.entityManager.query(
+              `SELECT * FROM ${refEntity.db_table_name} WHERE code = ? LIMIT 1`,
+              [row[attr.attribute_key]],
+            );
+
+            if (!refData.length) {
+              errors.push({
+                row: i + 1,
+                errors: [
+                  {
+                    field: attr.name,
+                    message: `Reference entity not found for code: ${row[attr.attribute_key]}`,
+                  },
+                ],
+              });
+              continue;
+            }
+
+            const existingError = errors.find((e) => e.row === i + 1);
+
+            if (refData[0].organization_id !== loggedInUser.organization_id) {
+              if (existingError) {
+                existingError.errors.push({
+                  field: attr.name,
+                  message: `Reference entity not found for code: ${row[attr.attribute_key]} does not belong to the organization`,
+                });
+                continue;
+              } else {
+                errors.push({
+                  row: i + 1,
+                  errors: [
+                    {
+                      field: attr.name,
+                      message: `Reference entity with code ${row[attr.attribute_key]} does not belong to the organization`,
+                    },
+                  ],
+                });
+                continue;
+              }
+            }
+
+            row[attr.attribute_key] = refData[0].id;
+          } catch (err) {
+            errors.push({
+              row: i + 1,
+              errors: [
+                {
+                  field: attr.name,
+                  message: `Error fetching reference entity for ${attr.attribute_key}`,
+                },
+              ],
+            });
+          }
         }
       }
     }
@@ -255,6 +303,7 @@ export class MasterService {
       uniqueFields,
       loggedInUser,
       duplicateHandling,
+      errors,
     );
 
     return { message: 'Entity data uploaded successfully' };
@@ -345,6 +394,7 @@ export class MasterService {
     uniqueFields: string[],
     loggedInUser: any,
     duplicateHandling: 'skip_duplicates' | 'overwrite_items',
+    errors: { row: number; errors: any[] }[],
   ): Promise<void> {
     const entityMaster =
       await this.entityMasterService.findByMappedEntityType(entityType);
@@ -357,6 +407,38 @@ export class MasterService {
     if (!entityService)
       throw new Error(`Entity service not found for ${entityType}`);
 
+    for (const [i, row] of data.entries()) {
+      row.entity_type = entityType;
+      row.organization_id = loggedInUser.organization_id;
+
+      const rowErrors =
+        await this.entityValidationService.validateExcelEntityData(
+          row,
+          entityMaster,
+        );
+
+      const existingError = errors.find((e) => e.row === i + 1);
+
+      if (rowErrors?.length > 0) {
+        if (existingError) {
+          existingError.errors.push(...rowErrors);
+        } else {
+          errors.push({
+            row: i + 1,
+            errors: rowErrors,
+          });
+        }
+      }
+    }
+
+    if (errors.length > 0) {
+      throw new BadRequestException({
+        status: false,
+        message: `Validation errors found in the uploaded data.`,
+        error: errors,
+      });
+    }
+
     for (const row of data) {
       const qb = this.entityManager
         .createQueryBuilder()
@@ -381,15 +463,10 @@ export class MasterService {
 
       const existing = await qb.limit(1).getRawOne();
 
-      row.entity_type = entityType;
-      row.organization_id = loggedInUser.organization_id;
-
       if (existing) {
-        if (duplicateHandling === 'skip_duplicates') {
-          continue; // Skip this row
-        } else if (duplicateHandling === 'overwrite_items') {
+        if (duplicateHandling === 'skip_duplicates') continue;
+        if (duplicateHandling === 'overwrite_items') {
           row.id = existing.id;
-
           await entityService.updateEntity(row, loggedInUser);
         }
       } else {

package/src/module/meta/entity/attribute-master.entity.ts

@@ -6,7 +6,7 @@ export class AttributeMaster extends BaseEntity {
   @Column({ name: 'mapped_entity_type', type: 'varchar', nullable: true })
   mapped_entity_type: string;
 
-  @Column({ name: 'mapped_entity_id' ,nullable: true })
+  @Column({ name: 'mapped_entity_id', nullable: true })
   mapped_entity_id: number;
 
   @Column({ name: 'element_type', type: 'varchar', nullable: true, length: 50 })
@@ -62,9 +62,12 @@ export class AttributeMaster extends BaseEntity {
   @Column({ name: 'is_unique', nullable: true })
   is_unique: number;
 
+  @Column({ name: 'regex', nullable: true })
+  regex: string;
+
   @Column({ name: 'can_export', nullable: true })
   can_export: number;
 
   @Column({ name: 'appcode', nullable: true })
-  appcode:string;
+  appcode: string;
 }

package/src/module/meta/entity/base-entity.entity.ts

@@ -49,4 +49,7 @@ export class BaseEntity {
   @Column({ name: 'organization_id', type: 'int', nullable: true })
   @Expose()
   organization_id: number;
+  @Column({ name: 'appcode',type: 'varchar', length: 100, nullable: true })
+  @Expose()
+  appcode: string;
 }

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

@@ -141,7 +141,7 @@ protected readonly entityValidationService: EntityValidationService;
   
     return result;
   }
-
+  
   async updateEntity(
     entityData: BaseEntity,
     loggedInUser: UserData | null,

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

@@ -14,7 +14,7 @@ export class EntityValidationService {
   constructor(
     private readonly attributeMasterService: AttributeMasterService,
     private readonly reflectionHelper: ReflectionHelper,
-    private dataSource: DataSource
+    private dataSource: DataSource,
   ) {}
 
   /**
@@ -27,8 +27,8 @@ export class EntityValidationService {
     const errors: ValidationError[] = [];
 
     attributeData
-      .filter(attr => attr.required)
-      .forEach(attr => {
+      .filter((attr) => attr.required)
+      .forEach((attr) => {
         const value = entityData[attr.attribute_key];
         if (!this.hasValidValue(value)) {
           errors.push({
@@ -48,32 +48,34 @@ export class EntityValidationService {
     entityData: Record<string, any>,
     attributeData: AttributeMaster[],
     entityType: string,
-    db_table_name: string
+    db_table_name: string,
   ): Promise<ValidationError[]> {
     const errors: ValidationError[] = [];
-  
-    for (const attr of attributeData.filter(a => a.is_unique)) {
+
+    for (const attr of attributeData.filter((a) => a.is_unique)) {
       const value = entityData[attr.attribute_key];
-  
+
       if (this.hasValidValue(value)) {
         let qb = this.dataSource
           .createQueryBuilder()
           .select('*')
           .from(db_table_name, db_table_name)
           .where(`${db_table_name}.${attr.attribute_key} = :value`, { value });
-  
+
         // Add AND condition for organization_id if present
         const orgId = entityData.organization_id;
 
         if (orgId !== undefined && orgId !== null) {
-          qb = qb.andWhere(`${db_table_name}.organization_id = :organization_id`, {
-            organization_id: orgId,
-          });
+          qb = qb.andWhere(
+            `${db_table_name}.organization_id = :organization_id`,
+            {
+              organization_id: orgId,
+            },
+          );
         }
 
-  
         const existing = await qb.limit(1).getRawOne();
-  
+
         if (existing) {
           errors.push({
             field: attr.name,
@@ -82,27 +84,71 @@ export class EntityValidationService {
         }
       }
     }
-  
+
+    return errors;
+  }
+
+  /**
+   * Validates regex patterns for fields based on attribute metadata.
+   */
+  async validateRegexFields(
+    entityData: Record<string, any>,
+    attributeData: AttributeMaster[],
+  ): Promise<ValidationError[]> {
+    const errors: ValidationError[] = [];
+
+    for (const attr of attributeData.filter((a) => a.regex)) {
+      const value = entityData[attr.attribute_key];
+      if (this.hasValidValue(value)) {
+        const regex = new RegExp(attr.regex);
+        if (!regex.test(value)) {
+          errors.push({
+            field: attr.name,
+            message: `Field ${attr.name} does not match the required pattern.`,
+          });
+        }
+      }
+    }
+
     return errors;
   }
-  
-  
+
   /**
    * Validates both required and unique fields for a given entity type.
    */
   async validateEntityData(
     entityData: Record<string, any>,
-    entityMaster
+    entityMaster,
   ): Promise<ValidationError[]> {
-    const attributes = await this.attributeMasterService.findAttributesByMappedEntityType(entityData.entity_type);
-  
+    const attributes =
+      await this.attributeMasterService.findAttributesByMappedEntityType(
+        entityData.entity_type,
+      );
+
     const requiredErrors = this.validateRequiredFields(entityData, attributes);
-    const uniqueErrors = await this.validateUniqueFields(entityData, attributes, entityData.entity_type,entityMaster.db_table_name);
-  
-    return [...requiredErrors, ...uniqueErrors];
+    const uniqueErrors = await this.validateUniqueFields(
+      entityData,
+      attributes,
+      entityData.entity_type,
+      entityMaster.db_table_name,
+    );
+    const regexErros = await this.validateRegexFields(entityData, attributes);
+    return [...requiredErrors, ...uniqueErrors, ...regexErros];
   }
-  
 
+  async validateExcelEntityData(
+    entityData: Record<string, any>,
+    entityMaster,
+  ): Promise<ValidationError[]> {
+    const attributes =
+      await this.attributeMasterService.findAttributesByMappedEntityType(
+        entityData.entity_type,
+      );
+
+    const requiredErrors = this.validateRequiredFields(entityData, attributes);
+    const regexErros = await this.validateRegexFields(entityData, attributes);
+    return [...requiredErrors, ...regexErros];
+  }
   private hasValidValue(value: any): boolean {
     if (value === null || value === undefined) return false;
     if (typeof value === 'string' && value.trim() === '') return false;