rez_core 2.1.30 → 2.1.32

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "rez_core",
-  "version": "2.1.30",
+  "version": "2.1.32",
   "description": "",
-  "author": "",
+  "author": "", 
   "private": false,
   "license": "UNLICENSED",
   "scripts": {

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

@@ -25,7 +25,6 @@ export class FilterService {
     column: string | undefined,
     whereClauses: { query: string; params: Record<string, any> }[],
   ) {
-    console.log('GTETABCOUNTS', tableName, column, whereClauses);
     if (!column) return [];
 
     let whereSQL = '';
@@ -96,8 +95,6 @@ export class FilterService {
         'LIST',
       );
 
-    console.log(getTableMeta, 'GETTABLEMETA');
-
     if (!getTableMeta) {
       throw new BadRequestException(
         `Table meta not found for entity_type: ${entity_type}`,
@@ -110,7 +107,6 @@ export class FilterService {
         true,
       );
 
-    console.log(getTableColumnMeta, 'GETTABLECOLUMNMETA');
     // const attributeMeta =
     //   await this.attributeMasterService.findAttributesByMappedEntityType(
     //     entity_type,
@@ -123,7 +119,6 @@ export class FilterService {
       {} as Record<string, any>,
     );
 
-    console.log(attributeMetaMap, 'ATTRIBUTEMETAMAP');
     // Get and parse filters
     const savedFilters = await this.getSavedFilters(savedFilterCode);
     const baseFilters = [
@@ -133,7 +128,7 @@ export class FilterService {
     ];
 
     const baseWhere = this.buildWhereClauses(baseFilters, attributeMetaMap);
-    console.log(baseWhere, 'BASEWHERE', level_type, level_id);
+
     if (level_type && level_id) {
       baseWhere.push({
         query: 'e.level_type = :level_type AND e.level_id = :level_id',
@@ -144,9 +139,7 @@ export class FilterService {
       });
     }
 
-    console.log('OUSTSIDE SKIP');
     if (this.skipLevelFilterEntities.includes(entity_type)) {
-      console.log('INSIDE SKIP');
       baseWhere.push({
         query: 'e.appcode = :appcode',
         params: { appcode },
@@ -160,15 +153,12 @@ export class FilterService {
       [user_id, entity_type],
     );
 
-    console.log('LAYOUTPREFERNECE', layoutPreference);
-
     // 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) {
-      console.log('IN LAYOUT');
       allTabs = await this.gettab_value_counts(
         getTableMeta.data_source,
         layout.attribute,
@@ -220,8 +210,6 @@ export class FilterService {
       filteredTabs = allTabs;
     }
 
-    console.log(allTabs, 'ALLTABSE');
-
     const dataWhere = [...baseWhere];
 
     if (tabs?.columnName && tabs?.value) {
@@ -255,6 +243,7 @@ export class FilterService {
           },
           tabAttrMeta,
         );
+
         if (tabCondition) {
           dataWhere.push(tabCondition);
         }
@@ -272,21 +261,33 @@ export class FilterService {
       qb.andWhere(clause.query, clause.params);
     });
 
-    if (Array.isArray(sortby)) {
-      // Optional sorting
-      sortby.forEach(({ sortColum, sortType }) => {
-        qb.addOrderBy(
-          `e.${sortColum}`,
-          sortType.toUpperCase() === 'DSC' ? 'DESC' : 'ASC',
+    // if (Array.isArray(sortby)) {
+    //   // Optional sorting
+    //   sortby.forEach(({ sortColum, sortType }) => {
+    //     qb.addOrderBy(
+    //       `e.${sortColum}`,
+    //       sortType.toUpperCase() === 'DSC' ? 'DESC' : 'ASC',
+    //     );
+    //   });
+    // }
+
+    if (layoutPreference && layoutPreference[0]?.layout_json?.sorting) {
+      if (Array.isArray(layoutPreference[0]?.layout_json?.sorting?.tabs)) {
+        let preferenceTabArray =
+          layoutPreference[0]?.layout_json?.sorting?.tabs;
+        let tabFilter = preferenceTabArray.find(
+          (tabData) => tabData.tab_name === tabs?.value,
         );
-      });
-    }
 
-    if (
-      layoutPreference &&
-      layoutPreference[0]?.layout_json?.sorting?.sortby?.length > 0
-    ) {
-      if (Array.isArray(layoutPreference[0]?.layout_json?.sorting?.sortby)) {
+        tabFilter?.sortby.forEach(({ column, order }) => {
+          qb.addOrderBy(
+            `e.${column}`,
+            order?.toUpperCase() === 'DSC' ? 'DESC' : 'ASC',
+          );
+        });
+      } else if (
+        Array.isArray(layoutPreference[0]?.layout_json?.sorting?.sortby)
+      ) {
         // Optional sorting
         layoutPreference[0]?.layout_json?.sorting?.sortby?.forEach(
           ({ column, order }) => {

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

@@ -4,11 +4,9 @@ import { UserData } from '../entity/user.entity';
 import { UserSessionService } from './user-session.service';
 import { UserService } from './user.service';
 import { ConfigService } from '@nestjs/config';
-import { UserAppMappingService } from 'src/module/meta/service/user-app-mapping.service';
-import { UserRoleMappingRepository } from '../repository/user-role-mapping.repository';
 import { InjectRepository } from '@nestjs/typeorm';
 import { UserRoleMapping } from '../entity/user-role-mapping.entity';
-import { Repository } from 'typeorm';
+import { DataSource, Repository } from 'typeorm';
 import { Role } from '../entity/role.entity';
 
 @Injectable()
@@ -21,6 +19,7 @@ export class LoginService {
     private readonly userRoleMappingRepository: Repository<UserRoleMapping>,
     @InjectRepository(Role)
     private readonly roleRepo: Repository<Role>,
+    private readonly dataSource: DataSource,
   ) {}
 
   masterKey: string = this.configService.get('MASTER_KEY') || '';
@@ -59,58 +58,29 @@ export class LoginService {
       };
     }
   
-    let defaultAccess;
-    let appcode = user.last_app_access;
+    let appcode = user.last_app_access || 'ADM';
   
-    if (!appcode) {
-      appcode = 'ADM';
+    if (!user.last_app_access) {
       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,
-      },
+      where: { user_id: user.id, appcode },
     });
   
     if (!roleMappings.length) {
-      throw new BadRequestException(
-        'User does not have any access mapped for this app.',
-      );
+      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,
+    const defaultAccess = await this.getDefaultAccess(user, roleMappings);
+  
+    await this.userService.setLastLevelTypeAndId(
+      user.id,
+      defaultAccess.level_type,
+      defaultAccess.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,
-    });
+    const token = await this.userSessionService.createSession(user, appcode, defaultAccess);
   
     if (user.is_firstlogin === 1) {
       user.invitation_status = 'ACCEPTED';
@@ -128,6 +98,52 @@ export class LoginService {
     };
   }
   
+  private async getDefaultAccess(
+    user: any,
+    roleMappings: any[],
+  ): Promise<{ level_type: string; level_id: string }> {
+    const orgAccess = roleMappings.find(r => r.level_type === 'ORG');
+    const brnAccesses = roleMappings.filter(r => r.level_type === 'BRN');
+    const schAccesses = roleMappings.filter(r => r.level_type === 'SCH');
+  
+    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) {
+      return { level_type: user.last_level_type, level_id: user.last_level_id };
+    }
+  
+    if (orgAccess) {
+      return { level_type: 'ORG', level_id: orgAccess.level_id };
+    }
+  
+    if (brnAccesses.length) {
+      const brandId = brnAccesses[0].level_id;
+  
+      const rows = await this.dataSource.query(
+        `SELECT id FROM cr_school WHERE brand_id = ? ORDER BY id ASC LIMIT 1`,
+        [brandId],
+      );
+  
+      if (rows.length) {
+        return { level_type: 'SCH', level_id: rows[0].id };
+      } else {
+        throw new BadRequestException(
+          'User has BRN access but no schools found under that brand.',
+        );
+      }
+    }
+  
+    if (schAccesses.length) {
+      return { level_type: 'SCH', level_id: schAccesses[0].level_id };
+    }
+  
+    throw new BadRequestException(
+      'User does not have ORG, BRN, or SCH access for this app.',
+    );
+  }
+  
 
   async loginWithGoogle(email: string, name) {
     let user = await this.userService.findByEmailId(email);