rez_core 2.0.0 → 2.0.2

package/src/module/module/repository/menu.repository.ts

@@ -14,59 +14,64 @@ export class MenuRepository extends Repository<MenuData> {
   /**
    * Get all role IDs assigned to a user.
    */
-  async getUserRoles(userId: number): Promise<number[]> {
+  async getUserRoles(userId: number, appcode: string): Promise<number[]> {
     const roles = await this.dataSource
       .getRepository(UserRoleMapping)
-      .createQueryBuilder('userRoleMapping')
-      .select('userRoleMapping.role_id')
-      .where('userRoleMapping.user_id = :userId', { userId })
-      .getMany();
-
-    return roles.map((role) => role.role_id);
+      .createQueryBuilder('urm')
+      .innerJoin('cr_role', 'role', 'role.id = urm.role_id') // manual join
+      .select('urm.role_id')
+      .where('urm.user_id = :userId', { userId })
+      .andWhere('role.appcode = :appcode', { appcode })
+      .getRawMany();
+  
+    return roles. map((r) => r.urm_role_id);
   }
+  
 
   /**
    * Get module codes that the user has access to based on their role IDs.
-   */
-  async getAccessibleModules(roleIds: number[]): Promise<string[]> {
-    // Get role codes from role IDs
-    const roleCodes = await this.dataSource
-      .getRepository(Role)
-      .createQueryBuilder('role')
-      .select('role.code')
-      .where('role.id IN (:...roleIds)', { roleIds })
-      .getMany();
+   */async getAccessibleModules(roleIds: number[], appCode: string): Promise<string[]> {
+  // Get role codes from role IDs
+  const roleCodes = await this.dataSource
+  .getRepository(Role)
+  .createQueryBuilder('role')
+  .select('role.code')
+  .where('role.id IN (:...roleIds)', { roleIds })
+  .getMany();
 
-    const codes = roleCodes.map((role) => role.code);
+const codes = roleCodes.map((role) => role.code);
 
-    if (codes.length === 0) {
-      return [];
-    }
+if (codes.length === 0) {
+  return [];
+}
 
-    // Get accessible modules using role codes
-    const modules = await this.dataSource
-      .getRepository(ModuleAccess)
-      .createQueryBuilder('moduleAccess')
-      .select('moduleAccess.module_code')
-      .where('moduleAccess.role_code IN (:...codes)', { codes })
-      .andWhere('moduleAccess.access_flag > 0')
-      .getMany();
+// Get accessible modules using role codes and appCode
+const modules = await this.dataSource
+  .getRepository(ModuleAccess)
+  .createQueryBuilder('moduleAccess')
+  .select('moduleAccess.module_code')
+  .where('moduleAccess.role_code IN (:...codes)', { codes })
+  .andWhere('moduleAccess.access_flag > 0')
+  .andWhere('LOWER(moduleAccess.appcode) = LOWER(:appCode)', { appCode }) // case-insensitive
+  .getMany();
 
-    return modules.map((module) => module.module_code);
-  }
+return modules.map((module) => module.module_code);
+}
 
-  async getMenuItems(moduleCodes: string[]): Promise<MenuData[]> {
-    const menuItems = await this.createQueryBuilder('menu')
-      .leftJoin('cr_module', 'module', 'menu.module_code = module.module_code')
-      .where('menu.module_code IN (:...moduleCodes)', { moduleCodes })
-      .select([
-        'menu.*',
-        'module.component_name AS component',
-        'module.title AS title',
-        'module.entity_type AS entity_type',
-      ])
-      .getRawMany();
+async getMenuItems(moduleCodes: string[], appcode: string): Promise<MenuData[]> {
+  const menuItems = await this.createQueryBuilder('menu')
+    .leftJoin('cr_module', 'module', 'menu.module_code = module.module_code')
+    .where('menu.module_code IN (:...moduleCodes)', { moduleCodes })
+    .andWhere('LOWER(module.appcode) = LOWER(:appcode)', { appcode }) // appcode filter
+    .select([
+      'menu.*',
+      'module.component_name AS component',
+      'module.title AS title',
+      'module.entity_type AS entity_type',
+    ])
+    .getRawMany();
+
+  return menuItems;
+}
 
-    return menuItems;
-  }
 }

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

@@ -21,36 +21,42 @@ export class ModuleAccessRepository {
     private readonly moduleActionRepo: Repository<ModuleAction>,
   ) {}
 
-  async getRoles() {
-    const roles = await this.roleRepo.find();
-    return roles.map(role => ({
+  async getRoles({ appcode }: { appcode: string }) {
+    const roles = await this.roleRepo.find({
+      where: { appcode: appcode },
+    });
+    return roles.map((role) => ({
       label: role.name,
       value: role.id,
     }));
   }
 
-  async getModules() {
-    const modules = await this.moduleRepo.find({ where: { module_level: 'MAINMOD' } });
-    return modules.map(mod => ({
+  async getModules({ appcode }: { appcode: string }) {
+    const modules = await this.moduleRepo.find({
+      where: { module_level: 'MAINMOD', appcode: appcode },
+    });
+    return modules.map((mod) => ({
       label: mod.name,
       value: mod.id,
     }));
   }
 
-  async getAccessListing(roleIds: number[]) {
-    const roles = await this.roleRepo.find({ where: { id: In(roleIds) } });
-    const roleCodes = roles.map(role => role.code);
+  async getAccessListing(roleIds: number[], appcode: string) {
+    const roles = await this.roleRepo.find({
+      where: { id: In(roleIds), appcode: appcode },
+    });
+    const roleCodes = roles.map((role) => role.code);
 
     const moduleAccesses = await this.moduleAccessRepo.find({
-      where: { role_code: In(roleCodes) },
+      where: { role_code: In(roleCodes), appcode: appcode },
     });
 
-    return roles.map(role => ({
+    return roles.map((role) => ({
       role_code: role.code,
       name: role.name,
       permission: moduleAccesses
-        .filter(access => access.role_code === role.code)
-        .map(access => ({
+        .filter((access) => access.role_code === role.code)
+        .map((access) => ({
           action: access.action_type,
           access: access.access_flag,
           code: access.module_code,
@@ -58,20 +64,31 @@ export class ModuleAccessRepository {
     }));
   }
 
-  async getMenuListing(mainModIds: string[]) {
-    const mainModules = mainModIds.length === 1 && mainModIds[0] === '-1'
-      ? await this.moduleRepo.find({ where: { module_level: 'MAINMOD' } })
-      : await this.moduleRepo.find({ where: { id: In(mainModIds), module_level: 'MAINMOD' } });
+  async getMenuListing(mainModIds: string[], appcode: string) {
+    const mainModules =
+      mainModIds.length === 1 && mainModIds[0] === '-1'
+        ? await this.moduleRepo.find({
+            where: { module_level: 'MAINMOD', appcode: appcode },
+          })
+        : await this.moduleRepo.find({
+            where: {
+              id: In(mainModIds),
+              module_level: 'MAINMOD',
+              appcode: appcode,
+            },
+          });
 
     if (!mainModules.length) return [];
 
-    const wbsCodes = mainModules.map(mod => mod.wbs_code);
+    const wbsCodes = mainModules.map((mod) => mod.wbs_code);
 
     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}%`])),
+        wbsCodes
+          .map((code) => `module.wbs_code LIKE :code${code}`)
+          .join(' OR '),
+        Object.fromEntries(wbsCodes.map((code) => [`code${code}`, `${code}%`])),
       )
       .getMany();
 
@@ -79,28 +96,29 @@ export class ModuleAccessRepository {
 
     const buildHierarchy = (parentWbs: string): any[] =>
       modules
-        .filter(mod =>
-          mod.wbs_code.startsWith(`${parentWbs}.`) &&
-          mod.wbs_code.split('.').length === parentWbs.split('.').length + 1,
+        .filter(
+          (mod) =>
+            mod.wbs_code.startsWith(`${parentWbs}.`) &&
+            mod.wbs_code.split('.').length === parentWbs.split('.').length + 1,
         )
-        .map(mod => ({
+        .map((mod) => ({
           name: mod.name,
           code: mod.module_code,
           permission: moduleActions
-            .filter(action => action.module_code === mod.module_code)
-            .map(action => ({
+            .filter((action) => action.module_code === mod.module_code)
+            .map((action) => ({
               action: action.action_type,
               name: action.action_type,
             })),
           submod: buildHierarchy(mod.wbs_code),
         }));
 
-    return mainModules.map(mod => ({
+    return mainModules.map((mod) => ({
       name: mod.name,
       code: mod.module_code,
       permission: moduleActions
-        .filter(action => action.module_code === mod.module_code)
-        .map(action => ({
+        .filter((action) => action.module_code === mod.module_code)
+        .map((action) => ({
           action: action.action_type,
           name: action.action_type,
         })),
@@ -108,13 +126,16 @@ export class ModuleAccessRepository {
     }));
   }
 
-  async updateModuleAccess(accessList: {
-    role_code: string;
-    module_code: string;
-    action_type: string;
-    access_flag: number;
-    app_code: string;
-  }[]): Promise<boolean> {
+  async updateModuleAccess(
+    accessList: {
+      role_code: string;
+      module_code: string;
+      action_type: string;
+      access_flag: number;
+      appcode: string;
+    }[],
+    appcode: string,
+  ): Promise<boolean> {
     try {
       for (const access of accessList) {
         const existing = await this.moduleAccessRepo.findOne({
@@ -122,7 +143,7 @@ export class ModuleAccessRepository {
             role_code: access.role_code,
             module_code: access.module_code,
             action_type: access.action_type,
-            app_code: access.app_code,
+            appcode: access.appcode || appcode,
           },
         });
 
@@ -130,7 +151,9 @@ export class ModuleAccessRepository {
           existing.access_flag = access.access_flag;
           await this.moduleAccessRepo.save(existing);
         } else {
-          await this.moduleAccessRepo.save(this.moduleAccessRepo.create(access));
+          await this.moduleAccessRepo.save(
+            this.moduleAccessRepo.create(access),
+          );
         }
       }
       return true;
@@ -140,24 +163,23 @@ export class ModuleAccessRepository {
     }
   }
 
-
   // src/module/module-access/repository/module-access.repository.ts
 
   async getModuleUIConfig(moduleCode: string, roleIds: number[]) {
     const module = await this.moduleRepo.findOne({
       where: { module_code: moduleCode },
     });
-  
+
     if (!module) {
       throw new BadRequestException('Module not found');
     }
-  
+
     const roles = await this.roleRepo.find({
       where: { id: In(roleIds) },
     });
-  
-    const roleCodes = roles.map(role => role.code);
-  
+
+    const roleCodes = roles.map((role) => role.code);
+
     const actions = await this.moduleAccessRepo.find({
       where: {
         module_code: moduleCode,
@@ -165,9 +187,9 @@ export class ModuleAccessRepository {
         access_flag: 1,
       },
     });
-  
-    const uniqueActions = [...new Set(actions.map(a => a.action_type))];
-  
+
+    const uniqueActions = [...new Set(actions.map((a) => a.action_type))];
+
     return {
       entity_type: module.entity_type,
       title: module.title,
@@ -175,7 +197,4 @@ export class ModuleAccessRepository {
       action: uniqueActions,
     };
   }
-  
-
-
 }

package/src/module/module/service/menu.service.ts

@@ -9,22 +9,22 @@ export class MenuService {
   /**
    * Fetch and construct menu hierarchy for a given user.
    */
-  async getUserMenu(userId: number) {
+  async getUserMenu(userId: number,appcode:string): Promise<{ menu: any[] }> {
     // Step 1: Get the roles of the user
-    const roleCodes = await this.menuRepository.getUserRoles(userId);
+    const roleCodes = await this.menuRepository.getUserRoles(userId,appcode);
     if (!roleCodes.length) {
       return { menu: [] }; // Return empty menu if user has no roles
     }
 
     // Step 2: Get the modules the user has access to
     const moduleCodes =
-      await this.menuRepository.getAccessibleModules(roleCodes);
+      await this.menuRepository.getAccessibleModules(roleCodes,appcode);
     if (!moduleCodes.length) {
       return { menu: [] }; // Return empty menu if no accessible modules
     }
 
     // Step 3: Get the menu items based on accessible modules
-    const menuItems = await this.menuRepository.getMenuItems(moduleCodes);
+    const menuItems = await this.menuRepository.getMenuItems(moduleCodes,appcode);
 
     // Step 4: Build hierarchical menu structure
     const menuTree = this.buildMenuHierarchy(menuItems);

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

@@ -13,31 +13,36 @@ export class ModuleAccessService {
     private readonly moduleAccessRepository: ModuleAccessRepository,
   ) {}
 
-  async getRoles() {
-    return this.moduleAccessRepository.getRoles();
+  async getRoles({ appcode }: { appcode: string }) {
+    return this.moduleAccessRepository.getRoles({ appcode });
   }
 
-  async getModules() {
-    return this.moduleAccessRepository.getModules();
+  async getModules({ appcode }: { appcode: string }) {
+    return this.moduleAccessRepository.getModules({
+      appcode,
+    });
   }
 
-  async getAccessListing(roleIds: number[]) {
-    return this.moduleAccessRepository.getAccessListing(roleIds);
+  async getAccessListing(roleIds: number[], appcode: string) {
+    return this.moduleAccessRepository.getAccessListing(roleIds, appcode);
   }
 
-  async getMenuListing(mainModIds: string[]) {
-    return this.moduleAccessRepository.getMenuListing(mainModIds);
+  async getMenuListing(mainModIds: string[], appcode: string) {
+    return this.moduleAccessRepository.getMenuListing(mainModIds, appcode);
   }
 
   async updateModuleAccess(
     moduleAccessData: any[],
+    appcode: string,
   ): Promise<{ success: boolean; msg: string }> {
     if (!moduleAccessData || moduleAccessData.length === 0) {
       return { success: false, msg: 'No data provided' };
     }
 
-    const result =
-      await this.moduleAccessRepository.updateModuleAccess(moduleAccessData);
+    const result = await this.moduleAccessRepository.updateModuleAccess(
+      moduleAccessData,
+      appcode,
+    );
 
     if (result) {
       return { success: true, msg: 'Module access updated successfully' };
@@ -51,7 +56,4 @@ export class ModuleAccessService {
   async getModuleUIConfig(moduleCode: string, roleIds: number[]) {
     return this.moduleAccessRepository.getModuleUIConfig(moduleCode, roleIds);
   }
-  
-
-  
 }

package/src/module/user/dto/create-user.dto.ts

@@ -55,4 +55,5 @@ export class CreateUserDto extends BaseEntity {
   invitation_status: string;
   is_defaultadmin: number;
   is_customer: number;
+  appcode: string;  
 }

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

@@ -10,9 +10,6 @@ export class Role extends BaseEntity {
     this.entity_type = ENTITYTYPE_ROLE;
   }
 
-  @Column({ length: 50, type: 'varchar', nullable: true })
-  app_code: string;
-
   @Column({ type: 'int', nullable: true })
   is_system: number;
 

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

@@ -23,4 +23,7 @@ export class UserRoleMapping {
 
   @Column({ type: 'int', nullable: true })
   is_default: number;
+
+  @Column({type: 'varchar'})
+  appcode: string;
 }

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

@@ -24,9 +24,13 @@ export class RoleService extends EntityServiceImpl {
   async createEntity(
     entityData: BaseEntity,
     loggedInUser: UserData | null,
+    manager?: EntityManager,
+    appcode?: string,
   ): Promise<BaseEntity> {
     let role = entityData as Role;
-
+    if(appcode){
+      role.appcode = appcode ;
+    }
     if (await this.roleRepository.isRoleNameExists(role.name,{organization_id:entityData.organization_id})) {
       throw new BadRequestException('Role name already exists.');
     }
@@ -51,7 +55,7 @@ export class RoleService extends EntityServiceImpl {
           module_code: perm.module_code,
           action_type: perm.action_type,
           access_flag: perm.access_flag,
-          app_code: perm.app_code,
+          appcode: perm.appcode,
         }),
       );
 
@@ -128,7 +132,7 @@ export class RoleService extends EntityServiceImpl {
           module_code: perm.module_code,
           action_type: perm.action_type,
           access_flag: perm.access_flag,
-          app_code: perm.app_code,
+          appcode: perm.appcode,
         }),
       );
 

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

@@ -35,8 +35,12 @@ export class UserService extends EntityServiceImpl {
     entityData: BaseEntity,
     loggedInUser: UserData | null,
     manager?: EntityManager,
+    appcode?: string,
   ): Promise<BaseEntity> {
     let userData = entityData as CreateUserDto;
+    if(appcode){
+      userData.appcode = appcode;
+    }
     let existingUser = await this.userRepository.findByEmailId(
       userData.email_id,
       loggedInUser?.organization_id,