rez_core 5.0.152 → 5.0.154

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "5.0.152",
+  "version": "5.0.154",
   "description": "",
   "author": "",
   "private": false,

package/src/config/bull.config.ts

@@ -13,10 +13,10 @@ export class BullConfigService implements SharedBullConfigurationFactory {
   createSharedConfiguration(): BullModuleOptions {
     return {
       redis: {
-        host: this.configService.get<string>('REDIS_HOST', '43.205.35.45'),
-        port: this.configService.get<number>('REDIS_PORT', 6379),
-        password: this.configService.get<string>('REDIS_PASSWORD','Rezolut123'),
-        db: this.configService.get<number>('REDIS_DB', 0),
+        host: '43.205.35.45',
+        port: 6379,
+        password: 'Rezolut123',
+        db: 0,
         // Enable offline queue to handle Redis disconnections
         enableOfflineQueue: true,
         // Retry strategy for Redis connection

package/src/core.module.ts

@@ -19,7 +19,6 @@ import { MapperModule } from './module/mapper/mapper.module';
 import { WorkflowScheduleModule } from './module/workflow-schedule/workflow-schedule.module';
 import { LinkedAttributesModule } from './module/linked_attributes/linked_attributes.module';
 import { ExportModule } from './module/export/export.module';
-import { EntityJSONModule } from './module/entity_json/entity_json.module';
 
 @Global()
 @Module({})
@@ -49,8 +48,7 @@ export class CoreModule {
       WorkflowScheduleModule.forRoot({ is_workflow: isWorkflow }),
       MapperModule,
       LinkedAttributesModule,
-      ExportModule,
-      EntityJSONModule
+      ExportModule
     ];
 
     const exportsArray = [
@@ -69,8 +67,7 @@ export class CoreModule {
       WorkflowAutomationModule,
       WorkflowScheduleModule.forRoot({ is_workflow: isWorkflow }),
       LinkedAttributesModule,
-      ExportModule,
-      EntityJSONModule
+      ExportModule
     ];
 
     if (isSso) {

package/src/module/entity_json/entity_json.module.ts

@@ -13,6 +13,6 @@ import { EntityJSONRepository } from './service/entityJson.repository';
   imports: [EntityModule, TypeOrmModule.forFeature([EntityJson]),FilterModule,UtilsModule],
   controllers: [EntityJSONController],
   providers: [EntityJSONService,EntityJSONRepository],
-  exports: [EntityJSONService],
+  exports: [],
 })
 export class EntityJSONModule {}

package/src/module/entity_json/service/entity_json.service.ts

@@ -107,7 +107,7 @@ export class EntityJSONService extends EntityServiceImpl {
     dropdown.push(...mainAttributes.map(a => ({ label: a.name, value: a.flat_json_key })));
     dropdown.push(...relatedAttributes.map(a => ({ label: a.name, value: a.flat_json_key })));
     if (linkedAttributes.length > 0) {
-      dropdown.push(...linkedAttributes.map(a => ({ label: a.name, value: a.target_attribute_key })));
+      dropdown.push(...linkedAttributes.map(a => ({ label: a.name, value: a.attribute_key })));
     }
 
     return dropdown;

package/src/module/filter/controller/filter.controller.ts

@@ -48,7 +48,9 @@ export class FilterController {
       sortby,
     } = body;
 
-    return this.filterService.applyFilterWithRouting({
+    
+
+    return this.filterService.applyFilterWrapper({
       entity_type,
       quickFilter,
       savedFilterCode,

package/src/module/filter/entity/saved-filter-master.entity.ts

@@ -24,6 +24,9 @@ export class SavedFilterMaster extends BaseEntity {
   @Column({ type: 'boolean', default: false, nullable: true })
   is_shared: boolean;
 
-  @Column({ type: 'varchar', length: 100, nullable: true })
-  is_editable: string;
+  @Column({ type: 'boolean', default: false, nullable: true })
+  is_editable: boolean;
+
+  @Column({ type: 'varchar', length: 200, nullable: true })
+  description: string;
 }

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

@@ -9,16 +9,11 @@ import { FilterService } from './service/filter.service';
 import { FilterController } from './controller/filter.controller';
 import { FilterEvaluatorService } from './service/filter-evaluator.service';
 import { SavedFilterDetailRepository } from './repository/saved.filter-detail.repository';
-import { FlatjsonFilterService } from './service/flatjson-filter.service';
-import { ConfigModule } from '@nestjs/config';
-import { UtilsModule } from 'src/utils/utils.module';
 
 @Module({
   imports: [
     TypeOrmModule.forFeature([SavedFilterDetail, SavedFilterMaster]),
-    forwardRef(() => EntityModule),
-    ConfigModule,
-    UtilsModule,
+    forwardRef(() => EntityModule)
   ],
   controllers: [FilterController],
   providers: [
@@ -26,15 +21,13 @@ import { UtilsModule } from 'src/utils/utils.module';
     SavedFilterRepositoryService,
     FilterService,
     FilterEvaluatorService,
-    SavedFilterDetailRepository,
-    FlatjsonFilterService,
+    SavedFilterDetailRepository
   ],
   exports: [
     'SavedFilterService',
     SavedFilterRepositoryService,
     FilterService,
     FilterEvaluatorService,
-    FlatjsonFilterService,
   ],
 })
 export class FilterModule {}

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

@@ -107,6 +107,7 @@ export class SavedFilterRepositoryService {
       value: filter.id,
       code: filter.code,
     }));
+    // return filters;
   }
 
   async getSharedFiltersByLevelTypeAndLevelId(
@@ -127,11 +128,14 @@ export class SavedFilterRepositoryService {
       },
     });
 
-    return filters.map((filter) => ({
-      label: filter.name,
-      value: filter.id,
-      code: filter.code,
-    }));
+    return filters;
+
+    // return filters.map((filter) => ({
+    //   label: filter.name,
+    //   value: filter.id,
+    //   code: filter.code,
+
+    // }));
   }
 
   async getFilterById(id: number): Promise<

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

@@ -11,7 +11,6 @@ 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 {
@@ -27,7 +26,6 @@ export class FilterService {
     @Inject() protected readonly loggingService: LoggingService,
     private readonly configService: ConfigService,
     private readonly reflectionHelper: ReflectionHelper,
-    private readonly flatjsonFilterService: FlatjsonFilterService,
   ) {}
 
   private async gettab_value_counts(
@@ -98,53 +96,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 =
-      this.configService.get<string>('ENABLE_FLATJSON_FILTER') === 'true' ||
-      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,

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

@@ -3,6 +3,8 @@ import { GenericMessageDto, IntegrationService } from './integration.service';
 import { IcsMeetingService } from 'src/module/ics/service/ics.service';
 import { LoggingService } from 'src/utils/service/loggingUtil.service';
 import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
+import { MediaDataService } from 'src/module/meta/service/media-data.service';
+import axios from 'axios';
 
 @Injectable()
 export class WrapperService {
@@ -13,6 +15,7 @@ export class WrapperService {
     private readonly icsService: IcsMeetingService,
     private readonly loggingService: LoggingService,
     private readonly reflectionHelper: ReflectionHelper,
+    private readonly mediaService: MediaDataService,
   ) {}
 
   /**
@@ -405,6 +408,40 @@ export class WrapperService {
         [],
       );
 
+      // attachments: [1, 2, 3, 4]
+
+      if (entity.attachments && entity.attachments.length > 0) {
+        mailPayload.attachments = [];
+
+        for (const attachmentId of entity.attachments) {
+          // Step 1: Download or get media file
+          const url = await this.mediaService.getMediaDownloadUrl(
+            attachmentId,
+            {},
+            60000,
+          );
+
+          if (!url?.signedUrl) continue;
+
+          // Step 2: Fetch file content
+          const response = await axios.get(url.signedUrl, {
+            responseType: 'arraybuffer',
+          });
+
+          // Step 3: Convert to base64
+          const base64Content = Buffer.from(response.data).toString('base64');
+
+          // Step 4: Push formatted attachment
+          mailPayload.attachments.push({
+            content: base64Content,
+            type:
+              response.headers['content-type'] || 'application/octet-stream',
+            filename: `attachment-${attachmentId}`,
+            disposition: 'attachment',
+          });
+        }
+      }
+
       // Step 5️⃣ Send via Integration Service
       const result =
         await this.integrationService.sendGenericMessage(mailPayload);

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

@@ -6,15 +6,10 @@ import {
   Post,
   Req,
   UseGuards,
-  Param,
-  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(
@@ -39,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 },