rez_core 7.0.13 → 7.1.1

package/src/module/eav/service/eav-factory.service.ts

@@ -1,93 +1,93 @@
-import { Injectable, BadRequestException } from '@nestjs/common';
-import { IEAVStrategy } from '../interface/eav-strategy.interface';
-import { EAVVarcharService } from './eav-varchar.service';
-import { EAVIntService } from './eav-int.service';
-import { EAVBooleanService } from './eav-boolean.service';
-import { EAVDecimalService } from './eav-decimal.service';
-import { EAVTextService } from './eav-text.service';
-import { EAVJsonService } from './eav-json.service';
-import { EAVDateService } from './eav-date.service';
-import { EAVTimeService } from './eav-time.service';
-import { EAVTimestampService } from './eav-timestamp.service';
-import { EavDataType, EavPrimaryDataType } from '../../../constant/db-data-type.constant';
-
-/**
- * Factory service to resolve the appropriate EAV service based on data type
- * Implements the Factory Pattern
- */
-@Injectable()
-export class EAVFactoryService {
-    private readonly serviceMap: Map<string, IEAVStrategy>;
-
-    constructor(
-        private readonly eavVarcharService: EAVVarcharService,
-        private readonly eavIntService: EAVIntService,
-        private readonly eavBooleanService: EAVBooleanService,
-        private readonly eavDecimalService: EAVDecimalService,
-        private readonly eavTextService: EAVTextService,
-        private readonly eavJsonService: EAVJsonService,
-        private readonly eavDateService: EAVDateService,
-        private readonly eavTimeService: EAVTimeService,
-        private readonly eavTimestampService: EAVTimestampService,
-    ) {
-        // Initialize the service map with all available data type services using enum constants
-        this.serviceMap = new Map<string, IEAVStrategy>([
-            // String types
-            [EavDataType.VARCHAR, this.eavVarcharService],
-            [EavDataType.STRING, this.eavVarcharService],
-            // Numeric types
-            [EavDataType.INT, this.eavIntService],
-            [EavDataType.INTEGER, this.eavIntService],
-            [EavDataType.DECIMAL, this.eavDecimalService],
-            [EavDataType.FLOAT, this.eavDecimalService],
-            // Boolean types
-            [EavDataType.BOOLEAN, this.eavBooleanService],
-            [EavDataType.BOOL, this.eavBooleanService],
-            // Text types
-            [EavDataType.TEXT, this.eavTextService],
-            [EavDataType.JSON, this.eavJsonService],
-            // Date/Time types
-            [EavDataType.DATE, this.eavDateService],
-            [EavDataType.TIME, this.eavTimeService],
-            [EavDataType.TIMESTAMP, this.eavTimestampService],
-            [EavDataType.DATETIME, this.eavTimestampService],
-        ]);
-    }
-
-    /**
-     * Get the appropriate service based on data type
-     * @param dataType - The data type (varchar, int, boolean, etc.)
-     * @returns The corresponding EAV service
-     * @throws BadRequestException if data type is not supported
-     */
-    getService(dataType: string): IEAVStrategy {
-        const normalizedType = dataType.toLowerCase().trim();
-        const service = this.serviceMap.get(normalizedType);
-
-        if (!service) {
-            throw new BadRequestException(
-                `Unsupported data type: ${dataType}. Supported types: ${Array.from(this.serviceMap.keys()).join(', ')}`,
-            );
-        }
-
-        return service;
-    }
-
-    /**
-     * Get all supported data types
-     * @returns Array of supported data type names
-     */
-    getSupportedTypes(): string[] {
-        return Array.from(this.serviceMap.keys());
-    }
-
-    /**
-     * Check if a data type is supported
-     * @param dataType - The data type to check
-     * @returns True if supported, false otherwise
-     */
-    isTypeSupported(dataType: string): boolean {
-        const normalizedType = dataType.toLowerCase().trim();
-        return this.serviceMap.has(normalizedType);
-    }
-}
+import { Injectable, BadRequestException } from '@nestjs/common';
+import { IEAVStrategy } from '../interface/eav-strategy.interface';
+import { EAVVarcharService } from './eav-varchar.service';
+import { EAVIntService } from './eav-int.service';
+import { EAVBooleanService } from './eav-boolean.service';
+import { EAVDecimalService } from './eav-decimal.service';
+import { EAVTextService } from './eav-text.service';
+import { EAVJsonService } from './eav-json.service';
+import { EAVDateService } from './eav-date.service';
+import { EAVTimeService } from './eav-time.service';
+import { EAVTimestampService } from './eav-timestamp.service';
+import { EavDataType, EavPrimaryDataType } from '../../../constant/db-data-type.constant';
+
+/**
+ * Factory service to resolve the appropriate EAV service based on data type
+ * Implements the Factory Pattern
+ */
+@Injectable()
+export class EAVFactoryService {
+    private readonly serviceMap: Map<string, IEAVStrategy>;
+
+    constructor(
+        private readonly eavVarcharService: EAVVarcharService,
+        private readonly eavIntService: EAVIntService,
+        private readonly eavBooleanService: EAVBooleanService,
+        private readonly eavDecimalService: EAVDecimalService,
+        private readonly eavTextService: EAVTextService,
+        private readonly eavJsonService: EAVJsonService,
+        private readonly eavDateService: EAVDateService,
+        private readonly eavTimeService: EAVTimeService,
+        private readonly eavTimestampService: EAVTimestampService,
+    ) {
+        // Initialize the service map with all available data type services using enum constants
+        this.serviceMap = new Map<string, IEAVStrategy>([
+            // String types
+            [EavDataType.VARCHAR, this.eavVarcharService],
+            [EavDataType.STRING, this.eavVarcharService],
+            // Numeric types
+            [EavDataType.INT, this.eavIntService],
+            [EavDataType.INTEGER, this.eavIntService],
+            [EavDataType.DECIMAL, this.eavDecimalService],
+            [EavDataType.FLOAT, this.eavDecimalService],
+            // Boolean types
+            [EavDataType.BOOLEAN, this.eavBooleanService],
+            [EavDataType.BOOL, this.eavBooleanService],
+            // Text types
+            [EavDataType.TEXT, this.eavTextService],
+            [EavDataType.JSON, this.eavJsonService],
+            // Date/Time types
+            [EavDataType.DATE, this.eavDateService],
+            [EavDataType.TIME, this.eavTimeService],
+            [EavDataType.TIMESTAMP, this.eavTimestampService],
+            [EavDataType.DATETIME, this.eavTimestampService],
+        ]);
+    }
+
+    /**
+     * Get the appropriate service based on data type
+     * @param dataType - The data type (varchar, int, boolean, etc.)
+     * @returns The corresponding EAV service
+     * @throws BadRequestException if data type is not supported
+     */
+    getService(dataType: string): IEAVStrategy {
+        const normalizedType = dataType.toLowerCase().trim();
+        const service = this.serviceMap.get(normalizedType);
+
+        if (!service) {
+            throw new BadRequestException(
+                `Unsupported data type: ${dataType}. Supported types: ${Array.from(this.serviceMap.keys()).join(', ')}`,
+            );
+        }
+
+        return service;
+    }
+
+    /**
+     * Get all supported data types
+     * @returns Array of supported data type names
+     */
+    getSupportedTypes(): string[] {
+        return Array.from(this.serviceMap.keys());
+    }
+
+    /**
+     * Check if a data type is supported
+     * @param dataType - The data type to check
+     * @returns True if supported, false otherwise
+     */
+    isTypeSupported(dataType: string): boolean {
+        const normalizedType = dataType.toLowerCase().trim();
+        return this.serviceMap.has(normalizedType);
+    }
+}

