rez_core 6.5.61 → 6.5.62

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

@@ -1,28 +1,26 @@
 import { BadRequestException, Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { In, Not, Repository, IsNull, DataSource } from 'typeorm';
+import { In, IsNull, Not, Or, Repository } 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 dataSource: DataSource,
-  ) {}
+    private readonly reflectionHelper: ReflectionHelper,
+  ) {
+  }
 
   async getRoles({
     appcode,
@@ -33,24 +31,25 @@ export class ModuleAccessRepository {
     level_type?: string;
     level_id?: number;
   }) {
-    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)');
+    const where: any = {
+      app: {
+        code: appcode,
+      },
+      is_factory: Or(IsNull(), Not(1)), // 👈 include NULL and exclude factory roles
+    };
 
     if (level_type) {
-      query.andWhere('role.level_type = :level_type', { level_type });
+      where.level_type = level_type;
     }
 
     if (level_id !== undefined) {
-      query.andWhere('role.level_id = :level_id', {
-        level_id: String(level_id),
-      });
+      where.level_id = String(level_id);
     }
 
-    const roles = await query.getRawMany(); // use getRawMany since you're selecting from a raw table
+    const roles = await this.roleRepo.find({
+      where,
+      select: ['id', 'name'], // keep returned data same as your mapping
+    });
 
     return roles.map((role) => ({
       label: role.name,
@@ -68,11 +67,21 @@ export class ModuleAccessRepository {
     let modules: any[];
     if (loggedInUser.level_type == 'SCH') {
       modules = await this.moduleRepo.find({
-        where: { module_level: 'MAINMOD', appcode, level_type: 'SCH' },
+        where: {
+          module_level: 'MAINMOD',
+          app: {
+            code: appcode,
+          },
+          level_type: 'SCH',
+        },
       });
     } else {
       modules = await this.moduleRepo.find({
-        where: { module_level: 'MAINMOD', appcode },
+        where: {
+          module_level: 'MAINMOD', app: {
+            code: appcode,
+          },
+        },
       });
     }
 
@@ -105,53 +114,77 @@ export class ModuleAccessRepository {
       roles = await this.roleRepo.find({
         where: {
           id: In(fetchedRoleIds),
-          appcode,
+          app: {
+            code: appcode,
+          },
         },
       });
     } else {
       roles = await this.roleRepo.find({
         where: {
           id: In(roleIds.map((id) => Number(id))),
-          appcode,
+          app: {
+            code: appcode,
+          },
         },
       });
     }
 
     if (!roles.length) return [];
 
-    const roleCodes = roles.map((role) => role.code);
-
     const moduleAccesses = await this.moduleAccessRepo.find({
       where: {
-        role_code: In(roleCodes),
-        appcode,
+        role_id: In(roles.map((role) => role.id)),
+        app: {
+          code: appcode,
+        },
+        level_type: levelType,
+      },
+      relations: {
+        app: true,
+        module: true,
       },
     });
 
     return roles.map((role) => ({
-      role_code: role.code,
+      role_id: role.id,
       name: role.name,
       permission: moduleAccesses
-        .filter((access) => access.role_code === role.code)
+        .filter((access) => access.role_id === role.id)
         .map((access) => ({
           action: access.action_type,
           access: access.access_flag,
-          code: access.module_code,
+          module_id: access.module_id,
           level_type: access.level_type,
-          appcode: access.appcode,
+          app_id: access.app_id,
+          code: access?.module?.module_code,
+          appcode: access.app.code,
         })),
     }));
   }
 
   async getAllModulesByLevel(mainModIds: string[], appcode: string, levelType) {
+
+    const appMasterRepo = this.reflectionHelper.getRepoService('AppMaster');
+    // TODO Permissions not getting populated
+    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', appcode },
-          })
+          where: { module_level: 'MAINMOD', app_id: appMaster[0].id },
+        })
         : await this.moduleRepo.find({
-            where: { id: In(mainModIds), module_level: 'MAINMOD', appcode },
-          });
+          where: { id: In(mainModIds), module_level: 'MAINMOD', app: { code: appcode } },
+        });
 
     if (!mainModules.length) return {};
 
@@ -165,7 +198,7 @@ export class ModuleAccessRepository {
           .join(' OR '),
         Object.fromEntries(wbsCodes.map((code) => [`code${code}`, `${code}%`])),
       )
-      .andWhere('module.appcode = :appcode', { appcode })
+      .andWhere('module.app_id = :app_id', { app_id: appMaster[0].id })
       .andWhere('module.module_code != :excludedCode', {
         excludedCode: 'all_organization_adm_org',
       })
@@ -175,28 +208,27 @@ export class ModuleAccessRepository {
       (mod) => mod.module_code != 'all_organization_adm_org',
     );
 
