rez_core 0.0.1

package/src/module/master/service/master.service.ts

@@ -0,0 +1,37 @@
+import { Injectable } from '@nestjs/common';
+import { ExcelUtil } from '../../../utils/service/excelUtil.service';
+import { EntityManager } from 'typeorm';
+
+@Injectable()
+export class MasterService {
+  constructor(
+    private readonly entityManager: EntityManager,
+    private ExcelUtil: ExcelUtil,
+  ) {}
+
+  async processExcel(file): Promise<any> {
+    const data = ExcelUtil.readExcel(file.buffer);
+
+    for (const [tableName, records] of Object.entries(data)) {
+      await this.upsertData(tableName, records);
+    }
+
+    return { message: 'Data processed successfully' };
+  }
+
+  private async upsertData(tableName: string, records: any[]): Promise<void> {
+    if (!records.length) return;
+
+    await this.entityManager.transaction(async (manager) => {
+      for (const record of records) {
+        await manager
+          .createQueryBuilder()
+          .insert()
+          .into(tableName)
+          .values(record)
+          .orUpdate(Object.keys(record), ['id']) // Using 'id' as unique identifier
+          .execute();
+      }
+    });
+  }
+}

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

@@ -0,0 +1,108 @@
+import {
+  BadRequestException,
+  Body,
+  Controller,
+  Get,
+  HttpStatus,
+  Param,
+  Post,
+  Query,
+  Res,
+  UseGuards,
+} from '@nestjs/common';
+import { EntityServiceImpl } from '../service/entity-service-impl.service';
+import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
+import { Response } from 'express';
+import { EntityMasterService } from '../service/entity-master.service';
+import { BaseEntity } from '../entity/base-entity.entity';
+import { JwtAuthGuard } from '../../auth/guards/jwt.guard';
+
+@UseGuards(JwtAuthGuard)
+@Controller('entity')
+export class EntityController {
+  constructor(
+    private entityService: EntityServiceImpl,
+    private reflectionHelper: ReflectionHelper,
+    private entityMasterService: EntityMasterService,
+  ) {}
+
+  @Get('getById/:id')
+  // @Roles('USR', 'VIEW')
+  async getById(
+    @Param('id') id: number,
+    @Query('entity_type') entityType?: string,
+  ) {
+    if (!entityType) {
+      throw new BadRequestException(
+        'Query parameter "entity_type" is required',
+      );
+    }
+    const entityMaster = await this.entityMasterService.getEntityData(entityType);
+
+    const entityService =
+        await this.reflectionHelper.getBean<EntityServiceImpl>(
+            entityMaster.entityService,
+        );
+
+    if (entityService) {
+      return await entityService.getEntityData(entityType, id);
+    }
+  }
+
+  @Post('create')
+  // @Roles('USR', 'VIEW')
+  async create(
+    @Body() entityData: BaseEntity,
+    @Query('entity_type') entityType: string,
+    @Res() res: Response,
+  ) {
+    if (!entityType) {
+      throw new BadRequestException(
+        'Query parameter "entity_type" is required',
+      );
+    }
+    const entityMaster =
+      await this.entityMasterService.getEntityData(entityType);
+
+    const entityService =
+      await this.reflectionHelper.getBean<EntityServiceImpl>(
+        entityMaster.entityService,
+      );
+
+    if (entityService) {
+      return res.status(HttpStatus.OK).json(await entityService.createEntity(entityData, null));
+    }
+  }
+
+  @Post('update/:id')
+  async update(
+    @Param('id') id: number,
+    @Body() entityData: BaseEntity,
+    @Query('entity_type') entityType: string,
+    @Res() response: Response,
+  ) {
+    if (!entityType) {
+      throw new BadRequestException(
+        'Query parameter "entity_type" is required',
+      );
+    }
+
+    const entityMaster =
+      await this.entityMasterService.getEntityData(entityType);
+
+    const entityService =
+      await this.reflectionHelper.getBean<EntityServiceImpl>(
+        entityMaster.entityService,
+      );
+
+    if (entityService) {
+      let existingEntity = await entityService.getEntityData(entityType, id);
+      if (!existingEntity) {
+      }
+      // let mergeEntity = JsonUtil.merge(existingEntity, entityData);
+
+      entityData = await entityService.updateEntity(entityData, null);
+      return response.status(HttpStatus.OK).json(entityData);
+    }
+  }
+}

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

