rez_core 7.1.28 → 7.1.30

package/src/module/entity/{meta → data}/service/entity-data.service.ts

@@ -1,13 +1,31 @@
-import { BadRequestException, Inject, Injectable } from '@nestjs/common';
+import {
+  BadRequestException, Body,
+  Get,
+  HttpCode,
+  Inject,
+  Injectable, InternalServerErrorException, NotFoundException,
+  Param,
+  Post,
+  Query,
+  Req,
+  Request,
+} from '@nestjs/common';
 import { UserData } from '../../../auth/dto/user.dto';
-import { AttributeMasterService } from './attribute-master.service';
+import { AttributeMasterService } from '../../meta/meta/service/attribute-master.service';
 import { ConfigService } from '@nestjs/config';
 import { firstValueFrom } from 'rxjs';
 import { IMicroserviceClients } from '../../../microservice-client/service/microservice-clients';
 import { ListMasterService } from '../../../listmaster/service/list-master.service';
 import { STATUS_ACTIVE, STATUS_INACTIVE } from '../../../../constant/global.constant';
-import { EntityMasterService } from './entity-master.service';
+import { EntityMasterService } from '../../meta/meta/service/entity-master.service';
 import { EntityManager } from 'typeorm';
+import { ReflectionHelper } from '../../../../utils/service/reflection-helper.service';
+import { EntityServiceImpl } from './entity-service-impl.service';
+import { BaseEntity } from '../../meta/meta/entity/base-entity.entity';
+import { MessagePattern, Payload } from '@nestjs/microservices';
+import {
+  WorkflowAutomationEngineService
+} from '../../../workflow/workflow-automation/service/workflow-automation-engine.service';
 
 @Injectable()
 export class EntityDataService {
@@ -22,11 +40,230 @@ export class EntityDataService {
     private readonly listMasterService: ListMasterService,
     @Inject('EntityMasterService')
     private readonly entityMasterService: EntityMasterService,
+    private readonly reflectionHelper: ReflectionHelper,
+    private readonly workflowAutomationEngineService: WorkflowAutomationEngineService,
   ) {
   }
 
   schema = this.configService.get('DB_SCHEMA');
 
+  async getById(
+    entityType: string,
+    id: number,
+    loggedInUser: UserData,
+    resolved = false,
+  ) {
+    if (!entityType) {
+      throw new BadRequestException(
+        'Query parameter "entity_type" is required',
+      );
+    }
+    const entityMaster = await this.entityMasterService.getEntityData(
+      entityType,
+      loggedInUser,
+    );
+
+    const entityService =
+      await this.reflectionHelper.getBean<EntityServiceImpl>(
+        entityMaster.entity_service,
+      );
+
+    if (entityService) {
+      return await entityService.getEntityData(entityType, id, loggedInUser, resolved);
+    }
+  }
+
+  async getDataByCode(
+    code: string,
+    loggedInUser: UserData,
+    entityType?: string,
+  ) {
+
+    if (!entityType) {
+      throw new BadRequestException(
+        'Query parameter "entity_type" is required',
+      );
+    }
+
+    const entityMaster = await this.entityMasterService.getEntityData(
+      entityType,
+      loggedInUser,
+    );
+
+    const entityService =
+      await this.reflectionHelper.getBean<EntityServiceImpl>(
+        entityMaster.entity_service,
+      );
+
+    if (entityService) {
+      return await entityService.getEntityDataByCode(
+        entityType,
+        code,
+        loggedInUser,
+      );
+    }
+  }
+
+  async create(
+    entityData: BaseEntity,
+    entityType: string,
+    loggedInUser: UserData,
+  ) {
+    if (!entityType) {
+      throw new BadRequestException(
+        `Query parameter "entity_type" is required`,
+      );
+    }
+
+    const entityMaster = await this.entityMasterService.getEntityData(
+      entityType,
+      loggedInUser,
+    );
+
+    const entityService =
+      await this.reflectionHelper.getBean<EntityServiceImpl>(
+        entityMaster.entity_service,
+      );
+
+    if (!entityService) {
+      throw new InternalServerErrorException(
+        `No service found for entity_type "${entityType}"`,
+      );
+    }
+
+    // ✅ Create
+    const savedData = await entityService.createEntity(
+      entityData,
+      loggedInUser as UserData,
+      null,
+    );
+
+    // ✅ Run workflow automation (no preUpdateStates for CREATE)
+    await this.workflowAutomationEngineService.handleEntityEvent(
+      entityType,
+      'CREATE',
+      savedData,
+      loggedInUser,
+      null,
+    );
+
+    return savedData;
+  }
+
+  async update(
+   id: number,
+   entityData: BaseEntity,
+   entityType: string,
+   loggedInUser: UserData
+  ) {
+    if (!entityType) {
+      throw new BadRequestException(
+        'Query parameter "entity_type" is required',
+      );
+    }
+
+    const entityMaster = await this.entityMasterService.getEntityData(
+      entityType,
+      loggedInUser,
+    );
+
+    const entityService =
+      await this.reflectionHelper.getBean<EntityServiceImpl>(
+        entityMaster.entity_service,
+      );
+
+    if (!entityService) {
+      throw new InternalServerErrorException(
+        `No service found for entity_type "${entityType}"`,
+      );
+    }
+
+    // 1️⃣ Get old state
+    const existingEntity = await entityService.getEntityData(
+      entityType,
+      id,
+      loggedInUser,
+    );
+    if (!existingEntity) {
+      throw new NotFoundException(`No entity found for id "${id}"`);
+    }
+
+    // 2️⃣ Pre-evaluate criteria
+    const workflows = await this.workflowAutomationEngineService[
+      'wfService'
+      ].getActiveRules(entityType, 'UPDATE', loggedInUser);
+    const preUpdateStates: Record<number, boolean> = {};
+    for (const wf of workflows) {
+      preUpdateStates[wf.id] = await this.workflowAutomationEngineService[
+        'filterEvaluator'
+        ].evaluateCriteria(
+        entityType,
+        wf.condition_filter_code,
+        existingEntity.id,
+        loggedInUser,
+      );
+    }
+
+    // 3️⃣ Update
+    const updatedData = await entityService.updateEntity(
+      entityData,
+      loggedInUser as UserData,
+    );
+
+    // 4️⃣ Run workflow automation (pass preUpdateStates)
+    await this.workflowAutomationEngineService.handleEntityEvent(
+      entityType,
+      'UPDATE',
+      updatedData,
+      loggedInUser,
+      preUpdateStates,
+    );
+
+    return updatedData;
+  }
+
+  async delete(
+    id: number,
+    entityType: string,
+    loggedInUser: UserData,
+  ) {
+
+    if (!entityType) {
+      throw new BadRequestException(
+        'Query parameter "entity_type" is required',
+      );
+    }
+
+    const entityMaster = await this.entityMasterService.getEntityData(
+      entityType,
+      loggedInUser,
+    );
+
+    const entityService =
+      await this.reflectionHelper.getBean<EntityServiceImpl>(
+        entityMaster.entity_service,
+      );
+
+    if (!entityService) {
+      throw new InternalServerErrorException(
+        `No service found for entity_type "${entityType}"`,
+      );
+    }
+
+    const existingEntity = await entityService.getEntityData(
+      entityType,
+      id,
+      loggedInUser,
+    );
+
+    if (!existingEntity) {
+      throw new NotFoundException(`No entity found for id "${id}"`);
+    }
+
+    return await entityService.deleteEntity(entityType, id, loggedInUser);
+  }
+
+
   async getDropDownData(
     entity_type: string,
     attribute_key: string,

package/src/module/entity/{meta → data}/service/entity-dynamic.service.ts

@@ -3,13 +3,13 @@ import { STATUS_ACTIVE } from 'src/constant/global.constant';
 import { EntityManager, In } from 'typeorm';
 import { UserData } from 'src/module/auth/dto/user.dto';
 import { MediaDataService } from './media-data.service';
-import { EntityMasterRepository } from '../repository/entity-master.repository';
+import { EntityMasterRepository } from '../../meta/meta/repository/entity-master.repository';
 import { ConfigService } from '@nestjs/config';
 import { EntityServiceImpl } from './entity-service-impl.service';
-import { EAVService } from '../../eav/service/eav.service';
+import { EAVService } from '../eav/service/eav.service';
 import { AttributeStorageType } from '../../../../constant/attribute.constant';
 import { StorageType } from '../../../../constant/entity.constant';
-import { EntityJSONService } from '../../entity_json/service/entity_json.service';
+import { EntityJSONService } from '../entity_json/service/entity_json.service';
 
 @Injectable()
 export class EntityDynamicService extends EntityServiceImpl {
@@ -944,27 +944,6 @@ export class EntityDynamicService extends EntityServiceImpl {
 
   // -----------------------------
 
-  async getEntitiesDropdownList(
-    loggedInUser: any,
-    appcode?: string,
-  ): Promise<any> {
-    const entityMasters =
-      await this.entityMasterRepo.findByEnterpriseIdAndAppCode(
-        loggedInUser.enterprise_id,
-        appcode,
-      );
-
-    let dropdown = [] as any;
-    entityMasters.map((entityMaster) =>
-      dropdown.push({
-        label: entityMaster.name,
-        value: entityMaster.mapped_entity_type,
-      }),
-    );
-
-    return dropdown;
-  }
-
   async getCode(entityType: string, loggedInUser: any): Promise<string> {
     const enterprise_id = loggedInUser.enterprise_id;
 

package/src/module/entity/{meta → data}/service/entity-service-impl.service.ts

@@ -1,9 +1,9 @@
 import { EntityService } from './entity.service';
 import { BadRequestException, forwardRef, Inject, Injectable, NotFoundException } from '@nestjs/common';
 import { UserData } from 'src/module/auth/dto/user.dto';
-import { EntityMasterService } from './entity-master.service';
+import { EntityMasterService } from '../../meta/meta/service/entity-master.service';
 import { ReflectionHelper } from '../../../../utils/service/reflection-helper.service';
-import { BaseEntity } from '../entity/base-entity.entity';
+import { BaseEntity } from '../../meta/meta/entity/base-entity.entity';
 import { LoggingService } from '../../../../utils/service/loggingUtil.service';
 import { EntityManager } from 'typeorm';
 import { ENTITYTYPE_ENTITYMASTER, STATUS_ACTIVE } from '../../../../constant/global.constant';

package/src/module/entity/{meta → data}/service/entity-validation.service.ts

@@ -1,6 +1,6 @@
 import { Inject, Injectable } from '@nestjs/common';
-import { AttributeMasterService } from 'src/module/entity/meta/service/attribute-master.service';
-import { AttributeMaster } from '../entity/attribute-master.entity';
+import { AttributeMasterService } from 'src/module/entity/meta/meta/service/attribute-master.service';
+import { AttributeMaster } from '../../meta/meta/entity/attribute-master.entity';
 import { ConfigService } from '@nestjs/config';
 
 interface ValidationError {

package/src/module/entity/{meta → data}/service/entity.service.ts

@@ -1,5 +1,5 @@
 import { UserData } from 'src/module/auth/dto/user.dto';
-import { BaseEntity } from '../entity/base-entity.entity';
+import { BaseEntity } from '../../meta/meta/entity/base-entity.entity';
 import { EntityManager } from 'typeorm';
 
 export interface EntityService<T extends BaseEntity> {

package/src/module/entity/{export → data}/service/export.service.ts

@@ -1,13 +1,13 @@
 import { Inject, Injectable } from '@nestjs/common';
-import { FilterRequestDto } from '../../filter/dto/filter-request.dto';
+import { FilterRequestDto } from '../filter/dto/filter-request.dto';
 import { ExcelData } from '../../../../utils/dto/excel-data.dto';
 import * as path from 'path';
 import * as fs from 'fs';
 import { ExcelHelper } from '../../../../utils/service/excel-helper.service';
-import { AttributeMasterService } from '../../meta/service/attribute-master.service';
-import { EntityMasterService } from '../../meta/service/entity-master.service';
-import { EntityFilterService } from '../../filter/service/entity-filter.service';
-import { LayoutPreferenceService } from '../../layout_preference/service/layout_preference.service';
+import { AttributeMasterService } from '../../meta/meta/service/attribute-master.service';
+import { EntityMasterService } from '../../meta/meta/service/entity-master.service';
+import { EntityFilterService } from '../filter/service/entity-filter.service';
+import { LayoutPreferenceService } from '../../meta/layout_preference/service/layout_preference.service';
 import { ExcelsheetData } from '../../../../utils/dto/excelsheet-data.dto';
 
 @Injectable()

package/src/module/entity/{meta → data}/service/media-data.service.ts

@@ -8,8 +8,8 @@ import {
   ENTITYTYPE_MEDIA,
   STATUS_PENDING,
 } from '../../../../constant/global.constant';
-import { MediaData } from '../entity/media-data.entity';
-import { MediaDataRepository } from '../repository/media-data.repository';
+import { MediaData } from '../../meta/meta/entity/media-data.entity';
+import { MediaDataRepository } from '../../meta/meta/repository/media-data.repository';
 import { EntityServiceImpl } from './entity-service-impl.service';
 
 @Injectable()

package/src/module/entity/{meta → data}/service/resolver.service.ts

@@ -2,7 +2,7 @@ import { Inject, Injectable } from '@nestjs/common';
 import * as moment from 'moment';
 import { ListMasterService } from 'src/module/listmaster/service/list-master.service';
 import { ModuleRef } from '@nestjs/core';
-import { AttributeMasterRepository } from '../repository/attribute-master.repository';
+import { AttributeMasterRepository } from '../../meta/meta/repository/attribute-master.repository';
 
 @Injectable()
 export class ResolverService {

package/src/module/entity/{mapper → meta}/controller/field-mapper.controller.ts

@@ -11,9 +11,9 @@ import {
   Req,
   UseGuards,
 } from '@nestjs/common';
-import { FieldMapperService } from '../service/field-mapper.service';
+import { FieldMapperService } from '../mapper/service/field-mapper.service';
 import { JwtAuthGuard } from '../../../auth/guards/jwt.guard';
-import { FieldMapperDto } from '../dto/field-mapper.dto';
+import { FieldMapperDto } from '../mapper/dto/field-mapper.dto';
 
 @Controller('field-mapper')
 @UseGuards(JwtAuthGuard)
@@ -51,13 +51,6 @@ export class FieldMapperController {
     return this.fieldMapperService.createFieldMappers(dtos, loggedInUser);
   }
 
-  @Post('bulk-update')
-  @HttpCode(HttpStatus.OK)
-  async updateBulk(@Req() req: any, @Body() dtos: FieldMapperDto[]) {
-    const loggedInUser = req.user.userData;
-    return this.fieldMapperService.updateFieldMappers(dtos, loggedInUser);
-  }
-
   @Get('getFields/:mapperId')
   async getFieldsByMapper(
     @Param('mapperId') mapperId: number,

package/src/module/entity/{linked_attributes → meta}/controller/linked_attributes.controller.ts

@@ -10,9 +10,9 @@ import {
   Query,
 } from '@nestjs/common';
 import { ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
-import { LinkedAttributesService } from '../service/linked_attributes.service';
+import { LinkedAttributesService } from '../linked_attributes/service/linked_attributes.service';
 import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
-import { CreateLinkedAttributeSmartDto } from '../dto/create-linked-attribute-smart.dto';
+import { CreateLinkedAttributeSmartDto } from '../linked_attributes/dto/create-linked-attribute-smart.dto';
 
 @ApiTags('Linked Attributes')
 @Controller('linked-attributes')

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

@@ -1,8 +1,25 @@
-import { Body, Controller, HttpCode, HttpStatus, Inject, Post, Query, Req, Res, UseGuards } from '@nestjs/common';
-import { ListingLayoutService } from '../service/entity-table.service';
+import {
+  Body,
+  Controller,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Inject, Param,
+  Post,
+  Query,
+  Req, Request,
+  Res,
+  UseGuards,
+} from '@nestjs/common';
+import { ListingLayoutService } from '../meta/service/listing-layout.service';
 import { Response } from 'express';
 import { JwtAuthGuard } from '../../../auth/guards/jwt.guard';
-import { EntityMasterService } from '../service/entity-master.service';
+import { EntityMasterService } from '../meta/service/entity-master.service';
+import { ViewMasterService } from '../meta/service/view-master.service';
+import { MapperService } from '../mapper/service/mapper.service';
+import { LayoutPreferenceService } from '../layout_preference/service/layout_preference.service';
+import { EntityRelationService } from '../meta/service/entity-relation.service';
+import { AttributeMasterService } from '../meta/service/attribute-master.service';
 
 @Controller('meta')
 @UseGuards(JwtAuthGuard)
@@ -10,7 +27,17 @@ export class MetaController {
   constructor(
     private readonly entityTableService: ListingLayoutService,
     @Inject('EntityMasterService')
-    private readonly entityMaster: EntityMasterService,
+    private readonly entityMasterService: EntityMasterService,
+    @Inject('ViewMasterService')
+    private readonly viewMasterService: ViewMasterService,
+    @Inject('MapperService')
+    private readonly mapperService: MapperService,
+    @Inject('LayoutPreferenceService')
+    private readonly layoutPreferenceService: LayoutPreferenceService,
+    @Inject('EntityRelationService')
+    private readonly entityRelationService: EntityRelationService,
+    @Inject('AttributeMasterService')
+    private readonly attributeMasterService: AttributeMasterService,
   ) {
   }
 
@@ -44,7 +71,7 @@ export class MetaController {
     @Req() req: Request & { user: any },
   ) {
     const loggedInUser = req.user.userData;
-    const entitydata = await this.entityMaster.getFilterMetaData(
+    const entitydata = await this.entityMasterService.getFilterMetaData(
       entityType,
       loggedInUser,
     );
@@ -60,7 +87,7 @@ export class MetaController {
   @HttpCode(HttpStatus.OK)
   async getOperationList(@Req() req: Request & { user: any }) {
     const loggedInUser = req.user.userData;
-    const result = await this.entityMaster.getOperationList(loggedInUser);
+    const result = await this.entityMasterService.getOperationList(loggedInUser);
     return result;
   }
 
@@ -71,10 +98,143 @@ export class MetaController {
     @Body('entity_type') entity_type: string,
   ) {
     const loggedInUser = req.user.userData;
-    const result = await this.entityMaster.getAttributesOfTypeDate(
+    const result = await this.entityMasterService.getAttributesOfTypeDate(
       entity_type,
       loggedInUser,
     );
     return result;
   }
+
+  @Get('getEntityMasterList')
+  async getEntityMasterList(
+    @Req() req: Request & { user: any },
+    @Query('appcode') appcode?: string,
+  ) {
+    const loggedInUser = req.user.userData;
+    return await this.entityMasterService.getEntityMasterList(
+      loggedInUser,
+      appcode,
+    );
+  }
+
+  @Get('view_master')
+  @HttpCode(HttpStatus.OK)
+  async getEntityJsonByType(
+    @Query('entity_type') entityType: string,
+    @Query('type') type: string,
+    @Query('code') code: string,
+    @Res() res: Response,
+    @Req() req: Request & { user: any },
+  ) {
+    const loggedInUser = req.user.userData;
+
+    try {
+      if (!entityType || !type) {
+        return res.status(HttpStatus.BAD_REQUEST).json({
+          success: false,
+          message: 'Missing entity_type or type query parameter',
+        });
+      }
+
+      const result = await this.viewMasterService.getEntityJson(
+        entityType,
+        type,
+        loggedInUser,
+        code,
+      );
+
+      return res.status(HttpStatus.OK).json({
+        success: true,
+        message: 'Entity data fetched successfully',
+        data: result,
+      });
+    } catch (error) {
+      return res.status(HttpStatus.INTERNAL_SERVER_ERROR).json({
+        success: false,
+        message: error.message || 'Error fetching entity data',
+      });
+    }
+  }
+
+  @Get('mapper/all')
+  async getByMappedEntityType(@Query('mapped_entity_type') mappedEntityType: string,
+                              @Req() req: Request & { user: any },
+                              @Query('filter') filter?: string,
+                              @Query('status') status?: string,
+  ) {
+    const loggedInUser = req.user.userData;
+    return this.mapperService.getByMappedEntityType(mappedEntityType,loggedInUser, filter, status);
+  }
+
+  @Get('layout-preference')
+  @UseGuards(JwtAuthGuard)
+  @HttpCode(HttpStatus.OK)
+  async getFilterById(
+    @Query('entity_type') entity_type: string,
+    @Query('type') type: string,
+    @Req() req: Request & { user: any },
+  ) {
+    const userDat = req.user.userData;
+
+    return this.layoutPreferenceService.getLayoutPreferenceByUserID(
+      userDat.id,
+      entity_type,
+      userDat.level_id,
+      userDat.level_type,
+      type,
+    );
+  }
+
+  @Get('entity-relation/:source_entity_type')
+  async getEntityRelations(
+    @Param('source_entity_type') sourceEntityType: string,
+    @Query('include') include: string, // <-- new param
+    @Request() req: any,
+  ): Promise<any> {
+    const loggedInUser = req.user.userData;
+    const shouldIncludeSelf = include === 'true';
+
+    return this.entityRelationService.getEntityRelations(
+      sourceEntityType,
+      loggedInUser,
+      shouldIncludeSelf,
+    );
+  }
+
+  @Get('entity-relation/getAllEntityRelationDropdown/:entity_type')
+  @HttpCode(HttpStatus.OK)
+  async getAllEntity(
+    @Param('entity_type') entity_type: string,
+    @Req() req: Request & { user: any },
+  ) {
+
+    const loggedInUser = req.user.userData;
+
+    // console.log(loggedInUser);
+    return await this.entityRelationService.getAllEntityDropDown(entity_type,loggedInUser)
+  }
+
+
+  @Get('attribute-master/getDropdownList/:entityType')
+  async getAttributesDropdownList(
+    @Param('entityType') entityType: string,
+    @Req() req: Request & { user: any },
+  ) {
+    const loggedInUser = req.user.userData;
+    return await this.attributeMasterService.getAttributesDropdownList(
+      entityType,
+      loggedInUser,
+    );
+  }
+
+  @Get('attribute-master/getAttributes')
+  async getAttributes(
+    @Query('entity_type') entityType: string,
+    @Req() req: Request & { user: any },
+    @Query('direct') direct: boolean = false,
+    @Query('element_type') elementType?: string,
+  ) {
+    const loggedInUser = req.user.userData;
+    return await this.attributeMasterService.getEntityAttributes(entityType, loggedInUser, direct, elementType);
+  }
 }

package/src/module/entity/{layout_preference → meta/layout_preference}/entity/layout_preference.entity.ts

@@ -1,4 +1,4 @@
-import { BaseEntity } from 'src/module/entity/meta/entity/base-entity.entity';
+import { BaseEntity } from 'src/module/entity/meta/meta/entity/base-entity.entity';
 import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
 
 @Entity({ name: 'frm_entity_layout_pref' })

package/src/module/entity/{layout_preference → meta/layout_preference}/layout_preference.module.ts

@@ -1,5 +1,4 @@
 import { forwardRef, Module } from '@nestjs/common';
-import { LayoutPreferenceController } from './controller/layout_preference.controller';
 import { LayoutPreferenceService } from './service/layout_preference.service';
 import { EntityModule } from '../meta/entity.module';
 import { TypeOrmModule } from '@nestjs/typeorm';
@@ -12,7 +11,7 @@ import { AttributeMaster } from '../meta/entity/attribute-master.entity';
     forwardRef(() => EntityModule),
     TypeOrmModule.forFeature([LayoutPreference, AttributeMaster]),
   ],
-  controllers: [LayoutPreferenceController],
+  controllers: [],
   providers: [
     { provide: 'LayoutPreferenceService', useClass: LayoutPreferenceService },
     LayoutPreferenceRepository,

package/src/module/entity/{layout_preference → meta/layout_preference}/repository/layout_preference.repository.ts

@@ -2,7 +2,7 @@ import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
 import { LayoutPreference } from '../entity/layout_preference.entity';
-import { AttributeMaster } from 'src/module/entity/meta/entity/attribute-master.entity';
+import { AttributeMaster } from 'src/module/entity/meta/meta/entity/attribute-master.entity';
 
 @Injectable()
 export class LayoutPreferenceRepository {