rez_core 2.1.53 → 2.1.54

package/package.json

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

package/src/module/listmaster/controller/list-master.controller.ts

@@ -1,8 +1,11 @@
 import {
   Body,
   Controller,
+  Delete,
+  Get,
   HttpCode,
   HttpStatus,
+  Inject,
   Param,
   Post,
   Query,
@@ -11,10 +14,15 @@ import {
 } from '@nestjs/common';
 import { ListMasterService } from '../service/list-master.service';
 import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+import { ListMasterItemService } from '../service/list-master-item.service';
 
 @Controller('list-master')
 export class ListMasterController {
-  constructor(private readonly service: ListMasterService) {}
+  constructor(
+    @Inject('ListMasterService')
+    private readonly service: ListMasterService,
+    private readonly listMasterItemService: ListMasterItemService,
+  ) {}
 
   @Post('/getDropdownData/:type')
   @UseGuards(JwtAuthGuard)
@@ -39,4 +47,31 @@ export class ListMasterController {
       loggedInUser,
     );
   }
+
+  @Get('/getListMasterItems/:type')
+  @UseGuards(JwtAuthGuard)
+  @HttpCode(HttpStatus.OK)
+  async getListMasterItems(@Param('type') type: string) {
+    console.log('Fetching list master items for type:', type);
+    return await this.listMasterItemService.getListMasterItemsByType(type);
+  }
+  @Post('/upsertListMasterItem/:type')
+  @UseGuards(JwtAuthGuard)
+  @HttpCode(HttpStatus.OK)
+  async upsertListMasterItem(@Param('type') type: string, @Body() item: any) {
+    return await this.listMasterItemService.upsertListMasterItem(
+      type,
+      item.items,
+    );
+  }
+
+  @Delete('/deleteListMasterItem/:type/:name')
+  @UseGuards(JwtAuthGuard)
+  @HttpCode(HttpStatus.OK)
+  async deleteListMasterItem(
+    @Param('type') type: string,
+    @Param('name') name: string,
+  ): Promise<string> {
+    return await this.listMasterItemService.deleteListMasterItem(type, name);
+  }
 }

package/src/module/listmaster/entity/list-master.entity.ts

@@ -26,4 +26,7 @@ export class ListMasterData extends BaseEntity {
 
   @Column({ nullable: true })
   custom_source_id: number;
+
+  @Column({ nullable: true, default: '' })
+  description: string;
 }

package/src/module/listmaster/listmaster.module.ts

@@ -9,11 +9,22 @@ import { EntityModule } from '../meta/entity.module';
 import { ListMasterController } from './controller/list-master.controller';
 import { ThirdPartyModule } from '../third-party-module/third-party.module';
 import { HttpModule } from '@nestjs/axios';
+import { ListMasterItemService } from './service/list-master-item.service';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([ListMasterData, ListMasterItems]),forwardRef(() => EntityModule), ThirdPartyModule, HttpModule],
-  providers: [ListMasterRepository, ListMasterItemsRepository, ListMasterService],
+  imports: [
+    TypeOrmModule.forFeature([ListMasterData, ListMasterItems]),
+    forwardRef(() => EntityModule),
+    ThirdPartyModule,
+    HttpModule,
+  ],
+  providers: [
+    { provide: 'ListMasterService', useClass: ListMasterService },
+    ListMasterItemService,
+    ListMasterRepository,
+    ListMasterItemsRepository,
+  ],
   controllers: [ListMasterController],
-  exports:[ListMasterService]
+  exports: ['ListMasterService'],
 })
 export class ListMasterModule {}

package/src/module/listmaster/repository/list-master-items.repository.ts

@@ -4,18 +4,37 @@ import { Repository } from 'typeorm';
 import { ListMasterItems } from '../entity/list-master-items.entity';
 
 @Injectable()
-export class ListMasterItemsRepository{
+export class ListMasterItemsRepository {
+  constructor(
+    @InjectRepository(ListMasterItems)
+    private repo: Repository<ListMasterItems>,
+  ) {}
 
-    constructor(
-        @InjectRepository(ListMasterItems) private repo: Repository<ListMasterItems>,
-      ) {}
-    
-    async findItemsByType(type: string) {
-        const items = await this.repo.find({
-          where: { listtype: type, status: 'active' },
-          order: { sortindex: 'ASC' },
-        });
-        return items.map(i => ({ label: i.name, value: i.value }));
-      }
+  async create(item: Partial<ListMasterItems>) {
+    const newItem = this.repo.create(item);
+    return this.repo.save(newItem);
+  }
 
-}
+  async update(id: number, item: Partial<ListMasterItems>) {
+    await this.repo.update(id, item);
+    return this.repo.findOne({ where: { id } });
+  }
+
+  async findItemsByType(type: string) {
+    const items = await this.repo.find({
+      where: { listtype: type, status: 'active' },
+      order: { sortindex: 'ASC' },
+    });
+    return items.map((i) => ({ label: i.name, value: i.value }));
+  }
+
+  async findOneByNameAndType(name: string, type: string) {
+    return this.repo.findOne({
+      where: { name, listtype: type, status: 'active' },
+    });
+  }
+
+  async delete(item: Partial<ListMasterItems>) {
+    return this.repo.delete(item);
+  }
+}

