rez_core 7.1.4 → 7.1.7

package/src/module/eav/service/eav-time.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 { EAVTimeRepository } from '../repository/eav-time.repository';
-
-@Injectable()
-export class EAVTimeService implements IEAVStrategy {
-    constructor(private readonly repository: EAVTimeRepository) { }
-
-    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 { EAVTimeRepository } from '../repository/eav-time.repository';
+
+@Injectable()
+export class EAVTimeService implements IEAVStrategy {
+    constructor(private readonly repository: EAVTimeRepository) { }
+
+    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-timestamp.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 { EAVTimestampRepository } from '../repository/eav-timestamp.repository';
-
-@Injectable()
-export class EAVTimestampService implements IEAVStrategy {
-    constructor(private readonly repository: EAVTimestampRepository) { }
-
-    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 { EAVTimestampRepository } from '../repository/eav-timestamp.repository';
+
+@Injectable()
+export class EAVTimestampService implements IEAVStrategy {
+    constructor(private readonly repository: EAVTimestampRepository) { }
+
+    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-varchar.service.ts

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

@@ -1,116 +1,116 @@
-import { Injectable } from '@nestjs/common';
-import { EAVFactoryService } from './eav-factory.service';
-import { CreateEAVDto, UpdateEAVDto, EAVQueryDto } from '../dto/eav-operation.dto';
-
-/**
- * Main EAV Service - Orchestrator/Facade
- * Provides a simple interface for CRUD operations on EAV data
- * Delegates to appropriate type-specific services via the factory
- */
-@Injectable()
-export class EAVService {
-    constructor(private readonly eavFactory: EAVFactoryService) { }
-
-    /**
-     * Create a new EAV record
-     * @param dataType - The data type (varchar, int, boolean, etc.)
-     * @param dto - The data to create
-     * @param modifiedBy - Optional user ID who is creating the record
-     * @returns The created record
-     */
-    async create(dataType: string, dto: CreateEAVDto, modifiedBy?: number): Promise<any> {
-        const service = this.eavFactory.getService(dataType);
-        return await service.create(dto, modifiedBy);
-    }
-
-    /**
-     * Find a single EAV record
-     * @param dataType - The data type
-     * @param query - Query parameters (entity_type, entity_id, key)
-     * @returns The found record or null
-     */
-    async findOne(dataType: string, query: EAVQueryDto): Promise<any> {
-        const service = this.eavFactory.getService(dataType);
-        return await service.findOne(query);
-    }
-
-    /**
-     * Find all EAV records matching the query
-     * @param dataType - The data type
-     * @param query - Partial query parameters
-     * @returns Array of matching records
-     */
-    async findAll(dataType: string, query: Partial<EAVQueryDto>): Promise<any[]> {
-        const service = this.eavFactory.getService(dataType);
-        return await service.findAll(query);
-    }
-
-    /**
-     * Update an existing EAV record
-     * @param dataType - The data type
-     * @param query - Query to find the record (entity_type, entity_id, key)
-     * @param dto - The updated data
-     * @param modifiedBy - Optional user ID who is updating the record
-     * @returns The updated record or null
-     */
-    async update(
-        dataType: string,
-        query: EAVQueryDto,
-        dto: UpdateEAVDto,
-        modifiedBy?: number,
-    ): Promise<any> {
-        const service = this.eavFactory.getService(dataType);
-        return await service.update(query, dto, modifiedBy);
-    }
-
-    /**
-     * Delete an EAV record
-     * @param dataType - The data type
-     * @param query - Query to find the record (entity_type, entity_id, key)
-     * @returns True if deleted, false otherwise
-     */
-    async delete(dataType: string, query: EAVQueryDto): Promise<boolean> {
-        const service = this.eavFactory.getService(dataType);
-        return await service.delete(query);
-    }
-
-    /**
-     * Create or update an EAV record (upsert)
-     * @param dataType - The data type
-     * @param dto - The data to create or update
-     * @param modifiedBy - Optional user ID
-     * @returns The created or updated record
-     */
-    async upsert(dataType: string, dto: CreateEAVDto, modifiedBy?: number): Promise<any> {
-        const query: EAVQueryDto = {
-            entity_type: dto.entity_type,
-            entity_id: dto.entity_id,
-            key: dto.key,
-        };
-
-        const existing = await this.findOne(dataType, query);
-
-        if (existing) {
-            return await this.update(dataType, query, { value: dto.value }, modifiedBy);
-        } else {
-            return await this.create(dataType, dto, modifiedBy);
-        }
-    }
-
-    /**
-     * Get all supported data types
-     * @returns Array of supported data type names
-     */
-    getSupportedTypes(): string[] {
-        return this.eavFactory.getSupportedTypes();
-    }
-
-    /**
-     * Check if a data type is supported
-     * @param dataType - The data type to check
-     * @returns True if supported, false otherwise
-     */
-    isTypeSupported(dataType: string): boolean {
-        return this.eavFactory.isTypeSupported(dataType);
-    }
-}
+import { Injectable } from '@nestjs/common';
+import { EAVFactoryService } from './eav-factory.service';
+import { CreateEAVDto, UpdateEAVDto, EAVQueryDto } from '../dto/eav-operation.dto';
+
+/**
+ * Main EAV Service - Orchestrator/Facade
+ * Provides a simple interface for CRUD operations on EAV data
+ * Delegates to appropriate type-specific services via the factory
+ */
+@Injectable()
+export class EAVService {
+    constructor(private readonly eavFactory: EAVFactoryService) { }
+
+    /**
+     * Create a new EAV record
+     * @param dataType - The data type (varchar, int, boolean, etc.)
+     * @param dto - The data to create
+     * @param modifiedBy - Optional user ID who is creating the record
+     * @returns The created record
+     */
+    async create(dataType: string, dto: CreateEAVDto, modifiedBy?: number): Promise<any> {
+        const service = this.eavFactory.getService(dataType);
+        return await service.create(dto, modifiedBy);
+    }
+
+    /**
+     * Find a single EAV record
+     * @param dataType - The data type
+     * @param query - Query parameters (entity_type, entity_id, key)
+     * @returns The found record or null
+     */
+    async findOne(dataType: string, query: EAVQueryDto): Promise<any> {
+        const service = this.eavFactory.getService(dataType);
+        return await service.findOne(query);
+    }
+
+    /**
+     * Find all EAV records matching the query
+     * @param dataType - The data type
+     * @param query - Partial query parameters
+     * @returns Array of matching records
+     */
+    async findAll(dataType: string, query: Partial<EAVQueryDto>): Promise<any[]> {
+        const service = this.eavFactory.getService(dataType);
+        return await service.findAll(query);
+    }
+
+    /**
+     * Update an existing EAV record
+     * @param dataType - The data type
+     * @param query - Query to find the record (entity_type, entity_id, key)
+     * @param dto - The updated data
+     * @param modifiedBy - Optional user ID who is updating the record
+     * @returns The updated record or null
+     */
+    async update(
+        dataType: string,
+        query: EAVQueryDto,
+        dto: UpdateEAVDto,
+        modifiedBy?: number,
+    ): Promise<any> {
+        const service = this.eavFactory.getService(dataType);
+        return await service.update(query, dto, modifiedBy);
+    }
+
+    /**
+     * Delete an EAV record
+     * @param dataType - The data type
+     * @param query - Query to find the record (entity_type, entity_id, key)
+     * @returns True if deleted, false otherwise
+     */
+    async delete(dataType: string, query: EAVQueryDto): Promise<boolean> {
+        const service = this.eavFactory.getService(dataType);
+        return await service.delete(query);
+    }
+
+    /**
+     * Create or update an EAV record (upsert)
+     * @param dataType - The data type
+     * @param dto - The data to create or update
+     * @param modifiedBy - Optional user ID
+     * @returns The created or updated record
+     */
+    async upsert(dataType: string, dto: CreateEAVDto, modifiedBy?: number): Promise<any> {
+        const query: EAVQueryDto = {
+            entity_type: dto.entity_type,
+            entity_id: dto.entity_id,
+            key: dto.key,
+        };
+
+        const existing = await this.findOne(dataType, query);
+
+        if (existing) {
+            return await this.update(dataType, query, { value: dto.value }, modifiedBy);
+        } else {
+            return await this.create(dataType, dto, modifiedBy);
+        }
+    }
+
+    /**
+     * Get all supported data types
+     * @returns Array of supported data type names
+     */
+    getSupportedTypes(): string[] {
+        return this.eavFactory.getSupportedTypes();
+    }
+
+    /**
+     * Check if a data type is supported
+     * @param dataType - The data type to check
+     * @returns True if supported, false otherwise
+     */
+    isTypeSupported(dataType: string): boolean {
+        return this.eavFactory.isTypeSupported(dataType);
+    }
+}