rez_core 6.5.2 → 6.5.5

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

@@ -25,11 +25,11 @@ export class ModuleAccessRepository {
   ) {}
 
   async getRoles({
-    appcode,
+    appId,
     level_type,
     level_id,
   }: {
-    appcode: string;
+    appId: number;
     level_type?: string;
     level_id?: number;
   }) {
@@ -37,7 +37,7 @@ export class ModuleAccessRepository {
       .createQueryBuilder()
       .select('*')
       .from('sso_role', 'role')
-      .where('role.appcode = :appcode', { appcode })
+      .where('role.app_id = :appId', { appId })
       .andWhere('(role.is_factory IS NULL OR role.is_factory != 1)');
 
     if (level_type) {
@@ -59,20 +59,20 @@ export class ModuleAccessRepository {
   }
 
   async getModules({
-    appcode,
+    app_id,
     loggedInUser,
   }: {
-    appcode: string;
+    app_id: any;
     loggedInUser: any;
   }) {
     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_id, level_type: 'SCH' },
       });
     } else {
       modules = await this.moduleRepo.find({
-        where: { module_level: 'MAINMOD', appcode },
+        where: { module_level: 'MAINMOD', app_id },
       });
     }
 
@@ -87,7 +87,7 @@ export class ModuleAccessRepository {
 
   async getAccessListing(
     roleIds: (number | string)[],
-    appcode: string,
+    appId: number,
     levelType: string,
     levelId?: number, // add levelId as input so we can fetch roles based on it
   ) {
@@ -96,7 +96,7 @@ export class ModuleAccessRepository {
     if (roleIds.length === 1 && roleIds[0] === -1) {
       // Internally call getRoles
       const fetchedRoles = await this.getRoles({
-        appcode,
+        appId,
         level_type: levelType,
         level_id: levelId,
       });
@@ -105,52 +105,51 @@ export class ModuleAccessRepository {
       roles = await this.roleRepo.find({
         where: {
           id: In(fetchedRoleIds),
-          appcode,
+          app_id: appId,
         },
       });
     } else {
       roles = await this.roleRepo.find({
         where: {
           id: In(roleIds.map((id) => Number(id))),
-          appcode,
+          app_id: appId,
         },
       });
     }
 
     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_id: appId,
+        level_type: levelType,
       },
     });
 
     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,
+          action_id: access.action_id,
           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,
         })),
     }));
   }
 
-  async getAllModulesByLevel(mainModIds: string[], appcode: string, levelType) {
+  async getAllModulesByLevel(mainModIds: string[], app_id: number, levelType) {
     const mainModules =
       mainModIds.length === 1 && mainModIds[0] === '-1'
         ? await this.moduleRepo.find({
-            where: { module_level: 'MAINMOD', appcode },
+          where: { module_level: 'MAINMOD', app_id },
           })
         : await this.moduleRepo.find({
-            where: { id: In(mainModIds), module_level: 'MAINMOD', appcode },
+            where: { id: In(mainModIds), module_level: 'MAINMOD', app_id },
           });
 
     if (!mainModules.length) return {};
@@ -165,7 +164,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 })
       .andWhere('module.module_code != :excludedCode', {
         excludedCode: 'all_organization_adm_org',
       })
