rez_core 2.0.41 → 2.0.43

package/package.json

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

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

@@ -20,4 +20,15 @@ export class OrganizationController {
     // const enterpriseId = req.user['enterpriseId']; // or adapt based on your user structure
     return this.orgService.findById(userData?.organization_id);
   }
+
+  @UseGuards(JwtAuthGuard)
+  @Get('hierarchy')
+  async getOrganizationHierarchy(@Req() req: Request & { user: any }) {
+    const userId = req.user.userData?.id;
+    const appcode = req.user.userData?.appcode;
+
+    console.log(userId, appcode, 'userId, appcode');
+
+    return await this.orgService.getOrganizationHierarchy(userId, appcode);
+  }
 }

package/src/module/enterprise/enterprise.module.ts

@@ -8,6 +8,9 @@ import { OrganizationAppMappingService } from './service/organization-app-mappin
 import { OrganizationAppMapping } from './entity/organization-app-mapping.entity';
 import { BrandData } from './entity/brand.entity';
 import { SchoolData } from './entity/school.entity';
+import { BrandRepository } from './repository/brand.repository';
+import { SchoolRepository } from './repository/school.repository';
+import { UtilsModule } from 'src/utils/utils.module';
 
 @Module({
   imports: [
@@ -18,9 +21,15 @@ import { SchoolData } from './entity/school.entity';
       SchoolData,
     ]),
     UserModule,
+    UtilsModule,
   ],
   controllers: [OrganizationController],
-  providers: [OrganizationService, OrganizationAppMappingService],
+  providers: [
+    OrganizationService,
+    OrganizationAppMappingService,
+    BrandRepository,
+    SchoolRepository,
+  ],
   exports: [OrganizationService],
 })
 export class EnterpriseModule {}

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

@@ -1,9 +1,11 @@
 import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
-import { Entity } from 'typeorm';
+import { Column, Entity } from 'typeorm';
 
 @Entity({ name: 'cr_school' })
 export class SchoolData extends BaseEntity {
+  @Column({ name: 'brand_id', nullable: true })
   brand_id: number;
 
+  @Column({ name: 'brand_code', nullable: true })
   brand_code: string;
 }

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

@@ -0,0 +1,23 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { EnterpriseData } from '../entity/enterprise.entity';
+import { Repository } from 'typeorm';
+import { BrandData } from '../entity/brand.entity';
+
+@Injectable()
+export class BrandRepository {
+  constructor(
+    @InjectRepository(BrandData)
+    private readonly brandRepository: Repository<BrandData>,
+  ) {}
+
+  async findAllByOrgId(orgId: number): Promise<BrandData[]> {
+    return await this.brandRepository.find({
+      where: { organization_id: orgId },
+    });
+  }
+
+  async findOne(id: number): Promise<BrandData | null> {
+    return await this.brandRepository.findOne({ where: { id } });
+  }
+}

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