-    const moduleCodes = allModules.map((m) => m.module_code);
+    const modules = allModules.map((m) => m.id);
 
     const allActions = await this.moduleActionRepo.find({
-      where: { module_code: In(moduleCodes) },
-    });
+      where: {
+        module_id: In(modules),
+      }
+    })
 
     // Map actions by module_code with VIEW action first
     const actionMap = allActions.reduce(
       (acc, action) => {
-        if (!acc[action.module_code]) acc[action.module_code] = [];
-
+        if (!acc[action?.module_id]) acc[action?.module_id] = [];
         const actionItem = {
-          action: action.action_type,
+          action: action.action_code,
           name: action.action_name,
         };
-
-        if (action.action_type === 'VIEW') {
-          acc[action.module_code].unshift(actionItem); // ➕ Add VIEW at start
+        if (action.action_code === 'VIEW') {
+          acc[action?.module_id].unshift(actionItem); // ➕ Add VIEW at start
         } else {
-          acc[action.module_code].push(actionItem); // ➕ Add others at end
+          acc[action?.module_id].push(actionItem); // ➕ Add others at end
         }
-
         return acc;
       },
       {} as Record<string, { action: string; name: string }[]>,
@@ -215,12 +247,13 @@ 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] || [],
+            permission: actionMap[mod.id] || [],
             submod: buildHierarchy(mod.wbs_code),
           }));
 
@@ -228,8 +261,9 @@ 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] || [],
+          permission: actionMap[mod.id] || [],
           submod: buildHierarchy(mod.wbs_code),
         }));
 
@@ -254,10 +288,16 @@ export class ModuleAccessRepository {
       for (const access of accessList) {
         const existing = await this.moduleAccessRepo.findOne({
           where: {
-            role_code: access.role_code,
-            module_code: access.module_code,
+            role: {
+              code: access.role_code,
+            },
+            module: {
+              module_code: access.module_code,
+            },
             action_type: access.action_type,
-            appcode: access.appcode,
+            app: {
+              code: access.appcode,
+            },
             level_type: access.level_type,
           },
         });
@@ -267,7 +307,7 @@ export class ModuleAccessRepository {
           await this.moduleAccessRepo.save(existing);
         } else {
           await this.moduleAccessRepo.save(
-            await this.moduleAccessRepo.create(access),
+            this.moduleAccessRepo.create(access),
           );
         }
       }
@@ -285,13 +325,10 @@ 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_code: moduleCode,
-        role_code: In(roleCodes),
+        module_id: module.id,
+        role_id: In(roleIds),
         access_flag: 1,
       },
     });
@@ -301,16 +338,18 @@ export class ModuleAccessRepository {
     return {
       entity_type: module.entity_type,
       title: module.title,
-      ui_config: module.ui_config || {},
       action: uniqueActions,
     };
   }
