rez_core 2.0.96 → 2.0.98

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "2.0.96",
+  "version": "2.0.98",
   "description": "",
   "author": "",
   "private": false,
@@ -89,7 +89,6 @@
       "js",
       "json",
       "ts"
-      
     ],
     "rootDir": "src",
     "testRegex": ".*\\.spec\\.ts$",

package/src/module/filter/service/filter.service.ts

@@ -1,12 +1,11 @@
-import { Injectable, BadRequestException, Inject } from '@nestjs/common';
+import { BadRequestException, Inject, Injectable } from '@nestjs/common';
 import { AttributeMasterService } from 'src/module/meta/service/attribute-master.service';
 import { EntityMasterService } from 'src/module/meta/service/entity-master.service';
+import { EntityTableColumnService } from 'src/module/meta/service/entity-table-column.service';
+import { EntityTableService } from 'src/module/meta/service/entity-table.service';
 import { DataSource } from 'typeorm';
-import { SavedFilterService } from './saved-filter.service';
 import { FilterRequestDto } from '../dto/filter-request.dto';
-import { EntityTableService } from 'src/module/meta/service/entity-table.service';
-import { EntityTableColumnService } from 'src/module/meta/service/entity-table-column.service';
-import { get } from 'http';
+import { SavedFilterService } from './saved-filter.service';
 
 @Injectable()
 export class FilterService {
@@ -19,7 +18,7 @@ export class FilterService {
     @Inject('SavedFilterService')
     private readonly savedFilterService: SavedFilterService,
   ) {}
-  private readonly skipLevelFilterEntities = ['USR', 'UPR'];
+  private readonly skipLevelFilterEntities = [];
 
   private async gettab_value_counts(
     tableName: string,
@@ -129,11 +128,7 @@ export class FilterService {
 
     const baseWhere = this.buildWhereClauses(baseFilters, attributeMetaMap);
 
-    if (
-      level_type &&
-      level_id &&
-      !this.skipLevelFilterEntities.includes(entity_type)
-    ) {
+    if (level_type && level_id) {
       baseWhere.push({
         query: 'e.level_type = :level_type AND e.level_id = :level_id',
         params: {

package/src/module/master/service/master.service.ts

@@ -411,11 +411,11 @@ export class MasterService {
       row.entity_type = entityType;
       row.organization_id = loggedInUser.organization_id;
 
-      const rowErrors =
-        await this.entityValidationService.validateExcelEntityData(
-          row,
-          entityMaster,
-        );
+      const rowErrors = await this.entityValidationService.validateEntityData(
+        row,
+        entityMaster,
+        loggedInUser,
+      );
 
       const existingError = errors.find((e) => e.row === i + 1);
 
@@ -466,13 +466,13 @@ export class MasterService {
         .andWhere(`${entityMaster.db_table_name}.level_id = :levelId`, {
           levelId: loggedInUser.level_id,
         });
-    
+
       const existing = await qb.limit(1).getRawOne();
 
       row.entity_type = entityType;
       row.organization_id = loggedInUser.organization_id;
-      row.status="ACTIVE"
-      
+      row.status = 'ACTIVE';
+
       let errors = [];
       if (existing) {
         if (duplicateHandling === 'skip_duplicates') continue;

package/src/module/meta/service/entity-service-impl.service.ts

@@ -47,6 +47,7 @@ export class EntityServiceImpl implements EntityService<BaseEntity> {
       await this.entityValidationService.validateEntityData(
         entityData,
         entityMaster,
+        loggedInUser,
       );
     if (validationErrors.length > 0) {
       throw new BadRequestException({

package/src/module/meta/service/entity-validation.service.ts

@@ -49,6 +49,7 @@ export class EntityValidationService {
     attributeData: AttributeMaster[],
     entityType: string,
     db_table_name: string,
+    loggedInUser: any,
   ): Promise<ValidationError[]> {
     const errors: ValidationError[] = [];
 
@@ -64,12 +65,16 @@ export class EntityValidationService {
 
         // Add AND condition for organization_id if present
         const orgId = entityData.organization_id;
+        const level_type = loggedInUser.level_type;
+        const level_id = loggedInUser.level_id;
 
         if (orgId !== undefined && orgId !== null) {
           qb = qb.andWhere(
-            `${db_table_name}.organization_id = :organization_id`,
+            `${db_table_name}.organization_id = :organization_id AND ${db_table_name}.level_type = :level_type AND ${db_table_name}.level_id = :level_id`,
             {
               organization_id: orgId,
+              level_type: level_type,
+              level_id: level_id,
             },
           );
         }
@@ -119,6 +124,7 @@ export class EntityValidationService {
   async validateEntityData(
     entityData: Record<string, any>,
     entityMaster,
+    loggedInUser: any,
   ): Promise<ValidationError[]> {
     const attributes =
       await this.attributeMasterService.findAttributesByMappedEntityType(
@@ -131,6 +137,7 @@ export class EntityValidationService {
       attributes,
       entityData.entity_type,
       entityMaster.db_table_name,
+      loggedInUser,
     );
     const regexErros = await this.validateRegexFields(entityData, attributes);
     return [...requiredErrors, ...uniqueErrors, ...regexErros];

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

@@ -6,8 +6,9 @@ import { UserRoleMapping } from 'src/module/user/entity/user-role-mapping.entity
 
 @Injectable()
 export class MenuService {
-  constructor(private readonly menuRepository: MenuRepository,
-    private readonly datasource:DataSource
+  constructor(
+    private readonly menuRepository: MenuRepository,
+    private readonly datasource: DataSource,
   ) {}
 
   /**
@@ -20,25 +21,34 @@ export class MenuService {
     levelId: number,
   ): Promise<{ menu: any[] }> {
     // Step 1: Resolve roles (with fallback logic inside)
-    const roleCodes = await this.menuRepository.resolveUserRoles(userId, appcode, levelType, levelId);
-    console.log(roleCodes)
+    const roleCodes = await this.menuRepository.resolveUserRoles(
+      userId,
+      appcode,
+      levelType,
+      levelId,
+    );
     if (!roleCodes.length) return { menu: [] };
-  
+
     // Step 2: Get accessible modules
-    const moduleCodes = await this.menuRepository.getAccessibleModules(roleCodes, appcode);
-    console.log(moduleCodes)
+    const moduleCodes = await this.menuRepository.getAccessibleModules(
+      roleCodes,
+      appcode,
+    );
     if (!moduleCodes.length) return { menu: [] };
-  
+
     // Step 3: Get menu items for the given level type
-    const menuItems = await this.menuRepository.getMenuItems(moduleCodes, appcode, levelType);
-    console.log(menuItems)
-  
+    const menuItems = await this.menuRepository.getMenuItems(
+      moduleCodes,
+      appcode,
+      levelType,
+    );
+
     // Step 4: Build hierarchy
     const menuTree = this.buildMenuHierarchy(menuItems);
-  
+
     return { menu: menuTree };
   }
-  
+
   /**
    * Converts a flat list of menu items into a hierarchical tree.
    */
@@ -69,8 +79,4 @@ export class MenuService {
   async getUserRoles(userId: number, appcode: string): Promise<any> {
     return this.menuRepository.getUserRoles(userId, appcode);
   }
-
-
-
-  
 }

package/src/module/user/controller/login.controller.ts

@@ -1,4 +1,5 @@
 import {
+  BadRequestException,
   Body,
   Controller,
   Get,
@@ -68,6 +69,35 @@ export class LoginController {
     },
   ): Promise<any> {
     const currentUser = req.user.userData;
+    const currentAppcode = currentUser.appcode;
+
+    // If appcode is changing, validate the new level_id/level_type
+    if (data.appcode !== currentAppcode) {
+      const isValidAccess = await this.userSessionService.checkIfUserHasMapping(
+        currentUser.id,
+        data.appcode,
+        data.level_type,
+        data.level_id,
+      );
+
+      if (!isValidAccess) {
+        // If not valid, fetch the default one
+        const userMapping =
+          await this.userSessionService.getUserRoleMappingForApp(
+            currentUser.id,
+            data.appcode,
+          );
+
+        if (!userMapping) {
+          throw new BadRequestException(
+            `No mapping found for user in app ${data.appcode}`,
+          );
+        }
+
+        data.level_type = userMapping.level_type;
+        data.level_id = userMapping.level_id;
+      }
+    }
 
     return await this.userSessionService.switchCurrentLevelService(
       currentUser,

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

@@ -6,6 +6,7 @@ import { JwtAuthService } from 'src/module/auth/services/jwt.service';
 import { ConfigService } from '@nestjs/config';
 import { UserRoleMappingService } from './user-role-mapping.service';
 import { DataSource } from 'typeorm';
+import { UserRoleMapping } from '../entity/user-role-mapping.entity';
 
 @Injectable()
 export class UserSessionService {
@@ -96,4 +97,31 @@ export class UserSessionService {
       level_id: data.level_id,
     };
   }
+
+  async checkIfUserHasMapping(
+    userId: number,
+    appcode: string,
+    levelType: string,
+    levelId: string,
+  ): Promise<boolean> {
+    const count = await this.dataSource
+      .getRepository(UserRoleMapping)
+      .createQueryBuilder('cr_user_role_mapping')
+      .where('cr_user_role_mapping.user_id = :userId', { userId })
+      .andWhere('cr_user_role_mapping.appcode = :appcode', { appcode })
+      .andWhere('cr_user_role_mapping.level_type = :levelType', { levelType })
+      .andWhere('cr_user_role_mapping.level_id = :levelId', { levelId })
+      .getCount();
+
+    return count > 0;
+  }
+
+  async getUserRoleMappingForApp(userId: number, appcode: string) {
+    return await this.dataSource
+      .getRepository(UserRoleMapping)
+      .createQueryBuilder('cr_user_role_mapping')
+      .where('cr_user_role_mapping.user_id = :userId', { userId })
+      .andWhere('cr_user_role_mapping.appcode = :appcode', { appcode })
+      .getOne(); // You can return .getMany() if you want to let user choose
+  }
 }