@@ -0,0 +1,155 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { DataSource, Repository } from 'typeorm';
+import { SchoolData } from '../entity/school.entity';
+import { UserRoleMapping } from 'src/module/user/entity/user-role-mapping.entity';
+
+@Injectable()
+export class SchoolRepository {
+  constructor(
+    @InjectRepository(SchoolData)
+    private readonly schoolRepo: Repository<SchoolData>,
+    private readonly dataSource: DataSource,
+  ) {}
+
+  async findAllByOrgId(brdId: number): Promise<SchoolData[]> {
+    return await this.schoolRepo.find({
+      where: { brand_id: brdId },
+    });
+  }
+
+  async findAllByBrandId(brdId: number): Promise<SchoolData[]> {
+    return await this.schoolRepo.find({
+      where: { brand_id: brdId },
+    });
+  }
+
+  async getUserContextDropdown(userId: number, appCode: string) {
+    const userRoleRepo = this.dataSource.getRepository(UserRoleMapping);
+
+    // Check if user has any org level access for the app
+    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();
+
+    console.log(hasOrgAccess);
+    if (hasOrgAccess.length > 0) {
+      // Return nested Org -> Brand -> School structure
+      const schools = await this.dataSource
+        .createQueryBuilder()
+        .select([
+          'org.id AS org_id',
+          'org.name AS org_name',
+          'br.id AS brand_id',
+          'br.name AS brand_name',
+          'sch.id AS school_id',
+          'sch.name AS school_name',
+        ])
+        .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();
+      const result = {};
+
+      for (const row of schools) {
+        const {
+          org_id,
+          org_name,
+          brand_id,
+          brand_name,
+          school_id,
+          school_name,
+        } = row;
+
+        if (!result[org_id]) {
+          result[org_id] = {
+            org_id,
+            org_name,
+            brands: {},
+          };
+        }
+        if (!result[org_id].brands[brand_id]) {
+          result[org_id].brands[brand_id] = {
+            brand_id,
+            brand_name,
+            schools: [],
+          };
+        }
+        result[org_id].brands[brand_id].schools.push({
+          school_id,
+          school_name,
+        });
+      }
+
+      return Object.values(result).map((org: { [key: string]: any }) => ({
+        ...org,
+        brands: Object.values(org.brands),
+      }));
+    } else {
+      // 1. Get schools via BRN-level access
+      const brnMappings = await this.dataSource
+        .createQueryBuilder()
+        .select([
+          'brand.id AS brand_id',
+          'brand.name AS brand_name',
+          'school.id AS school_id',
+          'school.name AS school_name',
+        ])
+        .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();
+
+      // 2. Get directly mapped schools via SCH-level access
+      const schMappings = await this.dataSource
+        .createQueryBuilder()
+        .select([
+          'brand.id AS brand_id',
+          'brand.name AS brand_name',
+          'school.id AS school_id',
+          'school.name AS school_name',
+        ])
+        .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();
+
+      // 3. Combine both mappings
+      const allMappings = [...brnMappings, ...schMappings];
+
+      // 4. Group by brand
+      const result = {};
+      for (const row of allMappings) {
+        const { brand_id, brand_name, school_id, school_name } = row;
+
+        if (!result[brand_id]) {
+          result[brand_id] = {
+            brand_id,
+            brand_name,
+            schools: [],
+          };
+        }
+
+        // prevent duplicates if needed
+        if (
+          school_id &&
+          !result[brand_id].schools.some((s) => s.school_id === school_id)
+        ) {
+          result[brand_id].schools.push({ school_id, school_name });
+        }
+      }
+
+      return Object.values(result);
+    }
+  }
+}

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