@@ -0,0 +1,67 @@
+import { BaseEntity } from './base-entity.entity';
+import { Column, Entity } from 'typeorm';
+
+@Entity({ name: 'cr_attribute_master' })
+export class AttributeMaster extends BaseEntity {
+  @Column({ name: 'mapped_entity_type', type: 'varchar', nullable: true })
+  mapped_entity_type: string;
+
+  @Column({ name: 'mapped_entity_id' })
+  mapped_entity_id: number;
+
+  @Column({ name: 'element_type', type: 'varchar', nullable: true, length: 50 })
+  element_type: string;
+
+  @Column({
+    name: 'data_source_type',
+    type: 'varchar',
+    nullable: true,
+    length: 50,
+  })
+  data_source_type: string;
+
+  @Column({ name: 'datasource_list', type: 'varchar', nullable: true })
+  datasource_list: string;
+
+  @Column({
+    name: 'custom_values',
+    type: 'varchar',
+    length: 2000,
+    nullable: true,
+  })
+  custom_values: string;
+
+  @Column({ name: 'max_length', nullable: true })
+  max_length: number;
+
+  @Column({ name: 'required', nullable: true })
+  required: number;
+
+  @Column({
+    name: 'description',
+    type: 'varchar',
+    length: 2000,
+    nullable: true,
+  })
+  description: string;
+
+  @Column({
+    name: 'attribute_key',
+    type: 'varchar',
+    nullable: true,
+    length: 50,
+  })
+  attribute_key: string;
+
+  @Column({ name: 'db_datatype', type: 'varchar', nullable: true, length: 50 })
+  db_datatype: string;
+
+  @Column({ name: 'category', type: 'varchar', nullable: true, length: 50 })
+  category: string;
+
+  @Column({ name: 'is_unique', nullable: true })
+  is_unique: number;
+
+  @Column({ name: 'can_export', nullable: true })
+  can_export: number;
+}

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

@@ -0,0 +1,53 @@
+import { Column, PrimaryGeneratedColumn } from 'typeorm';
+import { StatusType } from '../../../constant/status.constant';
+import {Expose} from "class-transformer";
+
+export class BaseEntity {
+  constructor() {
+    this.created_date = new Date();
+  }
+
+  @PrimaryGeneratedColumn({ type: 'bigint' })
+  @Expose()
+  id: number;
+  @Column({ name: 'entity_type', type: 'varchar', length: 100, nullable: true })
+  @Expose()
+  entity_type: string;
+  @Column({ name: 'name', type: 'varchar', length: 100, nullable: true })
+  @Expose()
+  name: string;
+  @Column({ name: 'status', type: 'varchar', nullable: true, length: 100 })
+  @Expose()
+  status: StatusType;
+  @Column({ name: 'parent_type', type: 'varchar', length: 100, nullable: true })
+  @Expose()
+  parent_type: string;
+  @Column({ name: 'parent_id', type: 'bigint', nullable: true })
+  @Expose()
+  parent_id: number;
+  @Column({ name: 'code', type: 'varchar', length: 100, nullable: true })
+  @Expose()
+  code: string;
+  @Column({ name: 'created_by', type: 'bigint', nullable: true })
+  @Expose()
+  created_by: number;
+  @Column({
+    name: 'created_date',
+    type: 'datetime',
+    nullable: true,
+  })
+  @Expose()
+  created_date: Date;
+  @Column({ name: 'modified_by', type: 'bigint', nullable: true })
+  @Expose()
+  modified_by: number;
+  @Column({ name: 'modified_date', type: 'datetime', nullable: true })
+  @Expose()
+  modified_date: Date;
+  @Column({ name: 'enterprise_id', type: 'int', nullable: true })
+  @Expose()
+  enterprise_id: number;
+  @Column({ name: 'organization_id', type: 'int', nullable: true })
+  @Expose()
+  organization_id: number;
+}

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

