rez_core 6.5.75 → 6.5.76

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

@@ -0,0 +1,67 @@
+import { Injectable } from '@nestjs/common';
+import { DataSource, Repository } from 'typeorm';
+import { EAVText } from '../entity/eav-text.entity';
+
+@Injectable()
+export class EAVTextRepository extends Repository<EAVText> {
+    constructor(private dataSource: DataSource) {
+        super(EAVText, dataSource.createEntityManager());
+    }
+
+    /**
+     * Find by entity_type, entity_id, and key
+     */
+    async findByEntityAndKey(
+        entityType: string,
+        entityId: string | number,
+        key: string,
+    ): Promise<EAVText | null> {
+        return await this.findOne({
+            where: {
+                entity_type: entityType,
+                entity_id: String(entityId),
+                key: key,
+            },
+        });
+    }
+
+    /**
+     * Find all by partial criteria
+     */
+    async findByPartialCriteria(criteria: {
+        entity_type?: string;
+        entity_id?: string | number;
+        key?: string;
+    }): Promise<EAVText[]> {
+        const where: any = {};
+
+        if (criteria.entity_type) {
+            where.entity_type = criteria.entity_type;
+        }
+        if (criteria.entity_id) {
+            where.entity_id = String(criteria.entity_id);
+        }
+        if (criteria.key) {
+            where.key = criteria.key;
+        }
+
+        return await this.find({ where });
+    }
+
+    /**
+     * Delete by entity_type, entity_id, and key
+     */
+    async deleteByEntityAndKey(
+        entityType: string,
+        entityId: string | number,
+        key: string,
+    ): Promise<boolean> {
+        const result = await this.delete({
+            entity_type: entityType,
+            entity_id: String(entityId),
+            key: key,
+        });
+
+        return (result.affected ?? 0) > 0;
+    }
+}

package/src/module/eav/repository/eav-time.repository.ts

@@ -0,0 +1,67 @@
+import { Injectable } from '@nestjs/common';
+import { DataSource, Repository } from 'typeorm';
+import { EAVTime } from '../entity/eav-time.entity';
+
+@Injectable()
+export class EAVTimeRepository extends Repository<EAVTime> {
+    constructor(private dataSource: DataSource) {
+        super(EAVTime, dataSource.createEntityManager());
+    }
+
+    /**
+     * Find by entity_type, entity_id, and key
+     */
+    async findByEntityAndKey(
+        entityType: string,
+        entityId: string | number,
+        key: string,
+    ): Promise<EAVTime | null> {
+        return await this.findOne({
+            where: {
+                entity_type: entityType,
+                entity_id: String(entityId),
+                key: key,
+            },
+        });
+    }
+
+    /**
+     * Find all by partial criteria
+     */
+    async findByPartialCriteria(criteria: {
+        entity_type?: string;
+        entity_id?: string | number;
+        key?: string;
+    }): Promise<EAVTime[]> {
+        const where: any = {};
+
+        if (criteria.entity_type) {
+            where.entity_type = criteria.entity_type;
+        }
+        if (criteria.entity_id) {
+            where.entity_id = String(criteria.entity_id);
+        }
+        if (criteria.key) {
+            where.key = criteria.key;
+        }
+
+        return await this.find({ where });
+    }
+
+    /**
+     * Delete by entity_type, entity_id, and key
+     */
+    async deleteByEntityAndKey(
+        entityType: string,
+        entityId: string | number,
+        key: string,
+    ): Promise<boolean> {
+        const result = await this.delete({
+            entity_type: entityType,
+            entity_id: String(entityId),
+            key: key,
+        });
+
+        return (result.affected ?? 0) > 0;
+    }
+}

package/src/module/eav/repository/eav-timestamp.repository.ts