package/src/module/eav/service/eav-int.service.ts

@@ -1,64 +1,64 @@
-import { Injectable } from '@nestjs/common';
-import { IEAVStrategy } from '../interface/eav-strategy.interface';
-import { CreateEAVDto, UpdateEAVDto, EAVQueryDto } from '../dto/eav-operation.dto';
-import { EAVIntRepository } from '../repository/eav-int.repository';
-
-@Injectable()
-export class EAVIntService implements IEAVStrategy {
-    constructor(private readonly repository: EAVIntRepository) { }
-
-    async create(dto: CreateEAVDto, modifiedBy?: number): Promise<any> {
-        const entity = this.repository.create({
-            entity_type: dto.entity_type,
-            entity_id: String(dto.entity_id),
-            key: dto.key,
-            value: dto.value,
-            modified_by: modifiedBy,
-        });
-
-        return await this.repository.save(entity);
-    }
-
-    async findOne(query: EAVQueryDto): Promise<any> {
-        return await this.repository.findByEntityAndKey(
-            query.entity_type,
-            query.entity_id,
-            query.key,
-        );
-    }
-
-    async findAll(query: Partial<EAVQueryDto>): Promise<any[]> {
-        return await this.repository.findByPartialCriteria({
-            entity_type: query.entity_type,
-            entity_id: query.entity_id,
-            key: query.key,
-        });
-    }
-
-    async update(query: EAVQueryDto, dto: UpdateEAVDto, modifiedBy?: number): Promise<any> {
-        const existing = await this.repository.findByEntityAndKey(
-            query.entity_type,
-            query.entity_id,
-            query.key,
-        );
-
-        if (!existing) {
-            return null;
-        }
-
-        existing.value = dto.value;
-        if (modifiedBy !== undefined) {
-            existing.modified_by = modifiedBy;
-        }
-
-        return await this.repository.save(existing);
-    }
-
-    async delete(query: EAVQueryDto): Promise<boolean> {
-        return await this.repository.deleteByEntityAndKey(
-            query.entity_type,
-            query.entity_id,
-            query.key,
-        );
-    }
-}
+import { Injectable } from '@nestjs/common';
+import { IEAVStrategy } from '../interface/eav-strategy.interface';
+import { CreateEAVDto, UpdateEAVDto, EAVQueryDto } from '../dto/eav-operation.dto';
+import { EAVIntRepository } from '../repository/eav-int.repository';
+
+@Injectable()
+export class EAVIntService implements IEAVStrategy {
+    constructor(private readonly repository: EAVIntRepository) { }
+
+    async create(dto: CreateEAVDto, modifiedBy?: number): Promise<any> {
+        const entity = this.repository.create({
+            entity_type: dto.entity_type,
+            entity_id: String(dto.entity_id),
+            key: dto.key,
+            value: dto.value,
+            modified_by: modifiedBy,
+        });
+
+        return await this.repository.save(entity);
+    }
+
+    async findOne(query: EAVQueryDto): Promise<any> {
+        return await this.repository.findByEntityAndKey(
+            query.entity_type,
+            query.entity_id,
+            query.key,
+        );
+    }
+
+    async findAll(query: Partial<EAVQueryDto>): Promise<any[]> {
+        return await this.repository.findByPartialCriteria({
+            entity_type: query.entity_type,
+            entity_id: query.entity_id,
+            key: query.key,
+        });
+    }
+
+    async update(query: EAVQueryDto, dto: UpdateEAVDto, modifiedBy?: number): Promise<any> {
+        const existing = await this.repository.findByEntityAndKey(
+            query.entity_type,
+            query.entity_id,
+            query.key,
+        );
+
+        if (!existing) {
+            return null;
+        }
+
+        existing.value = dto.value;
+        if (modifiedBy !== undefined) {
+            existing.modified_by = modifiedBy;
+        }
+
+        return await this.repository.save(existing);
+    }
+
+    async delete(query: EAVQueryDto): Promise<boolean> {
+        return await this.repository.deleteByEntityAndKey(
+            query.entity_type,
+            query.entity_id,
+            query.key,
+        );
+    }
+}

