rez_core 6.5.47 → 6.5.50

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

@@ -3,13 +3,18 @@ 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(
@@ -25,6 +30,20 @@ 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) {
@@ -34,4 +53,85 @@ 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/dto/create-linked-attribute-smart.dto.ts

@@ -0,0 +1,54 @@
+import {
+  IsString,
+  IsNotEmpty,
+  IsArray,
+  IsOptional,
+  IsBoolean,
+  ValidateNested,
+} from 'class-validator';
+import { Type } from 'class-transformer';
+
+export class FilterConditionDto {
+  @IsString()
+  @IsNotEmpty()
+  filter_attribute: string;
+
+  @IsString()
+  @IsNotEmpty()
+  filter_operator: string;
+
+  @IsNotEmpty()
+  filter_value: any;
+}
+
+export class CreateLinkedAttributeSmartDto {
+  @IsString()
+  @IsNotEmpty()
+  field_name: string;
+
+  @IsString()
+  @IsNotEmpty()
+  mapped_entity_type: string;
+
+  @IsString()
+  @IsNotEmpty()
+  applicable_entity_type: string;
+
+  @IsString()
+  @IsNotEmpty()
+  applicable_attribute_key: string;
+
+  @IsString()
+  @IsNotEmpty()
+  saved_filter_code: string;
+
+  // @IsArray()
+  // @IsOptional()
+  // @ValidateNested({ each: true })
+  // @Type(() => FilterConditionDto)
+  // filter_conditions?: FilterConditionDto[];
+
+  @IsBoolean()
+  @IsOptional()
+  backfill?: boolean;
+}

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

@@ -1,12 +1,19 @@
-import { Module } from '@nestjs/common';
+import { Module, forwardRef } 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, TypeOrmModule.forFeature([LinkedAttributes])],
+  imports: [
+    EntityModule,
+    forwardRef(() => FilterModule),
+    forwardRef(() => EntityJSONModule),
+    TypeOrmModule.forFeature([LinkedAttributes]),
+  ],
   controllers: [LinkedAttributesController],
   providers: [
     { provide: 'LinkedAttributesService', useClass: LinkedAttributesService },