rez_core 2.1.54 → 2.1.56

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "2.1.54",
+  "version": "2.1.56",
   "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,
   ) {}
 
@@ -51,27 +53,49 @@ export class ListMasterController {
   @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);
+  async getListMasterItems(
+    @Param('type') type: string,
+    @Query('search') search?: string,
+  ) {
+    return await this.listMasterItemService.getListMasterItemsByType(
+      type,
+      search,
+    );
   }
+
+  @Get('')
+  @UseGuards(JwtAuthGuard)
+  @HttpCode(HttpStatus.OK)
+  async getAllListMasterItems(
+    @Query('search') search?: string,
+  ): Promise<any[]> {
+    return await this.service.getAllListMasterItems(search);
+  }
+
   @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,26 @@ 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, search?: string) {
+    const qb = this.repo
+      .createQueryBuilder('item')
+      .where('item.listtype = :type', { type });
+
+    if (search?.trim()) {
+      qb.andWhere(
+        '(LOWER(item.name) LIKE :search OR LOWER(item.code) LIKE :search)',
+        { search: `%${search.toLowerCase()}%` },
+      );
+    }
+
+    qb.orderBy('item.sortindex', sortBy === 'asc' ? 'ASC' : 'DESC');
+
+    return await qb.getMany();
+  }
+
+  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,32 @@ import { Repository } from 'typeorm';
 import { InjectRepository } from '@nestjs/typeorm';
 
 @Injectable()
-export class ListMasterRepository{
-
-    constructor(
-        @InjectRepository(ListMasterData) private readonly repo:  Repository<ListMasterData>) {}
-    
-    findByType(type: string) {
-        return this.repo.findOne({ where: { type } });
-      }
-}
+export class ListMasterRepository {
+  constructor(
+    @InjectRepository(ListMasterData)
+    private readonly repo: Repository<ListMasterData>,
+  ) {}
+
+  findByType(type: string) {
+    return this.repo.findOne({ where: { type } });
+  }
+
+  findByName(name: string) {
+    return this.repo.findOne({ where: { name } });
+  }
+
+  async findAllItems(search?: string) {
+    const qb = this.repo
+      .createQueryBuilder('item')
+      .where('item.source = :source', { source: 'master' });
+
+    if (search?.trim()) {
+      qb.andWhere(
+        '(LOWER(item.name) LIKE :search OR LOWER(item.code) LIKE :search)',
+        { search: `%${search.toLowerCase()}%` },
+      );
+    }
+
+    return await qb.getMany();
+  }
+}

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

@@ -1,55 +1,96 @@
-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, search?: string) {
+    return this.listItemsRepo.findAllItemsByListType(listType, 'asc', search);
   }
 
-  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> {
+    for (const item of items) {
+      let existingItem;
 
-      console.log('Existing item found:', existingItem);
+      // If code is provided, use it for lookup
+      if (item.code) {
+        existingItem = await this.listItemsRepo.findOneByCodeAndType(
+          item.code,
+          listType,
+        );
+      }
 
       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
+
+        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

@@ -13,7 +13,6 @@ import { HttpService } from '@nestjs/axios';
 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()
@@ -242,14 +241,17 @@ 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';
+    entityData.sort_by = entityData.sort_by || 'asc';
 
     // 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;
   }
 
@@ -272,4 +279,8 @@ export class ListMasterService {
   async getEntityData(entity_type: string, id: number): Promise<any> {
     return await this.entityServiceImpl.getEntityData(entity_type, id);
   }
+
+  async getAllListMasterItems(search?: string): Promise<any[]> {
+    return await this.listMasterRepo.findAllItems(search);
+  }
 }