rez_core 0.0.1 → 0.0.2

package/src/module/meta/service/preference.service.ts

@@ -4,6 +4,7 @@ import { PreferenceRepository } from '../repository/preference.repository';
 import { EntityMasterService } from './entity-master.service';
 import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
 import { LoggingService } from '../../../utils/service/loggingUtil.service';
+import { EntityListService } from './entity-list.service';
 
 @Injectable()
 export class PreferenceService extends EntityServiceImpl {
@@ -11,9 +12,15 @@ export class PreferenceService extends EntityServiceImpl {
     entityMasterService: EntityMasterService,
     reflectionHelper: ReflectionHelper,
     loggingService: LoggingService,
+    entityListService: EntityListService,
     private readonly preferenceRepository: PreferenceRepository,
   ) {
-    super(entityMasterService, reflectionHelper, loggingService);
+    super(
+      entityMasterService,
+      reflectionHelper,
+      entityListService,
+      loggingService,
+    );
   }
 
   async getPreferenceValue(preferenceKey: string): Promise<string | undefined> {

package/src/module/module/controller/module-access.controller.ts

@@ -1,20 +1,34 @@
-import { Controller, Put, Body, Post, Get, Query } from '@nestjs/common';
+import { Controller, Get, Post, Body, Query } from '@nestjs/common';
 import { ModuleAccessService } from '../service/module-access.service';
 
 @Controller('module-access')
 export class ModuleAccessController {
   constructor(private readonly moduleAccessService: ModuleAccessService) {}
 
+  @Get('roles')
+  async getRoles() {
+    return this.moduleAccessService.getRoles();
+  }
+
+  @Get('modules')
+  async getModules() {
+    return this.moduleAccessService.getModules();
+  }
+
+  @Get('access-listing')
+  async getAccessListing(@Query('roles') roleIds: string) {
+    const roleIdArray = roleIds.split(',').map(Number);
+    return this.moduleAccessService.getAccessListing(roleIdArray);
+  }
+
+  @Get('menu-listing')
+  async getMenuListing(@Query('mainmod') mainModIds: string) {
+    const mainModArray = mainModIds.split(',').map(String);
+    return this.moduleAccessService.getMenuListing(mainModArray);
+  }
+
   @Post('update')
   async updateModuleAccess(@Body() moduleAccessData: any[]) {
     return this.moduleAccessService.updateModuleAccess(moduleAccessData);
   }
-
-  @Get('list')
-  async getModuleAccess(
-    @Query('role_code') roleCode?: string,
-    @Query('mainmod') mainMod?: string
-  ) {
-    return this.moduleAccessService.getModuleAccess(roleCode, mainMod);
-  }
 }

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

@@ -12,6 +12,9 @@ export class ModuleData {
   @Column({type: 'varchar', length: 100, nullable: true })
   module_code: string;
 
+  @Column({type: 'varchar', length: 100, nullable: true })
+  wbs_code: string;
+
   @Column({type: 'varchar', length: 100, nullable: true })
   status: StatusType;
 

package/src/module/module/repository/module-access.repository.ts

@@ -1,21 +1,102 @@
 import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository, In } from 'typeorm';
+import { Role } from 'src/module/user/entity/role.entity';
 import { ModuleAccess } from '../entity/module-access.entity';
+import { ModuleAction } from '../entity/module-action.entity';
 import { ModuleData } from '../entity/module.entity';
-import { Role } from 'src/module/user/entity/role.entity';
 
 @Injectable()
 export class ModuleAccessRepository {
   constructor(
-    @InjectRepository(ModuleAccess)
-    private readonly moduleAccessRepo: Repository<ModuleAccess>,
     @InjectRepository(Role)
     private readonly roleRepo: Repository<Role>,
     @InjectRepository(ModuleData)
-    private readonly moduleRepo: Repository<ModuleData>
+    private readonly moduleRepo: Repository<ModuleData>,
+    @InjectRepository(ModuleAccess)
+    private readonly moduleAccessRepo: Repository<ModuleAccess>,
+    @InjectRepository(ModuleAction)
+    private readonly moduleActionRepo: Repository<ModuleAction>
   ) {}
 
+  async getRoles() {
+    return this.roleRepo.find();
+  }
+
+  async getModules() {
+    return this.moduleRepo.find({ where: { module_level: 'MAINMOD' }});
+  }
+
+  async getAccessListing(roleIds: number[]) {
+    // Fetch roles using role IDs
+    const roles = await this.roleRepo.find({ where: { id: In(roleIds) } });
+  
+    // Extract role codes from roles
+    const roleCodes = roles.map(role => role.code);
+  
+    // Fetch module access using role codes
+    const moduleAccesses = await this.moduleAccessRepo.find({ where: { role_code: In(roleCodes) } });
+  
+    // Map role data to include access permissions
+    return roles.map(role => ({
+      role_code: role.code,
+      name: role.name,
+      permission: moduleAccesses
+        .filter(access => access.role_code === role.code)
+        .map(access => ({
+          action: access.action_type,
+          access: access.access_flag,
+          code: access.module_code
+        }))
+    }));
+  }
+  
+  async getMenuListing(mainModIds: string[]) {
+    // Get MAINMOD modules using their IDs
+    const mainModules = await this.moduleRepo.find({ 
+        where: { id: In(mainModIds), module_level: 'MAINMOD' } 
+    });
+
+    if (!mainModules.length) return [];
+
+    // Extract WBS codes of the MAINMOD modules
+    const wbsCodes = mainModules.map(mod => mod.wbs_code);
+
+    // Fetch all related modules using `LIKE` for WBS structure
+    const modules = await this.moduleRepo.createQueryBuilder("module")
+        .where(
+            wbsCodes.map(code => `module.wbs_code LIKE :code${code}`).join(" OR "),
+            Object.fromEntries(wbsCodes.map(code => [`code${code}`, `${code}%`]))
+        )
+        .getMany();
+
+    // Fetch module actions
+    const moduleActions = await this.moduleActionRepo.find();
+
+    // Function to recursively build module hierarchy
+    const buildHierarchy = (parentWbs: string) => {
+        return modules
+            .filter(mod => mod.wbs_code.startsWith(parentWbs) && mod.wbs_code !== parentWbs)
+            .map(mod => ({
+                name: mod.name,
+                code: mod.module_code,
+                permission: moduleActions
+                    .filter(action => action.module_code === mod.module_code)
+                    .map(action => ({ action: action.action_type, name: action.action_type })),
+                submod: buildHierarchy(mod.wbs_code)
+            }));
+    };
+
+    // Construct the final hierarchical response
+    return mainModules.map(mod => ({
+        name: mod.name,
+        code: mod.module_code,
+        permission: moduleActions
+            .filter(action => action.module_code === mod.module_code)
+            .map(action => ({ action: action.action_type, name: action.action_type })),
+        submod: buildHierarchy(mod.wbs_code)
+    }));
+}
   async updateModuleAccess(moduleAccessData: any[]): Promise<boolean> {
     try {
       for (const access of moduleAccessData) {
@@ -44,23 +125,4 @@ export class ModuleAccessRepository {
       return false;
     }
   }
-
-  async getModuleAccess(roleCode?: string, moduleCode?: string) {
-    const roles = await this.roleRepo.find({ take: 5 }); // Fetch top 5 roles
-    const modules = await this.moduleRepo.find(); // Fetch all modules
-
-    let filteredRoles = roles;
-    if (roleCode) {
-      const roleCodes = roleCode.split(',');
-      filteredRoles = filteredRoles.filter((role) => roleCodes.includes(role.code)); // Use correct property
-    }
-
-    let filteredModules = modules;
-    if (moduleCode) {
-      const moduleCodes = moduleCode.split(',');
-      filteredModules = filteredModules.filter((module) => moduleCodes.includes(module.module_code)); // Use correct property
-    }
-
-    return { roles: filteredRoles, modules: filteredModules };
-  }
-}
+}

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

@@ -5,6 +5,22 @@ import { ModuleAccessRepository } from '../repository/module-access.repository';
 export class ModuleAccessService {
   constructor(private readonly moduleAccessRepository: ModuleAccessRepository) {}
 
+  async getRoles() {
+    return this.moduleAccessRepository.getRoles();
+  }
+
+  async getModules() {
+    return this.moduleAccessRepository.getModules();
+  }
+
+  async getAccessListing(roleIds: number[]) {
+    return this.moduleAccessRepository.getAccessListing(roleIds);
+  }
+
+  async getMenuListing(mainModIds: string[]) {
+    return this.moduleAccessRepository.getMenuListing(mainModIds);
+  }
+
   async updateModuleAccess(moduleAccessData: any[]): Promise<{ success: boolean; msg: string }> {
     if (!moduleAccessData || moduleAccessData.length === 0) {
       return { success: false, msg: 'No data provided' };
@@ -18,8 +34,4 @@ export class ModuleAccessService {
       return { success: false, msg: 'Failed to update module access' };
     }
   }
-
-  async getModuleAccess(roleCode?: string, mainMod?: string) {
-    return this.moduleAccessRepository.getModuleAccess(roleCode, mainMod);
-  }
 }

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

@@ -15,6 +15,6 @@ export class Role extends BaseEntity {
   @Column({ type: 'int', nullable: true })
   is_system: number;
 
-  @Column({ type: 'varchar', length: 250 })
+  @Column({ type: 'varchar', length: 250 ,nullable:true})
   description: string;
 }

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

@@ -6,15 +6,17 @@ import { LoggingService } from '../../../utils/service/loggingUtil.service';
 import { BaseEntity } from '../../meta/entity/base-entity.entity';
 import { UserData } from '../entity/user.entity';
 import { Role } from '../entity/role.entity';
+import {EntityListService} from "../../meta/service/entity-list.service";
 
 @Injectable()
 export class RoleService extends EntityServiceImpl {
   constructor(
     entityMasterService: EntityMasterService,
     reflectionHelper: ReflectionHelper,
+    entityListService: EntityListService,
     loggingService: LoggingService,
   ) {
-    super(entityMasterService, reflectionHelper, loggingService);
+    super(entityMasterService, reflectionHelper,entityListService, loggingService);
   }
 
   async createEntity(

package/src/module/user/service/user-session.service.ts

@@ -9,9 +9,10 @@ export class UserSessionService {
   constructor(
     private readonly userSessionRepository: UserSessionRepository,
     private readonly jwtAuthService: JwtAuthService,
+    private readonly clockIDGenService: ClockIDGenService
   ) {}
   async createSession(user) {
-    const sessionToken = ClockIDGenService.idGenerator('SES');
+    const sessionToken = this.clockIDGenService.idGenerator('SES');
 
     const userSession: any = new UserSession();
     userSession.user_id = user.id;

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

@@ -6,7 +6,6 @@ import { LoggingService } from '../../../utils/service/loggingUtil.service';
 import { UserData } from '../entity/user.entity';
 import { BaseEntity } from '../../meta/entity/base-entity.entity';
 import { UserRepository } from '../repository/user.repository';
-import { StatusType } from '../../../constant/status.constant';
 import { EncryptUtilService } from '../../../utils/service/encryptUtil.service';
 import { ClockIDGenService } from '../../../utils/service/clockIDGenUtil.service';
 import {
@@ -17,18 +16,26 @@ import {
 import { CreateUserDto } from '../dto/create-user.dto';
 import { UserRoleMappingService } from './user-role-mapping.service';
 import { UserRoleMapping } from '../entity/user-role-mapping.entity';
-import {plainToInstance} from "class-transformer";
+import { plainToInstance } from 'class-transformer';
+import { EntityListService } from '../../meta/service/entity-list.service';
 
 @Injectable()
 export class UserService extends EntityServiceImpl {
   constructor(
     entityMasterService: EntityMasterService,
     reflectionHelper: ReflectionHelper,
+    entityListService: EntityListService,
     loggingService: LoggingService,
     private userRepository: UserRepository,
     private userRoleMappingService: UserRoleMappingService,
+    private readonly clockIDGenService: ClockIDGenService
   ) {
-    super(entityMasterService, reflectionHelper, loggingService);
+    super(
+      entityMasterService,
+      reflectionHelper,
+      entityListService,
+      loggingService,
+    );
   }
 
   async createEntity(
@@ -58,7 +65,7 @@ export class UserService extends EntityServiceImpl {
       );
     } else {
       password = EncryptUtilService.encryptGCM(
-        ClockIDGenService.idGenerator(''),
+        this.clockIDGenService.idGenerator(''),
         masterKey,
         masterIv,
       );
@@ -120,14 +127,16 @@ export class UserService extends EntityServiceImpl {
       userDto.password = password;
     }
 
-    let userData = plainToInstance(UserData, userDto, {excludeExtraneousValues: true});
+    let userData = plainToInstance(UserData, userDto, {
+      excludeExtraneousValues: true,
+    });
     let savedData = await super.updateEntity(userData, loggedInUserData);
     if (userDto.roles) {
       let roles = userDto.roles;
       for (const role in roles) {
         let userRoleMapping = new UserRoleMapping(
-            savedData.id,
-            Number(roles[role]),
+          savedData.id,
+          Number(roles[role]),
         );
         await this.userRoleMappingService.assignUserRole(userRoleMapping);
       }

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

@@ -19,6 +19,7 @@ import { UserRoleMapping } from './entity/user-role-mapping.entity';
 import { UserRoleMappingRepository } from './repository/user-role-mapping.repository';
 import { UserRoleMappingService } from './service/user-role-mapping.service';
 import { RoleRepository } from './repository/role.repository';
+import { EntityListService } from '../meta/service/entity-list.service';
 
 @Module({
   imports: [
@@ -37,14 +38,14 @@ import { RoleRepository } from './repository/role.repository';
     JwtService,
     UserRoleMappingRepository,
     UserRoleMappingService,
-    RoleRepository
+    RoleRepository,
   ],
   exports: [
     'UserService',
     UserSessionService,
     'RoleService',
     UserRoleMappingService,
-    RoleRepository
+    RoleRepository,
   ],
   controllers: [LoginController, UserController],
 })

package/src/utils/service/clockIDGenUtil.service.ts

@@ -1,21 +1,19 @@
 import { Injectable } from "@nestjs/common";
 
 @Injectable()
-export class ClockIDGenService{
+export class ClockIDGenService {
+    private _counter = 0n;
+    private timestampBits = 42;
+    private timestampMask = BigInt(Math.floor(Math.pow(2, this.timestampBits)) - 1);
+    private counterBits = 10;
+    private counterMask = BigInt(Math.floor(Math.pow(2, this.counterBits)) - 1);
 
-    static _counter = 0n;
-    static timestampBits = 42;
-    static timestampMask = BigInt(Math.floor(Math.pow(2, ClockIDGenService.timestampBits)) - 1);
-    static counterBits = 10;
-    static counterMask = BigInt(Math.floor(Math.pow(2, ClockIDGenService.counterBits)) - 1);
-
-    static idGenerator(prefix?: string) {
+    idGenerator(prefix?: string): string {
         const timestamp = BigInt(Date.now()) & this.timestampMask;
         const counter = BigInt(this._counter++) & this.counterMask;
-        let now = timestamp << BigInt(this.counterBits)
+        let now = timestamp << BigInt(this.counterBits);
         now = now | counter;
         const id = now.toString(36).toUpperCase();
-        return prefix + id;
+        return prefix ? prefix + id : id;
     }
-
-}
+}

package/src/utils/utils.module.ts

@@ -1,14 +1,12 @@
-import { Global, Module } from '@nestjs/common';
-import { TypeOrmModule } from '@nestjs/typeorm';
-import { DataSource } from 'typeorm';
-import { LoggingService } from './service/loggingUtil.service';
-import { ReflectionHelper } from './service/reflection-helper.service';
-import { ExcelUtil } from './service/excelUtil.service';
+import {Global, Module} from "@nestjs/common";
+import { LoggingService } from "./service/loggingUtil.service";
+import {ReflectionHelper} from "./service/reflection-helper.service";
+import { ExcelUtil } from "./service/excelUtil.service";
+import { ClockIDGenService } from "./service/clockIDGenUtil.service";
 
 @Global()
 @Module({
-  imports: [TypeOrmModule.forFeature([])], // Import TypeORM to make DataSource available
-  providers: [LoggingService, ReflectionHelper, ExcelUtil], // Ensure DataSource is provided
-  exports: [LoggingService, ReflectionHelper, ExcelUtil],
+  providers: [LoggingService, ReflectionHelper,ExcelUtil,ClockIDGenService],
+  exports: [LoggingService, ReflectionHelper,ExcelUtil,ClockIDGenService],
 })
 export class UtilsModule {}