rez_core 6.1.5 → 6.1.7

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

@@ -1,82 +1,82 @@
-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,
-    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,
-      appcode,
-      levelType,
-      levelId,
-    );
-    if (!roleCodes.length) return { menu: [] };
-
-    // Step 2: Get accessible modules
-    const moduleCodes = await this.menuRepository.getAccessibleModules(
-      roleCodes,
-      appcode,
-    );
-    if (!moduleCodes.length) return { menu: [] };
-
-    // Step 3: Get menu items for the given level type
-    const menuItems = await this.menuRepository.getMenuItems(
-      moduleCodes,
-      appcode,
-      levelType,
-    );
-
-    // Step 4: Build hierarchy
-    const menuTree = this.buildMenuHierarchy(menuItems);
-
-    return { menu: menuTree };
-  }
-
-  /**
-   * Converts a flat list of menu items into a hierarchical tree.
-   */
-  private buildMenuHierarchy(menuItems: MenuData[]): any[] {
-    const menuMap = new Map<string, any>(); // Use module_code as the key
-    const rootMenu: any[] = [];
-
-    // Initialize menu items in the map
-    menuItems.forEach((menu) => {
-      menuMap.set(menu.wbs_code, { ...menu, submenu: [] });
-    });
-
-    // Build the hierarchy based on WBS code
-    menuItems.forEach((menu) => {
-      const parentWbs = menu.wbs_code.split('.').slice(0, -1).join('.'); // Get parent WBS code
-
-      if (parentWbs && menuMap.has(parentWbs)) {
-        menuMap.get(parentWbs).submenu.push(menuMap.get(menu.wbs_code));
-      } else {
-        rootMenu.push(menuMap.get(menu.wbs_code));
-      }
-    });
-
-    return rootMenu;
-  }
-
-  // get user roles
-  async getUserRoles(userId: number, appcode: string): Promise<any> {
-    return this.menuRepository.getUserRoles(userId, appcode);
-  }
-}
+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,
+    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,
+      appcode,
+      levelType,
+      levelId,
+    );
+    if (!roleCodes.length) return { menu: [] };
+
+    // Step 2: Get accessible modules
+    const moduleCodes = await this.menuRepository.getAccessibleModules(
+      roleCodes,
+      appcode,
+    );
+    if (!moduleCodes.length) return { menu: [] };
+
+    // Step 3: Get menu items for the given level type
+    const menuItems = await this.menuRepository.getMenuItems(
+      moduleCodes,
+      appcode,
+      levelType,
+    );
+
+    // Step 4: Build hierarchy
+    const menuTree = this.buildMenuHierarchy(menuItems);
+
+    return { menu: menuTree };
+  }
+
+  /**
+   * Converts a flat list of menu items into a hierarchical tree.
+   */
+  private buildMenuHierarchy(menuItems: MenuData[]): any[] {
+    const menuMap = new Map<string, any>(); // Use module_code as the key
+    const rootMenu: any[] = [];
+
+    // Initialize menu items in the map
+    menuItems.forEach((menu) => {
+      menuMap.set(menu.wbs_code, { ...menu, submenu: [] });
+    });
+
+    // Build the hierarchy based on WBS code
+    menuItems.forEach((menu) => {
+      const parentWbs = menu.wbs_code.split('.').slice(0, -1).join('.'); // Get parent WBS code
+
+      if (parentWbs && menuMap.has(parentWbs)) {
+        menuMap.get(parentWbs).submenu.push(menuMap.get(menu.wbs_code));
+      } else {
+        rootMenu.push(menuMap.get(menu.wbs_code));
+      }
+    });
+
+    return rootMenu;
+  }
+
+  // get user roles
+  async getUserRoles(userId: number, appcode: string): Promise<any> {
+    return this.menuRepository.getUserRoles(userId, appcode);
+  }
+}

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

