rez_core 5.0.76 → 5.0.77

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

@@ -1,187 +1,187 @@
-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,
-    loggedInUser: any,
-  ): Promise<ValidationError[]> {
-    const errors: ValidationError[] = [];
-    const currentId = entityData.id; // assuming 'id' is the primary key
-
-    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/level_type/level_id if present
-        if (entityType !== 'ORG' && entityType !== 'ORGP') {
-          const orgId = loggedInUser.organization_id;
-          const level_type = loggedInUser.level_type;
-          const level_id = loggedInUser.level_id;
-
-          if (orgId !== undefined && orgId !== null) {
-            qb = qb.andWhere(
-              `${db_table_name}.organization_id = :organization_id AND ${db_table_name}.level_type = :level_type AND ${db_table_name}.level_id = :level_id`,
-              {
-                organization_id: orgId,
-                level_type,
-                level_id,
-              },
-            );
-          }
-        }
-
-        // Skip the current record when checking for uniqueness during update
-        if (currentId) {
-          qb = qb.andWhere(`${db_table_name}.id != :id`, { id: currentId });
-        }
-
-        const existing = await qb.limit(1).getRawOne();
-
-        if (existing) {
-          errors.push({
-            field: attr.name,
-            message: `Field ${attr.name} must be unique. Value ${value} already exists.`,
-          });
-        }
-      }
-    }
-
-    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,
-    loggedInUser: any,
-  ): Promise<ValidationError[]> {
-    const attributes =
-      await this.attributeMasterService.findAttributesByMappedEntityType(
-        entityMaster.mapped_entity_type,
-        loggedInUser,
-      );
-    const requiredErrors = this.validateRequiredFields(entityData, attributes);
-    const uniqueErrors = await this.validateUniqueFields(
-      entityData,
-      attributes,
-      entityData.entity_type,
-      entityMaster.db_table_name,
-      loggedInUser,
-    );
-    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];
-  // }
-  async validateImportData(
-    entityData: Record<string, any>,
-    entityMaster,
-    loggedInUser: any,
-  ): Promise<ValidationError[]> {
-    const attributes =
-      await this.attributeMasterService.findAttributesByMappedEntityType(
-        entityMaster.mapped_entity_type,
-        loggedInUser,
-      );
-    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;
-    return true;
-  }
-}
+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,
+    loggedInUser: any,
+  ): Promise<ValidationError[]> {
+    const errors: ValidationError[] = [];
+    const currentId = entityData.id; // assuming 'id' is the primary key
+
+    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/level_type/level_id if present
+        if (entityType !== 'ORG' && entityType !== 'ORGP') {
+          const orgId = loggedInUser.organization_id;
+          const level_type = loggedInUser.level_type;
+          const level_id = loggedInUser.level_id;
+
+          if (orgId !== undefined && orgId !== null) {
+            qb = qb.andWhere(
+              `${db_table_name}.organization_id = :organization_id AND ${db_table_name}.level_type = :level_type AND ${db_table_name}.level_id = :level_id`,
+              {
+                organization_id: orgId,
+                level_type,
+                level_id,
+              },
+            );
+          }
+        }
+
+        // Skip the current record when checking for uniqueness during update
+        if (currentId) {
+          qb = qb.andWhere(`${db_table_name}.id != :id`, { id: currentId });
+        }
+
+        const existing = await qb.limit(1).getRawOne();
+
+        if (existing) {
+          errors.push({
+            field: attr.name,
+            message: `Field ${attr.name} must be unique. Value ${value} already exists.`,
+          });
+        }
+      }
+    }
+
+    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,
+    loggedInUser: any,
+  ): Promise<ValidationError[]> {
+    const attributes =
+      await this.attributeMasterService.findAttributesByMappedEntityType(
+        entityMaster.mapped_entity_type,
+        loggedInUser,
+      );
+    const requiredErrors = this.validateRequiredFields(entityData, attributes);
+    const uniqueErrors = await this.validateUniqueFields(
+      entityData,
+      attributes,
+      entityData.entity_type,
+      entityMaster.db_table_name,
+      loggedInUser,
+    );
+    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];
+  // }
+  async validateImportData(
+    entityData: Record<string, any>,
+    entityMaster,
+    loggedInUser: any,
+  ): Promise<ValidationError[]> {
+    const attributes =
+      await this.attributeMasterService.findAttributesByMappedEntityType(
+        entityMaster.mapped_entity_type,
+        loggedInUser,
+      );
+    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;
+    return true;
+  }
+}

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