package/src/module/eav/service/eav-json.service.ts

@@ -1,64 +1,64 @@
-import { Injectable } from '@nestjs/common';
-import { IEAVStrategy } from '../interface/eav-strategy.interface';
-import { CreateEAVDto, UpdateEAVDto, EAVQueryDto } from '../dto/eav-operation.dto';
-import { EAVJsonRepository } from '../repository/eav-json.repository';
-
-@Injectable()
-export class EAVJsonService implements IEAVStrategy {
-    constructor(private readonly repository: EAVJsonRepository) { }
-
-    async create(dto: CreateEAVDto, modifiedBy?: number): Promise<any> {
-        const entity = this.repository.create({
-            entity_type: dto.entity_type,
-            entity_id: String(dto.entity_id),
-            key: dto.key,
-            value: dto.value,
-            modified_by: modifiedBy,
-        });
-
-        return await this.repository.save(entity);
-    }
-
-    async findOne(query: EAVQueryDto): Promise<any> {
-        return await this.repository.findByEntityAndKey(
-            query.entity_type,
-            query.entity_id,
-            query.key,
-        );
-    }
-
-    async findAll(query: Partial<EAVQueryDto>): Promise<any[]> {
-        return await this.repository.findByPartialCriteria({
-            entity_type: query.entity_type,
-            entity_id: query.entity_id,
-            key: query.key,
-        });
-    }
-
-    async update(query: EAVQueryDto, dto: UpdateEAVDto, modifiedBy?: number): Promise<any> {
-        const existing = await this.repository.findByEntityAndKey(
-            query.entity_type,
-            query.entity_id,
-            query.key,
-        );
-
-        if (!existing) {
-            return null;
-        }
-
-        existing.value = dto.value;
-        if (modifiedBy !== undefined) {
-            existing.modified_by = modifiedBy;
-        }
-
-        return await this.repository.save(existing);
-    }
-
-    async delete(query: EAVQueryDto): Promise<boolean> {
-        return await this.repository.deleteByEntityAndKey(
-            query.entity_type,
-            query.entity_id,
-            query.key,
-        );
-    }
-}
+import { Injectable } from '@nestjs/common';
+import { IEAVStrategy } from '../interface/eav-strategy.interface';
+import { CreateEAVDto, UpdateEAVDto, EAVQueryDto } from '../dto/eav-operation.dto';
+import { EAVJsonRepository } from '../repository/eav-json.repository';
+
+@Injectable()
+export class EAVJsonService implements IEAVStrategy {
+    constructor(private readonly repository: EAVJsonRepository) { }
+
+    async create(dto: CreateEAVDto, modifiedBy?: number): Promise<any> {
+        const entity = this.repository.create({
+            entity_type: dto.entity_type,
+            entity_id: String(dto.entity_id),
+            key: dto.key,
+            value: dto.value,
+            modified_by: modifiedBy,
+        });
+
+        return await this.repository.save(entity);
+    }
+
+    async findOne(query: EAVQueryDto): Promise<any> {
+        return await this.repository.findByEntityAndKey(
+            query.entity_type,
+            query.entity_id,
+            query.key,
+        );
+    }
+
+    async findAll(query: Partial<EAVQueryDto>): Promise<any[]> {
+        return await this.repository.findByPartialCriteria({
+            entity_type: query.entity_type,
+            entity_id: query.entity_id,
+            key: query.key,
+        });
+    }
+
+    async update(query: EAVQueryDto, dto: UpdateEAVDto, modifiedBy?: number): Promise<any> {
+        const existing = await this.repository.findByEntityAndKey(
+            query.entity_type,
+            query.entity_id,
+            query.key,
+        );
+
+        if (!existing) {
+            return null;
+        }
+
+        existing.value = dto.value;
+        if (modifiedBy !== undefined) {
+            existing.modified_by = modifiedBy;
+        }
+
+        return await this.repository.save(existing);
+    }
+
+    async delete(query: EAVQueryDto): Promise<boolean> {
+        return await this.repository.deleteByEntityAndKey(
+            query.entity_type,
+            query.entity_id,
+            query.key,
+        );
+    }
+}

