rez_core 2.1.54 → 2.1.55

package/package.json

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

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

@@ -9,6 +9,7 @@ import {
   Param,
   Post,
   Query,
+  Req,
   Request,
   UseGuards,
 } from '@nestjs/common';
@@ -21,6 +22,7 @@ export class ListMasterController {
   constructor(
     @Inject('ListMasterService')
     private readonly service: ListMasterService,
+    @Inject('ListMasterItemService')
     private readonly listMasterItemService: ListMasterItemService,
   ) {}
 
@@ -58,20 +60,27 @@ export class ListMasterController {
   @Post('/upsertListMasterItem/:type')
   @UseGuards(JwtAuthGuard)
   @HttpCode(HttpStatus.OK)
-  async upsertListMasterItem(@Param('type') type: string, @Body() item: any) {
+  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/:name')
+  @Delete('/deleteListMasterItem/:type/:code')
   @UseGuards(JwtAuthGuard)
   @HttpCode(HttpStatus.OK)
   async deleteListMasterItem(
     @Param('type') type: string,
-    @Param('name') name: string,
+    @Param('code') code: string,
   ): Promise<string> {
-    return await this.listMasterItemService.deleteListMasterItem(type, name);
+    return await this.listMasterItemService.deleteListMasterItem(type, code);
   }
 }

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

@@ -20,11 +20,11 @@ import { ListMasterItemService } from './service/list-master-item.service';
   ],
   providers: [
     { provide: 'ListMasterService', useClass: ListMasterService },
-    ListMasterItemService,
+    { 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

@@ -28,9 +28,16 @@ export class ListMasterItemsRepository {
     return items.map((i) => ({ label: i.name, value: i.value }));
   }
 
-  async findOneByNameAndType(name: string, type: string) {
+  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: { name, listtype: type, status: 'active' },
+      where: { code, listtype: type },
     });
   }
 

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

@@ -1,55 +1,106 @@
-import { Injectable, NotFoundException } from '@nestjs/common';
+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(type: string) {
-    return await this.listItemsRepo.findItemsByType(type);
+  async getListMasterItemsByType(listType: string) {
+    return await this.listItemsRepo.findAllItemsByListType(listType, 'asc');
   }
 
-  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
+  async createEntity(entityData: any, loggedInUser: UserData): Promise<any> {
+    return await this.entityServiceImpl.createEntity(entityData, loggedInUser);
+  }
 
-    console.log('Upserting list master item for type:', type, item);
+  async updateEntity(entityData: any, loggedInUser: UserData): Promise<any> {
+    return await this.entityServiceImpl.updateEntity(entityData, loggedInUser);
+  }
 
-    // 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,
-      );
+  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.listItemsRepo.update(existingItem.id, i);
+        await this.updateEntity(
+          {
+            ...existingItem,
+            ...item,
+            listtype: listType,
+          },
+          loggedInUser,
+        );
       } else {
-        await this.listItemsRepo.create(i);
+        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.findItemsByType(type);
+    const updatedItems = await this.listItemsRepo.findAllItemsByListType(
+      listType,
+      'asc',
+    );
 
     return {
-      type,
+      listType,
       items: updatedItems,
     };
   }
 
-  async deleteListMasterItem(type: string, name: string): Promise<string> {
-    const item = await this.listItemsRepo.findOneByNameAndType(name, type);
+  async deleteListMasterItem(listType: string, code: string): Promise<string> {
+    const item = await this.listItemsRepo.findOneByCodeAndType(code, listType);
     if (!item) {
       throw new NotFoundException(
-        `Item with name ${name} not found in type ${type}`,
+        `Item with name ${code} not found in type ${listType}`,
       );
     }
-    await this.listItemsRepo.delete({ listtype: type, name: name });
-    return `Item with name ${name} deleted successfully from type ${type}`;
+    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

@@ -242,14 +242,16 @@ export class ListMasterService {
     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.findByType(
-      entityData.type,
+    const existingListMaster = await this.listMasterRepo.findByName(
+      entityData.name,
     );
+
     if (existingListMaster) {
       throw new BadRequestException(
-        'List master with the same type already exists.',
+        'List master with the same name already exists',
       );
     }
 
@@ -262,6 +264,11 @@ export class ListMasterService {
       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;
   }