rez_core 7.0.0 → 7.0.2

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

@@ -1,392 +0,0 @@
-import { BadRequestException, Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/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 reflectionHelper: ReflectionHelper,
-  ) {
-  }
-
-  async getRoles({
-    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
-    };
-
-    if (level_type) {
-      where.level_type = level_type;
-    }
-
-    if (level_id !== undefined) {
-      where.level_id = String(level_id);
-    }
-
-    const roles = await this.roleRepo.find({
-      where,
-      select: ['id', 'name'], // keep returned data same as your mapping
-    });
-
-    return roles.map((role) => ({
-      label: role.name,
-      value: role.id,
-    }));
-  }
-
-  async getModules({
-    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',
-        },
-      });
-    } else {
-      modules = await this.moduleRepo.find({
-        where: {
-          module_level: 'MAINMOD', app: {
-            code: appcode,
-          },
-        },
-      });
-    }
-
-    return modules
-      .map((mod) => ({
-        label: mod.name,
-        value: mod.id,
-        group: mod.level_type,
-      }))
-      .sort((a, b) => a.group.localeCompare(b.group));
-  }
-
-  async getAccessListing(
-    roleIds: (number | string)[],
-    appcode: string,
-    levelType: string,
-    levelId?: number, // add levelId as input so we can fetch roles based on it
-  ) {
-    let roles;
-
-    if (roleIds.length === 1 && roleIds[0] === -1) {
-      // Internally call getRoles
-      const fetchedRoles = await this.getRoles({
-        appcode,
-        level_type: levelType,
-        level_id: levelId,
-      });
-
-      const fetchedRoleIds = fetchedRoles.map((r) => r.value);
-      roles = await this.roleRepo.find({
-        where: {
-          id: In(fetchedRoleIds),
-          app: {
-            code: appcode,
-          },
-        },
-      });
-    } else {
-      roles = await this.roleRepo.find({
-        where: {
-          id: In(roleIds.map((id) => Number(id))),
-          app: {
-            code: appcode,
-          },
-        },
-      });
-    }
-
-    if (!roles.length) return [];
-
-    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,
-      },
-    });
-
-    return roles.map((role) => ({
-      role_id: role.id,
-      name: role.name,
-      permission: moduleAccesses
-        .filter((access) => access.role_id === role.id)
-        .map((access) => ({
-          action: access.action_type,
-          access: access.access_flag,
-          module_id: access.module_id,
-          level_type: access.level_type,
-          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', app_id: appMaster[0].id },
-        })
-        : await this.moduleRepo.find({
-          where: { id: In(mainModIds), module_level: 'MAINMOD', app: { code: appcode } },
-        });
-
-    if (!mainModules.length) return {};
-
-    const wbsCodes = mainModules.map((mod) => mod.wbs_code);
-
-    let allModules = await this.moduleRepo
-      .createQueryBuilder('module')
-      .where(
-        wbsCodes
-          .map((code) => `module.wbs_code LIKE :code${code}`)
-          .join(' OR '),
-        Object.fromEntries(wbsCodes.map((code) => [`code${code}`, `${code}%`])),
-      )
-      .andWhere('module.app_id = :app_id', { app_id: appMaster[0].id })
-      .andWhere('module.module_code != :excludedCode', {
-        excludedCode: 'all_organization_adm_org',
-      })
-      .getMany();
-
-    allModules = allModules.filter(
-      (mod) => mod.module_code != 'all_organization_adm_org',
-    );
-
-    const modules = allModules.map((m) => m.id);
-
-    const allActions = await this.moduleActionRepo.find({
-      where: {
-        module_id: In(modules),
-      }
-    })
-
-    // Map actions by module_code with VIEW action first
-    const actionMap = allActions.reduce(
-      (acc, action) => {
-        if (!acc[action?.module_id]) acc[action?.module_id] = [];
-        const actionItem = {
-          action: action.action_code,
-          name: action.action_name,
-        };
-        if (action.action_code === 'VIEW') {
-          acc[action?.module_id].unshift(actionItem); // ➕ Add VIEW at start
-        } else {
-          acc[action?.module_id].push(actionItem); // ➕ Add others at end
-        }
-        return acc;
-      },
-      {} as Record<string, { action: string; name: string }[]>,
-    );
-
-    const levelsToReturn = levelType === 'ORG' ? ['ORG', 'SCH'] : ['SCH'];
-
-    const groupedByLevel: Record<string, any[]> = {};
-
-    for (const lvl of levelsToReturn) {
-      const filteredModules = allModules.filter((m) => m.level_type === lvl);
-
-      const buildHierarchy = (parentWbs: string): any[] =>
-        filteredModules
-          .filter(
-            (mod) =>
-              mod.wbs_code.startsWith(`${parentWbs}.`) &&
-              mod.wbs_code.split('.').length ===
-              parentWbs.split('.').length + 1,
-          )
-          .map((mod) => ({
-            name: mod.name,
-            module_id: mod.id,
-            code: mod.module_code,
-            permission: actionMap[mod.id] || [],
-            submod: buildHierarchy(mod.wbs_code),
-          }));
-
-      const levelModules = mainModules
-        .filter((mod) => mod.level_type === lvl)
-        .map((mod) => ({
-          name: mod.name,
-          module_id: mod.id,
-          code: mod.module_code,
-          permission: actionMap[mod.id] || [],
-          submod: buildHierarchy(mod.wbs_code),
-        }));
-
-      if (levelModules.length) {
-        groupedByLevel[lvl] = levelModules;
-      }
-    }
-    return groupedByLevel;
-  }
-
-  async updateModuleAccess(
-    accessList: {
-      role_code: string;
-      module_code: string;
-      action_type: string;
-      access_flag: number;
-      appcode: string;
-      level_type: string;
-    }[],
-  ): Promise<boolean> {
-    try {
-      for (const access of accessList) {
-        const existing = await this.moduleAccessRepo.findOne({
-          where: {
-            role: {
-              code: access.role_code,
-            },
-            module: {
-              module_code: access.module_code,
-            },
-            action_type: access.action_type,
-            app: {
-              code: access.appcode,
-            },
-            level_type: access.level_type,
-          },
-        });
-
-        if (existing) {
-          existing.access_flag = access.access_flag;
-          await this.moduleAccessRepo.save(existing);
-        } else {
-          await this.moduleAccessRepo.save(
-            this.moduleAccessRepo.create(access),
-          );
-        }
-      }
-      return true;
-    } catch (error) {
-      console.error('Error updating module access:', error);
-      return false;
-    }
-  }
-
-  async getModuleUIConfig(moduleCode: string, roleIds: number[]) {
-    const module = await this.moduleRepo.findOne({
-      where: { module_code: moduleCode },
-    });
-
-    if (!module) throw new BadRequestException('Module not found');
-
-    const actions = await this.moduleAccessRepo.find({
-      where: {
-        module_id: module.id,
-        role_id: In(roleIds),
-        access_flag: 1,
-      },
-    });
-
-    const uniqueActions = [...new Set(actions.map((a) => a.action_type))];
-
-    return {
-      entity_type: module.entity_type,
-      title: module.title,
-      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),
-        app: {
-          code: appcode,
-        },
-      },
-      select: ['id', 'code'],
-    });
-
-    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_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.app_id = :app_id', { app_id: appMaster.id })
-      .getRawMany();
-
-    // Step 3: Format output
-    return accessRecords.map((record) => ({
-      action: record.action_type,
-      access: record.access_flag,
-      code: record.module_code,
-      level_type: record.level_type,
-      appcode: record.appcode,
-    }));
-  }
-}

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