package/src/module/eav/service/eav-text.service.ts

@@ -1,64 +1,64 @@
-import { Injectable } from '@nestjs/common';
-import { IEAVStrategy } from '../interface/eav-strategy.interface';
-import { CreateEAVDto, UpdateEAVDto, EAVQueryDto } from '../dto/eav-operation.dto';
-import { EAVTextRepository } from '../repository/eav-text.repository';
-
-@Injectable()
-export class EAVTextService implements IEAVStrategy {
-    constructor(private readonly repository: EAVTextRepository) { }
-
-    async create(dto: CreateEAVDto, modifiedBy?: number): Promise<any> {
-        const entity = this.repository.create({
-            entity_type: dto.entity_type,
-            entity_id: String(dto.entity_id),
-            key: dto.key,
-            value: dto.value,
-            modified_by: modifiedBy,
-        });
-
-        return await this.repository.save(entity);
-    }
-
-    async findOne(query: EAVQueryDto): Promise<any> {
-        return await this.repository.findByEntityAndKey(
-            query.entity_type,
-            query.entity_id,
-            query.key,
-        );
-    }
-
-    async findAll(query: Partial<EAVQueryDto>): Promise<any[]> {
-        return await this.repository.findByPartialCriteria({
-            entity_type: query.entity_type,
-            entity_id: query.entity_id,
-            key: query.key,
-        });
-    }
-
-    async update(query: EAVQueryDto, dto: UpdateEAVDto, modifiedBy?: number): Promise<any> {
-        const existing = await this.repository.findByEntityAndKey(
-            query.entity_type,
-            query.entity_id,
-            query.key,
-        );
-
-        if (!existing) {
-            return null;
-        }
-
-        existing.value = dto.value;
-        if (modifiedBy !== undefined) {
-            existing.modified_by = modifiedBy;
-        }
-
-        return await this.repository.save(existing);
-    }
-
-    async delete(query: EAVQueryDto): Promise<boolean> {
-        return await this.repository.deleteByEntityAndKey(
-            query.entity_type,
-            query.entity_id,
-            query.key,
-        );
-    }
-}
+import { Injectable } from '@nestjs/common';
+import { IEAVStrategy } from '../interface/eav-strategy.interface';
+import { CreateEAVDto, UpdateEAVDto, EAVQueryDto } from '../dto/eav-operation.dto';
+import { EAVTextRepository } from '../repository/eav-text.repository';
+
+@Injectable()
+export class EAVTextService implements IEAVStrategy {
+    constructor(private readonly repository: EAVTextRepository) { }
+
+    async create(dto: CreateEAVDto, modifiedBy?: number): Promise<any> {
+        const entity = this.repository.create({
+            entity_type: dto.entity_type,
+            entity_id: String(dto.entity_id),
+            key: dto.key,
+            value: dto.value,
+            modified_by: modifiedBy,
+        });
+
+        return await this.repository.save(entity);
+    }
+
+    async findOne(query: EAVQueryDto): Promise<any> {
+        return await this.repository.findByEntityAndKey(
+            query.entity_type,
+            query.entity_id,
+            query.key,
+        );
+    }
+
+    async findAll(query: Partial<EAVQueryDto>): Promise<any[]> {
+        return await this.repository.findByPartialCriteria({
+            entity_type: query.entity_type,
+            entity_id: query.entity_id,
+            key: query.key,
+        });
+    }
+
+    async update(query: EAVQueryDto, dto: UpdateEAVDto, modifiedBy?: number): Promise<any> {
+        const existing = await this.repository.findByEntityAndKey(
+            query.entity_type,
+            query.entity_id,
+            query.key,
+        );
+
+        if (!existing) {
+            return null;
+        }
+
+        existing.value = dto.value;
+        if (modifiedBy !== undefined) {
+            existing.modified_by = modifiedBy;
+        }
+
+        return await this.repository.save(existing);
+    }
+
+    async delete(query: EAVQueryDto): Promise<boolean> {
+        return await this.repository.deleteByEntityAndKey(
+            query.entity_type,
+            query.entity_id,
+            query.key,
+        );
+    }
+}