@@ -1,189 +1,189 @@
-import { BadRequestException, Inject, 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 { 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';
-
-@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,
-  ) {
-  }
-
-  async getModules({ appcode, loggedInUser }: { appcode: string, loggedInUser: UserData }) {
-    return this.moduleAccessRepository.getModules({
-      appcode, loggedInUser,
-    });
-  }
-
-  async getRoles({
-                   appcode,
-                   level_type,
-                   level_id,
-                   include,
-                 }: {
-    appcode: string;
-    level_type?: string;
-    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)
-    if (!include) {
-      query.andWhere('(role.is_factory IS NULL OR role.is_factory != 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),
-      });
-    }
-
-    const roles = await query.getRawMany();
-
-    return roles.map((role) => ({
-      label: role.name,
-      value: role.id,
-    }));
-  }
-
-  async getAccessListing(
-    roleIds: number[],
-    appcode: string,
-    levelType: string,
-    level_id?: number,
-  ) {
-    return this.moduleAccessRepository.getAccessListing(
-      roleIds,
-      appcode,
-      levelType,
-      level_id,
-    );
-  }
-
-  async getMenuListing(
-    mainModIds: string[],
-    appcode: string,
-    levelType: string,
-  ): Promise<Record<string, any[]>> {
-    if (!appcode) {
-      throw new BadRequestException('Appcode is required');
-    }
-
-    return this.moduleAccessRepository.getAllModulesByLevel(
-      mainModIds,
-      appcode,
-      levelType,
-    );
-  }
-
-  async updateModuleAccess(
-    moduleAccessData: {
-      role_code: string;
-      module_code: string;
-      action_type: string;
-      access_flag: number;
-      appcode: string;
-      level_type: string;
-    }[],
-  ): Promise<{ success: boolean; msg: string }> {
-    if (!moduleAccessData || moduleAccessData.length === 0) {
-      return { success: false, msg: 'No data provided' };
-    }
-
-    const result =
-      await this.moduleAccessRepository.updateModuleAccess(moduleAccessData);
-
-    if (result) {
-      return { success: true, msg: 'Module access updated successfully' };
-    } else {
-      return { success: false, msg: 'Failed to update module access' };
-    }
-  }
-
-  // src/module/module-access/service/module-access.service.ts
-
-  async getModuleUIConfig(moduleCode: string, roleIds: number[]) {
-    return this.moduleAccessRepository.getModuleUIConfig(moduleCode, roleIds);
-  }
-
-  async getUserPermissions({
-                             userId,
-                             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(
-      userId,
-      appcode,
-      level_type,
-      level_id,
-    );
-
-    if (!roleCodes || roleCodes.length === 0) {
-      return [];
-    }
-
-    const roleIds = roleCodes.map(Number);
-
-    // 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 schoolRepo = this.reflectionHelper.getRepoService('SSOSchool');
-
-      const school = await schoolRepo.findOne({
-        where: {
-          id: level_id,
-        },
-      });
-
-      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');
-      }
-    }
-
-    // Step 4: Return all permissions normally
-    return allPermissions;
-  }
-}
+import { BadRequestException, Inject, 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 { 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';
+
+@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,
+  ) {
+  }
+
+  async getModules({ appcode, loggedInUser }: { appcode: string, loggedInUser: UserData }) {
+    return this.moduleAccessRepository.getModules({
+      appcode, loggedInUser,
+    });
+  }
+
+  async getRoles({
+                   appcode,
+                   level_type,
+                   level_id,
+                   include,
+                 }: {
+    appcode: string;
+    level_type?: string;
+    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)
+    if (!include) {
+      query.andWhere('(role.is_factory IS NULL OR role.is_factory != 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),
+      });
+    }
+
+    const roles = await query.getRawMany();
+
+    return roles.map((role) => ({
+      label: role.name,
+      value: role.id,
+    }));
+  }
+
+  async getAccessListing(
+    roleIds: number[],
+    appcode: string,
+    levelType: string,
+    level_id?: number,
+  ) {
+    return this.moduleAccessRepository.getAccessListing(
+      roleIds,
+      appcode,
+      levelType,
+      level_id,
+    );
+  }
+
+  async getMenuListing(
+    mainModIds: string[],
+    appcode: string,
+    levelType: string,
+  ): Promise<Record<string, any[]>> {
+    if (!appcode) {
+      throw new BadRequestException('Appcode is required');
+    }
+
+    return this.moduleAccessRepository.getAllModulesByLevel(
+      mainModIds,
+      appcode,
+      levelType,
+    );
+  }
+
+  async updateModuleAccess(
+    moduleAccessData: {
+      role_code: string;
+      module_code: string;
+      action_type: string;
+      access_flag: number;
+      appcode: string;
+      level_type: string;
+    }[],
+  ): Promise<{ success: boolean; msg: string }> {
+    if (!moduleAccessData || moduleAccessData.length === 0) {
+      return { success: false, msg: 'No data provided' };
+    }
+
+    const result =
+      await this.moduleAccessRepository.updateModuleAccess(moduleAccessData);
+
+    if (result) {
+      return { success: true, msg: 'Module access updated successfully' };
+    } else {
+      return { success: false, msg: 'Failed to update module access' };
+    }
+  }
+
+  // src/module/module-access/service/module-access.service.ts
+
+  async getModuleUIConfig(moduleCode: string, roleIds: number[]) {
+    return this.moduleAccessRepository.getModuleUIConfig(moduleCode, roleIds);
+  }
+
+  async getUserPermissions({
+                             userId,
+                             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(
+      userId,
+      appcode,
+      level_type,
+      level_id,
+    );
+
+    if (!roleCodes || roleCodes.length === 0) {
+      return [];
+    }
+
+    const roleIds = roleCodes.map(Number);
+
+    // 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 schoolRepo = this.reflectionHelper.getRepoService('SSOSchool');
+
+      const school = await schoolRepo.findOne({
+        where: {
+          id: level_id,
+        },
+      });
+
+      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');
+      }
+    }
+
+    // Step 4: Return all permissions normally
+    return allPermissions;
+  }
+}

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

