rez_core 6.5.61 → 6.5.63

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

@@ -1,11 +1,12 @@
 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';
 import { OtpRepository } from '../repository/otp.repository';
 import { LoginService } from './../../user/service/login.service';
 import { EmailService } from './email.service';
+import { PreferenceService } from 'src/module/preference_master/preference.service';
 
 @Injectable()
 export class OtpService {
@@ -14,9 +15,11 @@ export class OtpService {
     private readonly idGen: ClockIDGenService,
     private configService: ConfigService,
     private readonly loginService: LoginService,
-    private readonly emailService: EmailService,
     private readonly dataSource: DataSource,
-  ) {}
+    // private readonly preferenceService: PreferenceService,
+    private readonly emailService: EmailService,
+  ) {
+  }
 
   VERIFY_OTP = this.configService.get('VERIFY_OTP') || 'true';
   DEFAULT_OTP = this.configService.get('DEFAULT_OTP') || '123456';
@@ -39,7 +42,7 @@ export class OtpService {
     otp.verified = 0;
     otp.expiration_date = new Date(Date.now() + expiresIn * 60 * 1000);
 
-    const userData = await this.dataSource
+    const userData: any = await this.dataSource
       .getRepository('sso_user')
       .findOne({ where: { email_id: identifier } });
 
@@ -48,7 +51,15 @@ export class OtpService {
       otp: otp.otp,
     };
 
-    await this.emailService.sendEmail(identifier, 'OTP Verification', data);
+    // TODO: Inject and use PreferenceService here
+    // const preference = await this.preferenceService.fetchPreferenceByType('OTP', true);
+
+    // if (preference) {
+    //   let otpBody = preference.filter((item) => item.key === 'OTP_BODY')[0].value;
+    //   otpBody = otpBody.replace('${otp}', otp.otp);
+    //   const otpSubject = preference.filter((item) => item.key === 'OTP_SUBJECT')[0].value;
+    //   this.emailService.sendEmailWithoutTemplate(userData.email_id, otpSubject, otpBody);
+    // }
 
     return await this.otpRepository.save(otp);
   }

package/src/module/preference_master/entity/preference.entity.ts

@@ -0,0 +1,25 @@
+import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn } from 'typeorm';
+
+@Entity('sso_preference_master')
+export class PreferenceData {
+    @PrimaryGeneratedColumn()
+    id: number;
+
+    @Column({ name: 'enterprise_id', type: 'int' })
+    enterpriseId: number;
+
+    @Column({ name: 'preference_type', type: 'varchar', length: 15 })
+    preferenceType: string;
+
+    @Column({ type: 'varchar', length: 255 })
+    key: string;
+
+    @Column({ type: 'text' })
+    value: string;
+
+    @CreateDateColumn({ name: 'created_date', type: 'timestamp' })
+    createdDate: Date;
+
+    @Column({ type: 'boolean', default: true })
+    status: boolean;
+}

package/src/module/preference_master/preference.service.ts

@@ -0,0 +1,27 @@
+// src/module/preference_master/preference.service.ts
+import { Injectable } from '@nestjs/common';
+import { PreferenceData } from './entity/preference.entity';
+import { PreferenceRepository } from './repo/preference.repository';
+
+@Injectable()
+export class PreferenceService {
+    constructor(
+        private readonly preferenceRepository: PreferenceRepository
+    ) { }
+
+    async fetchPreference(
+        entID: number,
+        key: string,
+        status: boolean,
+    ): Promise<PreferenceData | null> {
+        return await this.preferenceRepository.findByEntIdAndKeyAndStatus(
+            entID,
+            key,
+            status,
+        );
+    }
+
+    async fetchPreferenceByType(preferenceType: string, status: boolean) {
+        return await this.preferenceRepository.findByPreferenceType(preferenceType, status);
+    }
+}

package/src/module/preference_master/repo/preference.repository.ts

