rez_core 0.0.7 → 1.0.2-o

package/src/module/module/repository/menu.repository.ts

@@ -22,7 +22,7 @@ export class MenuRepository extends Repository<MenuData> {
       .where('userRoleMapping.user_id = :userId', { userId })
       .getMany();
 
-    return roles.map(role => role.role_id);
+    return roles.map((role) => role.role_id);
   }
 
   /**
@@ -36,13 +36,13 @@ export class MenuRepository extends Repository<MenuData> {
       .select('role.code')
       .where('role.id IN (:...roleIds)', { roleIds })
       .getMany();
-  
-    const codes = roleCodes.map(role => role.code);
-  
+
+    const codes = roleCodes.map((role) => role.code);
+
     if (codes.length === 0) {
       return [];
     }
-  
+
     // Get accessible modules using role codes
     const modules = await this.dataSource
       .getRepository(ModuleAccess)
@@ -51,11 +51,9 @@ export class MenuRepository extends Repository<MenuData> {
       .where('moduleAccess.role_code IN (:...codes)', { codes })
       .andWhere('moduleAccess.access_flag > 0')
       .getMany();
-  
-    return modules.map(module => module.module_code);
+
+    return modules.map((module) => module.module_code);
   }
-  
-  
 
   /**
    * Get menu items based on accessible modules.
@@ -65,5 +63,4 @@ export class MenuRepository extends Repository<MenuData> {
       .where('menu.module_code IN (:...moduleCodes)', { moduleCodes })
       .getMany();
   }
-  
 }

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

@@ -1,6 +1,6 @@
 import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { Repository, In } from 'typeorm';
+import { In, 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';
@@ -16,7 +16,7 @@ export class ModuleAccessRepository {
     @InjectRepository(ModuleAccess)
     private readonly moduleAccessRepo: Repository<ModuleAccess>,
     @InjectRepository(ModuleAction)
-    private readonly moduleActionRepo: Repository<ModuleAction>
+    private readonly moduleActionRepo: Repository<ModuleAction>,
   ) {}
 
   async getRoles() {
@@ -24,83 +24,98 @@ export class ModuleAccessRepository {
   }
 
   async getModules() {
-    return this.moduleRepo.find({ where: { module_level: 'MAINMOD' }});
+    return this.moduleRepo.find({ where: { module_level: 'MAINMOD' } });
   }
 
   async getAccessListing(roleIds: number[]) {
     // Fetch roles using role IDs
     const roles = await this.roleRepo.find({ where: { id: In(roleIds) } });
-  
+
     // Extract role codes from roles
-    const roleCodes = roles.map(role => role.code);
-  
+    const roleCodes = roles.map((role) => role.code);
+
     // Fetch module access using role codes
-    const moduleAccesses = await this.moduleAccessRepo.find({ where: { role_code: In(roleCodes) } });
-  
+    const moduleAccesses = await this.moduleAccessRepo.find({
+      where: { role_code: In(roleCodes) },
+    });
+
     // Map role data to include access permissions
-    return roles.map(role => ({
+    return roles.map((role) => ({
       role_code: role.code,
       name: role.name,
       permission: moduleAccesses
-        .filter(access => access.role_code === role.code)
-        .map(access => ({
+        .filter((access) => access.role_code === role.code)
+        .map((access) => ({
           action: access.action_type,
           access: access.access_flag,
-          code: access.module_code
-        }))
+          code: access.module_code,
+        })),
     }));
   }
-  
+
   async getMenuListing(mainModIds: string[]) {
     // Get MAINMOD modules using their IDs
-    const mainModules = await this.moduleRepo.find({ 
-        where: { id: In(mainModIds), module_level: 'MAINMOD' } 
+    const mainModules = await this.moduleRepo.find({
+      where: { id: In(mainModIds), module_level: 'MAINMOD' },
     });
 
     if (!mainModules.length) return [];
 
     // Extract WBS codes of the MAINMOD modules
-    const wbsCodes = mainModules.map(mod => mod.wbs_code);
+    const wbsCodes = mainModules.map((mod) => mod.wbs_code);
 
     // Fetch all related modules using `LIKE` for WBS structure
-    const modules = 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}%`]))
-        )
-        .getMany();
+    const modules = 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}%`])),
+      )
+      .getMany();
 
     // Fetch module actions
     const moduleActions = await this.moduleActionRepo.find();
 
     // Function to recursively build module hierarchy
     const buildHierarchy = (parentWbs: string) => {
-        return modules
-            .filter(mod => mod.wbs_code.startsWith(parentWbs) && mod.wbs_code !== parentWbs)
-            .map(mod => ({
-                name: mod.name,
-                code: mod.module_code,
-                permission: moduleActions
-                    .filter(action => action.module_code === mod.module_code)
-                    .map(action => ({ action: action.action_type, name: action.action_type })),
-                submod: buildHierarchy(mod.wbs_code)
-            }));
+      return modules
+        .filter(
+          (mod) =>
+            mod.wbs_code.startsWith(parentWbs) && mod.wbs_code !== parentWbs,
+        )
+        .map((mod) => ({
+          name: mod.name,
+          code: mod.module_code,
+          permission: moduleActions
+            .filter((action) => action.module_code === mod.module_code)
+            .map((action) => ({
+              action: action.action_type,
+              name: action.action_type,
+            })),
+          submod: buildHierarchy(mod.wbs_code),
+        }));
     };
 
     // Construct the final hierarchical response
-    return mainModules.map(mod => ({
-        name: mod.name,
-        code: mod.module_code,
-        permission: moduleActions
-            .filter(action => action.module_code === mod.module_code)
-            .map(action => ({ action: action.action_type, name: action.action_type })),
-        submod: buildHierarchy(mod.wbs_code)
+    return mainModules.map((mod) => ({
+      name: mod.name,
+      code: mod.module_code,
+      permission: moduleActions
+        .filter((action) => action.module_code === mod.module_code)
+        .map((action) => ({
+          action: action.action_type,
+          name: action.action_type,
+        })),
+      submod: buildHierarchy(mod.wbs_code),
     }));
-}
+  }
   async updateModuleAccess(moduleAccessData: any[]): Promise<boolean> {
     try {
       for (const access of moduleAccessData) {
-        const { role_code, module_code, action_type, access_flag, app_code } = access;
+        const { role_code, module_code, action_type, access_flag, app_code } =
+          access;
 
         const existingEntry = await this.moduleAccessRepo.findOne({
           where: { role_code, module_code, action_type, app_code },

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

@@ -17,14 +17,15 @@ export class MenuService {
     }
 
     // Step 2: Get the modules the user has access to
-    const moduleCodes = await this.menuRepository.getAccessibleModules(roleCodes);
+    const moduleCodes =
+      await this.menuRepository.getAccessibleModules(roleCodes);
     if (!moduleCodes.length) {
       return { menu: [] }; // Return empty menu if no accessible modules
     }
 
     // Step 3: Get the menu items based on accessible modules
     const menuItems = await this.menuRepository.getMenuItems(moduleCodes);
-    
+
     // Step 4: Build hierarchical menu structure
     const menuTree = this.buildMenuHierarchy(menuItems);
 
@@ -37,25 +38,23 @@ export class MenuService {
   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 => {
+    menuItems.forEach((menu) => {
       menuMap.set(menu.wbs_code, { ...menu, submenu: [] });
     });
-  
+
     // Build the hierarchy based on WBS code
-    menuItems.forEach(menu => {
+    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;
   }
-  
-  
 }

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

@@ -3,7 +3,9 @@ import { ModuleAccessRepository } from '../repository/module-access.repository';
 
 @Injectable()
 export class ModuleAccessService {
-  constructor(private readonly moduleAccessRepository: ModuleAccessRepository) {}
+  constructor(
+    private readonly moduleAccessRepository: ModuleAccessRepository,
+  ) {}
 
   async getRoles() {
     return this.moduleAccessRepository.getRoles();
@@ -21,12 +23,15 @@ export class ModuleAccessService {
     return this.moduleAccessRepository.getMenuListing(mainModIds);
   }
 
-  async updateModuleAccess(moduleAccessData: any[]): Promise<{ success: boolean; msg: string }> {
+  async updateModuleAccess(
+    moduleAccessData: any[],
+  ): Promise<{ success: boolean; msg: string }> {
     if (!moduleAccessData || moduleAccessData.length === 0) {
       return { success: false, msg: 'No data provided' };
     }
 
-    const result = await this.moduleAccessRepository.updateModuleAccess(moduleAccessData);
+    const result =
+      await this.moduleAccessRepository.updateModuleAccess(moduleAccessData);
 
     if (result) {
       return { success: true, msg: 'Module access updated successfully' };

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

@@ -0,0 +1,41 @@
+import { BadRequestException, Body, Controller, HttpCode, HttpStatus, Post, Query } from '@nestjs/common';
+import { OtpService } from '../service/otp.service';
+import { ConfigService } from '@nestjs/config';
+
+@Controller('otp')
+export class OtpController{
+
+  constructor(private readonly otpService: OtpService,
+    private configService: ConfigService,
+  ) {
+  }
+  
+  otpExpiry = this.configService.get('OTP_EXPIRY')|| '2';
+  otpLength = this.configService.get('OTP_LENGTH')|| '6';
+
+  @Post('generate')
+  @HttpCode(HttpStatus.OK)
+  async generateOtp(@Body() request: any) {
+    let identifier = request.identifier;
+    let service = request.service;
+
+    if(!identifier || !service) {
+      throw new BadRequestException('Missing identifier or service!');
+    }
+    let otp = await this.otpService.generate(identifier, service, parseInt(this.otpExpiry), parseInt(this.otpLength));
+    return {'otp_id':otp.otp_id, 'success': true};
+  }
+
+  @Post('verify')
+  @HttpCode(HttpStatus.OK)
+  async verifyOtp(@Body() request: any) {
+    let otp = request.otp;
+    let otpId = request.otp_id;
+
+    let verify = await this.otpService.verifyOtp(otp, otpId);
+    if (!verify) {
+      throw new BadRequestException('Invalid OTP!');
+    }
+    return {'message': 'OTP verified successfully!', 'success': true};
+  }
+}

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

@@ -0,0 +1,28 @@
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity({ name: 'cr_otp' })
+export class Otp {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ name: 'otp_id', type: 'varchar', length: 50, nullable: true })
+  otp_id: string;
+
+  @Column({ name: 'service', type: 'varchar', length: 50, nullable: true })
+  service: string;
+
+  @Column({ name: 'otp', type: 'varchar', length: 50, nullable: true })
+  otp: string;
+
+  @Column({ name: 'identifier', type: 'varchar', nullable: true })
+  identifier: string;
+
+  @Column({ name: 'created_date', type: 'datetime', nullable: true })
+  created_date: Date;
+
+  @Column({name: 'expiration_date', type: 'datetime'})
+  expiration_date: Date;
+
+  @Column({name: 'verified', type: 'int', nullable: true})
+  verified: number;
+}

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

@@ -0,0 +1,14 @@
+import { Module } from '@nestjs/common';
+import { OtpService } from './service/otp.service';
+import { OtpRepository } from './repository/otp.repository';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { Otp } from './entity/otp.entity';
+import { OtpController } from './controller/otp.controller';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Otp])],
+  providers: [OtpService, OtpRepository],
+  exports: [OtpService],
+  controllers: [OtpController]
+})
+export class NotificationModule {}

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

@@ -0,0 +1,27 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Otp } from '../entity/otp.entity';
+import { Repository } from 'typeorm';
+
+@Injectable()
+export class OtpRepository {
+  constructor(
+    @InjectRepository(Otp) private readonly otpRepository: Repository<Otp>,
+  ) {}
+
+  async save(otp: Otp) {
+    return await this.otpRepository.save(otp);
+  }
+
+  async findByOtpId(otpId: string) {
+    return await this.otpRepository.findOne({
+      where: {
+        otp_id: otpId,
+      },
+    });
+  }
+
+  async update(id: number, otp: Otp){
+    return await this.otpRepository.update(id, otp);
+  }
+}

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

@@ -0,0 +1,56 @@
+import { Injectable } from '@nestjs/common';
+import { OtpRepository } from '../repository/otp.repository';
+import { Otp } from '../entity/otp.entity';
+import { ClockIDGenService } from '../../../utils/service/clockIDGenUtil.service';
+import { ConfigService } from '@nestjs/config';
+
+@Injectable()
+export class OtpService {
+  constructor(
+    private readonly otpRepository: OtpRepository,
+    private readonly idGen: ClockIDGenService,
+    private configService: ConfigService,
+  ) {
+  }
+  
+  VERIFY_OTP = this.configService.get('VERIFY_OTP') || 'true';
+  DEFAULT_OTP = this.configService.get('DEFAULT_OTP') || '123456';
+
+
+  async generate(identifier: string, service: string, expiresIn: number = 5, otpLength: number = 6) {
+    let otp = new Otp();
+    otp.created_date = new Date();
+    otp.otp_id = this.idGen.idGenerator();
+    otp.identifier = identifier;
+    otp.otp = 'true' === this.VERIFY_OTP ? this.generateOtp(otpLength) : this.DEFAULT_OTP;
+    otp.service = service;
+    otp.verified = 0;
+    otp.expiration_date = new Date(Date.now() + expiresIn * 60 * 1000);
+
+    return await this.otpRepository.save(otp);
+  }
+
+  async verifyOtp(otp: string, otpId: string) {
+    let otpEntity = await this.findByOtpId(otpId);
+    if (otpEntity) {
+      if (otpEntity.otp === otp && new Date(Date.now()) <= otpEntity.expiration_date && 0 === otpEntity.verified) {
+        otpEntity.verified = 1;
+        const updatedOtp = await this.otpRepository.update(otpEntity.id, otpEntity);
+        if (updatedOtp) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  async findByOtpId(otpId: string) {
+    return await this.otpRepository.findByOtpId(otpId);
+  }
+
+  private generateOtp(length: number): string {
+    const min = 10 ** (length - 1);
+    const max = 10 ** length - 1;
+    return Math.floor(min + Math.random() * (max - min + 1)).toString();
+  }
+}

package/src/module/user/controller/login.controller.ts

@@ -18,11 +18,12 @@ export class LoginController {
   constructor(private loginService: LoginService) {}
 
   @Post('login')
+  
   async login(@Body() body, @Res() res: Response) {
-    console.log("hey")
     return res
       .status(HttpStatus.OK)
       .json(await this.loginService.login(body.email_id, body.password));
+      
   }
 
   @UseGuards(JwtAuthGuard)

package/src/module/user/controller/user.controller.ts

@@ -1,28 +1,28 @@
-import {
-  Body,
-  Controller,
-  HttpStatus,
-  Inject,
-  Post,
-  Res,
-  ValidationPipe,
-} from '@nestjs/common';
-import { UserService } from '../service/user.service';
-import { CreateUserDto } from '../dto/create-user.dto';
-import { Response } from 'express';
-
-@Controller('user')
-export class UserController {
-  constructor(
-    @Inject('UserService') private readonly userService: UserService,
-  ) {}
-
-  @Post('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);
-  }
-}
+import {
+  Body,
+  Controller,
+  HttpStatus,
+  Inject,
+  Post,
+  Res,
+  ValidationPipe,
+} from '@nestjs/common';
+import { UserService } from '../service/user.service';
+import { CreateUserDto } from '../dto/create-user.dto';
+import { Response } from 'express';
+
+@Controller('user')
+export class UserController {
+  constructor(
+    @Inject('UserService') private readonly userService: UserService,
+  ) {}
+
+  @Post('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);
+  }
+}

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

@@ -1,52 +1,52 @@
-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 { 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';
 
 export class CreateUserDto extends BaseEntity {
-    constructor() {
-        super();
-        this.entity_type = ENTITYTYPE_USER;
-    }
+  constructor() {
+    super();
+    this.entity_type = ENTITYTYPE_USER;
+  }
 
-    @IsString()
-    @IsNotEmpty()
-    @Matches(/^[A-Za-z][A-Za-z]*$/, {message: 'enter valid first name'})
-    @Expose()
-    first_name: string;
+  @IsString()
+  @IsNotEmpty()
+  @Matches(/^[A-Za-z][A-Za-z]*$/, { message: 'enter valid first name' })
+  @Expose()
+  first_name: string;
 
-    @IsString()
-    @IsNotEmpty()
-    @Matches(/^[A-Za-z][A-Za-z]*$/, {message: 'enter valid last name'})
-    @Expose()
-    last_name: string;
+  @IsString()
+  @IsNotEmpty()
+  @Matches(/^[A-Za-z][A-Za-z]*$/, { message: 'enter valid last name' })
+  @Expose()
+  last_name: string;
 
-    @IsString()
-    @IsNotEmpty()
-    @Matches(
-        /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$/,
-        {message: 'enter valid email'},
-    )
-    email_id: string;
+  @IsString()
+  @IsNotEmpty()
+  @Matches(
+    /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$/,
+    { message: 'enter valid email' },
+  )
+  email_id: string;
 
-    @IsString()
-    @IsNotEmpty()
-    @Matches(
-        /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/,
-        {
-            message:
-                'Password must be at least 8 characters long, contain at least one uppercase letter, one lowercase letter, one digit, and one special character',
-        },
-    )
-    @Expose()
-    password: string;
+  @IsString()
+  @IsNotEmpty()
+  @Matches(
+    /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/,
+    {
+      message:
+        'Password must be at least 8 characters long, contain at least one uppercase letter, one lowercase letter, one digit, and one special character',
+    },
+  )
+  @Expose()
+  password: string;
 
-    @IsString()
-    @IsNotEmpty()
-    @Matches(/^[0-9]{10}$/, {message: 'enter valid contact number'})
-    @Expose()
-    mobile: string;
+  @IsString()
+  @IsNotEmpty()
+  @Matches(/^[0-9]{10}$/, { message: 'enter valid contact number' })
+  @Expose()
+  mobile: string;
 
-    @Expose()
-    roles: any[];
+  @Expose()
+  roles: any[];
 }

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

@@ -1,4 +1,4 @@
-import { PartialType } from '@nestjs/mapped-types';
-import { CreateUserDto } from './create-user.dto';
-
-export class UpdateUserDto extends PartialType(CreateUserDto) {}
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateUserDto } from './create-user.dto';
+
+export class UpdateUserDto extends PartialType(CreateUserDto) {}

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

@@ -15,6 +15,6 @@ export class Role extends BaseEntity {
   @Column({ type: 'int', nullable: true })
   is_system: number;
 
-  @Column({ type: 'varchar', length: 250 ,nullable:true})
+  @Column({ type: 'varchar', length: 250, nullable: true })
   description: string;
 }