rez_core 1.0.78 → 1.0.80

package/package.json

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

package/src/module/meta/controller/entity.controller.ts

@@ -159,15 +159,18 @@ export class EntityController {
     @Param('entity_type') entityType: string,
     @Query('list_entity_type') listEntityType: string,
     @Query('display_type') displayType: string,
+    @Query('sample_export') sampleExport: boolean,
     @Query() filterCriteria: Record<string, any>,
     @Res() res: Response, // Express Response for file handling
   ) {
     try {
+
       const filePath = await this.entityService.generateExcelReport(
         entityType,
         filterCriteria,
         listEntityType,
         displayType,
+        sampleExport
       );
 
       if (!filePath || !fs.existsSync(filePath)) {

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

@@ -35,6 +35,7 @@ import { ViewMasterService } from './service/view-master.service';
 import { ViewMasterController } from './controller/view-master.controller';
 import { ViewMaterRespository } from './repository/view-master.repository';
 import { MetaController } from './controller/meta.controller';
+import { EntityValidationService } from './service/entity-validation.service';
 
 @Module({
   imports: [
@@ -71,6 +72,7 @@ import { MetaController } from './controller/meta.controller';
     SectionMasterService,
     FieldGroupService,
     ViewMaterRespository,
+    EntityValidationService,
     { provide: 'ViewMasterService', useClass: ViewMasterService },
   ],
   exports: [
@@ -79,6 +81,7 @@ import { MetaController } from './controller/meta.controller';
     PreferenceService,
     EntityListService,
     EntityTableService,
+    EntityValidationService,
     EntityTableColumnService,
     MediaDataService,
     SectionMasterService,

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

@@ -16,6 +16,7 @@ import { ExcelsheetData } from '../../../utils/dto/excelsheet-data.dto';
 import { EntityTableService } from './entity-table.service';
 import { EntityTableColumnService } from './entity-table-column.service';
 import { ENTITYTYPE_ENTITYMASTER } from '../../../constant/global.constant';
+import { EntityValidationService } from './entity-validation.service';
 
 @Injectable()
 export class EntityServiceImpl implements EntityService<BaseEntity> {
@@ -26,12 +27,15 @@ export class EntityServiceImpl implements EntityService<BaseEntity> {
   @Inject() protected readonly reflectionHelper: ReflectionHelper;
   @Inject() protected readonly entityListService: EntityListService;
   @Inject() protected readonly loggingService: LoggingService;
+  @Inject()
+protected readonly entityValidationService: EntityValidationService;
+
 
   async createEntity(
     entityData: BaseEntity,
     loggedInUser: UserData | null,
     manager?: EntityManager,
-  ): Promise<BaseEntity> {
+  ){
     if (!entityData.entity_type) {
       throw new BadRequestException(`EntityType is missing`);
     }
@@ -39,6 +43,16 @@ export class EntityServiceImpl implements EntityService<BaseEntity> {
       entityData.entity_type,
     );
 
+    const validationErrors = await this.entityValidationService.validateEntityData(entityData,entityMaster);
+    if (validationErrors.length > 0) {
+      
+     return {
+        success: false,
+        errors: validationErrors,
+      };
+     
+    }
+
     const repo = manager
       ? manager.getRepository(entityMaster.entity_data_class) // <-- Use transaction-safe repo
       : this.reflectionHelper.getRepoService(entityMaster.entity_data_class);
@@ -186,6 +200,7 @@ export class EntityServiceImpl implements EntityService<BaseEntity> {
     filterCriteria: Record<string, any>,
     listEntityType: string,
     displayType: string,
+    sampleExport: boolean,
   ): Promise<string | null> {
     let fileName: string;
     try {
@@ -196,6 +211,7 @@ export class EntityServiceImpl implements EntityService<BaseEntity> {
         filterCriteria,
         listEntityType,
         displayType,
+        sampleExport
       );
 
       const modifiedDate = new Date().toISOString().replace(/[-T:.Z]/g, '');
@@ -218,19 +234,20 @@ export class EntityServiceImpl implements EntityService<BaseEntity> {
     filterCriteria: Record<string, any>,
     listEntityType: string,
     displayType: string,
+    sampleExport: boolean,
   ) {
-    const sheet: ExcelsheetData = {
-      sheetName: entityType,
-      headers: [],
-      rowList: [],
-    };
-
     const entityTable =
       await this.entityTableService.findByEntityTypeAndListTypeAndDisplayType(
         entityType,
         listEntityType,
         displayType,
       );
+    const sheet: ExcelsheetData = {
+      sheetName: entityTable?.data_source || 'sheet',
+      headers: [],
+      rowList: [],
+    };
+
     if (entityTable) {
       const entityTableColumnList =
         await this.entityTableColumnService.findByParentIdAndParentType(
@@ -243,14 +260,17 @@ export class EntityServiceImpl implements EntityService<BaseEntity> {
         (col) => col.attribute_key,
       );
 
-      const filteredList = await this.entityListService.getFilteredList(
-        entityTable,
-        filterCriteria,
-        undefined,
-        undefined,
-        undefined,
-        undefined,
-      );
+      let filteredList: any[] = [];
+      if(!sampleExport) {
+        filteredList = await this.entityListService.getFilteredList(
+          entityTable,
+          filterCriteria,
+          undefined,
+          undefined,
+          undefined,
+          undefined,
+        );
+      }
 
       sheet.rowList = filteredList.map((item) =>
         attributeList.map((attr) =>

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

@@ -0,0 +1,100 @@
+import { Injectable } from '@nestjs/common';
+import { AttributeMasterService } from 'src/module/meta/service/attribute-master.service';
+import { AttributeMaster } from '../entity/attribute-master.entity';
+import { ReflectionHelper } from 'src/utils/service/reflection-helper.service';
+import { DataSource } from 'typeorm';
+
+interface ValidationError {
+  field: string;
+  message: string;
+}
+
+@Injectable()
+export class EntityValidationService {
+  constructor(
+    private readonly attributeMasterService: AttributeMasterService,
+    private readonly reflectionHelper: ReflectionHelper,
+    private dataSource: DataSource
+  ) {}
+
+  /**
+   * Validates required fields based on attribute metadata.
+   */
+  validateRequiredFields(
+    entityData: Record<string, any>,
+    attributeData: AttributeMaster[],
+  ): ValidationError[] {
+    const errors: ValidationError[] = [];
+
+    attributeData
+      .filter(attr => attr.required)
+      .forEach(attr => {
+        const value = entityData[attr.attribute_key];
+        if (!this.hasValidValue(value)) {
+          errors.push({
+            field: attr.name,
+            message: `Field ${attr.name} is required.`,
+          });
+        }
+      });
+
+    return errors;
+  }
+
+  /**
+   * Validates uniqueness of fields based on attribute metadata.
+   */
+  async validateUniqueFields(
+    entityData: Record<string, any>,
+    attributeData: AttributeMaster[],
+    entityType: string,
+    db_table_name: string
+  ): Promise<ValidationError[]> {
+    const errors: ValidationError[] = [];
+  
+    for (const attr of attributeData.filter(a => a.is_unique)) {
+      const value = entityData[attr.attribute_key];
+  
+      if (this.hasValidValue(value)) {
+        const existing = await this.dataSource
+          .createQueryBuilder()
+          .select("*")
+          .from(db_table_name, db_table_name)
+          .where(`${db_table_name}.${attr.attribute_key} = :value`, { value })
+          .limit(1)
+          .getRawOne();
+  
+        if (existing) {
+          errors.push({
+            field: attr.name,
+            message: `Field ${attr.name} must be unique. Value ${value} already exists.`,
+          });
+        }
+      }
+    }
+  
+    return errors;
+  }
+  
+  /**
+   * Validates both required and unique fields for a given entity type.
+   */
+  async validateEntityData(
+    entityData: Record<string, any>,
+    entityMaster
+  ): Promise<ValidationError[]> {
+    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];
+  }
+  
+
+  private hasValidValue(value: any): boolean {
+    if (value === null || value === undefined) return false;
+    if (typeof value === 'string' && value.trim() === '') return false;
+    return true;
+  }
+}

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

@@ -42,5 +42,6 @@ export interface EntityService<T extends BaseEntity> {
     filterCriteria: Record<string, any>,
     listEntityType: string,
     displayType: string,
+    sampleExport: boolean,
   ): Promise<string | null>;
 }