+
   async getModuleAccessByRoles(roleIds: number[], appcode: string) {
     // Step 1: Get role codes from sso_role
     const roles = await this.roleRepo.find({
       where: {
         id: In(roleIds),
-        appcode,
+        app: {
+          code: appcode,
+        },
       },
       select: ['id', 'code'],
     });
@@ -318,18 +357,27 @@ export class ModuleAccessRepository {
     const roleCodes = roles.map((r) => r.code);
     if (!roleCodes.length) return [];
 
+    const appMasterRepo = this.reflectionHelper.getRepoService('AppMaster');
+    const appMaster = await appMasterRepo.findOne({
+      where: {
+        code: appcode,
+      },
+    });
+
     // Step 2: Fetch full access data
     const accessRecords = await this.moduleAccessRepo
       .createQueryBuilder('access')
       .select([
-        'access.module_code AS module_code',
+        'access.module_id AS module_id',
+        'm.module_code AS module_code',
         'access.action_type AS action_type',
         'access.access_flag AS access_flag',
         'access.level_type AS level_type',
         'access.appcode AS appcode',
       ])
+      .innerJoin('sso_module', 'm', 'm.id = access.module_id')
       .where('access.role_code IN (:...roleCodes)', { roleCodes })
-      .andWhere('access.appcode = :appcode', { appcode })
+      .andWhere('access.app_id = :app_id', { app_id: appMaster.id })
       .getRawMany();
 
     // Step 3: Format output

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

@@ -1,15 +1,13 @@
 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.
@@ -30,15 +28,15 @@ export class MenuService {
     if (!roleCodes.length) return { menu: [] };
 
     // Step 2: Get accessible modules
-    const moduleCodes = await this.menuRepository.getAccessibleModules(
+    const modules = await this.menuRepository.getAccessibleModules(
       roleCodes,
       appcode,
     );
-    if (!moduleCodes.length) return { menu: [] };
+    if (!modules.length) return { menu: [] };
 
     // Step 3: Get menu items for the given level type
     const menuItems = await this.menuRepository.getMenuItems(
-      moduleCodes,
+      modules,
       appcode,
       levelType,
     );
@@ -76,7 +74,7 @@ export class MenuService {
   }
 
   // get user roles
-  async getUserRoles(userId: number, appcode: string): Promise<any> {
-    return this.menuRepository.getUserRoles(userId, appcode);
+  async getUserRoles(userId: number, app_id: number): Promise<any> {
+    return this.menuRepository.getUserRoles(userId, app_id);
   }
 }

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

@@ -1,27 +1,21 @@
-import { BadRequestException, Inject, Injectable } from '@nestjs/common';
+import { BadRequestException, Injectable } from '@nestjs/common';
 import { ModuleAccessRepository } from '../repository/module-access.repository';
-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 { IsNull, Not, Or, Repository } 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>
   ) {
   }
 
@@ -42,25 +36,26 @@ export class ModuleAccessService {
     level_id?: number;
     include?: boolean;
   }) {
-    const query = this.dataSource
-      .createQueryBuilder()
-      .select('*')
-      .from('sso_role', 'role')
-      .where('role.appcode = :appcode', { appcode });
 
-    // Only add this condition if `include` is false (exclude factory roles)
+    const where: any = {
+      app: {
+        code: appcode
+      }
+    };
+
     if (!include) {
-      query.andWhere('(role.is_factory IS NULL OR role.is_factory != 1)');
+      where.is_factory = Or(IsNull(), Not(1));
     }
 
     if (level_type && level_id) {
-      query.andWhere('role.level_type = :level_type', { level_type });
-      query.andWhere('role.level_id = :level_id', {
-        level_id: String(level_id),
-      });
+      where.level_type = level_type;
+      where.level_id = String(level_id);
     }
 
-    const roles = await query.getRawMany();
+    const roles = await this.roleRepo.find({
+      where,
+    });
+
 
     return roles.map((role) => ({
       label: role.name,
@@ -88,7 +83,7 @@ export class ModuleAccessService {
     levelType: string,
   ): Promise<Record<string, any[]>> {
     if (!appcode) {
-      throw new BadRequestException('Appcode is required');
+      throw new BadRequestException('App code is required');
     }
 
     return this.moduleAccessRepository.getAllModulesByLevel(
@@ -133,13 +128,11 @@ export class ModuleAccessService {
                              appcode,
                              level_type,
                              level_id,
-                             enterprise_id,
                            }: {
     userId: number;
     appcode: string;
     level_type: string;
     level_id: number;
-    enterprise_id: number;
   }) {
     // Step 1: Resolve roles
     const roleCodes = await this.menuRepository.resolveUserRoles(
@@ -172,12 +165,7 @@ export class ModuleAccessService {
         },
       });
 
-      const resolveStatus = await this.listMasterService.getResolvedListCode(
-        STATUS_INACTIVE,
-        enterprise_id || 0,
-      );
-
-      if (!school || school.status === resolveStatus.id) {
+      if (!school || school.status === StatusConstant.INACTIVE) {
         // Return only VIEW permissions
         return allPermissions.filter((perm) => perm.action === 'VIEW');
       }

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

@@ -1,8 +1,58 @@
-import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
-import { Column, Entity } from 'typeorm';
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
 
 @Entity({ name: 'frm_notification' })
-export class NotificationData extends BaseEntity {
+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;
+
   @Column({ name: 'user_id', type: 'int', nullable: true })
   user_id: number | null;
 

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

@@ -15,12 +15,14 @@ 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';
+import { PreferenceService } from '../preference_master/preference.service';
+import { PreferenceRepository } from '../meta/repository/preference.repository';
+import { PreferenceData } from '../preference_master/entity/preference.entity';
 
 @Module({
   imports: [
-    TypeOrmModule.forFeature([Otp, NotificationData]),
+    TypeOrmModule.forFeature([Otp, NotificationData, PreferenceData]),
     MailerModule.forRootAsync({
       imports: [ConfigModule],
       inject: [ConfigService],
@@ -49,14 +51,13 @@ import { FirebaseAdminProvider } from './firebase-admin.config';
     AuthModule,
     UserModule,
     IcsMeetingModule,
-    EntityModule,
   ],
   providers: [
     OtpService,
     OtpRepository,
     EmailService,
     NotificationsService,
-    FirebaseAdminProvider,
+    FirebaseAdminProvider
   ],
   exports: [
     OtpService,
@@ -66,4 +67,4 @@ import { FirebaseAdminProvider } from './firebase-admin.config';
   ],
   controllers: [OtpController, NotificationsController],
 })
-export class NotificationModule {}
+export class NotificationModule { }

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

@@ -10,7 +10,7 @@ export class EmailService {
     private readonly mailerService: MailerService,
     private readonly datasource: DataSource,
     private readonly icsService: IcsMeetingService,
-  ) {}
+  ) { }
 
   async sendEmail(
     email: string,
@@ -124,4 +124,19 @@ export class EmailService {
 
     return { success: true, message: 'Email sent successfully' };
   }
+
+  async sendEmailWithoutTemplate(to: string, subject: string, body: string) {
+    try {
+      await this.mailerService.sendMail({
+        to,
+        subject,
+        html: body,
+      });
+      console.log(`Email sent successfully to ${to} via NodeMailer.`);
+    } catch (error) {
+      console.error(`Failed to send email to ${to} via NodeMailer:`, error);
+      throw error; // Re-throw to allow calling context to handle
+    }
+  }
+
 }

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

@@ -10,7 +10,6 @@ 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,