rez_core 6.5.75 → 6.5.76

package/src/module/eav/service/eav-text.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 { 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,
+        );
+    }
+}

package/src/module/eav/service/eav-time.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 { 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

@@ -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 { 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

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

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

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

package/src/module/listmaster/service/list-master-item.service.ts

@@ -36,7 +36,7 @@ export class ListMasterItemService extends EntityServiceImpl {
 
   async createEntity(entityData: any, loggedInUser: UserData): Promise<any> {
     try {
-      const generatedCode = CodeGeneratorService.generateCode(entityData.name);
+      const generatedCode = CodeGeneratorService.generateCode(entityData.code);
 
       entityData.code = generatedCode;
       entityData.value = generatedCode;
@@ -72,46 +72,7 @@ export class ListMasterItemService extends EntityServiceImpl {
         if (!name) {
           throw new BadRequestException(`name is missing at index ${i}`);
         }
-
-        if (code) {
-          // Check if code exists
-          const existingItem = await this.listItemsRepo.findOneByCondition({
-            code,
-            listtype: listType,
-            enterprise_id: entId,
-          });
-
-          if (existingItem) {
-            // It's an update — check if name is changing to a used name
-            if (existingItem.name.toLowerCase() !== name.toLowerCase()) {
-              const nameExists = await this.listItemsRepo.findOneByCondition({
-                name,
-                listtype: listType,
-                enterprise_id: entId,
-              });
-
-              if (nameExists && nameExists.id !== existingItem.id) {
-                throw new BadRequestException(
-                  `${name} already used by another item`,
-                );
-              }
-            }
-
-            // Update the existing item
-            await this.updateEntity(
-              {
-                ...existingItem,
-                ...item,
-                name,
-                listtype: listType,
-              },
-              loggedInUser,
-            );
-
-            continue;
-          }
-        }
-
+        
         // Creation path
         const nameExists = await this.listItemsRepo.findOneByCondition({
           name,
@@ -119,34 +80,23 @@ export class ListMasterItemService extends EntityServiceImpl {
           enterprise_id: entId,
         });
 
-        if (nameExists) {
+        const codeExists = await this.listItemsRepo.findOneByCondition({
+          code,
+          listtype: listType,
+          enterprise_id: entId,
+        });
+
+        if (nameExists || codeExists) {
           throw new BadRequestException(
-            `list item with name ${name} already exists`,
+            `list item with name ${name} or code ${code} already exists`,
           );
         }
 
-        const finalCode = code || ''; // Could generate code here if needed
-
-        // Check if code already exists (if code is provided)
-        if (finalCode) {
-          const codeExists = await this.listItemsRepo.findOneByCondition({
-            code: finalCode,
-            listtype: listType,
-            enterprise_id: entId,
-          });
-
-          if (codeExists) {
-            throw new BadRequestException(
-              `list item with code ${finalCode} already exists`,
-            );
-          }
-        }
-
         await this.createEntity(
           {
             ...item,
             name,
-            code: finalCode,
+            code: code,
             listtype: listType,
             value: '',
           },

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

@@ -4,7 +4,6 @@ import {
   Controller,
   Get,
   HttpCode,
-  HttpStatus,
   InternalServerErrorException,
   NotFoundException,
   Param,
@@ -12,23 +11,17 @@ import {
   Query,
   Req,
   Request,
-  Res,
-  UseGuards,
 } from '@nestjs/common';
 import { EntityServiceImpl } from '../service/entity-service-impl.service';
-import { Response } from 'express';
 import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
 import { EntityMasterService } from '../service/entity-master.service';
 import { BaseEntity } from '../entity/base-entity.entity';
-import { JwtAuthGuard } from '../../auth/guards/jwt.guard';
-import * as fs from 'fs';
-import * as path from 'path';
 import { UserData } from '../../user/entity/user.entity';
 import {
   WorkflowAutomationEngineService,
 } from 'src/module/workflow-automation/service/workflow-automation-engine.service';
 
-@UseGuards(JwtAuthGuard)
+// @UseGuards(JwtAuthGuard)
 @Controller('entity')
 export class EntityController {
   constructor(
@@ -141,8 +134,7 @@ export class EntityController {
     @Query('entity_type') entityType: string,
     @Req() req: Request & { user: any },
   ) {
-    const loggedInUser = req.user.userData;
-    const appcode = loggedInUser.appcode;
+    const loggedInUser = req.user?.userData;
 
     if (!entityType) {
       throw new BadRequestException(

package/src/module/meta/entity/base-entity.entity.ts

@@ -20,6 +20,9 @@ export class BaseEntity {
   @Column({ name: 'status', type: 'varchar', nullable: true, length: 50 })
   status: string;
 
+  @Column({name: 'seq_no', type: 'bigint', nullable: true })
+  seq_no: number;
+
   @Column({ name: 'created_by', type: 'bigint', nullable: true })
   created_by: number;
 

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

@@ -0,0 +1,4 @@
+import { BaseEntity } from './base-entity.entity';
+
+export class DynamicEntity extends BaseEntity {
+}

package/src/module/meta/entity/entity-master.entity.ts

@@ -1,65 +1,31 @@
 import { BaseEntity } from './base-entity.entity';
 import { Column, Entity, Index } from 'typeorm';
+import { StorageType } from '../../../constant/storage-type.constant';
 
 @Entity({ name: 'frm_entity_master' })
 @Index('idx_entity_master_mapped_type_org', ['mapped_entity_type', 'enterprise_id'])
 export class EntityMaster extends BaseEntity {
 
-  @Column({
-    name: 'mapped_entity_type',
-    type: 'varchar',
-    length: 50,
-    nullable: false,
-  })
+  @Column({ name: 'mapped_entity_type', type: 'varchar', length: 50, nullable: false })
   mapped_entity_type: string;
 
-  @Column({ name: 'appcode', type: 'varchar', length: 50, nullable: true })
-  appcode: string;
-
-  @Column({ name: 'category', type: 'varchar', length: 50, nullable: true })
-  category: string;
+  @Column({name: 'app_id', type: 'int', nullable: true})
+  app_id: number;
 
-  @Column({ name: 'module', type: 'varchar', length: 200, nullable: true })
-  module: string;
-
-  @Column({
-    name: 'entity_data_class',
-    type: 'varchar',
-    length: 200,
-    nullable: true,
-  })
+  @Column({ name: 'entity_data_class', type: 'varchar', length: 200, nullable: true })
   entity_data_class: string;
 
-  @Column({
-    name: 'entity_service',
-    type: 'varchar',
-    length: 200,
-    nullable: true,
-  })
+  @Column({ name: 'entity_service', type: 'varchar', length: 200, nullable: true })
   entity_service: string;
 
-  @Column({
-    name: 'db_table_name',
-    type: 'varchar',
-    length: 200,
-    nullable: true,
-  })
-  db_table_name: string;
-
-  @Column({
-    name: 'description',
-    type: 'varchar',
-    length: 200,
-    nullable: true,
-  })
-  description: string;
+  // SELF,DYNAMIC
+  @Column({ name: 'storage_type', type: 'varchar' ,nullable: true, length: 20 })
+  storage_type: StorageType;
 
-  @Column({ name: 'storage_type', nullable: true, length: 20 })
-  storage_type: string;
-
-  @Column({ name: 'show_in_entity_list', nullable: true, length: 20 })
-  show_in_entity_list: string;
+  @Column({ name: 'db_table_name', type: 'varchar', length: 200, nullable: true })
+  db_table_name: string;
 
+  // manual/system/pattern
   @Column({ name: 'code_entry', nullable: true, length: 20 })
   code_entry: string;
 
@@ -69,12 +35,10 @@ export class EntityMaster extends BaseEntity {
   @Column({ name: 'data_source', nullable: true })
   data_source: string;
 
-  @Column({ name: 'is_workflow', nullable: true })
+  @Column({ name: 'is_workflow', type: 'boolean' ,nullable: true })
   is_workflow: boolean;
 
-  @Column({ name: 'doc_upload_path', nullable: true, length:50 })
-  doc_upload_path: string;
-
-  @Column({name: 'overwrite_path', type: 'int', nullable: true})
-  overwrite_path: number;
+  //FIXME: Remove appcode column
+  @Column({ name: 'appcode', type: 'varchar', length: 50, nullable: true })
+  appcode: string;
 }