@@ -175,10 +174,10 @@ 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
@@ -187,11 +186,11 @@ export class ModuleAccessRepository {
         if (!acc[action.module_code]) acc[action.module_code] = [];
 
         const actionItem = {
-          action: action.action_type,
+          action: action.action_code,
           name: action.action_name,
         };
 
-        if (action.action_type === 'VIEW') {
+        if (action.action_code === 'VIEW') {
           acc[action.module_code].unshift(actionItem); // ➕ Add VIEW at start
         } else {
           acc[action.module_code].push(actionItem); // ➕ Add others at end
@@ -219,7 +218,7 @@ export class ModuleAccessRepository {
           )
           .map((mod) => ({
             name: mod.name,
-            code: mod.module_code,
+            module_id: mod.id,
             permission: actionMap[mod.module_code] || [],
             submod: buildHierarchy(mod.wbs_code),
           }));
@@ -228,7 +227,7 @@ export class ModuleAccessRepository {
         .filter((mod) => mod.level_type === lvl)
         .map((mod) => ({
           name: mod.name,
-          code: mod.module_code,
+          module_id: mod.id,
           permission: actionMap[mod.module_code] || [],
           submod: buildHierarchy(mod.wbs_code),
         }));
@@ -242,11 +241,11 @@ export class ModuleAccessRepository {
 
   async updateModuleAccess(
     accessList: {
-      role_code: string;
-      module_code: string;
+      role_id: number;
+      module_id: number;
       action_type: string;
       access_flag: number;
-      appcode: string;
+      app_id: number;
       level_type: string;
     }[],
   ): Promise<boolean> {
@@ -254,10 +253,10 @@ 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_id: access.role_id,
+            module_id: access.module_id,
             action_type: access.action_type,
-            appcode: access.appcode,
+            app_id: access.app_id,
             level_type: access.level_type,
           },
         });
@@ -278,20 +277,17 @@ export class ModuleAccessRepository {
     }
   }
 
-  async getModuleUIConfig(moduleCode: string, roleIds: number[]) {
+  async getModuleUIConfig(moduleId: number, roleIds: number[]) {
     const module = await this.moduleRepo.findOne({
-      where: { module_code: moduleCode },
+      where: { id: moduleId },
     });
 
     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: moduleId,
+        role_id: In(roleIds),
         access_flag: 1,
       },
     });
@@ -301,16 +297,16 @@ 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) {
+
+  async getModuleAccessByRoles(roleIds: number[], app_id: number) {
     // Step 1: Get role codes from sso_role
     const roles = await this.roleRepo.find({
       where: {
         id: In(roleIds),
-        appcode,
+        app_id,
       },
       select: ['id', 'code'],
     });
@@ -329,7 +325,7 @@ export class ModuleAccessRepository {
         'access.appcode AS appcode',
       ])
       .where('access.role_code IN (:...roleCodes)', { roleCodes })
-      .andWhere('access.appcode = :appcode', { appcode })
+      .andWhere('access.app_id = :app_id', { app_id })
       .getRawMany();
 
     // Step 3: Format output

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

@@ -1,45 +1,43 @@
 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,
+    app_id: number,
     levelType: 'ORG' | 'SCH',
     levelId: number,
   ): Promise<{ menu: any[] }> {
     // Step 1: Resolve roles (with fallback logic inside)
     const roleCodes = await this.menuRepository.resolveUserRoles(
       userId,
-      appcode,
+      app_id,
       levelType,
       levelId,
     );
     if (!roleCodes.length) return { menu: [] };
 
     // Step 2: Get accessible modules
-    const moduleCodes = await this.menuRepository.getAccessibleModules(
+    const modules = await this.menuRepository.getAccessibleModules(
       roleCodes,
-      appcode,
+      app_id,
     );
-    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,
-      appcode,
+      modules,
+      app_id,
       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,16 +1,9 @@
-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 { STATUS_INACTIVE } from '../../../constant/global.constant';
+import { DataSource } 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()
@@ -19,25 +12,23 @@ export class ModuleAccessService {
     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 }) {
+  async getModules({ app_id, loggedInUser }: { app_id: number, loggedInUser: UserData }) {
     return this.moduleAccessRepository.getModules({
-      appcode, loggedInUser,
+      app_id, loggedInUser,
     });
   }
 
   async getRoles({
-                   appcode,
+                   appId,
                    level_type,
                    level_id,
                    include,
                  }: {
-    appcode: string;
+    appId: number;
     level_type?: string;
     level_id?: number;
     include?: boolean;
@@ -46,7 +37,7 @@ export class ModuleAccessService {
       .createQueryBuilder()
       .select('*')
       .from('sso_role', 'role')
-      .where('role.appcode = :appcode', { appcode });
+      .where('role.app_id = :appId', { appId });
 
     // Only add this condition if `include` is false (exclude factory roles)
     if (!include) {
@@ -70,13 +61,13 @@ export class ModuleAccessService {
 
   async getAccessListing(
     roleIds: number[],
-    appcode: string,
+    appId: number,
     levelType: string,
     level_id?: number,
   ) {
     return this.moduleAccessRepository.getAccessListing(
       roleIds,
-      appcode,
+      appId,
       levelType,
       level_id,
     );
@@ -84,27 +75,27 @@ export class ModuleAccessService {
 
   async getMenuListing(
     mainModIds: string[],
-    appcode: string,
+    appId: number,
     levelType: string,
   ): Promise<Record<string, any[]>> {
-    if (!appcode) {
-      throw new BadRequestException('Appcode is required');
+    if (!appId) {
+      throw new BadRequestException('AppId is required');
     }
 
     return this.moduleAccessRepository.getAllModulesByLevel(
       mainModIds,
-      appcode,
+      appId,
       levelType,
     );
   }
 
   async updateModuleAccess(
     moduleAccessData: {
-      role_code: string;
-      module_code: string;
+      role_id: number;
+      module_id: number;
       action_type: string;
       access_flag: number;
-      appcode: string;
+      app_id: number;
       level_type: string;
     }[],
   ): Promise<{ success: boolean; msg: string }> {
@@ -124,27 +115,25 @@ export class ModuleAccessService {
 
   // src/module/module-access/service/module-access.service.ts
 
-  async getModuleUIConfig(moduleCode: string, roleIds: number[]) {
-    return this.moduleAccessRepository.getModuleUIConfig(moduleCode, roleIds);
+  async getModuleUIConfig(moduleId: number, roleIds: number[]) {
+    return this.moduleAccessRepository.getModuleUIConfig(moduleId, roleIds);
   }
 
   async getUserPermissions({
                              userId,
-                             appcode,
+                             app_id,
                              level_type,
                              level_id,
-                             enterprise_id,
                            }: {
     userId: number;
-    appcode: string;
+    app_id: number;
     level_type: string;
     level_id: number;
-    enterprise_id: number;
   }) {
     // Step 1: Resolve roles
     const roleCodes = await this.menuRepository.resolveUserRoles(
       userId,
-      appcode,
+      app_id,
       level_type,
       level_id,
     );
@@ -159,7 +148,7 @@ export class ModuleAccessService {
     const allPermissions =
       await this.moduleAccessRepository.getModuleAccessByRoles(
         roleIds,
-        appcode,
+        app_id,
       );
 
     // Step 3: If level_type is SCH, check school status using raw query
@@ -172,12 +161,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 === STATUS_INACTIVE) {
         // Return only VIEW permissions
         return allPermissions.filter((perm) => perm.action === 'VIEW');
       }

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

@@ -1,5 +1,5 @@
 import { DataSource } from 'typeorm';
-import { BadRequestException, Injectable } from '@nestjs/common';
+import { Injectable } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { ClockIDGenService } from '../../../utils/service/clockIDGenUtil.service';
 import { Otp } from '../entity/otp.entity';
@@ -16,7 +16,8 @@ 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/user.controller.ts

@@ -18,15 +18,6 @@ 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) {

package/src/module/user/dto/create-user.dto.ts

@@ -2,12 +2,26 @@ import { IsNotEmpty, IsString, Matches } from 'class-validator';
 import { BaseEntity } from '../../meta/entity/base-entity.entity';
 import { ENTITYTYPE_USER } from '../../../constant/global.constant';
 import { Expose } from 'class-transformer';
+import { Column } from 'typeorm';
 
-export class CreateUserDto extends BaseEntity {
-  constructor() {
-    super();
-    this.entity_type = ENTITYTYPE_USER;
-  }
+export class CreateUserDto{
+
+  status: string;
+
+  code: string;
+
+  @Column({ name: 'enterprise_id', type: 'int', nullable: true })
+  @Expose()
+  enterprise_id: number | undefined;
+
+
+  @Column({ name: 'level_id', type: 'varchar', length: 100, nullable: true })
+  @Expose()
+  level_id: string;
+
+  @Column({ name: 'level_type', type: 'varchar', length: 100, nullable: true })
+  @Expose()
+  level_type: string;
 
   @IsString()
   @IsNotEmpty()
@@ -47,7 +61,6 @@ export class CreateUserDto extends BaseEntity {
   @Expose()
   mobile: string;
 
-  @Expose()
   roles: any[];
 
   is_firstlogin: number;

package/src/module/user/entity/role.entity.ts

@@ -1,14 +1,68 @@
-import { BaseEntity } from '../../meta/entity/base-entity.entity';
-import { ENTITYTYPE_ROLE } from '../../../constant/global.constant';
-import { Column, Entity } from 'typeorm';
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  JoinColumn,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
+} from 'typeorm';
 import { Exclude } from 'class-transformer';
+import { EnterpriseData } from '../../enterprise/entity/enterprise.entity';
+import { AppMaster } from '../../meta/entity/app-master.entity';
 
 @Entity({ name: 'sso_role' })
-export class Role extends BaseEntity {
-  constructor() {
-    super();
-    this.entity_type = ENTITYTYPE_ROLE;
-  }
+export class Role {
+
+  @PrimaryGeneratedColumn({ type: 'bigint' })
+  id: number;
+
+  @Column({ name: 'name', type: 'varchar', length: 100, nullable: true })
+  name: string;
+
+  @Column({ name: 'status', type: 'varchar', nullable: true, length: 100 })
+  status: string;
+
+  @Column({ name: 'code', type: 'varchar', length: 100, nullable: true })
+  code: string;
+
+  @Column({ name: 'created_by', type: 'bigint', nullable: true })
+  created_by: number;
+
+  @CreateDateColumn()
+  created_date: Date;
+
+  @Column({ name: 'modified_by', type: 'bigint', nullable: true })
+  modified_by: number;
+
+  @UpdateDateColumn()
+  modified_date: Date;
+
+  @Column({ name: 'enterprise_id', type: 'int', nullable: true })
+  enterprise_id: number;
+  
+  @ManyToOne(() => EnterpriseData, { nullable: true, onDelete: 'SET NULL' })
+  @JoinColumn({ name: 'enterprise_id', referencedColumnName: 'id' })
+  enterprise: EnterpriseData;
+
+  @Column({ name: 'organization_id', type: 'int', nullable: true })
+  organization_id: number;
+
+  @Column({ name: 'appcode', type: 'varchar', length: 100, nullable: true })
+  appcode: string;
+
+  @Column({ name: 'app_id', type: 'int', nullable: true })
+  app_id: number;
+
+  @ManyToOne(() => AppMaster, { nullable: true, onDelete: 'SET NULL' })
+  @JoinColumn({ name: 'app_id' , referencedColumnName: 'id' })
+  app: AppMaster;
+
+  @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({ type: 'int', nullable: true })
   is_system: number;
@@ -16,18 +70,10 @@ export class Role extends BaseEntity {
   @Column({ type: 'varchar', length: 250, nullable: true })
   description: string;
 
-  @Column({ type: 'int', nullable: true })
-  organization_id: number;
-
   @Exclude()
   copy_from_role_id: number;
 
   @Column({ type: 'int', nullable: true })
   is_factory: number;
 
-  @Column({ type: 'varchar', length: 250, nullable: true })
-  parent_type: string;
-
-  @Column({ type: 'int', nullable: true })
-  parent_id: number;
 }