rez_core 2.1.23 → 2.1.25

package/package.json

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

package/src/module/enterprise/controller/organization.controller.ts

@@ -23,7 +23,10 @@ export class OrganizationController {
 
   @UseGuards(JwtAuthGuard)
   @Get('hierarchy')
-  async getOrganizationHierarchy(): Promise<any[]> {
-    return await this.orgService.getOrganizationHierarchy();
+  async getOrganizationHierarchy(@Req() req: Request & { user: any }) {
+    const userId = req.user.userData?.id;
+    const appcode = req.user.userData?.appcode;
+
+    return await this.orgService.getOrganizationHierarchy(userId, appcode);
   }
 }

package/src/module/enterprise/repository/school.repository.ts

@@ -24,93 +24,166 @@ export class SchoolRepository {
     });
   }
 
-  async getUserContextDropdown(): Promise<any[]> {
-    const data = await this.dataSource
-      .createQueryBuilder()
-      .select([
-        'org.id AS org_id',
-        'org.name AS org_name',
-        'org.address AS org_address',
-        'org.type AS org_type',
-
-        // Full brand columns
-        'br.id AS brand_id',
-        'br.entity_type AS brand_entity_type',
-        'br.name AS brand_name',
-        'br.status AS brand_status',
-        'br.parent_type AS brand_parent_type',
-        'br.parent_id AS brand_parent_id',
-        'br.code AS brand_code',
-        'br.enterprise_id AS brand_enterprise_id',
-        'br.organization_id AS brand_organization_id',
-        'br.appcode AS brand_appcode',
-        'br.level_id AS brand_level_id',
-        'br.level_type AS brand_level_type',
-        'br.type AS brand_type',
-
-        // Full school columns
-        'sch.id AS school_id',
-        'sch.entity_type AS school_entity_type',
-        'sch.name AS school_name',
-        'sch.status AS school_status',
-        'sch.parent_type AS school_parent_type',
-        'sch.parent_id AS school_parent_id',
-        'sch.code AS school_code',
-        'sch.enterprise_id AS school_enterprise_id',
-        'sch.organization_id AS school_organization_id',
-        'sch.appcode AS school_appcode',
-        'sch.level_id AS school_level_id',
-        'sch.level_type AS school_level_type',
-        'sch.type AS school_type',
-      ])
-      .from('cr_school', 'sch')
-      .innerJoin('cr_brand', 'br', 'sch.brand_id = br.id')
-      .innerJoin('cr_organization', 'org', 'br.organization_id = org.id')
-      .orderBy('org.id, br.id, sch.id')
-      .getRawMany();
-
-    const result = {};
+  async getUserContextDropdown(userId: number, appCode: string) {
+    const userRoleRepo = this.dataSource.getRepository(UserRoleMapping);
 
-    for (const row of data) {
-      const { org_id, org_name, org_address, org_type: type, brand_id } = row;
+    const hasOrgAccess = await userRoleRepo
+      .createQueryBuilder('urm')
+      .where('urm.user_id = :userId', { userId })
+      .andWhere('urm.appcode = :appCode', { appCode })
+      .andWhere('urm.level_type = :levelType', { levelType: 'ORG' })
+      .getRawMany();
 
-      // const {
-      //   school_id,ol_
-      // } = row;
+    if (hasOrgAccess.length > 0) {
+      const schools = await this.dataSource
+        .createQueryBuilder()
+        .select([
+          'org.id AS org_id',
+          'org.name AS org_name',
+          'org.address AS org_address',
+          'org.status AS org_status',
+          'br.id AS brand_id',
+          'br.name AS brand_name',
+          'br.status AS brand_status',
+          'sch.id AS school_id',
+          'sch.name AS school_name',
+          'sch.location AS school_location',
+          'sch.status AS school_status',
+        ])
+        .from('cr_school', 'sch')
+        .innerJoin('cr_brand', 'br', 'sch.brand_id = br.id')
+        .innerJoin('cr_organization', 'org', 'br.organization_id = org.id')
+        .where('org.id = :orgId', { orgId: hasOrgAccess[0].urm_level_id })
+        .getRawMany();
 
-      if (!result[org_id]) {
-        result[org_id] = {
+      const result = {};
+      for (const row of schools) {
+        const {
           org_id,
           org_name,
           org_address,
-          type,
-          brands: {},
-        };
-      }
+          org_status,
+          brand_id,
+          brand_name,
+          brand_status,
+          school_id,
+          school_name,
+          school_location,
+          school_status,
+        } = row;
 
-      if (!result[org_id].brands[brand_id]) {
-        const brandInfo: any = {};
-        for (const key in row) {
-          if (key.startsWith('brand_')) {
-            brandInfo[key.replace('brand_', '')] = row[key];
-          }
+        if (!result[org_id]) {
+          result[org_id] = {
+            org_id,
+            org_name,
+            org_address,
+            status: org_status,
+            type: 'Organization',
+            brands: {},
+          };
         }
-        brandInfo.schools = [];
-        result[org_id].brands[brand_id] = brandInfo;
+
+        if (!result[org_id].brands[brand_id]) {
+          result[org_id].brands[brand_id] = {
+            brand_id,
+            brand_name,
+            status: brand_status,
+            type: 'Brand',
+            schools: [],
+          };
+        }
+
+        result[org_id].brands[brand_id].schools.push({
+          school_id,
+          school_name,
+          school_location,
+          status: school_status,
+          type: 'School',
+        });
       }
 
-      const schoolInfo: any = {};
-      for (const key in row) {
-        if (key.startsWith('school_')) {
-          schoolInfo[key.replace('school_', '')] = row[key];
+      return Object.values(result).map((org: any) => ({
+        ...org,
+        brands: Object.values(org.brands),
+      }));
+    } else {
+      const brnMappings = await this.dataSource
+        .createQueryBuilder()
+        .select([
+          'brand.id AS brand_id',
+          'brand.name AS brand_name',
+          'brand.status AS brand_status',
+          'school.id AS school_id',
+          'school.name AS school_name',
+          'school.location AS school_location',
+          'school.status AS school_status',
+        ])
+        .from('cr_user_role_mapping', 'urm')
+        .innerJoin('cr_brand', 'brand', 'brand.id = urm.level_id')
+        .innerJoin('cr_school', 'school', 'school.brand_id = brand.id')
+        .where('urm.user_id = :userId', { userId })
+        .andWhere('urm.appcode = :appCode', { appCode })
+        .andWhere('urm.level_type = :levelType', { levelType: 'BRN' })
+        .getRawMany();
+
+      const schMappings = await this.dataSource
+        .createQueryBuilder()
+        .select([
+          'brand.id AS brand_id',
+          'brand.name AS brand_name',
+          'brand.status AS brand_status',
+          'school.id AS school_id',
+          'school.name AS school_name',
+          'school.location AS school_location',
+          'school.status AS school_status',
+        ])
+        .from('cr_user_role_mapping', 'urm')
+        .innerJoin('cr_school', 'school', 'school.id = urm.level_id')
+        .innerJoin('cr_brand', 'brand', 'brand.id = school.brand_id')
+        .where('urm.user_id = :userId', { userId })
+        .andWhere('urm.appcode = :appCode', { appCode })
+        .andWhere('urm.level_type = :levelType', { levelType: 'SCH' })
+        .getRawMany();
+
+      const allMappings = [...brnMappings, ...schMappings];
+
+      const result = {};
+      for (const row of allMappings) {
+        const {
+          brand_id,
+          brand_name,
+          brand_status,
+          school_id,
+          school_name,
+          school_location,
+          school_status,
+        } = row;
+
+        if (!result[brand_id]) {
+          result[brand_id] = {
+            brand_id,
+            brand_name,
+            status: brand_status,
+            type: 'Brand',
+            schools: [],
+          };
+        }
+
+        if (
+          school_id &&
+          !result[brand_id].schools.some((s) => s.school_id === school_id)
+        ) {
+          result[brand_id].schools.push({
+            school_id,
+            school_name,
+            school_location,
+            status: school_status,
+            type: 'School',
+          });
         }
       }
-      result[org_id].brands[brand_id].schools.push(schoolInfo);
-    }
 
-    return Object.values(result).map((org: any) => ({
-      ...org,
-      brands: Object.values(org.brands),
-    }));
+      return Object.values(result);
+    }
   }
 }

package/src/module/enterprise/service/organization.service.ts

@@ -78,7 +78,7 @@ export class OrganizationService {
     await repo.delete(id);
   }
 
-  async getOrganizationHierarchy(): Promise<any[]> {
-    return await this.schoolRepository.getUserContextDropdown();
+  async getOrganizationHierarchy(userId: number, appCode: string) {
+    return await this.schoolRepository.getUserContextDropdown(userId, appCode);
   }
 }

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

@@ -129,6 +129,7 @@ export class ModuleAccessService {
     level_type: string;
     level_id: number;
   }) {
+    // Step 1: Resolve roles
     const roleCodes = await this.menuRepository.resolveUserRoles(
       userId,
       appcode,
@@ -141,8 +142,34 @@ export class ModuleAccessService {
     }
   
     const roleIds = roleCodes.map(Number);
-    return this.moduleAccessRepository.getModuleAccessByRoles(roleIds, appcode);
+  
+    // Step 2: Get full permissions
+    const allPermissions = await this.moduleAccessRepository.getModuleAccessByRoles(
+      roleIds,
+      appcode,
+    );
+  
+    // Step 3: If level_type is SCH, check school status using raw query
+    if (level_type === 'SCH') {
+      const result = await this.dataSource.query(
+        `SELECT * FROM cr_school WHERE id = ${level_id}`,
+        [level_id],
+      );
+  
+      const school = result?.[0];
+  
+      if (!school || school.status === "INACTIVE") {
+        // Return only VIEW permissions
+        return allPermissions.filter(
+          (perm) => perm.action === 'VIEW'
+        );
+      }
+    }
+  
+    // Step 4: Return all permissions normally
+    return allPermissions;
   }
   
   
+  
 }

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

@@ -44,4 +44,10 @@ export class UserData extends BaseEntity {
 
   @Column({ type: 'varchar', nullable: true })
   last_app_access: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  last_level_type: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  last_level_id: string;
 }

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

@@ -59,25 +59,41 @@ export class LoginService {
       };
     }
 
-    // ✅ Get user-role mappings for this app
-    const roleMappings = await this.userRoleMappingRepository.find({
-      where: {
-        user_id: user.id,
-        appcode: user.last_app_access,
-      },
-    });
+    let defaultAccess;
 
-    if (!roleMappings.length) {
-      throw new BadRequestException(
-        'User does not have any access mapped for this app.',
-      );
-    }
+    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 };
-    const defaultAccess = roleMappings.sort(
-      (a, b) => priority[a.level_type] - priority[b.level_type],
-    )[0];
+      // ✅ 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
 

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

@@ -85,8 +85,8 @@ export class UserSessionService {
     };
 
     await this.dataSource.query(
-      `UPDATE cr_user SET last_app_access = ? WHERE id = ?`,
-      [data.appcode, currentUser.id],
+      `UPDATE cr_user SET last_app_access  = ? , last_level_type = ?, last_level_id = ? WHERE id = ?`,
+      [data.appcode, data.level_type, data.level_id, currentUser.id],
     );
 
     return {

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

@@ -249,4 +249,21 @@ export class UserService extends EntityServiceImpl {
 
     await this.userRepository.saveUser(user); // This persists the updated field
   }
+
+  async setLastLevelTypeAndId(
+    userId: number,
+    levelType: string,
+    levelId: string,
+  ): Promise<void> {
+    const user = await this.userRepository.findById(userId);
+
+    if (!user) {
+      throw new BadRequestException('User not found');
+    }
+
+    user.last_level_type = levelType;
+    user.last_level_id = levelId;
+
+    await this.userRepository.saveUser(user); // This persists the updated field
+  }
 }