rez_core 6.5.31 → 6.5.33

package/src/module/filter/service/filter.service.ts

@@ -1,4 +1,4 @@
-import { BadRequestException, forwardRef, Inject, Injectable } from '@nestjs/common';
+import { BadRequestException, Inject, Injectable } from '@nestjs/common';
 import { AttributeMasterService } from 'src/module/meta/service/attribute-master.service';
 import { EntityMasterService } from 'src/module/meta/service/entity-master.service';
 import { FilterCondition, FilterRequestDto } from '../dto/filter-request.dto';
@@ -11,30 +11,21 @@ import { LoggingService } from 'src/utils/service/loggingUtil.service';
 import { ConfigService } from '@nestjs/config';
 import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
 import { EntityManager } from 'typeorm';
-import { FlatjsonFilterService } from './flatjson-filter.service';
 
 @Injectable()
 export class FilterService {
   constructor(
     private entityManager: EntityManager,
-    @Inject(forwardRef(() => AttributeMasterService))
     private readonly attributeMasterService: AttributeMasterService,
-    @Inject(forwardRef(() => EntityMasterService))
     private readonly entityMasterService: EntityMasterService,
-    @Inject('EntityRelationService')
-    private readonly entityRelationService: EntityRelationService,
     @Inject('SavedFilterService')
     private readonly savedFilterService: SavedFilterService,
-    @Inject(forwardRef(() => ResolverService))
+    @Inject('EntityRelationService')
+    private readonly entityRelationService: EntityRelationService,
     private readonly resolverService: ResolverService,
-    @Inject(forwardRef(() => LoggingService))
-    protected readonly loggingService: LoggingService,
+    @Inject() protected readonly loggingService: LoggingService,
     private readonly configService: ConfigService,
-    @Inject(forwardRef(() => ReflectionHelper))
     private readonly reflectionHelper: ReflectionHelper,
-    @Inject(forwardRef(() => FlatjsonFilterService))
-    private readonly flatjsonFilterService: FlatjsonFilterService,
-  
   ) {
   }
 
@@ -108,51 +99,6 @@ export class FilterService {
     ];
   }
 