@@ -1,58 +1,58 @@
-import {
-  Body,
-  Controller,
-  Get,
-  Post,
-  Query,
-  Req,
-  UseGuards,
-} from '@nestjs/common';
-import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
-import { NotificationsService } from '../service/notification.service';
-
-@Controller('notifications')
-export class NotificationsController {
-  constructor(private readonly notificationsService: NotificationsService) {}
-
-  // Store token from frontend
-  @Post('register-token')
-  async registerToken(@Body() body: { userId?: string; token: string }) {
-    // Optional: associate token with userId if provided
-    return this.notificationsService.saveToken(body.userId, body.token);
-  }
-
-  @Post('send')
-  async sendNotification(
-    @Body()
-    body: {
-      token: string;
-      title: string;
-      message: string;
-      data?: Record<string, any>;
-    },
-  ) {
-    return this.notificationsService.sendToDevice(
-      body.token,
-      body.title,
-      body.message,
-      body.data,
-    );
-  }
-
-  @Get('all')
-  @UseGuards(JwtAuthGuard)
-  async getNotifications(@Req() req: any, @Query() filterQuery: any) {
-    const loggedInUser = req.user.userData;
-    return this.notificationsService.getAllNotifications(
-      loggedInUser,
-      filterQuery,
-    );
-  }
-
-  @Post('mark-all-read')
-  @UseGuards(JwtAuthGuard)
-  async markAllAsRead(@Req() req: any) {
-    const loggedInUser = req.user.userData;
-    return this.notificationsService.markAllAsRead(loggedInUser);
-  }
-}
+import {
+  Body,
+  Controller,
+  Get,
+  Post,
+  Query,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+import { NotificationsService } from '../service/notification.service';
+
+@Controller('notifications')
+export class NotificationsController {
+  constructor(private readonly notificationsService: NotificationsService) {}
+
+  // Store token from frontend
+  @Post('register-token')
+  async registerToken(@Body() body: { userId?: string; token: string }) {
+    // Optional: associate token with userId if provided
+    return this.notificationsService.saveToken(body.userId, body.token);
+  }
+
+  @Post('send')
+  async sendNotification(
+    @Body()
+    body: {
+      token: string;
+      title: string;
+      message: string;
+      data?: Record<string, any>;
+    },
+  ) {
+    return this.notificationsService.sendToDevice(
+      body.token,
+      body.title,
+      body.message,
+      body.data,
+    );
+  }
+
+  @Get('all')
+  @UseGuards(JwtAuthGuard)
+  async getNotifications(@Req() req: any, @Query() filterQuery: any) {
+    const loggedInUser = req.user.userData;
+    return this.notificationsService.getAllNotifications(
+      loggedInUser,
+      filterQuery,
+    );
+  }
+
+  @Post('mark-all-read')
+  @UseGuards(JwtAuthGuard)
+  async markAllAsRead(@Req() req: any) {
+    const loggedInUser = req.user.userData;
+    return this.notificationsService.markAllAsRead(loggedInUser);
+  }
+}