rez_core 2.1.53 → 2.1.55

package/package.json

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

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

@@ -1,20 +1,30 @@
 import {
   Body,
   Controller,
+  Delete,
+  Get,
   HttpCode,
   HttpStatus,
+  Inject,
   Param,
   Post,
   Query,
+  Req,
   Request,
   UseGuards,
 } 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,
+    @Inject('ListMasterItemService')
+    private readonly listMasterItemService: ListMasterItemService,
+  ) {}
 
   @Post('/getDropdownData/:type')
   @UseGuards(JwtAuthGuard)
@@ -39,4 +49,38 @@ 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,
+    @Req() req: Request & { user: any },
+  ) {
+    let loggedInUser = req.user.userData;
+
+    return await this.listMasterItemService.upsertListMasterItem(
+      type,
+      item.items,
+      loggedInUser,
+    );
+  }
+
+  @Delete('/deleteListMasterItem/:type/:code')
+  @UseGuards(JwtAuthGuard)
+  @HttpCode(HttpStatus.OK)
+  async deleteListMasterItem(
+    @Param('type') type: string,
+    @Param('code') code: string,
+  ): Promise<string> {
+    return await this.listMasterItemService.deleteListMasterItem(type, code);
+  }
 }

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 },
+    { provide: 'ListMasterItemService', useClass: ListMasterItemService },
+    ListMasterRepository,
+    ListMasterItemsRepository,
+  ],
   controllers: [ListMasterController],
-  exports:[ListMasterService]
+  exports: ['ListMasterService', 'ListMasterItemService'],
 })
 export class ListMasterModule {}

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

@@ -4,18 +4,44 @@ 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 findAllItemsByListType(type: string, sortBy: string) {
+    return this.repo.find({
+      where: { listtype: type },
+      order: { sortindex: sortBy === 'asc' ? 'ASC' : 'DESC' },
+    });
+  }
+
+  async findOneByCodeAndType(code: string, type: string) {
+    return this.repo.findOne({
+      where: { code, listtype: type },
+    });
+  }
+
+  async delete(item: Partial<ListMasterItems>) {
+    return this.repo.delete(item);
+  }
+}

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

@@ -4,12 +4,17 @@ import { Repository } from 'typeorm';
 import { InjectRepository } from '@nestjs/typeorm';
 
 @Injectable()
-export class ListMasterRepository{
+export class ListMasterRepository {
+  constructor(
+    @InjectRepository(ListMasterData)
+    private readonly repo: Repository<ListMasterData>,
+  ) {}
 
-    constructor(
-        @InjectRepository(ListMasterData) private readonly repo:  Repository<ListMasterData>) {}
-    
-    findByType(type: string) {
-        return this.repo.findOne({ where: { type } });
-      }
-}
+  findByType(type: string) {
+    return this.repo.findOne({ where: { type } });
+  }
+
+  findByName(name: string) {
+    return this.repo.findOne({ where: { name } });
+  }
+}

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

@@ -0,0 +1,106 @@
+import {
+  forwardRef,
+  Inject,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { ListMasterItemsRepository } from '../repository/list-master-items.repository';
+import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+import { UserData } from 'src/module/user/entity/user.entity';
+
+@Injectable()
+export class ListMasterItemService {
+  constructor(
+    private readonly listItemsRepo: ListMasterItemsRepository,
+    private readonly listMasterRepo: ListMasterItemsRepository,
+    @Inject(forwardRef(() => EntityServiceImpl))
+    private readonly entityServiceImpl: EntityServiceImpl,
+  ) {}
+
+  async getListMasterItemsByType(listType: string) {
+    return await this.listItemsRepo.findAllItemsByListType(listType, 'asc');
+  }
+
+  async createEntity(entityData: any, loggedInUser: UserData): Promise<any> {
+    return await this.entityServiceImpl.createEntity(entityData, loggedInUser);
+  }
+
+  async updateEntity(entityData: any, loggedInUser: UserData): Promise<any> {
+    return await this.entityServiceImpl.updateEntity(entityData, loggedInUser);
+  }
+
+  async upsertListMasterItem(
+    listType: string,
+    items: any[],
+    loggedInUser,
+  ): Promise<any> {
+    console.log('Upserting list master items for type:', listType);
+
+    for (const item of items) {
+      console.log('Processing item:', item);
+
+      let existingItem;
+
+      // If code is provided, use it for lookup
+      if (item.code) {
+        console.log('Code provided:', item.code);
+        existingItem = await this.listItemsRepo.findOneByCodeAndType(
+          item.code,
+          listType,
+        );
+
+        console.log('Existing item found by code:', existingItem);
+      }
+
+      console.log('Existing item found:', existingItem);
+
+      if (existingItem) {
+        await this.updateEntity(
+          {
+            ...existingItem,
+            ...item,
+            listtype: listType,
+          },
+          loggedInUser,
+        );
+      } else {
+        const createdItem = await this.createEntity(
+          {
+            ...item,
+            listtype: listType,
+            value: '',
+          },
+          loggedInUser,
+        );
+
+        // now update the value of the item to its code
+        console.log('Created item, updating value to code:', createdItem.code);
+
+        await this.listItemsRepo.update(createdItem.id, {
+          value: createdItem.code,
+        });
+      }
+    }
+
+    const updatedItems = await this.listItemsRepo.findAllItemsByListType(
+      listType,
+      'asc',
+    );
+
+    return {
+      listType,
+      items: updatedItems,
+    };
+  }
+
+  async deleteListMasterItem(listType: string, code: string): Promise<string> {
+    const item = await this.listItemsRepo.findOneByCodeAndType(code, listType);
+    if (!item) {
+      throw new NotFoundException(
+        `Item with name ${code} not found in type ${listType}`,
+      );
+    }
+    await this.listItemsRepo.delete({ code, listtype: listType });
+    return `Item with name ${code} deleted successfully from type ${listType}`;
+  }
+}

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,47 @@ 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';
+    entityData.type = entityData.type || 'LIST_MASTER';
+
+    // check if a list master with the same type already exists
+    const existingListMaster = await this.listMasterRepo.findByName(
+      entityData.name,
+    );
+
+    if (existingListMaster) {
+      throw new BadRequestException(
+        'List master with the same name already exists',
+      );
+    }
+
+    const createdListMaster = await this.entityServiceImpl.createEntity(
+      entityData,
+      loggedInUser,
+    );
+
+    if (!createdListMaster) {
+      throw new BadRequestException('Failed to create entity');
+    }
+
+    createdListMaster.type = createdListMaster.code;
+
+    // update the type of the created list master to code
+    await this.entityServiceImpl.updateEntity(createdListMaster, loggedInUser);
+
+    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,