@@ -0,0 +1,67 @@
+import { Injectable } from '@nestjs/common';
+import { DataSource, Repository } from 'typeorm';
+import { EAVTimeStamp } from '../entity/eav-timestamp.entity';
+
+@Injectable()
+export class EAVTimestampRepository extends Repository<EAVTimeStamp> {
+    constructor(private dataSource: DataSource) {
+        super(EAVTimeStamp, dataSource.createEntityManager());
+    }
+
+    /**
+     * Find by entity_type, entity_id, and key
+     */
+    async findByEntityAndKey(
+        entityType: string,
+        entityId: string | number,
+        key: string,
+    ): Promise<EAVTimeStamp | null> {
+        return await this.findOne({
+            where: {
+                entity_type: entityType,
+                entity_id: String(entityId),
+                key: key,
+            },
+        });
+    }
+
+    /**
+     * Find all by partial criteria
+     */
+    async findByPartialCriteria(criteria: {
+        entity_type?: string;
+        entity_id?: string | number;
+        key?: string;
+    }): Promise<EAVTimeStamp[]> {
+        const where: any = {};
+
+        if (criteria.entity_type) {
+            where.entity_type = criteria.entity_type;
+        }
+        if (criteria.entity_id) {
+            where.entity_id = String(criteria.entity_id);
+        }
+        if (criteria.key) {
+            where.key = criteria.key;
+        }
+
+        return await this.find({ where });
+    }
+
+    /**
+     * Delete by entity_type, entity_id, and key
+     */
+    async deleteByEntityAndKey(
+        entityType: string,
+        entityId: string | number,
+        key: string,
+    ): Promise<boolean> {
+        const result = await this.delete({
+            entity_type: entityType,
+            entity_id: String(entityId),
+            key: key,
+        });
+
+        return (result.affected ?? 0) > 0;
+    }
+}

package/src/module/eav/repository/eav-varchar.repository.ts

@@ -0,0 +1,67 @@
+import { Injectable } from '@nestjs/common';
+import { DataSource, Repository } from 'typeorm';
+import { EAVVarchar } from '../entity/eav-varchar.entity';
+
+@Injectable()
+export class EAVVarcharRepository extends Repository<EAVVarchar> {
+    constructor(private dataSource: DataSource) {
+        super(EAVVarchar, dataSource.createEntityManager());
+    }
+
+    /**
+     * Find by entity_type, entity_id, and key
+     */
+    async findByEntityAndKey(
+        entityType: string,
+        entityId: string | number,
+        key: string,
+    ): Promise<EAVVarchar | null> {
+        return await this.findOne({
+            where: {
+                entity_type: entityType,
+                entity_id: String(entityId),
+                key: key,
+            },
+        });
+    }
+
+    /**
+     * Find all by partial criteria
+     */
+    async findByPartialCriteria(criteria: {
+        entity_type?: string;
+        entity_id?: string | number;
+        key?: string;
+    }): Promise<EAVVarchar[]> {
+        const where: any = {};
+
+        if (criteria.entity_type) {
+            where.entity_type = criteria.entity_type;
+        }
+        if (criteria.entity_id) {
+            where.entity_id = String(criteria.entity_id);
+        }
+        if (criteria.key) {
+            where.key = criteria.key;
+        }
+
+        return await this.find({ where });
+    }
+
+    /**
+     * Delete by entity_type, entity_id, and key
+     */
+    async deleteByEntityAndKey(
+        entityType: string,
+        entityId: string | number,
+        key: string,
+    ): Promise<boolean> {
+        const result = await this.delete({
+            entity_type: entityType,
+            entity_id: String(entityId),
+            key: key,
+        });
+
+        return (result.affected ?? 0) > 0;
+    }
+}

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

@@ -0,0 +1,64 @@
+import { Injectable } from '@nestjs/common';
+import { IEAVStrategy } from '../interface/eav-strategy.interface';
+import { CreateEAVDto, UpdateEAVDto, EAVQueryDto } from '../dto/eav-operation.dto';
+import { EAVBooleanRepository } from '../repository/eav-boolean.repository';
+
+@Injectable()
+export class EAVBooleanService implements IEAVStrategy {
+    constructor(private readonly repository: EAVBooleanRepository) { }
+
+    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-date.service.ts

@@ -0,0 +1,64 @@
+import { Injectable } from '@nestjs/common';
+import { IEAVStrategy } from '../interface/eav-strategy.interface';
+import { CreateEAVDto, UpdateEAVDto, EAVQueryDto } from '../dto/eav-operation.dto';
+import { EAVDateRepository } from '../repository/eav-date.repository';
+
+@Injectable()
+export class EAVDateService implements IEAVStrategy {
+    constructor(private readonly repository: EAVDateRepository) { }
+
+    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-decimal.service.ts

@@ -0,0 +1,64 @@
+import { Injectable } from '@nestjs/common';
+import { IEAVStrategy } from '../interface/eav-strategy.interface';
+import { CreateEAVDto, UpdateEAVDto, EAVQueryDto } from '../dto/eav-operation.dto';
+import { EAVDecimalRepository } from '../repository/eav-decimal.repository';
+
+@Injectable()
+export class EAVDecimalService implements IEAVStrategy {
+    constructor(private readonly repository: EAVDecimalRepository) { }
+
+    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-factory.service.ts

@@ -0,0 +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);
+    }
+}

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

@@ -0,0 +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,
+        );
+    }
+}

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

@@ -0,0 +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,
+        );
+    }
+}