rez_core 6.5.73 → 6.5.75

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "6.5.73",
+  "version": "6.5.75",
   "description": "",
   "author": "",
   "private": false,
@@ -63,6 +63,7 @@
     "passport-google-oauth20": "^2.0.0",
     "passport-jwt": "^4.0.1",
     "passport-local": "^1.0.0",
+    "pg": "^8.16.3",
     "redis": "^4.7.1",
     "reflect-metadata": "^0.2.2",
     "rxjs": "^7.8.1",
@@ -122,4 +123,4 @@
     "coverageDirectory": "../coverage",
     "testEnvironment": "node"
   }
-}
+}

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

@@ -9,6 +9,9 @@ export class ListMasterData extends BaseEntity {
   @Column({nullable: true})
   type: string;
 
+  @Column({nullable: true})
+  storage_type: string;
+
   @Column({nullable: true})
   sort_by: string;
 

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

@@ -23,6 +23,7 @@ export class ListMasterItemsRepository {
   async findItemsByType(
     type: string,
     sort_by?,
+    storage_type?,
     inactiveIdsArray?: number[],
     enterprise_id?: number,
     params?: Record<string, string>,
@@ -79,9 +80,10 @@ export class ListMasterItemsRepository {
       order: orderBy,
     });
 
+    
     let result = items.map((i) => ({
       label: i.name,
-      value: i.id,
+      value: storage_type === 'code' ? i.code : parseInt(String(i.id), 10),
     }));
 
     // Handle inactive items if specified

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

@@ -127,6 +127,21 @@ export class ListMasterItemService extends EntityServiceImpl {
 
         const finalCode = code || ''; // Could generate code here if needed
 
+        // Check if code already exists (if code is provided)
+        if (finalCode) {
+          const codeExists = await this.listItemsRepo.findOneByCondition({
+            code: finalCode,
+            listtype: listType,
+            enterprise_id: entId,
+          });
+
+          if (codeExists) {
+            throw new BadRequestException(
+              `list item with code ${finalCode} already exists`,
+            );
+          }
+        }
+
         await this.createEntity(
           {
             ...item,

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

@@ -124,6 +124,7 @@ export class ListMasterService {
         return this.listItemsRepo.findItemsByType(
           type,
           config.sort_by,
+          config.storage_type,
           inactiveIdsArray,
           loggedInUser?.enterprise_id,
           params,
@@ -358,12 +359,9 @@ export class ListMasterService {
   async createEntity(entityData: any, loggedInUser: UserData): Promise<any> {
     // Trim and validate name and code
     const name = entityData.name?.trim();
-    // const code = entityData.code?.trim();
-
     if (!name) {
       throw new BadRequestException('Name is required and cannot be empty');
     }
-
     entityData.name = name;
     entityData.is_factory = entityData.is_factory || 0;
     entityData.source = entityData.source || 'master';
@@ -391,7 +389,6 @@ export class ListMasterService {
     if (!createdListMaster) {
       throw new BadRequestException('Failed to create entity');
     }
-
     return createdListMaster;
   }
 
@@ -590,6 +587,7 @@ export class ListMasterService {
       return this.listItemsRepo.findItemsByType(
         lmCode,
         listMaster.sort_by,
+        listMaster.storage_type,
         inactiveIdsArray,
         loggedInUser.enterprise_id,
         params,

package/src/module/module/controller/menu.controller.ts

@@ -1,10 +1,23 @@
-import { Controller, Get, Request, UseGuards } from '@nestjs/common';
+import {
+  BadRequestException,
+  Controller,
+  Get,
+  Post,
+  Request,
+  UploadedFile,
+  UseGuards,
+  UseInterceptors,
+} from '@nestjs/common';
 import { MenuService } from '../service/menu.service';
 import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+import { FileInterceptor } from '@nestjs/platform-express';
+import { Express } from 'express';
+import { ModuleImportService } from '../service/module-import.service';
 
 @Controller('menu')
 export class MenuController {
-  constructor(private readonly menuService: MenuService) {}
+  constructor(private readonly menuService: MenuService,
+              private readonly moduleImportService: ModuleImportService,) {}
 
   @UseGuards(JwtAuthGuard)
   @Get()
@@ -12,4 +25,17 @@ export class MenuController {
     const { id: userId, appcode, level_type, level_id } = req.user.userData;
     return this.menuService.getUserMenu(userId, appcode, level_type, level_id);
   }
+
+  @Post('upload-module-data')
+  @UseInterceptors(FileInterceptor('file'))
+  async uploadModuleDataXls(
+    @UploadedFile() file: Express.Multer.File,
+  ) {
+    if (!file) {
+      throw new BadRequestException('File is required');
+    }
+    return await this.moduleImportService.uploadModuleData(
+      file,
+    );
+  }
 }

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

@@ -14,6 +14,7 @@ import { UserRoleMapping } from '../user/entity/user-role-mapping.entity';
 import { UserModule } from '../user/user.module';
 import { Role } from '../user/entity/role.entity';
 import { ModuleAccess } from './entity/module-access.entity';
+import { ModuleImportService } from './service/module-import.service';
 
 @Module({
   imports: [
@@ -34,6 +35,7 @@ import { ModuleAccess } from './entity/module-access.entity';
     MenuService,
     MenuRepository,
     ModuleAccessRepository,
+    ModuleImportService
   ],
   exports: [ModuleAccessService,MenuService],
 })

package/src/module/module/service/module-import.service.ts

@@ -0,0 +1,294 @@
+import { BadRequestException, Injectable } from '@nestjs/common';
+import { EntityManager } from 'typeorm';
+import { ExcelUtil } from 'src/utils/service/excelUtil.service';
+import { ConfigService } from '@nestjs/config';
+
+@Injectable()
+export class ModuleImportService {
+    constructor(
+        private readonly entityManager: EntityManager,
+        private readonly configService: ConfigService,
+    ) { }
+
+    schema = this.configService.get('DB_SCHEMA');
+
+    private readonly moduleSequence = [
+        {
+            table: 'sso_module',
+            unique_fields: ['module_code'],
+        },
+        {
+            table: 'sso_menu',
+            unique_fields: ['module_id'],
+        },
+        {
+            table: 'sso_module_ucp',
+            unique_fields: ['module_id', 'action_code'],
+        },
+        {
+            table: 'sso_module_access',
+            unique_fields: ['module_id', 'action_type', 'role_id', 'level_type'],
+        },
+    ];
+
+    /**
+     * Get columns to exclude from INSERT/UPDATE operations based on table
+     * module_code is only needed in sso_module table, excluded from others
+     * action_type is only needed in sso_module_access table, excluded from others
+     */
+    private getExcludedColumns(tableName: string): string[] {
+        const baseExcluded = ['role_code', 'appcode'];
+
+        // module_code should only be included in sso_module table
+        if (tableName !== 'sso_module') {
+            baseExcluded.push('module_code');
+        }
+
+        // action_type should only be included in sso_module_access table
+        if (tableName !== 'sso_module_access') {
+            baseExcluded.push('action_type');
+        }
+
+        return baseExcluded;
+    }
+
+    async uploadModuleData(file) {
+        const data = ExcelUtil.readExcel(file.buffer);
+        const errors: any[] = [];
+
+        for (let i = 0; i < this.moduleSequence.length; i++) {
+            const { table, unique_fields } = this.moduleSequence[i];
+            const sheetData = data[table];
+
+            if (!sheetData) {
+                console.log(`Sheet ${table} not found in the Excel file.`);
+                continue;
+            }
+
+            console.log(`Processing sheet: ${table}`);
+
+            // Process each row and resolve codes to IDs
+            for (let rowIndex = 0; rowIndex < sheetData.length; rowIndex++) {
+                const row = sheetData[rowIndex];
+
+                try {
+                    // Resolve codes to IDs based on table
+                    if (table === 'sso_menu') {
+                        await this.resolveModuleCode(row);
+                        await this.resolveAppCode(row);
+                    } else if (table === 'sso_module_ucp') {
+                        await this.resolveModuleCode(row);
+                    } else if (table === 'sso_module_access') {
+                        await this.resolveModuleCode(row);
+                        await this.resolveRoleCode(row);
+                        await this.resolveAppCode(row);
+                        await this.resolveActionType(row);
+                    } else if (table === 'sso_module') {
+                        await this.resolveAppCode(row);
+                    }
+                } catch (error) {
+                    errors.push({
+                        sheet: table,
+                        row: rowIndex + 1,
+                        error: error.message,
+                    });
+                }
+            }
+
+            // If there are errors, throw exception before upserting
+            if (errors.length > 0) {
+                throw new BadRequestException({
+                    message: 'Validation errors found during code resolution',
+                    errors,
+                });
+            }
+
+            // Upsert data for this table
+            await this.upsertModuleData(table, unique_fields, sheetData);
+        }
+
+        return {
+            message: 'Module data uploaded successfully',
+        };
+    }
+
+    /**
+     * Resolve module_code to module_id
+     */
+    private async resolveModuleCode(row: any): Promise<void> {
+        if (!row.module_code) {
+            throw new Error('module_code is required but not provided');
+        }
+
+        const moduleData = await this.entityManager.query(
+            `SELECT id FROM ${this.schema}.sso_module WHERE module_code = $1 LIMIT 1`,
+            [row.module_code],
+        );
+
+        if (!moduleData || moduleData.length === 0) {
+            throw new Error(
+                `Module not found for module_code: ${row.module_code}`,
+            );
+        }
+
+        row.module_id = moduleData[0].id;
+    }
+
+    /**
+     * Resolve role_code to role_id
+     */
+    private async resolveRoleCode(row: any): Promise<void> {
+        if (!row.role_code) {
+            throw new Error('role_code is required but not provided');
+        }
+
+        const roleData = await this.entityManager.query(
+            `SELECT id FROM ${this.schema}.sso_role WHERE code = $1 LIMIT 1`,
+            [row.role_code],
+        );
+
+        if (!roleData || roleData.length === 0) {
+            throw new Error(`Role not found for role_code: ${row.role_code}`);
+        }
+
+        row.role_id = roleData[0].id;
+    }
+
+    /**
+     * Resolve appcode to app_id
+     */
+    private async resolveAppCode(row: any): Promise<void> {
+        if (!row.appcode) {
+            // appcode might be optional in some cases
+            return;
+        }
+
+        const appData = await this.entityManager.query(
+            `SELECT id FROM ${this.schema}.sso_app_master WHERE code = $1 LIMIT 1`,
+            [row.appcode],
+        );
+
+        if (!appData || appData.length === 0) {
+            throw new Error(`App not found for appcode: ${row.appcode}`);
+        }
+
+        row.app_id = appData[0].id;
+    }
+
+    /**
+     * Resolve action_type (action_code) to action_id
+     * This requires both module_code and action_type to find the correct action
+     */
+    private async resolveActionType(row: any): Promise<void> {
+        if (!row.action_type) {
+            throw new Error('action_type is required but not provided');
+        }
+
+        if (!row.module_code) {
+            throw new Error('module_code is required to resolve action_type');
+        }
+
+        // First get the module_id
+        const moduleData = await this.entityManager.query(
+            `SELECT id FROM ${this.schema}.sso_module WHERE module_code = $1 LIMIT 1`,
+            [row.module_code],
+        );
+
+        if (!moduleData || moduleData.length === 0) {
+            throw new Error(
+                `Module not found for module_code: ${row.module_code}`,
+            );
+        }
+
+        // Then find the action using module_id and action_code
+        const actionData = await this.entityManager.query(
+            `SELECT id FROM ${this.schema}.sso_module_ucp WHERE module_id = $1 AND action_code = $2 LIMIT 1`,
+            [moduleData[0].id, row.action_type],
+        );
+
+        if (!actionData || actionData.length === 0) {
+            throw new Error(
+                `Action not found for module_code: ${row.module_code} and action_type: ${row.action_type}`,
+            );
+        }
+
+        row.action_id = actionData[0].id;
+    }
+
+    /**
+     * Upsert data into the specified table
+     */
+    private async upsertModuleData(
+        tableName: string,
+        uniqueFields: string[],
+        data: any[],
+    ): Promise<void> {
+        const excludedColumns = this.getExcludedColumns(tableName);
+
+        for (const row of data) {
+            const whereClause = uniqueFields
+                .map((field, index) => `${field} = $${index + 1}`)
+                .join(' AND ');
+
+            const whereParams = uniqueFields.map((field) => row[field]);
+
+            const existing = await this.entityManager.query(
+                `SELECT * FROM ${this.schema}.${tableName} WHERE ${whereClause} LIMIT 1`,
+                whereParams,
+            );
+
+            if (existing.length > 0) {
+                // Update existing record
+                const setClauses: string[] = [];
+                const setParams: any[] = [];
+                let paramIndex = 1;
+
+                for (const key in row) {
+                    // Exclude code columns and unique fields from update
+                    if (row.hasOwnProperty(key) &&
+                        !uniqueFields.includes(key) &&
+                        !excludedColumns.includes(key)) {
+                        setClauses.push(`${key} = $${paramIndex}`);
+                        setParams.push(row[key]);
+                        paramIndex++;
+                    }
+                }
+
+                // Add where parameters
+                whereParams.forEach((param) => {
+                    setParams.push(param);
+                });
+
+                const updateWhereClause = uniqueFields
+                    .map((field, index) => `${field} = $${paramIndex + index}`)
+                    .join(' AND ');
+
+                if (setClauses.length > 0) {
+                    await this.entityManager.query(
+                        `UPDATE ${this.schema}.${tableName} SET ${setClauses.join(', ')} WHERE ${updateWhereClause}`,
+                        setParams,
+                    );
+                }
+            } else {
+                // Insert new record - exclude code columns
+                const filteredRow: any = {};
+                for (const key in row) {
+                    if (row.hasOwnProperty(key) && !excludedColumns.includes(key)) {
+                        filteredRow[key] = row[key];
+                    }
+                }
+
+                const columns = Object.keys(filteredRow).join(', ');
+                const placeholders = Object.keys(filteredRow)
+                    .map((_, index) => `$${index + 1}`)
+                    .join(', ');
+                const values = Object.values(filteredRow);
+
+                await this.entityManager.query(
+                    `INSERT INTO ${this.schema}.${tableName} (${columns}) VALUES (${placeholders})`,
+                    values,
+                );
+            }
+        }
+    }
+}

package/src/module/user/service/role.service.ts

@@ -1,7 +1,6 @@
 import { Injectable } from '@nestjs/common';
 import { UserData } from '../entity/user.entity';
 import { Role } from '../entity/role.entity';
-import { STATUS_INACTIVE } from 'src/constant/global.constant';
 import { RoleRepository } from '../repository/role.repository';
 import { Repository } from 'typeorm';
 import { InjectRepository } from '@nestjs/typeorm';
@@ -45,9 +44,9 @@ export class RoleService {
       return { success: false, error: 'Role name already exists.' };
     }
 
-    if(!role.code) {
+    if (!role.code) {
       const maxId = await this.roleRepository.findMaxIdRecord();
-      if(maxId && maxId.id) {
+      if (maxId && maxId.id) {
         role.code = `ROL${maxId.id + 1}`;
       } else {
         role.code = `ROL1`;
@@ -75,7 +74,7 @@ export class RoleService {
           access_flag: perm.access_flag,
           level_type: perm.level_type,
           appcode: perm.appcode,
-          module_id: perm.module_id
+          module_id: perm.module_id,
         }),
       );
 
@@ -93,7 +92,7 @@ export class RoleService {
       return { success: false, error: 'Role name is required' };
     }
 
-    if (role.status == STATUS_INACTIVE) {
+    if (role.status == StatusConstant.INACTIVE) {
       //get role by id
       const existingRole = await this.roleRepository.findById(id);