@@ -0,0 +1,62 @@
+import { BaseEntity } from './base-entity.entity';
+import { ENTITYTYPE_ENTITYMASTER } from '../../../constant/global.constant';
+import { Column, Entity } from 'typeorm';
+import { ApiProperty } from '@nestjs/swagger';
+
+@Entity({ name: 'cr_entity_master' })
+export class EntityMaster extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = ENTITYTYPE_ENTITYMASTER;
+  }
+
+  @Column({
+    name: 'mapped_entity_type',
+    type: 'varchar',
+    length: 50,
+    nullable: false,
+  })
+  @ApiProperty({ name: 'mapped_entity_type' })
+  mappedEntityType: 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: 'module', type: 'varchar', length: 200, nullable: true })
+  module: string;
+
+  @Column({
+    name: 'entity_data_class',
+    type: 'varchar',
+    length: 200,
+    nullable: true,
+  })
+  entityDataClass: string;
+
+  @Column({
+    name: 'entity_service',
+    type: 'varchar',
+    length: 200,
+    nullable: true,
+  })
+  entityService: string;
+
+  @Column({
+    name: 'db_table_name',
+    type: 'varchar',
+    length: 200,
+    nullable: true,
+  })
+  dbTableName: string;
+
+  @Column({
+    name: 'description',
+    type: 'varchar',
+    length: 200,
+    nullable: true,
+  })
+  description: string;
+}

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

@@ -0,0 +1,65 @@
+import { BaseEntity } from './base-entity.entity';
+import { Column, Entity } from 'typeorm';
+import { ENTITYTYPE_PREFERENCEMASTER } from '../../../constant/global.constant';
+
+@Entity({ name: 'cr_preference_master' })
+export class PreferenceMaster extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = ENTITYTYPE_PREFERENCEMASTER;
+  }
+
+  @Column({ name: 'appcode', type: 'varchar', length: 200, nullable: true })
+  appCode: string;
+
+  @Column({
+    name: 'display_name',
+    type: 'varchar',
+    length: 200,
+    nullable: true,
+  })
+  display_name: string;
+
+  @Column({
+    name: 'preference_key',
+    type: 'varchar',
+    length: 200,
+    nullable: true,
+  })
+  preference_key: string;
+
+  @Column({
+    name: 'preference_value',
+    type: 'varchar',
+    length: 200,
+    nullable: true,
+  })
+  preference_value: string;
+
+  @Column({
+    name: 'description',
+    type: 'varchar',
+    length: 2000,
+    nullable: true,
+  })
+  description: string;
+
+  @Column({ name: 'reflect_on', type: 'varchar', length: 200, nullable: true })
+  reflect_on: string;
+
+  @Column({
+    name: 'default_value',
+    type: 'varchar',
+    length: 200,
+    nullable: true,
+  })
+  default_value: string;
+
+  @Column({
+    name: 'possible_values',
+    type: 'varchar',
+    length: 200,
+    nullable: true,
+  })
+  possible_values: string;
+}

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

@@ -0,0 +1,32 @@
+import { Module } from '@nestjs/common';
+import { EntityMasterService } from './service/entity-master.service';
+import { EntityServiceImpl } from './service/entity-service-impl.service';
+import { EntityController } from './controller/entity.controller';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { UtilsModule } from '../../utils/utils.module';
+import { EntityMaster } from './entity/entity-master.entity';
+import { AttributeMaster } from './entity/attribute-master.entity';
+import { AttributeMasterRepository } from './repository/attribute-master.repository';
+import { PreferenceService } from './service/preference.service';
+import { PreferenceRepository } from './repository/preference.repository';
+import { PreferenceMaster } from './entity/preference.entity';
+import { MasterController } from '../master/controller/master.controller';
+import { MasterService } from '../master/service/master.service';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([EntityMaster, AttributeMaster, PreferenceMaster]),
+    UtilsModule,
+  ],
+  providers: [
+    EntityMasterService,
+    EntityServiceImpl,
+    AttributeMasterRepository,
+    PreferenceService,
+    PreferenceRepository,
+    MasterService,
+  ],
+  exports: [EntityMasterService, EntityServiceImpl, PreferenceService],
+  controllers: [EntityController, MasterController],
+})
+export class EntityModule {}

package/src/module/meta/repository/attribute-master.repository.ts