@@ -1,80 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { MenuRepository } from '../repository/menu.repository';
-import { MenuData } from '../entity/menu.entity';
-
-@Injectable()
-export class MenuService {
-  constructor(
-    private readonly menuRepository: MenuRepository,
-  ) {
-  }
-
-  /**
-   * 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 modules = await this.menuRepository.getAccessibleModules(
-      roleCodes,
-      appcode,
-    );
-    if (!modules.length) return { menu: [] };
-
-    // Step 3: Get menu items for the given level type
-    const menuItems = await this.menuRepository.getMenuItems(
-      modules,
-      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, app_id: number): Promise<any> {
-    return this.menuRepository.getUserRoles(userId, app_id);
-  }
-}

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

@@ -1,177 +0,0 @@
-import { BadRequestException, Injectable } from '@nestjs/common';
-import { ModuleAccessRepository } from '../repository/module-access.repository';
-import { IsNull, Not, Or, Repository } from 'typeorm';
-import { UserData } from 'src/module/user/entity/user.entity';
-import { MenuRepository } from '../repository/menu.repository';
-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 reflectionHelper: ReflectionHelper,
-    @InjectRepository(Role)
-    private readonly roleRepo: Repository<Role>
-  ) {
-  }
-
-  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 where: any = {
-      app: {
-        code: appcode
-      }
-    };
-
-    if (!include) {
-      where.is_factory = Or(IsNull(), Not(1));
-    }
-
-    if (level_type && level_id) {
-      where.level_type = level_type;
-      where.level_id = String(level_id);
-    }
-
-    const roles = await this.roleRepo.find({
-      where,
-    });
-
-
-    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('App code 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,
-                           }: {
-    userId: number;
-    appcode: string;
-    level_type: string;
-    level_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,
-        },
-      });
-
-      if (!school || school.status === StatusConstant.INACTIVE) {
-        // Return only VIEW permissions
-        return allPermissions.filter((perm) => perm.action === 'VIEW');
-      }
-    }
-
-    // Step 4: Return all permissions normally
-    return allPermissions;
-  }
-}