@@ -1,15 +1,22 @@
-import { Injectable } from '@nestjs/common';
+import { Inject, Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { EntityManager, Repository } from 'typeorm';
 import { OrganizationData } from '../entity/organization.entity';
 import { ClockIDGenService } from 'src/utils/service/clockIDGenUtil.service';
+import { UserService } from 'src/module/user/service/user.service';
+import { ENTITYTYPE_USER } from 'src/constant/global.constant';
+import { BrandRepository } from '../repository/brand.repository';
+import { SchoolRepository } from '../repository/school.repository';
 
 @Injectable()
 export class OrganizationService {
   constructor(
     @InjectRepository(OrganizationData)
     private readonly organizationRepository: Repository<OrganizationData>,
+    private readonly brandRepository: BrandRepository,
+    private readonly schoolRepository: SchoolRepository,
     private readonly idGen: ClockIDGenService,
+    @Inject('UserService') private readonly userService: UserService,
   ) {}
 
   async create(
@@ -46,7 +53,7 @@ export class OrganizationService {
     return await repo.findOne({ where: { id } });
   }
 
-  async findById(id:number | undefined){
+  async findById(id: number | undefined) {
     return await this.organizationRepository.find({ where: { id } });
   }
 
@@ -70,4 +77,8 @@ export class OrganizationService {
 
     await repo.delete(id);
   }
+
+  async getOrganizationHierarchy(userId: number, appCode: string) {
+    return await this.schoolRepository.getUserContextDropdown(userId, appCode);
+  }
 }

package/src/module/meta/controller/app-master.controller.ts

@@ -0,0 +1,38 @@
+import {
+  Controller,
+  Get,
+  Query,
+  Res,
+  HttpStatus,
+  UseGuards,
+  Inject,
+  Req,
+} from '@nestjs/common';
+import { JwtAuthGuard } from '../../auth/guards/jwt.guard';
+import { Response } from 'express';
+import { AppMasterService } from '../service/app-master.service';
+
+@Controller('apps')
+@UseGuards(JwtAuthGuard)
+export class AppMasterController {
+  constructor(private appMasterService: AppMasterService) {}
+
+  @Get('')
+  async getAppByAppCode(
+    @Req() req: Request & { user: any },
+    @Res() res: Response,
+  ) {
+    try {
+      const id = req.user.userData.id;
+
+      const data = await this.appMasterService.getAppMasterDataByAppCode(id);
+
+      return res.status(HttpStatus.OK).json(data);
+    } catch (error) {
+      return res.status(HttpStatus.INTERNAL_SERVER_ERROR).json({
+        success: false,
+        message: error.message || 'Error fetching entity data',
+      });
+    }
+  }
+}

package/src/module/meta/controller/entity.controller.ts

@@ -110,7 +110,6 @@ export class EntityController {
     @Req() req: Request & { user: any },
   ) {
     let loggedInUser = req.user.userData;
-    console.log(loggedInUser," loggedInUser");
     // let loggedInUser = await this.entityService.getEntityData(
     //   ENTITYTYPE_USER,
     //   requestedUser.userId,
@@ -121,18 +120,14 @@ export class EntityController {
       );
     }
 
-    console.log(entityType,"entityType");
     const entityMaster =
       await this.entityMasterService.getEntityData(entityType);
-    console.log(entityMaster, "entityMaster");
     const entityService =
       await this.reflectionHelper.getBean<EntityServiceImpl>(
         entityMaster.entity_service,
       );
-console.log(entityService, "entityService");
     if (entityService) {
       let existingEntity = await entityService.getEntityData(entityType, id);
-      console.log(existingEntity, "existingEntity");
       if (!existingEntity) {
       }
       // let mergeEntity = JsonUtil.merge(existingEntity, entityData);

package/src/module/meta/entity/app-master.entity.ts

@@ -1,8 +1,8 @@
-import { Entity, PrimaryGeneratedColumn } from 'typeorm';
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
 import { BaseEntity } from './base-entity.entity';
 
 @Entity({ name: 'cr_app_master' })
-export class UserAppMapping extends BaseEntity {
+export class AppMaster extends BaseEntity {
   constructor() {
     super();
     this.entity_type = 'APM';
@@ -10,4 +10,19 @@ export class UserAppMapping extends BaseEntity {
 
   @PrimaryGeneratedColumn()
   id: number;
+
+  @Column({ name: 'type', type: 'varchar', nullable: true })
+  type: string;
+
+  @Column({ name: 'color', type: 'varchar', nullable: true })
+  color: string;
+
+  @Column({ name: 'route', type: 'varchar', nullable: true })
+  route: string;
+
+  @Column({ name: 'description', type: 'varchar', nullable: true })
+  description: string;
+
+  @Column({ name: 'backgroudColor', type: 'varchar', nullable: true })
+  backgroudColor: string;
 }

package/src/module/meta/entity.module.ts

@@ -41,6 +41,12 @@ import { FilterModule } from '../filter/filter.module';
 import { UserAppMappingService } from './service/user-app-mapping.service';
 import { UserAppMappingRepository } from './repository/user-app-mapping.repository';
 import { UserAppMapping } from './entity/user-app-mapping.entity';
+import { AppMasterController } from './controller/app-master.controller';
+import { UserRoleMappingRepository } from '../user/repository/user-role-mapping.repository';
+import { UserRoleMapping } from '../user/entity/user-role-mapping.entity';
+import { AppMasterService } from './service/app-master.service';
+import { AppMasterRespository } from './repository/app-master.repository';
+import { AppMaster } from './entity/app-master.entity';
 
 @Module({
   imports: [
@@ -57,6 +63,8 @@ import { UserAppMapping } from './entity/user-app-mapping.entity';
       SectionMaster,
       FieldGroup,
       UserAppMapping,
+      UserRoleMapping,
+      AppMaster,
     ]),
     forwardRef(() => ListMasterModule),
     forwardRef(() => FilterModule),
@@ -84,6 +92,9 @@ import { UserAppMapping } from './entity/user-app-mapping.entity';
     { provide: 'ViewMasterService', useClass: ViewMasterService },
     UserAppMappingService,
     UserAppMappingRepository,
+    UserRoleMappingRepository,
+    AppMasterRespository,
+    AppMasterService,
   ],
   exports: [
     EntityMasterService,
@@ -100,6 +111,7 @@ import { UserAppMapping } from './entity/user-app-mapping.entity';
     AttributeMasterService,
     UserAppMappingService,
     UserAppMappingRepository,
+    AppMasterService,
   ],
   controllers: [
     EntityController,
@@ -107,6 +119,7 @@ import { UserAppMapping } from './entity/user-app-mapping.entity';
     MediaController,
     ViewMasterController,
     MetaController,
+    AppMasterController,
   ],
 })
 export class EntityModule {}

package/src/module/meta/repository/app-master.repository.ts

@@ -0,0 +1,20 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { BaseEntity, Repository } from 'typeorm';
+import { AppMaster } from '../entity/app-master.entity';
+
+@Injectable()
+export class AppMasterRespository {
+  constructor(
+    @InjectRepository(AppMaster)
+    private readonly AppMasterRespository: Repository<AppMaster>,
+  ) {}
+
+  async getAppMasterDataByAppCode(
+    appCode: string,
+  ): Promise<AppMaster[] | null> {
+    return await this.AppMasterRespository.find({
+      where: { appcode: appCode },
+    });
+  }
+}

package/src/module/meta/service/app-master.service.ts

@@ -0,0 +1,34 @@
+import { Injectable } from '@nestjs/common';
+import { UserRoleMappingRepository } from 'src/module/user/repository/user-role-mapping.repository';
+import { AppMasterRespository } from '../repository/app-master.repository';
+
+@Injectable()
+export class AppMasterService {
+  constructor(
+    private readonly appMasterRepository: AppMasterRespository,
+    private readonly userRoleMappingRepository: UserRoleMappingRepository,
+  ) {}
+
+  async getAppMasterDataByAppCode(userId: number) {
+    const app_code =
+      await this.userRoleMappingRepository.findDistinctAppcodeByUserId(userId);
+
+    const result: Record<string, any> = {};
+
+    if (app_code.appcode.length > 0) {
+      const resolvedData = await Promise.all(
+        app_code.appcode.map(async (element) => {
+          const data =
+            await this.appMasterRepository.getAppMasterDataByAppCode(element);
+          return { [element]: data };
+        }),
+      );
+
+      resolvedData.forEach((entry) => {
+        Object.assign(result, entry);
+      });
+    }
+
+    return result;
+  }
+}

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

@@ -117,12 +117,10 @@ export class EntityServiceImpl implements EntityService<BaseEntity> {
     id: number,
   ): Promise<BaseEntity | null> {
     const entityData = await this.entityMasterService.getEntityData(entityType);
-    console.log(entityData, 'entityData in getEntityData');
 
     const repoService = this.reflectionHelper.getRepoService(
       entityData.entity_data_class,
     );
-    console.log(repoService, 'repoService in getEntityData');
     if (!repoService) {
       throw new Error(
         `Repository service not found for entityType: ${entityType}`,

package/src/module/user/repository/user-role-mapping.repository.ts

@@ -47,4 +47,18 @@ export class UserRoleMappingRepository {
   async deleteByUserId(userId: number) {
     await this.userRoleMappingRepository.delete({ user_id: userId });
   }
+
+  async findDistinctAppcodeByUserId(
+    userId: number,
+  ): Promise<{ appcode: string[] }> {
+    const result = await this.userRoleMappingRepository
+      .createQueryBuilder('urm')
+      .select('DISTINCT urm.appcode', 'appcode')
+      .where('urm.user_id = :userId', { userId })
+      .getRawMany();
+
+    const appcodeArray = result.map((row) => row.appcode);
+
+    return { appcode: appcodeArray };
+  }
 }