@@ -0,0 +1,28 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { AttributeMaster } from '../entity/attribute-master.entity';
+import { Repository } from 'typeorm';
+
+@Injectable()
+export class AttributeMasterRepository {
+  constructor(
+    @InjectRepository(AttributeMaster)
+    private readonly attributeMasterRepository: Repository<AttributeMaster>,
+  ) {}
+
+  async findByMappedEntityIdAndMappedEntityTypeAndAttributeKeyAndOrganizationId(
+    mappedEntityId: number,
+    mappedEntityType: string,
+    attributeKey: string,
+    organizationId: number,
+  ): Promise<AttributeMaster | null> {
+    return await this.attributeMasterRepository.findOne({
+      where: {
+        mapped_entity_id: mappedEntityId,
+        mapped_entity_type: mappedEntityType,
+        attribute_key: attributeKey,
+        organization_id: organizationId,
+      },
+    });
+  }
+}

package/src/module/meta/repository/preference.repository.ts

@@ -0,0 +1,20 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { PreferenceMaster } from '../entity/preference.entity';
+import { Repository } from 'typeorm';
+
+@Injectable()
+export class PreferenceRepository {
+  constructor(
+    @InjectRepository(PreferenceMaster)
+    private readonly preferenceRepository: Repository<PreferenceMaster>,
+  ) {}
+
+  async findByPreferenceKey(
+    preferenceKey: string,
+  ): Promise<PreferenceMaster | null> {
+    return await this.preferenceRepository.findOne({
+      where: { preference_key: preferenceKey },
+    });
+  }
+}

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

@@ -0,0 +1,26 @@
+import { Injectable } from '@nestjs/common';
+import { Repository } from 'typeorm';
+import { InjectRepository } from '@nestjs/typeorm';
+import { EntityMaster } from '../entity/entity-master.entity';
+
+@Injectable()
+export class EntityMasterService {
+  constructor(
+    @InjectRepository(EntityMaster)
+    private entityMasterRepository: Repository<EntityMaster>,
+  ) {}
+
+  async getEntityData(mappedEntityType: string): Promise<EntityMaster> {
+    const entityMaster = await this.entityMasterRepository.findOne({
+      where: { mappedEntityType },
+    });
+
+    if (!entityMaster) {
+      throw new Error(
+        `Entity with mappedEntityType "${mappedEntityType}" not found.`,
+      );
+    }
+
+    return entityMaster;
+  }
+}

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

