rez_core 6.5.27 → 6.5.28

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(
@@ -130,21 +125,19 @@ export class ModuleAccessService {
 
   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 +152,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 +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,7 +15,6 @@ 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({
@@ -49,7 +48,6 @@ import { FirebaseAdminProvider } from './firebase-admin.config';
     AuthModule,
     UserModule,
     IcsMeetingModule,
-    EntityModule,
   ],
   providers: [
     OtpService,

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,

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/login.controller.ts

@@ -22,8 +22,7 @@ export class LoginController {
   constructor(
     private loginService: LoginService,
     private userSessionService: UserSessionService,
-    private configService: ConfigService,
-    private integrationService: IntegrationService,
+    private configService: ConfigService
   ) {}
 
   @Post('login')
@@ -86,12 +85,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,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,65 @@
-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: '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 +67,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;
 }

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

@@ -1,5 +1,9 @@
 import { ENTITYTYPE_USRROLMAP } from 'src/constant/global.constant';
-import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+import { EnterpriseData } from 'src/module/enterprise/entity/enterprise.entity';
+import { AppMaster } from 'src/module/meta/entity/app-master.entity';
+import { Column, Entity, JoinColumn, ManyToMany, ManyToOne, PrimaryGeneratedColumn } from 'typeorm';
+import { UserData } from './user.entity';
+import { Role } from './role.entity';
 
 @Entity({ name: 'sso_user_role_mapping' })
 export class UserRoleMapping {
@@ -15,21 +19,43 @@ export class UserRoleMapping {
   @Column({ type: 'varchar', nullable: true })
   entity_type: string;
 
-  @Column({ type: 'bigint', nullable: true })
+  @Column({type: 'bigint'})
   user_id: number;
 
-  @Column({ type: 'bigint', nullable: true })
+  @ManyToOne(() => UserData, {nullable: true, onDelete: 'SET NULL'})
+  @JoinColumn({ name: 'user_id', referencedColumnName: 'id' })
+  user: UserData;
+
+  @Column({type: 'bigint', nullable: true})
   role_id: number;
 
+  @ManyToOne(() => Role, {nullable: true, onDelete: 'SET NULL'})
+  @JoinColumn({ name: 'role_id', referencedColumnName: 'id' })
+  role: Role;
+
   @Column({ type: 'int', nullable: true })
   organization_id: number;
 
+  @Column({ name: 'enterprise_id', nullable: true })
+  enterprise_id: number;
+
+  @ManyToOne(() => EnterpriseData, {nullable: true, onDelete: 'SET NULL'})
+  @JoinColumn({ name: 'enterprise_id', referencedColumnName: 'id' })
+  enterpriseData: EnterpriseData;
+
   @Column({ type: 'int', nullable: true })
   is_default: number;
 
   @Column({ type: 'varchar', nullable: true })
   appcode: string;
 
+  @Column({ 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;
 

package/src/module/user/entity/user-session.entity.ts

@@ -1,4 +1,4 @@
-import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+import { Column, CreateDateColumn, Entity, PrimaryGeneratedColumn } from 'typeorm';
 
 @Entity({ name: 'sso_user_session' })
 export class UserSession {
@@ -12,16 +12,8 @@ export class UserSession {
   })
   is_session_loggedout: number;
 
-  @Column({
-    name: 'login_id',
-    nullable: true,
-    length: 50,
-  })
-  login_id: string;
-
-  @Column({
-    name: 'login_time',
-    nullable: true,
+  @CreateDateColumn({
+    name: 'login_time'
   })
   login_time: Date;
 
@@ -45,14 +37,6 @@ export class UserSession {
   })
   user_id: number;
 
-  @Column({
-    name: 'access_token',
-    nullable: true,
-    type: 'varchar',
-    length: 5000,
-  })
-  access_token: string;
-
   @Column({
     name: 'expiry_date',
     nullable: true,

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

@@ -1,13 +1,44 @@
-import { Column, Entity } from 'typeorm';
-import { ENTITYTYPE_USER } from '../../../constant/global.constant';
-import { BaseEntity } from '../../meta/entity/base-entity.entity';
+import { EnterpriseData } from 'src/module/enterprise/entity/enterprise.entity';
+import { AppMaster } from 'src/module/meta/entity/app-master.entity';
+import { Column, CreateDateColumn, Entity, JoinColumn, ManyToOne, PrimaryGeneratedColumn } from 'typeorm';
+import { Exclude } from 'class-transformer';
 
 @Entity({ name: 'sso_user' })
-export class UserData extends BaseEntity {
-  constructor() {
-    super();
-    this.entity_type = ENTITYTYPE_USER;
-  }
+export class UserData {
+
+  @PrimaryGeneratedColumn({ type: 'bigint' })
+  id: number;
+
+  @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;
+
+  @CreateDateColumn()
+  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: '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: 'varchar', length: 50, nullable: true })
   first_name: string;
@@ -39,14 +70,15 @@ export class UserData extends BaseEntity {
   @Column({ type: 'int', nullable: true })
   is_customer: number;
 
-  @Column({ type: 'int', nullable: true })
-  organization_id: number;
-
   @Column({ type: 'int', nullable: true })
   is_factory: number;
 
-  @Column({ type: 'varchar', nullable: true })
-  last_app_access: string;
+  @Column({ name: 'last_app_access_id', type: 'int', nullable: true })
+  last_app_access_id: number;
+
+  @ManyToOne(() => AppMaster)
+  @JoinColumn({ name: 'last_app_access_id' })
+  last_app: AppMaster;
 
   @Column({ type: 'varchar', nullable: true })
   last_level_type: string;
@@ -59,4 +91,7 @@ export class UserData extends BaseEntity {
 
   @Column({ type: 'varchar', nullable: true })
   profile_image: string;
+
+  @Exclude()
+  appcode: string;
 }

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

@@ -8,7 +8,7 @@ export class RoleRepository {
   constructor(
     @InjectRepository(Role)
     private readonly roleRepo: Repository<Role>,
-  ) {}
+  ) { }
 
   async findByCode(code: string): Promise<Role | null> {
     return this.roleRepo.findOne({ where: { code } });
@@ -16,7 +16,7 @@ export class RoleRepository {
 
   public async isRoleNameExists(
     name: string,
-    options?: { excludeRoleId?: number; organization_id?: number },
+    options?: { excludeRoleId?: number; enterprise_id?: number },
   ): Promise<boolean> {
     const query = this.roleRepo
       .createQueryBuilder('role')
@@ -28,9 +28,9 @@ export class RoleRepository {
       });
     }
 
-    if (options?.organization_id !== undefined) {
-      query.andWhere('role.organization_id = :organization_id', {
-        organization_id: options.organization_id,
+    if (options?.enterprise_id !== undefined) {
+      query.andWhere('role.enterprise_id = :enterprise_id', {
+        enterprise_id: options.enterprise_id,
       });
     }
 
@@ -53,11 +53,12 @@ export class RoleRepository {
    * Confirm level_type and level_id correspond to existing org/school.
     */
 
+
   public async isRoleNameWithLevelExists(
     name: string,
     options?: {
       excludeRoleId?: number;
-      organization_id?: number;
+      enterprise_id?: number;
       level_type?: string;
       level_id?: number;
     },
@@ -72,12 +73,6 @@ export class RoleRepository {
       });
     }
 
-    if (options?.organization_id !== undefined) {
-      query.andWhere('role.organization_id = :organization_id', {
-        organization_id: options.organization_id,
-      });
-    }
-
     if (options?.level_type) {
       query.andWhere('role.level_type = :level_type', {
         level_type: options.level_type,
@@ -93,4 +88,21 @@ export class RoleRepository {
     const existingRole = await query.getOne();
     return !!existingRole;
   }
+
+  async findById(id: number) {
+    return this.roleRepo.findOne({ where: { id } });
+  }
+
+  async saveRole(role: Role) {
+    let entity = this.roleRepo.create(role);
+    return await this.roleRepo.save(entity);
+  }
+
+  async updateRole(id: number, role: Role) {
+    return await this.roleRepo.update(id, role);
+  }
+
+  async findRoles(options: any): Promise<Role[]> {
+    return await this.roleRepo.find(options);
+  }
 }