rez_core 2.0.1 → 2.0.2

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,
-            appcode: 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/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/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.');
     }

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,