@@ -1,67 +1,67 @@
-import { UserData } from '../../user/entity/user.entity';
-import { BaseEntity } from '../entity/base-entity.entity';
-import { EntityListData } from '../dto/entity-list-data.dto';
-import { EntityManager } from 'typeorm';
-
-export interface EntityService<T extends BaseEntity> {
-  createEntity(
-    entityData: T,
-    loggedInUser: UserData,
-    manager?: EntityManager,
-  ): Promise<BaseEntity>;
-
-  getEntityData(
-    entityType: string,
-    entityId: number,
-    loggedInUser: UserData,
-  ): Promise<BaseEntity | null>;
-
-  getResolvedEntityData(
-    entityType: string,
-    entityId: number,
-    loggedInUser: UserData,
-  ): Promise<BaseEntity | null>;
-
-  getEntityList(
-    entityType: string,
-    loggedInUser: UserData,
-    filters?: Record<string, any>,
-  ): Promise<BaseEntity[]>;
-
-  updateEntity(
-    entityData: T,
-    loggedInUserData: UserData,
-    app_code?: string,
-  ): Promise<BaseEntity>;
-
-  deleteEntity(
-    entityType: string,
-    entityId: number,
-    loggedInUserData: UserData,
-  ): void;
-
-  findByCode(
-    entityType: string,
-    code: string,
-    loggedInUser: UserData,
-  ): Promise<BaseEntity>;
-
-  getFilterDataWithTabs(
-    entityType: string,
-    listType: string,
-    filters: Record<string, any>,
-    sortColumn: string | undefined,
-    sortOrder: string | undefined,
-    pageNumber: number,
-    pageSize: number,
-  ): Promise<EntityListData>;
-
-  generateExcelReport(
-    entityType: string,
-    filterCriteria: Record<string, any>,
-    listEntityType: string,
-    displayType: string,
-    sampleExport: boolean,
-    loggedInUser: UserData,
-  ): Promise<string | null>;
-}
+import { UserData } from '../../user/entity/user.entity';
+import { BaseEntity } from '../entity/base-entity.entity';
+import { EntityListData } from '../dto/entity-list-data.dto';
+import { EntityManager } from 'typeorm';
+
+export interface EntityService<T extends BaseEntity> {
+  createEntity(
+    entityData: T,
+    loggedInUser: UserData,
+    manager?: EntityManager,
+  ): Promise<BaseEntity>;
+
+  getEntityData(
+    entityType: string,
+    entityId: number,
+    loggedInUser: UserData,
+  ): Promise<BaseEntity | null>;
+
+  getResolvedEntityData(
+    entityType: string,
+    entityId: number,
+    loggedInUser: UserData,
+  ): Promise<BaseEntity | null>;
+
+  getEntityList(
+    entityType: string,
+    loggedInUser: UserData,
+    filters?: Record<string, any>,
+  ): Promise<BaseEntity[]>;
+
+  updateEntity(
+    entityData: T,
+    loggedInUserData: UserData,
+    app_code?: string,
+  ): Promise<BaseEntity>;
+
+  deleteEntity(
+    entityType: string,
+    entityId: number,
+    loggedInUserData: UserData,
+  ): void;
+
+  findByCode(
+    entityType: string,
+    code: string,
+    loggedInUser: UserData,
+  ): Promise<BaseEntity>;
+
+  getFilterDataWithTabs(
+    entityType: string,
+    listType: string,
+    filters: Record<string, any>,
+    sortColumn: string | undefined,
+    sortOrder: string | undefined,
+    pageNumber: number,
+    pageSize: number,
+  ): Promise<EntityListData>;
+
+  generateExcelReport(
+    entityType: string,
+    filterCriteria: Record<string, any>,
+    listEntityType: string,
+    displayType: string,
+    sampleExport: boolean,
+    loggedInUser: UserData,
+  ): Promise<string | null>;
+}