rez_core 6.5.72 → 6.5.74

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "6.5.72",
+  "version": "6.5.74",
   "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/app_master/service/app-master.service.ts

@@ -1,17 +1,18 @@
 import { Injectable } from '@nestjs/common';
 import { UserRoleMappingRepository } from 'src/module/user/repository/user-role-mapping.repository';
 import { AppMasterRespository } from '../repository/app-master.repository';
+import { UserRoleMappingService } from 'src/module/user/service/user-role-mapping.service';
 
 @Injectable()
 export class AppMasterService {
   constructor(
     private readonly appMasterRepository: AppMasterRespository,
-    private readonly userRoleMappingRepository: UserRoleMappingRepository,
+    private readonly userRoleMappingService:UserRoleMappingService
   ) {}
 
   async getAppMasterDataByAppCode(userId: number) {
     const app_code =
-      await this.userRoleMappingRepository.findDistinctAppcodeByUserId(userId);
+      await this.userRoleMappingService.findDistinctAppcodeByUserId(userId);
 
     const finalResult: any[] = [];
 

package/src/module/enterprise/controller/organization.controller.ts

@@ -12,6 +12,7 @@ import {
   HttpCode,
   HttpStatus,
   ParseIntPipe,
+  BadRequestException,
 } from '@nestjs/common';
 import { Request } from 'express';
 import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
@@ -79,9 +80,15 @@ export class OrganizationController {
     @Param('id', ParseIntPipe) id: number,
     @Body() organizationDto: Partial<OrganizationData>,
     @Req() req: Request & { user: any },
-  ): Promise<OrganizationData | null> {
+  ): Promise<OrganizationData> {
     const loggedInUser = req.user.userData;
-    return await this.orgService.update(id, organizationDto, loggedInUser);
+    const result = await this.orgService.update(id, organizationDto, loggedInUser);
+    
+    if (!result.success) {
+      throw new BadRequestException(result.error);
+    }
+    
+    return result.data;
   }
 
   @Delete(':id')

package/src/module/enterprise/service/organization.service.ts

@@ -10,6 +10,11 @@ import { SchoolRepository } from '../repository/school.repository';
 import { WBSCodeGenService } from 'src/utils/service/wbsCodeGen.service';
 import { StatusConstant } from '../../../constant/status.constant';
 
+// Type for update operation result
+export type UpdateResult<T> = 
+  | { success: true; data: T }
+  | { success: false; error: string };
+
 @Injectable()
 export class OrganizationService {
   constructor(
@@ -138,7 +143,7 @@ export class OrganizationService {
     organizationDto: Partial<OrganizationData>,
     loggedInUser?: any,
     manager?: EntityManager,
-  ): Promise<OrganizationData | null> {
+  ): Promise<UpdateResult<OrganizationData>> {
     const repo = manager
       ? manager.getRepository(OrganizationData)
       : this.organizationRepository;
@@ -146,12 +151,18 @@ export class OrganizationService {
     // Get existing organization
     const existingOrg = await repo.findOne({ where: { id } });
     if (!existingOrg) {
-      throw new Error(`Organization with id ${id} not found.`);
+      return {
+        success: false,
+        error: `Organization with id ${id} not found.`,
+      };
     }
 
     // Prevent circular reference - check if trying to set itself as parent
     if (organizationDto.parent_id === id) {
-      throw new Error('Organization cannot be its own parent.');
+      return {
+        success: false,
+        error: 'Organization cannot be its own parent.',
+      };
     }
 
     // Check if parent_id is being changed
@@ -161,7 +172,19 @@ export class OrganizationService {
 
     // If parent_id is being set or changed, recalculate WBS code
     if (parentIdChanged) {
+      // VALIDATION: Cannot change parent of organizations with WBS code length 5 or 11
+      const wbsCodeLength = existingOrg.wbs_code?.length || 0;
+      if (wbsCodeLength === 5 || wbsCodeLength === 11) {
+        return {
+          success: false,
+          error:
+            `Cannot change parent of organization with WBS code length ${wbsCodeLength}. ` +
+            `Organizations at this level (${existingOrg.wbs_code}) are locked and cannot be moved.`,
+        };
+      }
+
       const newParentId = organizationDto.parent_id;
+      const oldWbsCode = existingOrg.wbs_code;
 
       if (newParentId) {
         // Sub-org case: parent_id is being set
@@ -170,18 +193,39 @@ export class OrganizationService {
         });
 
         if (!parentOrg) {
-          throw new Error('Parent organization not found.');
+          return {
+            success: false,
+            error: 'Parent organization not found.',
+          };
         }
 
         if (!parentOrg.wbs_code) {
-          throw new Error('Parent organization must have a WBS code.');
+          return {
+            success: false,
+            error: 'Parent organization must have a WBS code.',
+          };
         }
 
-        // Prevent setting a descendant as parent (circular reference check)
-        if (parentOrg.wbs_code?.startsWith(existingOrg.wbs_code || '')) {
-          throw new Error(
-            'Cannot set a descendant organization as parent (circular reference).',
-          );
+        // CIRCULAR DEPENDENCY CHECK: Prevent setting a descendant as parent
+        // This checks if the proposed parent is actually a child/descendant of the current org
+        if (existingOrg.wbs_code && parentOrg.wbs_code) {
+          // Check if parent's WBS starts with current org's WBS (parent is a descendant)
+          if (parentOrg.wbs_code.startsWith(existingOrg.wbs_code + '.')) {
+            return {
+              success: false,
+              error:
+                `Cannot set organization ${parentOrg.wbs_code} as parent. ` +
+                `It is a descendant of ${existingOrg.wbs_code} (circular reference).`,
+            };
+          }
+          
+          // Also check if they're the same (redundant with earlier check, but explicit)
+          if (parentOrg.wbs_code === existingOrg.wbs_code) {
+            return {
+              success: false,
+              error: 'Organization cannot be its own parent (circular reference).',
+            };
+          }
         }
 
         // Find existing sub-orgs with the same parent_id (excluding current org)
@@ -235,6 +279,17 @@ export class OrganizationService {
 
         organizationDto.wbs_code = this.wbcCodeGenService.padCode(nextOrgCode);
       }
+
+      // CASCADE UPDATE: Update all descendant organizations' WBS codes
+      const newWbsCode = organizationDto.wbs_code;
+      if (oldWbsCode && newWbsCode && oldWbsCode !== newWbsCode) {
+        await this.updateDescendantWbsCodes(
+          repo,
+          oldWbsCode,
+          newWbsCode,
+          loggedInUser,
+        );
+      }
     }
 
     // Set modified_by
@@ -243,7 +298,19 @@ export class OrganizationService {
     }
 
     await repo.update(id, organizationDto);
-    return await repo.findOne({ where: { id } });
+    const updatedOrg = await repo.findOne({ where: { id } });
+    
+    if (!updatedOrg) {
+      return {
+        success: false,
+        error: 'Failed to retrieve updated organization.',
+      };
+    }
+
+    return {
+      success: true,
+      data: updatedOrg,
+    };
   }
 
   async remove(id: number, manager?: EntityManager): Promise<void> {
@@ -254,6 +321,45 @@ export class OrganizationService {
     await repo.delete(id);
   }
 
+  /**
+   * Recursively updates WBS codes for all descendant organizations
+   * when a parent organization's WBS code changes
+   */
+  private async updateDescendantWbsCodes(
+    repo: Repository<OrganizationData>,
+    oldWbsCode: string,
+    newWbsCode: string,
+    loggedInUser?: any,
+  ): Promise<void> {
+    // Find all organizations whose WBS code starts with the old WBS code
+    // This will get all direct and indirect descendants
+    const descendants = await repo
+      .createQueryBuilder('org')
+      .where('org.wbs_code LIKE :pattern', { pattern: `${oldWbsCode}.%` })
+      .getMany();
+
+    // Update each descendant's WBS code
+    for (const descendant of descendants) {
+      if (descendant.wbs_code) {
+        // Replace the old WBS prefix with the new one
+        const updatedWbsCode = descendant.wbs_code.replace(
+          oldWbsCode,
+          newWbsCode,
+        );
+
+        const updateData: Partial<OrganizationData> = {
+          wbs_code: updatedWbsCode,
+        };
+
+        if (loggedInUser) {
+          updateData.modified_by = loggedInUser.id;
+        }
+
+        await repo.update(descendant.id, updateData);
+      }
+    }
+  }
+
   async getOrganizationHierarchy(
     userId: number,
     appCode: string,

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/service/list-master.service.ts

@@ -358,12 +358,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 +388,6 @@ export class ListMasterService {
     if (!createdListMaster) {
       throw new BadRequestException('Failed to create entity');
     }
-
     return createdListMaster;
   }
 

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);