rez_core 2.1.25 → 2.1.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "2.1.25",
+  "version": "2.1.27",
   "description": "",
   "author": "",
   "private": false,

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

@@ -153,16 +153,25 @@ export class FilterService {
       [user_id, entity_type],
     );
 
-    const allTabs = await this.gettab_value_counts(
-      getTableMeta.data_source,
-      tabs?.columnName,
-      baseWhere,
-    );
-
     // Extract layout preference
     const layout = layoutPreference?.[0]?.layout_json?.quick_tab || {};
     let showList = layout?.show_list?.map((val) => val.toLowerCase()) || [];
 
+    let allTabs;
+    if (layout.attribute) {
+      allTabs = await this.gettab_value_counts(
+        getTableMeta.data_source,
+        layout.attribute,
+        baseWhere,
+      );
+    } else {
+      allTabs = await this.gettab_value_counts(
+        getTableMeta.data_source,
+        tabs?.columnName,
+        baseWhere,
+      );
+    }
+
     let filteredTabs;
 
     if (showList?.length > 0) {
@@ -201,20 +210,42 @@ export class FilterService {
       filteredTabs = allTabs;
     }
 
-    // Add tab.value filter only if present
     const dataWhere = [...baseWhere];
+
     if (tabs?.columnName && tabs?.value) {
       const tabAttrMeta = attributeMetaMap[tabs.columnName];
-      const tabCondition = this.buildCondition(
-        {
-          filter_attribute: tabs.columnName,
-          filter_operator: 'equal',
-          filter_value: tabs.value,
-        },
-        tabAttrMeta,
-      );
-      if (tabCondition) {
-        if (tabs.value.toLowerCase() !== 'all') dataWhere.push(tabCondition);
+      const tabValue = tabs.value.toLowerCase();
+
+      if (tabValue === 'others') {
+        const valuesToExclude = showList.filter((v) => v !== 'all');
+        if (valuesToExclude.length > 0) {
+          valuesToExclude.forEach((value) => {
+            const tabCondition = this.buildCondition(
+              {
+                filter_attribute: tabs.columnName,
+                filter_operator: 'not_equal',
+                filter_value: value,
+              },
+              tabAttrMeta,
+            );
+            if (tabCondition) {
+              dataWhere.push(tabCondition);
+            }
+          });
+        }
+      } else if (tabValue !== 'all') {
+        // Normal case: filter by equality
+        const tabCondition = this.buildCondition(
+          {
+            filter_attribute: tabs.columnName,
+            filter_operator: 'equal',
+            filter_value: tabs.value,
+          },
+          tabAttrMeta,
+        );
+        if (tabCondition) {
+          dataWhere.push(tabCondition);
+        }
       }
     }
 

package/src/module/layout_preference/service/layout_preference.service.ts

@@ -15,6 +15,8 @@ export class LayoutPreferenceService extends EntityServiceImpl {
   }
 
   async createEntity(entityData: BaseEntity, loggedInUser: UserData | null) {
+    console.log('lap api called', entityData);
+
     const { mapped_entity_type } = entityData as any;
     const userId = loggedInUser?.id;
 

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

@@ -28,7 +28,7 @@ export class LoginService {
 
   async login(email: string, password: string) {
     const user = await this.userService.findByEmailId(email);
-
+  
     if (!user) {
       return {
         success: false,
@@ -36,7 +36,7 @@ export class LoginService {
         type: 'email',
       };
     }
-
+  
     if (user.status !== 'ACTIVE') {
       return {
         success: false,
@@ -44,13 +44,13 @@ export class LoginService {
         type: 'email',
       };
     }
-
+  
     const encryptedPassword = EncryptUtilService.encryptGCM(
       password,
       this.masterKey,
       this.masterIv,
     );
-
+  
     if (encryptedPassword !== user.password) {
       return {
         success: false,
@@ -58,64 +58,67 @@ export class LoginService {
         type: 'password',
       };
     }
-
+  
     let defaultAccess;
-
-    if (!user.last_level_type && !user.last_level_id) {
-      const roleMappings = await this.userRoleMappingRepository.find({
-        where: {
-          user_id: user.id,
-          appcode: user.last_app_access,
-        },
-      });
-
-      if (!roleMappings.length) {
-        throw new BadRequestException(
-          'User does not have any access mapped for this app.',
-        );
-      }
-
-      // ✅ Pick default access based on priority
-      const priority = { org: 1, sch: 2, brn: 3 };
-      defaultAccess = roleMappings.sort(
-        (a, b) => priority[a.level_type] - priority[b.level_type],
-      )[0];
-
-      if ((defaultAccess.level_type, defaultAccess.level_id)) {
-        await this.userService.setLastLevelTypeAndId(
-          user.id,
-          defaultAccess.level_type,
-          defaultAccess.level_id,
-        );
-      }
-    } else {
-      defaultAccess = {
-        level_type: user.last_level_type,
-        level_id: user.last_level_id,
-      };
-    }
-
-    //appcode
-
     let appcode = user.last_app_access;
-
+  
     if (!appcode) {
       appcode = 'ADM';
       await this.userService.setDefaultLastAccess(user.id, appcode);
     }
-
+  
+    // ✅ Always fetch role mappings for the user + app
+    const roleMappings = await this.userRoleMappingRepository.find({
+      where: {
+        user_id: user.id,
+        appcode,
+      },
+    });
+  
+    if (!roleMappings.length) {
+      throw new BadRequestException(
+        'User does not have any access mapped for this app.',
+      );
+    }
+  
+    // 🔍 If user.last_level_type & level_id exist, validate them against URM
+    const validURM = roleMappings.find(
+      (r) =>
+        r.level_type === user.last_level_type &&
+        r.level_id === user.last_level_id,
+    );
+  
+    if (user.last_level_type && user.last_level_id && validURM) {
+      defaultAccess = {
+        level_type: user.last_level_type,
+        level_id: user.last_level_id,
+      };
+    } else {
+      // ❌ Fallback: Pick default based on priority
+      const priority = { org: 1, sch: 2, brn: 3 };
+      defaultAccess = roleMappings.sort(
+        (a, b) => priority[a.level_type] - priority[b.level_type],
+      )[0];
+  
+      await this.userService.setLastLevelTypeAndId(
+        user.id,
+        defaultAccess.level_type,
+        defaultAccess.level_id,
+      );
+    }
+  
     const token = await this.userSessionService.createSession(user, appcode, {
       level_type: defaultAccess.level_type,
       level_id: defaultAccess.level_id,
     });
-
+  
     if (user.is_firstlogin === 1) {
       user.invitation_status = 'ACCEPTED';
       user.is_firstlogin = 0;
       const { password, ...userWithoutPassword } = user;
       await this.userService.updateEntity(userWithoutPassword, user);
     }
-
+  
     return {
       success: true,
       accessToken: token,
@@ -124,6 +127,7 @@ export class LoginService {
       level_id: defaultAccess.level_id,
     };
   }
+  
 
   async loginWithGoogle(email: string, name) {
     let user = await this.userService.findByEmailId(email);