rez_core 6.5.23 → 6.5.26

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

@@ -1,55 +1,56 @@
 import { BadRequestException, Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { In, IsNull, Not, Or, Repository } from 'typeorm';
+import { In, Not, Repository, IsNull, DataSource } from 'typeorm';
 import { Role } from 'src/module/user/entity/role.entity';
 import { ModuleAccess } from '../entity/module-access.entity';
 import { ModuleAction } from '../entity/module-action.entity';
 import { ModuleData } from '../entity/module.entity';
-import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
 
 @Injectable()
 export class ModuleAccessRepository {
   constructor(
     @InjectRepository(Role)
     private readonly roleRepo: Repository<Role>,
+
     @InjectRepository(ModuleData)
     private readonly moduleRepo: Repository<ModuleData>,
+
     @InjectRepository(ModuleAccess)
     private readonly moduleAccessRepo: Repository<ModuleAccess>,
+
     @InjectRepository(ModuleAction)
     private readonly moduleActionRepo: Repository<ModuleAction>,
-    private readonly reflectionHelper: ReflectionHelper,
-  ) {
-  }
+
+    private readonly dataSource: DataSource,
+  ) {}
 
   async getRoles({
-                   appcode,
-                   level_type,
-                   level_id,
-                 }: {
+    appcode,
+    level_type,
+    level_id,
+  }: {
     appcode: string;
     level_type?: string;
     level_id?: number;
   }) {
-    const where: any = {
-      app: {
-        code: appcode,
-      },
-      is_factory: Or(IsNull(), Not(1)), // 👈 include NULL and exclude factory roles
-    };
+    const query = this.dataSource
+      .createQueryBuilder()
+      .select('*')
+      .from('sso_role', 'role')
+      .where('role.appcode = :appcode', { appcode })
+      .andWhere('(role.is_factory IS NULL OR role.is_factory != 1)');
 
     if (level_type) {
-      where.level_type = level_type;
+      query.andWhere('role.level_type = :level_type', { level_type });
     }
 
     if (level_id !== undefined) {
-      where.level_id = String(level_id);
+      query.andWhere('role.level_id = :level_id', {
+        level_id: String(level_id),
+      });
     }
 
-    const roles = await this.roleRepo.find({
-      where,
-      select: ['id', 'name'], // keep returned data same as your mapping
-    });
+    const roles = await query.getRawMany(); // use getRawMany since you're selecting from a raw table
 
     return roles.map((role) => ({
       label: role.name,
@@ -58,30 +59,20 @@ export class ModuleAccessRepository {
   }
 
   async getModules({
-                     appcode,
-                     loggedInUser,
-                   }: {
+    appcode,
+    loggedInUser,
+  }: {
     appcode: string;
     loggedInUser: any;
   }) {
     let modules: any[];
     if (loggedInUser.level_type == 'SCH') {
       modules = await this.moduleRepo.find({
-        where: {
-          module_level: 'MAINMOD',
-          app: {
-            code: appcode,
-          },
-          level_type: 'SCH',
-        },
+        where: { module_level: 'MAINMOD', appcode, level_type: 'SCH' },
       });
     } else {
       modules = await this.moduleRepo.find({
-        where: {
-          module_level: 'MAINMOD', app: {
-            code: appcode,
-          },
-        },
+        where: { module_level: 'MAINMOD', appcode },
       });
     }
 
@@ -114,76 +105,53 @@ export class ModuleAccessRepository {
       roles = await this.roleRepo.find({
         where: {
           id: In(fetchedRoleIds),
-          app: {
-            code: appcode,
-          },
+          appcode,
         },
       });
     } else {
       roles = await this.roleRepo.find({
         where: {
           id: In(roleIds.map((id) => Number(id))),
-          app: {
-            code: appcode,
-          },
+          appcode,
         },
       });
     }
 
     if (!roles.length) return [];
 
+    const roleCodes = roles.map((role) => role.code);
+
     const moduleAccesses = await this.moduleAccessRepo.find({
       where: {
-        role_id: In(roles.map((role) => role.id)),
-        app: {
-          code: appcode,
-        },
-        level_type: levelType,
-      },
-      relations: {
-        app: true,
-        module: true,
+        role_code: In(roleCodes),
+        appcode,
       },
     });
 
     return roles.map((role) => ({
-      role_id: role.id,
+      role_code: role.code,
       name: role.name,
       permission: moduleAccesses
-        .filter((access) => access.role_id === role.id)
+        .filter((access) => access.role_code === role.code)
         .map((access) => ({
           action: access.action_type,
           access: access.access_flag,
-          module_id: access.module_id,
+          code: access.module_code,
           level_type: access.level_type,
-          app_id: access.app_id,
-          code: access.module.module_code,
-          appcode: access.app.code,
+          appcode: access.appcode,
         })),
     }));
   }
 
   async getAllModulesByLevel(mainModIds: string[], appcode: string, levelType) {
-    const appMasterRepo = this.reflectionHelper.getRepoService('AppMaster');
-
-    const appMaster = await appMasterRepo.find({
-      where: {
-        code: appcode
-      }
-    });
-
-    if (!appMaster) {
-      return {};
-    }
-
     const mainModules =
       mainModIds.length === 1 && mainModIds[0] === '-1'
         ? await this.moduleRepo.find({
-          where: { module_level: 'MAINMOD', app_id: appMaster[0].id },
-        })
+            where: { module_level: 'MAINMOD', appcode },
+          })
         : await this.moduleRepo.find({
-          where: { id: In(mainModIds), module_level: 'MAINMOD', app: { code: appcode } },
-        });
+            where: { id: In(mainModIds), module_level: 'MAINMOD', appcode },
+          });
 
     if (!mainModules.length) return {};
 
@@ -197,7 +165,7 @@ export class ModuleAccessRepository {
           .join(' OR '),
         Object.fromEntries(wbsCodes.map((code) => [`code${code}`, `${code}%`])),
       )
-      .andWhere('module.app_id = :app_id', { app_id: appMaster[0].id })
+      .andWhere('module.appcode = :appcode', { appcode })
       .andWhere('module.module_code != :excludedCode', {
         excludedCode: 'all_organization_adm_org',
       })
@@ -207,10 +175,10 @@ export class ModuleAccessRepository {
       (mod) => mod.module_code != 'all_organization_adm_org',
     );
 
-    const modules = allModules.map((m) => m.id);
+    const moduleCodes = allModules.map((m) => m.module_code);
 
     const allActions = await this.moduleActionRepo.find({
-      where: { module_id: In(modules) },
+      where: { module_code: In(moduleCodes) },
     });
 
     // Map actions by module_code with VIEW action first
@@ -219,11 +187,11 @@ export class ModuleAccessRepository {
         if (!acc[action.module_code]) acc[action.module_code] = [];
 
         const actionItem = {
-          action: action.action_code,
+          action: action.action_type,
           name: action.action_name,
         };
 
-        if (action.action_code === 'VIEW') {
+        if (action.action_type === 'VIEW') {
           acc[action.module_code].unshift(actionItem); // ➕ Add VIEW at start
         } else {
           acc[action.module_code].push(actionItem); // ➕ Add others at end
@@ -247,11 +215,10 @@ export class ModuleAccessRepository {
             (mod) =>
               mod.wbs_code.startsWith(`${parentWbs}.`) &&
               mod.wbs_code.split('.').length ===
-              parentWbs.split('.').length + 1,
+                parentWbs.split('.').length + 1,
           )
           .map((mod) => ({
             name: mod.name,
-            module_id: mod.id,
             code: mod.module_code,
             permission: actionMap[mod.module_code] || [],
             submod: buildHierarchy(mod.wbs_code),
@@ -261,7 +228,6 @@ export class ModuleAccessRepository {
         .filter((mod) => mod.level_type === lvl)
         .map((mod) => ({
           name: mod.name,
-          module_id: mod.id,
           code: mod.module_code,
           permission: actionMap[mod.module_code] || [],
           submod: buildHierarchy(mod.wbs_code),
@@ -288,16 +254,10 @@ export class ModuleAccessRepository {
       for (const access of accessList) {
         const existing = await this.moduleAccessRepo.findOne({
           where: {
-            role: {
-              code: access.role_code,
-            },
-            module: {
-              module_code: access.module_code,
-            },
+            role_code: access.role_code,
+            module_code: access.module_code,
             action_type: access.action_type,
-            app: {
-              code: access.appcode,
-            },
+            appcode: access.appcode,
             level_type: access.level_type,
           },
         });
@@ -307,7 +267,7 @@ export class ModuleAccessRepository {
           await this.moduleAccessRepo.save(existing);
         } else {
           await this.moduleAccessRepo.save(
-            this.moduleAccessRepo.create(access),
+            await this.moduleAccessRepo.create(access),
           );
         }
       }
@@ -325,10 +285,13 @@ export class ModuleAccessRepository {
 
     if (!module) throw new BadRequestException('Module not found');
 
+    const roles = await this.roleRepo.find({ where: { id: In(roleIds) } });
+    const roleCodes = roles.map((role) => role.code);
+
     const actions = await this.moduleAccessRepo.find({
       where: {
-        module_id: module.id,
-        role_id: In(roleIds),
+        module_code: moduleCode,
+        role_code: In(roleCodes),
         access_flag: 1,
       },
     });
@@ -338,16 +301,16 @@ export class ModuleAccessRepository {
     return {
       entity_type: module.entity_type,
       title: module.title,
+      ui_config: module.ui_config || {},
       action: uniqueActions,
     };
   }
-
-  async getModuleAccessByRoles(roleIds: number[], app_id: number) {
+  async getModuleAccessByRoles(roleIds: number[], appcode: string) {
     // Step 1: Get role codes from sso_role
     const roles = await this.roleRepo.find({
       where: {
         id: In(roleIds),
-        app_id,
+        appcode,
       },
       select: ['id', 'code'],
     });
@@ -366,7 +329,7 @@ export class ModuleAccessRepository {
         'access.appcode AS appcode',
       ])
       .where('access.role_code IN (:...roleCodes)', { roleCodes })
-      .andWhere('access.app_id = :app_id', { app_id })
+      .andWhere('access.appcode = :appcode', { appcode })
       .getRawMany();
 
     // Step 3: Format output

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

@@ -1,43 +1,45 @@
 import { Injectable } from '@nestjs/common';
 import { MenuRepository } from '../repository/menu.repository';
 import { MenuData } from '../entity/menu.entity';
+import { DataSource } from 'typeorm';
+import { UserRoleMapping } from 'src/module/user/entity/user-role-mapping.entity';
 
 @Injectable()
 export class MenuService {
   constructor(
     private readonly menuRepository: MenuRepository,
-  ) {
-  }
+    private readonly datasource: DataSource,
+  ) {}
 
   /**
    * Fetch and construct menu hierarchy for a given user.
    */
   async getUserMenu(
     userId: number,
-    app_id: number,
+    appcode: string,
     levelType: 'ORG' | 'SCH',
     levelId: number,
   ): Promise<{ menu: any[] }> {
     // Step 1: Resolve roles (with fallback logic inside)
     const roleCodes = await this.menuRepository.resolveUserRoles(
       userId,
-      app_id,
+      appcode,
       levelType,
       levelId,
     );
     if (!roleCodes.length) return { menu: [] };
 
     // Step 2: Get accessible modules
-    const modules = await this.menuRepository.getAccessibleModules(
+    const moduleCodes = await this.menuRepository.getAccessibleModules(
       roleCodes,
-      app_id,
+      appcode,
     );
-    if (!modules.length) return { menu: [] };
+    if (!moduleCodes.length) return { menu: [] };
 
     // Step 3: Get menu items for the given level type
     const menuItems = await this.menuRepository.getMenuItems(
-      modules,
-      app_id,
+      moduleCodes,
+      appcode,
       levelType,
     );
 
@@ -74,7 +76,7 @@ export class MenuService {
   }
 
   // get user roles
-  async getUserRoles(userId: number, app_id: number): Promise<any> {
-    return this.menuRepository.getUserRoles(userId, app_id);
+  async getUserRoles(userId: number, appcode: string): Promise<any> {
+    return this.menuRepository.getUserRoles(userId, appcode);
   }
 }

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

@@ -1,21 +1,27 @@
-import { BadRequestException, Injectable } from '@nestjs/common';
+import { BadRequestException, Inject, Injectable } from '@nestjs/common';
 import { ModuleAccessRepository } from '../repository/module-access.repository';
-import { IsNull, Not, Or, Repository } from 'typeorm';
+import { RoleRepository } from 'src/module/user/repository/role.repository';
+import { RoleService } from '../../user/service/role.service';
+import {
+  ENTITYTYPE_ROLE,
+  STATUS_INACTIVE,
+} from '../../../constant/global.constant';
+import { Role } from '../../user/entity/role.entity';
+import { DataSource, EntityManager } from 'typeorm';
 import { UserData } from 'src/module/user/entity/user.entity';
 import { MenuRepository } from '../repository/menu.repository';
+import { ListMasterService } from 'src/module/listmaster/service/list-master.service';
 import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
-import { Role } from '../../user/entity/role.entity';
-import { InjectRepository } from '@nestjs/typeorm';
-import { StatusConstant } from '../../../constant/status.constant';
 
 @Injectable()
 export class ModuleAccessService {
   constructor(
     private readonly moduleAccessRepository: ModuleAccessRepository,
     private readonly menuRepository: MenuRepository,
+    private readonly dataSource: DataSource,
+    @Inject('ListMasterService')
+    private readonly listMasterService: ListMasterService,
     private readonly reflectionHelper: ReflectionHelper,
-    @InjectRepository(Role)
-    private readonly roleRepo: Repository<Role>
   ) {
   }
 
@@ -36,26 +42,25 @@ export class ModuleAccessService {
     level_id?: number;
     include?: boolean;
   }) {
+    const query = this.dataSource
+      .createQueryBuilder()
+      .select('*')
+      .from('sso_role', 'role')
+      .where('role.appcode = :appcode', { appcode });
 
-    const where: any = {
-      app: {
-        code: appcode
-      }
-    };
-
+    // Only add this condition if `include` is false (exclude factory roles)
     if (!include) {
-      where.is_factory = Or(IsNull(), Not(1));
+      query.andWhere('(role.is_factory IS NULL OR role.is_factory != 1)');
     }
 
     if (level_type && level_id) {
-      where.level_type = level_type;
-      where.level_id = String(level_id);
+      query.andWhere('role.level_type = :level_type', { level_type });
+      query.andWhere('role.level_id = :level_id', {
+        level_id: String(level_id),
+      });
     }
 
-    const roles = await this.roleRepo.find({
-      where,
-    });
-
+    const roles = await query.getRawMany();
 
     return roles.map((role) => ({
       label: role.name,
@@ -83,7 +88,7 @@ export class ModuleAccessService {
     levelType: string,
   ): Promise<Record<string, any[]>> {
     if (!appcode) {
-      throw new BadRequestException('App code is required');
+      throw new BadRequestException('Appcode is required');
     }
 
     return this.moduleAccessRepository.getAllModulesByLevel(
@@ -125,19 +130,21 @@ export class ModuleAccessService {
 
   async getUserPermissions({
                              userId,
-                             app_id,
+                             appcode,
                              level_type,
                              level_id,
+                             enterprise_id,
                            }: {
     userId: number;
-    app_id: number;
+    appcode: string;
     level_type: string;
     level_id: number;
+    enterprise_id: number;
   }) {
     // Step 1: Resolve roles
     const roleCodes = await this.menuRepository.resolveUserRoles(
       userId,
-      app_id,
+      appcode,
       level_type,
       level_id,
     );
@@ -152,7 +159,7 @@ export class ModuleAccessService {
     const allPermissions =
       await this.moduleAccessRepository.getModuleAccessByRoles(
         roleIds,
-        app_id,
+        appcode,
       );
 
     // Step 3: If level_type is SCH, check school status using raw query
@@ -165,7 +172,12 @@ export class ModuleAccessService {
         },
       });
 
-      if (!school || school.status === StatusConstant.INACTIVE) {
+      const resolveStatus = await this.listMasterService.getResolvedListCode(
+        STATUS_INACTIVE,
+        enterprise_id || 0,
+      );
+
+      if (!school || school.status === resolveStatus.id) {
         // Return only VIEW permissions
         return allPermissions.filter((perm) => perm.action === 'VIEW');
       }

package/src/module/notification/entity/notification.entity.ts

@@ -1,58 +1,8 @@
-import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
+import { Column, Entity } from 'typeorm';
 
 @Entity({ name: 'frm_notification' })
-export class NotificationData {
-  @PrimaryGeneratedColumn({ type: 'bigint' })
-  id: number;
-
-  @Column({ name: 'entity_type', type: 'varchar', length: 100, nullable: true })
-  entity_type: string;
-
-  @Column({ name: 'name', type: 'varchar', length: 100, nullable: true })
-  name: string;
-
-  @Column({ name: 'status', type: 'varchar', nullable: true, length: 100 })
-  status: string;
-
-  @Column({ name: 'parent_type', type: 'varchar', length: 100, nullable: true })
-  parent_type: string;
-
-  @Column({ name: 'parent_id', type: 'bigint', nullable: true })
-  parent_id: number;
-
-  @Column({ name: 'code', type: 'varchar', length: 100, nullable: true })
-  code: string;
-
-  @Column({ name: 'created_by', type: 'bigint', nullable: true })
-  created_by: number;
-
-  @Column({
-    name: 'created_date',
-    nullable: true,
-  })
-  created_date: Date;
-
-  @Column({ name: 'modified_by', type: 'bigint', nullable: true })
-  modified_by: number;
-
-  @Column({ name: 'modified_date', nullable: true })
-  modified_date: Date;
-
-  @Column({ name: 'enterprise_id', type: 'int', nullable: true })
-  enterprise_id: number;
-
-  @Column({ name: 'organization_id', type: 'int', nullable: true })
-  organization_id: number;
-
-  @Column({ name: 'appcode', type: 'varchar', length: 100, nullable: true })
-  appcode: string;
-
-  @Column({ name: 'level_id', type: 'varchar', length: 100, nullable: true })
-  level_id: string;
-
-  @Column({ name: 'level_type', type: 'varchar', length: 100, nullable: true })
-  level_type: string;
-
+export class NotificationData extends BaseEntity {
   @Column({ name: 'user_id', type: 'int', nullable: true })
   user_id: number | null;
 

package/src/module/notification/notification.module.ts

@@ -15,6 +15,7 @@ import { IcsMeetingModule } from '../ics/ics.module';
 import { NotificationData } from './entity/notification.entity';
 import { NotificationsController } from './controller/notification.controller';
 import { NotificationsService } from './service/notification.service';
+import { EntityModule } from '../meta/entity.module';
 import { FirebaseAdminProvider } from './firebase-admin.config';
 
 @Module({
@@ -48,6 +49,7 @@ import { FirebaseAdminProvider } from './firebase-admin.config';
     AuthModule,
     UserModule,
     IcsMeetingModule,
+    EntityModule,
   ],
   providers: [
     OtpService,

package/src/module/notification/service/notification.service.ts

@@ -10,6 +10,7 @@ import { ReflectionHelper } from 'src/utils/service/reflection-helper.service';
 export class NotificationsService {
   constructor(
     private readonly entityManager: EntityManager,
+    private readonly mediaDataService: MediaDataService,
     private readonly configService: ConfigService,
     private readonly reflectionHelper: ReflectionHelper,
     @Inject('FIREBASE_ADMIN') private readonly firebaseAdmin: typeof admin,

package/src/module/notification/service/otp.service.ts

@@ -1,5 +1,5 @@
 import { DataSource } from 'typeorm';
-import { Injectable } from '@nestjs/common';
+import { BadRequestException, Injectable } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { ClockIDGenService } from '../../../utils/service/clockIDGenUtil.service';
 import { Otp } from '../entity/otp.entity';
@@ -16,8 +16,7 @@ export class OtpService {
     private readonly loginService: LoginService,
     private readonly emailService: EmailService,
     private readonly dataSource: DataSource,
-  ) {
-  }
+  ) {}
 
   VERIFY_OTP = this.configService.get('VERIFY_OTP') || 'true';
   DEFAULT_OTP = this.configService.get('DEFAULT_OTP') || '123456';

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

@@ -22,7 +22,8 @@ export class LoginController {
   constructor(
     private loginService: LoginService,
     private userSessionService: UserSessionService,
-    private configService: ConfigService
+    private configService: ConfigService,
+    private integrationService: IntegrationService,
   ) {}
 
   @Post('login')
@@ -85,12 +86,12 @@ export class LoginController {
         const actualState = state.replace('gmail_config:', '');
 
         // Forward to communication service for Gmail config handling using already exchanged tokens
-        // const result = await this.integrationService.handleGmailTokensCallback(
-        //   email,
-        //   googleAccessToken,
-        //   googleRefreshToken,
-        //   actualState,
-        // );
+        const result = await this.integrationService.handleGmailTokensCallback(
+          email,
+          googleAccessToken,
+          googleRefreshToken,
+          actualState,
+        );
 
         return res.send(
           `<html><body><script>

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

@@ -18,6 +18,15 @@ export class UserController {
     @Inject('UserService') private readonly userService: UserService,
   ) {}
 
+  @Post('user/signup')
+  async signup(
+    @Body(new ValidationPipe()) createUserDto: CreateUserDto,
+    @Res() res: Response,
+  ) {
+    const result = await this.userService.createEntity(createUserDto, null);
+    res.status(HttpStatus.OK).json(result);
+  }
+
   @Post('check-email')
   @HttpCode(HttpStatus.OK)
   async checkEmail(@Body() body, @Res() res: Response) {