package/src/module/listmaster/service/list-master-item.service.ts

@@ -0,0 +1,55 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { ListMasterItemsRepository } from '../repository/list-master-items.repository';
+
+@Injectable()
+export class ListMasterItemService {
+  constructor(
+    private readonly listItemsRepo: ListMasterItemsRepository,
+    private readonly listMasterRepo: ListMasterItemsRepository,
+  ) {}
+
+  async getListMasterItemsByType(type: string) {
+    return await this.listItemsRepo.findItemsByType(type);
+  }
+
+  async upsertListMasterItem(type: string, item: any[]): Promise<any> {
+    // Check if list master item with type and name already exists then update it else create a new one
+
+    console.log('Upserting list master item for type:', type, item);
+
+    // will need to loop through the item array
+    for (const i of item) {
+      console.log('Processing item:', i);
+      const existingItem = await this.listItemsRepo.findOneByNameAndType(
+        i.name,
+        type,
+      );
+
+      console.log('Existing item found:', existingItem);
+
+      if (existingItem) {
+        await this.listItemsRepo.update(existingItem.id, i);
+      } else {
+        await this.listItemsRepo.create(i);
+      }
+    }
+
+    const updatedItems = await this.listItemsRepo.findItemsByType(type);
+
+    return {
+      type,
+      items: updatedItems,
+    };
+  }
+
+  async deleteListMasterItem(type: string, name: string): Promise<string> {
+    const item = await this.listItemsRepo.findOneByNameAndType(name, type);
+    if (!item) {
+      throw new NotFoundException(
+        `Item with name ${name} not found in type ${type}`,
+      );
+    }
+    await this.listItemsRepo.delete({ listtype: type, name: name });
+    return `Item with name ${name} deleted successfully from type ${type}`;
+  }
+}

package/src/module/listmaster/service/list-master.service.ts

@@ -1,6 +1,7 @@
-import { EntityServiceImpl } from '../../meta/service/entity-service-impl.service';
 import {
   BadRequestException,
+  forwardRef,
+  Inject,
   Injectable,
   NotFoundException,
 } from '@nestjs/common';
@@ -13,11 +14,14 @@ import { EntityManager } from 'typeorm';
 import { EntityMasterService } from 'src/module/meta/service/entity-master.service';
 import { UserData } from 'src/module/user/entity/user.entity';
 import { log } from 'console';
+import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
 
 @Injectable()
 export class ListMasterService {
   constructor(
     private readonly entityManager: EntityManager,
+    @Inject(forwardRef(() => EntityServiceImpl))
+    private readonly entityServiceImpl: EntityServiceImpl,
     private readonly entityMasterService: EntityMasterService,
     private readonly listMasterRepo: ListMasterRepository,
     private readonly listItemsRepo: ListMasterItemsRepository,
@@ -232,4 +236,40 @@ export class ListMasterService {
       return acc[key];
     }, obj);
   }
+
+  // createEntity method
+  async createEntity(entityData: any, loggedInUser: UserData): Promise<any> {
+    entityData.is_factory = entityData.is_factory || 0;
+    entityData.source = entityData.source || 'master';
+    entityData.status = entityData.status || 'ACTIVE';
+
+    // check if a list master with the same type already exists
+    const existingListMaster = await this.listMasterRepo.findByType(
+      entityData.type,
+    );
+    if (existingListMaster) {
+      throw new BadRequestException(
+        'List master with the same type already exists.',
+      );
+    }
+
+    const createdListMaster = await this.entityServiceImpl.createEntity(
+      entityData,
+      loggedInUser,
+    );
+
+    if (!createdListMaster) {
+      throw new BadRequestException('Failed to create entity');
+    }
+
+    return createdListMaster;
+  }
+
+  async updateEntity(entityData: any, loggedInUser: UserData): Promise<any> {
+    return await this.entityServiceImpl.updateEntity(entityData, loggedInUser);
+  }
+
+  async getEntityData(entity_type: string, id: number): Promise<any> {
+    return await this.entityServiceImpl.getEntityData(entity_type, id);
+  }
 }

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

@@ -140,7 +140,7 @@ export class EntityController {
 
     return {
       success: true,
-      data: updatedEntity.data,
+      data: updatedEntity,
     };
   }
 

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

@@ -12,7 +12,9 @@ export class EntityTableService {
   constructor(
     private entityTableRepository: EntityTableRepository,
     private readonly entityTableColumnRepository: EntityTableColumnRepository,
-    @Inject(forwardRef(() => ListMasterService))
+
+    @Inject(forwardRef(() => 'ListMasterService'))
+    @Inject('ListMasterService')
     private readonly listMasterService: ListMasterService,
 
     private readonly savedFilterRepoService: SavedFilterRepositoryService,