rez_core 7.1.1 → 7.1.3

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

@@ -1,187 +1,187 @@
-import { Inject, Injectable } from '@nestjs/common';
-import { AttributeMasterService } from 'src/module/meta/service/attribute-master.service';
-import { AttributeMaster } from '../entity/attribute-master.entity';
-import { ConfigService } from '@nestjs/config';
-
-interface ValidationError {
-  field: string;
-  message: string;
-}
-
-@Injectable()
-export class EntityValidationService {
-  constructor(
-    @Inject('AttributeMasterService')
-    private readonly attributeMasterService: AttributeMasterService,
-    private configService: ConfigService,
-  ) {
-  }
-
-  schema = this.configService.get('DB_SCHEMA');
-
-  /**
-   * 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.entityManager
-    //       .createQueryBuilder()
-    //       .select('*')
-    //       .from(`${this.schema}.${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 level_type = loggedInUser.level_type;
-    //       const level_id = loggedInUser.level_id;
-    //
-    //       if (level_type !== undefined && level_type !== null) {
-    //         qb = qb.andWhere(
-    //           `${db_table_name}.level_type = :level_type AND ${db_table_name}.level_id = :level_id`,
-    //           {
-    //             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 { Inject, Injectable } from '@nestjs/common';
+import { AttributeMasterService } from 'src/module/meta/service/attribute-master.service';
+import { AttributeMaster } from '../entity/attribute-master.entity';
+import { ConfigService } from '@nestjs/config';
+
+interface ValidationError {
+  field: string;
+  message: string;
+}
+
+@Injectable()
+export class EntityValidationService {
+  constructor(
+    @Inject('AttributeMasterService')
+    private readonly attributeMasterService: AttributeMasterService,
+    private configService: ConfigService,
+  ) {
+  }
+
+  schema = this.configService.get('DB_SCHEMA');
+
+  /**
+   * 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.entityManager
+    //       .createQueryBuilder()
+    //       .select('*')
+    //       .from(`${this.schema}.${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 level_type = loggedInUser.level_type;
+    //       const level_id = loggedInUser.level_id;
+    //
+    //       if (level_type !== undefined && level_type !== null) {
+    //         qb = qb.andWhere(
+    //           `${db_table_name}.level_type = :level_type AND ${db_table_name}.level_id = :level_id`,
+    //           {
+    //             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,48 +1,48 @@
-import { UserData } from 'src/module/auth/dto/user.dto';
-import { BaseEntity } from '../entity/base-entity.entity';
-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,
-    resolved?: boolean
-  ): 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>;
-}
+import { UserData } from 'src/module/auth/dto/user.dto';
+import { BaseEntity } from '../entity/base-entity.entity';
+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,
+    resolved?: boolean
+  ): 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>;
+}

package/src/module/meta/service/field-group.service.ts

@@ -1,103 +1,103 @@
-import { Injectable } from '@nestjs/common';
-import { EntityServiceImpl } from './entity-service-impl.service';
-import { BaseEntity } from '../entity/base-entity.entity';
-import { UserData } from 'src/module/auth/dto/user.dto';
-import { EntityManager } from 'typeorm';
-import { ViewMaster } from '../entity/view-master.entity';
-
-@Injectable()
-export class FieldGroupService extends EntityServiceImpl {
-  constructor() {
-    super();
-  }
-
-  async createEntity(
-    entityData: BaseEntity,
-    loggedInUser: UserData,
-    manager?: EntityManager,
-  ): Promise<BaseEntity> {
-    const entityMaster = await this.entityMasterService.getEntityData(
-      entityData.entity_type,
-      loggedInUser,
-    );
-    entityData.parent_id = entityMaster.id;
-    entityData.parent_type = entityMaster.entity_type;
-
-    const savedEntity = await super.createEntity(
-      entityData,
-      loggedInUser,
-      manager,
-    );
-    return savedEntity;
-  }
-
-  async updateEntity(
-    entityData: ViewMaster,
-    loggedInUserData: UserData | null,
-  ): Promise<BaseEntity> {
-    return entityData;
-  }
-
-  parseLayout(layoutJson: any) {
-    const stepsData: {
-      stepType: string;
-      stepId: string;
-      stepLabel: string;
-      stepPosition: number;
-      fields: {
-        type: string;
-        label: string;
-        id: string;
-      }[];
-    }[] = [];
-
-    if (layoutJson?.form?.children && Array.isArray(layoutJson.form.children)) {
-      const firstChild = layoutJson.form.children[0];
-
-      if (firstChild.type === 'wizard' && Array.isArray(firstChild.steps)) {
-        let i = 0;
-        for (const step of firstChild.steps) {
-          if (step.type === 'step') {
-            const fields = this.extractFields(step.fields);
-
-            stepsData.push({
-              stepType: step.type,
-              stepId: step.id,
-              stepLabel: step.label,
-              stepPosition: ++i,
-              fields: fields,
-            });
-          }
-        }
-      }
-    }
-    return stepsData;
-  }
-
-  extractFields(fieldsArray: any[]): {
-    type: string;
-    label: string;
-    id: string;
-  }[] {
-    const extractedFields: { type: string; label: string; id: string }[] = [];
-
-    function traverse(fields: any[]) {
-      for (const field of fields) {
-        if (field.type === 'field-set') {
-          extractedFields.push({
-            type: field.type,
-            label: field.label || 'No Label',
-            id: field.id || 'No ID',
-          });
-        }
-        if (Array.isArray(field.fields)) {
-          traverse(field.fields); // 📢 Recursive call
-        }
-      }
-    }
-
-    traverse(fieldsArray);
-
-    return extractedFields;
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { EntityServiceImpl } from './entity-service-impl.service';
+import { BaseEntity } from '../entity/base-entity.entity';
+import { UserData } from 'src/module/auth/dto/user.dto';
+import { EntityManager } from 'typeorm';
+import { ViewMaster } from '../entity/view-master.entity';
+
+@Injectable()
+export class FieldGroupService extends EntityServiceImpl {
+  constructor() {
+    super();
+  }
+
+  async createEntity(
+    entityData: BaseEntity,
+    loggedInUser: UserData,
+    manager?: EntityManager,
+  ): Promise<BaseEntity> {
+    const entityMaster = await this.entityMasterService.getEntityData(
+      entityData.entity_type,
+      loggedInUser,
+    );
+    entityData.parent_id = entityMaster.id;
+    entityData.parent_type = entityMaster.entity_type;
+
+    const savedEntity = await super.createEntity(
+      entityData,
+      loggedInUser,
+      manager,
+    );
+    return savedEntity;
+  }
+
+  async updateEntity(
+    entityData: ViewMaster,
+    loggedInUserData: UserData | null,
+  ): Promise<BaseEntity> {
+    return entityData;
+  }
+
+  parseLayout(layoutJson: any) {
+    const stepsData: {
+      stepType: string;
+      stepId: string;
+      stepLabel: string;
+      stepPosition: number;
+      fields: {
+        type: string;
+        label: string;
+        id: string;
+      }[];
+    }[] = [];
+
+    if (layoutJson?.form?.children && Array.isArray(layoutJson.form.children)) {
+      const firstChild = layoutJson.form.children[0];
+
+      if (firstChild.type === 'wizard' && Array.isArray(firstChild.steps)) {
+        let i = 0;
+        for (const step of firstChild.steps) {
+          if (step.type === 'step') {
+            const fields = this.extractFields(step.fields);
+
+            stepsData.push({
+              stepType: step.type,
+              stepId: step.id,
+              stepLabel: step.label,
+              stepPosition: ++i,
+              fields: fields,
+            });
+          }
+        }
+      }
+    }
+    return stepsData;
+  }
+
+  extractFields(fieldsArray: any[]): {
+    type: string;
+    label: string;
+    id: string;
+  }[] {
+    const extractedFields: { type: string; label: string; id: string }[] = [];
+
+    function traverse(fields: any[]) {
+      for (const field of fields) {
+        if (field.type === 'field-set') {
+          extractedFields.push({
+            type: field.type,
+            label: field.label || 'No Label',
+            id: field.id || 'No ID',
+          });
+        }
+        if (Array.isArray(field.fields)) {
+          traverse(field.fields); // 📢 Recursive call
+        }
+      }
+    }
+
+    traverse(fieldsArray);
+
+    return extractedFields;
+  }
+}