-  /**
-   * Route to flatjson or traditional filtering based on configuration
-   */
-  async applyFilterWithRouting(dto: FilterRequestDto) {
-    // Check if flatjson filtering is enabled via config or query param
-    const useFlatjson = dto.queryParams?.use_flatjson === 'true';
-
-    if (useFlatjson) {
-      await this.loggingService.log(
-        'info',
-        'FilterService',
-        'applyFilterWithRouting',
-        `Using FLATJSON filtering for ${dto.entity_type}`,
-      );
-
-      // Use new flatjson filtering service
-      const result = await this.flatjsonFilterService.applyFlatjsonFilter(dto);
-
-      // Transform to match existing response format
-      return {
-        success: true,
-        data: {
-          entity_tabs: result.tabCounts || [],
-          entity_list: result.data,
-          pagination: {
-            total: result.total,
-            page: result.page,
-            size: result.size,
-            totalPages: result.totalPages,
-          },
-        },
-      };
-    } else {
-      await this.loggingService.log(
-        'info',
-        'FilterService',
-        'applyFilterWithRouting',
-        `Using TRADITIONAL filtering for ${dto.entity_type}`,
-      );
-
-      // Use traditional filtering
-      return this.applyFilterWrapper(dto);
-    }
-  }
-
   async applyFilterWrapper(dto: FilterRequestDto) {
     const {
       entity_type,
@@ -281,9 +227,7 @@ export class FilterService {
       level_type,
       level_id,
       id: user_id,
-      appcode,
-      organization_id,
-      enterprise_id
+      enterprise_id,
     } = loggedInUser || {};
 
     // Fetch meta from entity table service
@@ -375,7 +319,7 @@ export class FilterService {
       entity_type !== 'TEM' && // ✅ skip TEMPLATE
       level_type &&
       level_id &&
-      organization_id &&
+      enterprise_id &&
       !customLevelType &&
       !customLevelId
     ) {
@@ -476,60 +420,60 @@ export class FilterService {
 
     const dataWhere = [...baseWhere];
 
-    // if (tabs?.columnName && tabs?.value) {
-    //   const tabAttrMeta = attributeMetaMap[tabs.columnName];
-    //   const tabValue = tabs.value.toLowerCase();
-
-    //   if (tabValue === 'others') {
-    //     // Extract 'value' (IDs) from showList, ignore 'all'
-    //     const valuesToExclude = showList
-    //       .filter((v) => v.label.toLowerCase() !== 'all')
-    //       .map((v) => v.value);
-
-    //     if (valuesToExclude.length > 0) {
-    //       for (const value of valuesToExclude) {
-    //         const resolvedId = await this.resolverService.getResolvedId(
-    //           loggedInUser,
-    //           tabs.columnName,
-    //           value,
-    //           entity_type,
-    //         );
-    //         if (resolvedId) {
-    //           const tabCondition = this.buildCondition(
-    //             {
-    //               filter_attribute: tabs.columnName,
-    //               filter_operator: 'not_equal',
-    //               filter_value: [resolvedId],
-    //               skip_id: true,
-    //             },
-    //             tabAttrMeta,
-    //           );
-    //           if (tabCondition) dataWhere.push(tabCondition);
-    //         }
-    //       }
-    //     }
-    //   } else if (tabValue !== 'all') {
-    //     const resolvedId = await this.resolverService.getResolvedId(
-    //       loggedInUser,
-    //       tabs.columnName,
-    //       tabs.value,
-    //       entity_type,
-    //     );
-
-    //     if (resolvedId) {
-    //       const tabCondition = this.buildCondition(
-    //         {
-    //           filter_attribute: tabs.columnName,
-    //           filter_operator: 'equal',
-    //           filter_value: [resolvedId],
-    //           skip_id: true,
-    //         },
-    //         tabAttrMeta,
-    //       );
-    //       if (tabCondition) dataWhere.push(tabCondition);
-    //     }
-    //   }
-    // }
+    if (tabs?.columnName && tabs?.value) {
+      const tabAttrMeta = attributeMetaMap[tabs.columnName];
+      const tabValue = tabs.value.toLowerCase();
+
+      if (tabValue === 'others') {
+        // Extract 'value' (IDs) from showList, ignore 'all'
+        const valuesToExclude = showList
+          .filter((v) => v.label.toLowerCase() !== 'all')
+          .map((v) => v.value);
+
+        if (valuesToExclude.length > 0) {
+          for (const value of valuesToExclude) {
+            const resolvedId = await this.resolverService.getResolvedId(
+              loggedInUser,
+              tabs.columnName,
+              value,
+              entity_type,
+            );
+            if (resolvedId) {
+              const tabCondition = this.buildCondition(
+                {
+                  filter_attribute: tabs.columnName,
+                  filter_operator: 'not_equal',
+                  filter_value: [resolvedId],
+                  skip_id: true,
+                },
+                tabAttrMeta,
+              );
+              if (tabCondition) dataWhere.push(tabCondition);
+            }
+          }
+        }
+      } else if (tabValue !== 'all') {
+        const resolvedId = await this.resolverService.getResolvedId(
+          loggedInUser,
+          tabs.columnName,
+          tabs.value,
+          entity_type,
+        );
+
+        if (resolvedId) {
+          const tabCondition = this.buildCondition(
+            {
+              filter_attribute: tabs.columnName,
+              filter_operator: 'equal',
+              filter_value: [resolvedId],
+              skip_id: true,
+            },
+            tabAttrMeta,
+          );
+          if (tabCondition) dataWhere.push(tabCondition);
+        }
+      }
+    }
 
     let qb = this.entityManager
       .createQueryBuilder()
@@ -572,11 +516,11 @@ export class FilterService {
 
     const formattedEntityList = entity_list.map(formatDatesInRow);
 
-    // const resolvedEntityList = await Promise.all(
-    //   formattedEntityList.map((row) =>
-    //     this.resolverService.getResolvedData(loggedInUser, row, entity_type),
-    //   ),
-    // );
+    const resolvedEntityList = await Promise.all(
+      formattedEntityList.map((row) =>
+        this.resolverService.getResolvedData(loggedInUser, row, entity_type),
+      ),
+    );
 
     const resolvedTabs = await Promise.all(
       filteredTabs.map(async (tab) => {
@@ -590,15 +534,14 @@ export class FilterService {
           return tab;
         }
 
-        // const resolvedVal = await this.resolverService.getResolvedValue(
-        //   loggedInUser,
-        //   tabAttrKey,
-        //   tab.tab_value,
-        //   entity_type,
-        // );
-        
+        const resolvedVal = await this.resolverService.getResolvedValue(
+          loggedInUser,
+          tabAttrKey,
+          tab.tab_value,
+          entity_type,
+        );
 
-        return { ...tab, tab_value: tab.tab_value ?? tab.tab_value };
+        return { ...tab, tab_value: resolvedVal ?? tab.tab_value };
       }),
     );
 
@@ -618,7 +561,7 @@ export class FilterService {
       success: true,
       data: {
         entity_tabs: resolvedTabs,
-        entity_list: formattedEntityList,
+        entity_list: resolvedEntityList,
         pagination: {
           total,
           page,

package/src/module/filter/service/saved-filter.service.ts

@@ -1,4 +1,4 @@
-import { BadRequestException, Inject, Injectable, forwardRef } from '@nestjs/common';
+import { BadRequestException, Injectable } from '@nestjs/common';
 import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
 import { BaseEntity } from '../../meta/entity/base-entity.entity';
 import { UserData } from '../../user/entity/user.entity';
@@ -7,12 +7,10 @@ import { ENTITYTYPE_SAVEDFILTERMASTER } from 'src/constant/global.constant';
 import { SavedFilterRepositoryService } from '../repository/saved-filter.repository';
 
 @Injectable()
-export class SavedFilterService {
-  constructor(
-    private readonly savedFilterRepo: SavedFilterRepositoryService,
-    @Inject(forwardRef(() => EntityServiceImpl))
-    private readonly entityServiceImpl: EntityServiceImpl,
-  ) {}
+export class SavedFilterService extends EntityServiceImpl {
+  constructor(private readonly savedFilterRepo: SavedFilterRepositoryService) {
+    super();
+  }
 
   async createEntity(
     entityData: any,
@@ -35,7 +33,7 @@ export class SavedFilterService {
     entityData.user_id = loggedInUser?.id ?? null;
 
     // Save the master record without code
-    const savedMaster = await this.entityServiceImpl.createEntity(master, loggedInUser);
+    const savedMaster = await super.createEntity(master, loggedInUser);
 
     // Generate the code like SFM00001 using the saved ID
     const code = `SFM${savedMaster.id.toString().padStart(5, '0')}`;
@@ -76,7 +74,7 @@ export class SavedFilterService {
   ): Promise<BaseEntity> {
     const master = entityData as SavedFilterMaster;
 
-    const existing = await this.entityServiceImpl.getEntityData(
+    const existing = await this.getEntityData(
       ENTITYTYPE_SAVEDFILTERMASTER,
       master.id,
       loggedInUser,
@@ -98,7 +96,7 @@ export class SavedFilterService {
     }
 
     const { filterDetails, ...persistableData } = master as any;
-    const updated = await this.entityServiceImpl.updateEntity(persistableData, loggedInUser);
+    const updated = await super.updateEntity(persistableData, loggedInUser);
 
     if (filterDetails?.length) {
       await this.savedFilterRepo.deleteDetailsByCode(updated.code);
@@ -122,22 +120,34 @@ export class SavedFilterService {
   }
 
   async deleteEntity(entityType: string, entityId: number, loggedInUser) {
-    // First get the entity data to retrieve the code
-    const entityData = await this.entityServiceImpl.getEntityData(
+    const entityMaster = await this.entityMasterService.getEntityData(
       entityType,
-      entityId,
       loggedInUser,
     );
 
+    const repoService = this.reflectionHelper.getRepoService(
+      entityMaster.entity_data_class,
+    );
+    if (!repoService) {
+      throw new Error(
+        `Repository service not found for entityType: ${entityType}`,
+      );
+    }
+
+    const entityData = await repoService.findOne({ where: { id: entityId } });
+
     if (!entityData) {
       throw new Error(`Entity not found for entityType: ${entityType}`);
     }
 
-    // Delete associated filter details
     await this.savedFilterRepo.deleteDetailsByCode(entityData.code);
 
-    // Then delete the entity itself
-    return await this.entityServiceImpl.deleteEntity(entityType, entityId, loggedInUser);
+    await repoService.delete(entityId);
+
+    return {
+      success: true,
+      message: `Entity with id ${entityId} deleted successfully.`,
+    };
   }
 
   async getDetailsByCode(code: string) {

package/src/module/integration/service/integration.service.ts

@@ -58,7 +58,6 @@ export interface GenericMessageDto {
   entity_type?: string;
   entity_id?: number;
   organization_id?: number;
-  enterprise_id?: number;
   mapped_entities?: any;
 }
 
@@ -100,7 +99,7 @@ export class IntegrationService {
     @Inject('FieldMapperService')
     private readonly fieldMapperService: FieldMapperService,
     private readonly entityService: EntityServiceImpl,
-    private readonly reflectionHelper: ReflectionHelper,
+    private readonly reflectionHelper:ReflectionHelper,
     @Inject(forwardRef(() => IntegrationQueueService))
     private readonly queueService?: IntegrationQueueService,
   ) {}
@@ -220,8 +219,7 @@ export class IntegrationService {
     integration_type?: string,
   ): Promise<any[]> {
     try {
-      const integrationSourceRepo =
-        this.reflectionHelper.getRepoService('IntegrationSource');
+      const integrationSourceRepo = this.reflectionHelper.getRepoService('IntegrationSource')
 
       const allIntegrationData = await integrationSourceRepo.find();
 
@@ -894,7 +892,6 @@ export class IntegrationService {
         entity_id,
         entity_type,
         organization_id,
-        enterprise_id,
         mapped_entities,
       } = messageDto;
 
@@ -939,7 +936,6 @@ export class IntegrationService {
       const loggedInUser = {
         id: user_id || null,
         organization_id: organization_id || -1,
-        enterprise_id: enterprise_id || -1,
         level_id: levelId,
         level_type: levelType,
         app_code: app_code,

package/src/module/integration/service/wrapper.service.ts

@@ -397,7 +397,6 @@ export class WrapperService {
         attachments: entity.attachments,
         mediaUrl: entity.mediaUrl,
         organization_id: organization_id,
-        enterprise_id: loggedInUser.enterprise_id,
       } as any;
 
       this.loggingService.log(

package/src/module/layout/controller/layout.controller.ts

@@ -18,20 +18,13 @@ import { ENTITYTYPE_USER } from '../../../constant/global.constant';
 export class LayoutController {
   constructor(
     private readonly headerSectionService: HeaderSectionService,
-    @Inject('UserService') private readonly userService: UserService,
   ) {}
 
   @Get('header')
   async getHeader(@Req() req: Request & { user: any }, @Res() res: Response) {
     const userData = req.user.userData;
-    // const userData = await this.userService.getEntityData(
-    //   ENTITYTYPE_USER,
-    //   userId,
-    // );
     if (userData) {
-      const response = await this.headerSectionService.findByOrganizationId(
-        userData.organization_id,
-      );
+      const response = await this.headerSectionService.getHeader();
       return res.json({
         success: true,
         data: response,

package/src/module/layout/entity/header-section.entity.ts

@@ -5,12 +5,6 @@ export class HeaderSection {
   @PrimaryGeneratedColumn()
   id: number;
 
-  @Column({ name: 'enterprise_id', type: 'int', nullable: true })
-  enterprise_id: number;
-
-  @Column({ nullable: true, type: 'int' })
-  organization_id: number;
-
   @Column({ length: 50, type: 'varchar', nullable: true })
   section_name: string;
 

package/src/module/layout/layout.module.ts

@@ -9,7 +9,7 @@ import { UserModule } from '../user/user.module';
 import { HeaderSectionService } from './service/header-section.service';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([HeaderSection, HeaderItems]), UserModule],
+  imports: [TypeOrmModule.forFeature([HeaderSection, HeaderItems])],
   controllers: [LayoutController],
   providers: [
     HeaderItemsRepository,

package/src/module/layout/repository/header-section.repository.ts

@@ -10,12 +10,6 @@ export class HeaderSectionRepository {
     private readonly headerSectionRepository: Repository<HeaderSection>,
   ) {}
 
-  async findByOrganizationId(organizationId: number) {
-    return await this.headerSectionRepository.find({
-      where: { organization_id: organizationId },
-    });
-  }
-
   async getHeaders() {
     return await this.headerSectionRepository.find();
   }

package/src/module/layout/service/header-section.service.ts

@@ -9,7 +9,7 @@ export class HeaderSectionService {
     private readonly headerItemsRepository: HeaderItemsRepository,
   ) {}
 
-  async findByOrganizationId(organizationId: number) {
+  async getHeader() {
     const headerSections = await this.headerSectionRepository.getHeaders();
     const response = {};
 

package/src/module/linked_attributes/controller/linked_attributes.controller.ts

@@ -3,18 +3,13 @@ import {
   Controller,
   Get,
   Inject,
-  Param,
   Post,
   Req,
   UseGuards,
-  Query,
 } from '@nestjs/common';
-import { ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
 import { LinkedAttributesService } from '../service/linked_attributes.service';
 import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
-import { CreateLinkedAttributeSmartDto } from '../dto/create-linked-attribute-smart.dto';
 
-@ApiTags('Linked Attributes')
 @Controller('linked-attributes')
 export class LinkedAttributesController {
   constructor(
@@ -30,20 +25,6 @@ export class LinkedAttributesController {
     return this.linkedAttributesService.getAllLinkedAttributes(loggedInUser);
   }
 
-  @Get('listing/:entity_type')
-  @UseGuards(JwtAuthGuard)
-  async getAttributeListing(
-    @Req() req: any,
-    @Param('entity_type') entity_type: string,
-  ) {
-    const loggedInUser = req.user?.userData;
-
-    return this.linkedAttributesService.getEntityListing(
-      entity_type,
-      loggedInUser,
-    );
-  }
-
   @Post('upsert')
   @UseGuards(JwtAuthGuard)
   async upsertLinkedAttributes(@Req() req: any, @Body() payload: any) {
@@ -53,85 +34,4 @@ export class LinkedAttributesController {
       loggedInUser,
     );
   }
-
-  @Post('smart')
-  @UseGuards(JwtAuthGuard)
-  @ApiOperation({ summary: 'Create linked attribute with auto-generation' })
-  @ApiResponse({
-    status: 201,
-    description: 'Linked attribute created successfully',
-  })
-  @ApiResponse({ status: 400, description: 'Validation failed' })
-  async createSmart(
-    @Body() dto: CreateLinkedAttributeSmartDto,
-    @Req() req: any,
-  ) {
-    const loggedInUser = req.user?.userData;
-    return await this.linkedAttributesService.createLinkedAttributeSmart(
-      dto,
-      loggedInUser,
-    );
-  }
-
-  @Post(':id/backfill')
-  @UseGuards(JwtAuthGuard)
-  @ApiOperation({
-    summary: 'Backfill existing entities with new linked attribute',
-  })
-  @ApiResponse({ status: 200, description: 'Backfill completed' })
-  @ApiResponse({ status: 404, description: 'Linked attribute not found' })
-  async backfill(@Param('id') id: number, @Req() req: any) {
-    const loggedInUser = req.user?.userData;
-    return await this.linkedAttributesService.backfillLinkedAttribute(
-      id,
-      loggedInUser,
-    );
-  }
-
-  @Post('backfill-all')
-  @UseGuards(JwtAuthGuard)
-  @ApiOperation({ summary: 'Backfill all entities of a given type' })
-  @ApiResponse({ status: 200, description: 'Backfill completed' })
-  async backfillAll(
-    @Query('entity_type') entity_type: string,
-    @Req() req: any,
-  ) {
-    const loggedInUser = req.user?.userData;
-    return await this.linkedAttributesService.backfillAllForEntity(
-      entity_type,
-      loggedInUser,
-    );
-  }
-
-  @Get('preview-key')
-  @UseGuards(JwtAuthGuard)
-  @ApiOperation({
-    summary: 'Preview generated attribute key before creation',
-  })
-  @ApiResponse({ status: 200, description: 'Preview generated successfully' })
-  async previewKey(
-    @Query('mapped_entity_type') mapped_entity_type: string,
-    @Query('entity_type') entity_type: string,
-    @Query('attribute_key') attribute_key: string,
-    @Query('organization_id') organization_id: number,
-    @Req() req: any,
-  ) {
-    const loggedInUser = req.user?.userData;
-
-    const sequence =
-      await this.linkedAttributesService['generateNextSequence'](
-        mapped_entity_type,
-        entity_type,
-        attribute_key,
-        organization_id,
-      );
-
-    const generated_key = this.linkedAttributesService.generateAttributeKey(
-      entity_type,
-      attribute_key,
-      sequence,
-    );
-
-    return { generated_key, sequence };
-  }
 }

package/src/module/linked_attributes/linked_attributes.module.ts

@@ -1,19 +1,12 @@
-import { Module, forwardRef } from '@nestjs/common';
+import { Module } from '@nestjs/common';
 import { EntityModule } from '../meta/entity.module';
-import { FilterModule } from '../filter/filter.module';
-import { EntityJSONModule } from '../entity_json/entity_json.module';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { LinkedAttributes } from './entity/linked_attribute.entity';
 import { LinkedAttributesController } from './controller/linked_attributes.controller';
 import { LinkedAttributesService } from './service/linked_attributes.service';
 
 @Module({
-  imports: [
-    EntityModule,
-    forwardRef(() => FilterModule),
-    forwardRef(() => EntityJSONModule),
-    TypeOrmModule.forFeature([LinkedAttributes]),
-  ],
+  imports: [EntityModule, TypeOrmModule.forFeature([LinkedAttributes])],
   controllers: [LinkedAttributesController],
   providers: [
     { provide: 'LinkedAttributesService', useClass: LinkedAttributesService },