@@ -0,0 +1,131 @@
+import { EntityService } from './entity.service';
+import { Injectable } from '@nestjs/common';
+import { UserData } from '../../user/entity/user.entity';
+import { EntityMasterService } from './entity-master.service';
+import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
+import { BaseEntity } from '../entity/base-entity.entity';
+import {LoggingService} from "../../../utils/service/loggingUtil.service";
+
+@Injectable()
+export class EntityServiceImpl implements EntityService<BaseEntity> {
+  constructor(
+    private entityMasterService: EntityMasterService,
+    private reflectionHelper: ReflectionHelper,
+    loggingService: LoggingService,
+  ) {}
+
+  async createEntity(
+    entityData: BaseEntity,
+    loggedInUser: UserData | null,
+  ): Promise<BaseEntity> {
+    const entityMaster = await this.entityMasterService.getEntityData(
+      entityData.entity_type,
+    );
+
+    const repoService = this.reflectionHelper.getRepoService(
+      entityMaster.entityDataClass,
+    );
+    if (!repoService) {
+      throw new Error(
+        `Repository service not found for entityType: ${entityData.entity_type}`,
+      );
+    }
+    entityData.entity_type = entityMaster.mappedEntityType;
+    entityData.created_date = new Date();
+    if (loggedInUser) {
+      entityData.created_by = loggedInUser.id;
+    }
+
+    const savedEntity = repoService.save(entityData);
+    return savedEntity;
+  }
+
+  deleteEntity(
+    entityType: string,
+    entityId: number,
+    loggedInUserData: UserData,
+  ) {}
+
+  async findByCode(entityType: string, code: string): Promise<BaseEntity> {
+    const entityData = await this.entityMasterService.getEntityData(entityType);
+
+    const repoService = this.reflectionHelper.getRepoService(
+      entityData.entityDataClass,
+    );
+    if (!repoService) {
+      throw new Error(
+        `Repository service not found for entityType: ${entityType}`,
+      );
+    }
+    const result = await repoService?.findOne({ where: { code: code } });
+
+    if (!result) {
+      throw new Error(`Entity not found for entityType: ${entityType}`);
+    }
+    return result;
+  }
+
+  async getEntityData(
+    entityType: string,
+    id: number,
+  ): Promise<BaseEntity | null> {
+    const entityData = await this.entityMasterService.getEntityData(entityType);
+    // this.loggingService.log(
+    //   'info',
+    //   EntityServiceImpl.name,
+    //   'GetEntity',
+    //   'STARTED',
+    //   [{ entityData }],
+    // );
+
+    const repoService = this.reflectionHelper.getRepoService(
+      entityData.entityDataClass,
+    );
+    if (!repoService) {
+      throw new Error(
+        `Repository service not found for entityType: ${entityType}`,
+      );
+    }
+    return await repoService.findOne({ where: { id: id } });
+  }
+
+  async getEntityList(entityType: string): Promise<BaseEntity[]> {
+    const entityData = await this.entityMasterService.getEntityData(entityType);
+    const repoService = this.reflectionHelper.getRepoService(
+      entityData.entityDataClass,
+    );
+    if (!repoService) {
+      throw new Error(
+        `Repository service not found for entityType: ${entityType}`,
+      );
+    }
+
+    const result = await repoService.find();
+    return result;
+  }
+
+  async updateEntity(
+    entityData: BaseEntity,
+    loggedInUserData: UserData | null,
+  ): Promise<BaseEntity> {
+    const entityMaster = await this.entityMasterService.getEntityData(
+      entityData.entity_type,
+    );
+
+    const repoService = this.reflectionHelper.getRepoService(
+      entityMaster.entityDataClass,
+    );
+    if (!repoService) {
+      throw new Error(
+        `Repository service not found for entityType: ${entityData.entity_type}`,
+      );
+    }
+
+    entityData.modified_date = new Date();
+    if (loggedInUserData) {
+      entityData.modified_by = loggedInUserData.id;
+    }
+    await repoService.update(entityData.id, entityData);
+    return await repoService.findOne({where : {id : entityData.id}})
+  }
+}

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

@@ -0,0 +1,23 @@
+import { UserData } from '../../user/entity/user.entity';
+import { BaseEntity } from '../entity/base-entity.entity';
+
+export interface EntityService<T extends BaseEntity> {
+  createEntity(entityData: T, loggedInUser: UserData): Promise<BaseEntity>;
+
+  getEntityData(
+    entityType: string,
+    entityId: number,
+  ): Promise<BaseEntity | null>;
+
+  getEntityList(entityType: string): Promise<BaseEntity[]>;
+
+  updateEntity(entityData: T, loggedInUserData: UserData): Promise<BaseEntity>;
+
+  deleteEntity(
+    entityType: string,
+    entityId: number,
+    loggedInUserData: UserData,
+  ): void;
+
+  findByCode(entityType: string, code: string): Promise<BaseEntity>;
+}

package/src/module/meta/service/preference.service.ts

@@ -0,0 +1,24 @@
+import { EntityServiceImpl } from './entity-service-impl.service';
+import { Injectable } from '@nestjs/common';
+import { PreferenceRepository } from '../repository/preference.repository';
+import { EntityMasterService } from './entity-master.service';
+import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
+import { LoggingService } from '../../../utils/service/loggingUtil.service';
+
+@Injectable()
+export class PreferenceService extends EntityServiceImpl {
+  constructor(
+    entityMasterService: EntityMasterService,
+    reflectionHelper: ReflectionHelper,
+    loggingService: LoggingService,
+    private readonly preferenceRepository: PreferenceRepository,
+  ) {
+    super(entityMasterService, reflectionHelper, loggingService);
+  }
+
+  async getPreferenceValue(preferenceKey: string): Promise<string | undefined> {
+    const preferenceMaster =
+      await this.preferenceRepository.findByPreferenceKey(preferenceKey);
+    return preferenceMaster?.preference_value;
+  }
+}