@@ -0,0 +1,36 @@
+// src/module/preference_master/preference.repository.ts
+import { Injectable } from '@nestjs/common';
+import { Repository } from 'typeorm';
+import { InjectRepository } from '@nestjs/typeorm';
+import { PreferenceData } from '../entity/preference.entity';
+
+@Injectable()
+export class PreferenceRepository {
+    constructor(
+        @InjectRepository(PreferenceData)
+        private preferenceRepository: Repository<PreferenceData>,
+    ) { }
+
+    async findByEntIdAndKeyAndStatus(
+        entID: number,
+        key: string,
+        status: boolean,
+    ): Promise<PreferenceData | null> {
+        return this.preferenceRepository.findOne({
+            where: {
+                enterpriseId: entID,
+                key,
+                status,
+            },
+        });
+    }
+
+    async findByPreferenceType(preferenceType: string, status: boolean) {
+        return this.preferenceRepository.find({
+            where: {
+                preferenceType,
+                status,
+            },
+        });
+    }
+}

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 '../../app_master/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/app_master/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/app_master/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,29 @@ export class RoleRepository {
     const existingRole = await query.getOne();
     return !!existingRole;
   }
+
+  async findById(id: number) {
+    return this.roleRepo.findOne({ where: { id } });
+  }
+
+  async findMaxIdRecord() {
+    return await this.roleRepo.findOne({
+      order: { id: 'DESC' },
+      where: {},
+      select: ['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);
+  }
 }

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

@@ -9,7 +9,7 @@ export class UserRoleMappingRepository {
   constructor(
     @InjectRepository(UserRoleMapping)
     private readonly userRoleMappingRepository: Repository<UserRoleMapping>,
-  ) {}
+  ) { }
 
   async save(
     userRoleMapping: UserRoleMapping,
@@ -123,4 +123,8 @@ export class UserRoleMappingRepository {
       },
     });
   }
+
+  async find(options: any): Promise<UserRoleMapping[]> {
+    return await this.userRoleMappingRepository.find(options);
+  }
 }

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

@@ -1,4 +1,3 @@
-import { OrganizationData } from './../../enterprise/entity/organization.entity';
 import { Repository } from 'typeorm';
 import { UserData } from '../entity/user.entity';
 import { Injectable } from '@nestjs/common';
@@ -8,34 +7,46 @@ import { InjectRepository } from '@nestjs/typeorm';
 export class UserRepository {
   constructor(
     @InjectRepository(UserData) private userRepository: Repository<UserData>,
-  ) {}
+  ) { }
 
   async findById(userId: number): Promise<UserData | null> {
     return this.userRepository.findOne({ where: { id: userId } });
   }
+
   async findByEmailId(
     email: string,
-    organization_id?: number,
+    enterprise_id?: number,
+    getLastApp?: boolean,
   ): Promise<UserData | null> {
     if (!email) return null;
 
     const where: any = { email_id: email };
-    if (organization_id !== undefined) {
-      where.organization_id = organization_id;
+
+    if (enterprise_id !== undefined) {
+      where.enterprise_id = enterprise_id;
     }
-    return this.userRepository.findOne({ where });
+
+    const options: any = { where };
+
+    if (getLastApp) {
+      options.relations = {
+        last_app: true,
+      };
+    }
+
+    return this.userRepository.findOne(options);
   }
 
   async findByMobile(
     mobile: string,
-    organization_id?: number,
+    enterprise_id?: number,
     appCode?: string,
   ): Promise<UserData | null> {
     if (!mobile) return null;
 
     const where: any = { mobile };
-    if (organization_id !== undefined) {
-      where.organization_id = organization_id;
+    if (enterprise_id !== undefined) {
+      where.enterprise_id = enterprise_id;
     }
     if (appCode !== undefined) {
       where.appcode = appCode;
@@ -47,4 +58,20 @@ export class UserRepository {
   async saveUser(user: UserData): Promise<UserData> {
     return this.userRepository.save(user);
   }
+
+  async updateUser(id: number, user: UserData) {
+    return await this.userRepository.update(id, user);
+  }
+
+  async find(options: any): Promise<UserData[]> {
+    return await this.userRepository.find(options);
+  }
+
+  async findMaxIdRecord() {
+    return await this.userRepository.findOne({
+      order: { id: 'DESC' },
+      select: ['id'],
+      where:{}
+    });
+  }
 }