rez_core 0.0.1

package/src/module/module/controller/menu.controller.ts

@@ -0,0 +1,15 @@
+import { Controller, Get, Request, UseGuards } from '@nestjs/common';
+import { MenuService } from '../service/menu.service';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+
+@Controller('menu')
+export class MenuController {
+  constructor(private readonly menuService: MenuService) {}
+
+  @UseGuards(JwtAuthGuard)
+  @Get()
+  async getMenu(@Request() req) {
+    const userId = req.user.userId;
+    return this.menuService.getUserMenu(userId);
+  }
+}

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

@@ -0,0 +1,20 @@
+import { Controller, Put, Body, Post, Get, Query } from '@nestjs/common';
+import { ModuleAccessService } from '../service/module-access.service';
+
+@Controller('module-access')
+export class ModuleAccessController {
+  constructor(private readonly moduleAccessService: ModuleAccessService) {}
+
+  @Post('update')
+  async updateModuleAccess(@Body() moduleAccessData: any[]) {
+    return this.moduleAccessService.updateModuleAccess(moduleAccessData);
+  }
+
+  @Get('list')
+  async getModuleAccess(
+    @Query('role_code') roleCode?: string,
+    @Query('mainmod') mainMod?: string
+  ) {
+    return this.moduleAccessService.getModuleAccess(roleCode, mainMod);
+  }
+}

package/src/module/module/entity/menu.entity.ts

@@ -0,0 +1,38 @@
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+import { StatusType } from '../../../constant/status.constant';
+
+@Entity({ name: 'cr_menu' })
+export class MenuData {
+  @PrimaryGeneratedColumn({ type: 'int' })
+  id: number;
+
+  @Column({ type: 'varchar', length: 100, nullable: true })
+  name: string;
+
+  @Column({type: 'varchar', length: 100, nullable: true })
+  module_code: string;
+
+  @Column({type: 'varchar', length: 100, nullable: true })
+  status: StatusType;
+
+  @Column({type: 'varchar', length: 100, nullable: true })
+  wbs_code: string;
+
+  @Column({type: 'varchar', nullable: true })
+  path: string;
+
+  @Column({type: 'varchar', length: 100, nullable: true })
+  icon: string;
+
+  @Column({type: 'varchar', length: 100, nullable: true })
+  module_level: string;
+
+  @Column({type: 'int', nullable: true})
+  parent_id: number;
+
+  @Column({type: 'varchar', length: 100, nullable: true })
+  parent_code: string;
+
+  @Column({type: 'int', nullable: true})
+  ui_visible: number;
+}

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

@@ -0,0 +1,22 @@
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity({ name: 'cr_module_access' })
+export class ModuleAccess {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({type: 'varchar', length: 100, nullable: true})
+  module_code: string;
+
+  @Column({type: 'varchar', length: 100, nullable: true })
+  role_code: string;
+
+  @Column({type: 'int', nullable: true })
+  access_flag: number;
+
+  @Column({type: 'varchar', length: 100, nullable: true })
+  action_type: string;
+
+  @Column({type: 'varchar', length: 100, nullable: true})
+  app_code: string;
+}

package/src/module/module/entity/module-action.entity.ts

@@ -0,0 +1,19 @@
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity({ name: 'module_action' })
+export class ModuleAction {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({type: 'int', nullable: true})
+  module_id: number;
+  
+  @Column({type: 'varchar', length: 100, nullable: true })
+  module_code: string;
+  
+  @Column({type: 'varchar', length: 100, nullable: true })
+  action_name:string
+
+  @Column({type: 'varchar', length: 50, nullable: true })
+  action_type: string;
+}

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

@@ -0,0 +1,29 @@
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+import { StatusType } from '../../../constant/status.constant';
+
+@Entity({ name: 'cr_module' })
+export class ModuleData {
+  @PrimaryGeneratedColumn({ type: 'int' })
+  id: number;
+
+  @Column({type: 'varchar', length: 100, nullable: true })
+  name: string;
+
+  @Column({type: 'varchar', length: 100, nullable: true })
+  module_code: string;
+
+  @Column({type: 'varchar', length: 100, nullable: true })
+  status: StatusType;
+
+  @Column({type: 'varchar', length: 100, nullable: true })
+  module_level: string;
+
+  @Column({type: 'int', nullable: true })
+  parent_id: number;
+
+  @Column({type: 'varchar', length: 100, nullable: true })
+  parent_code: string;
+
+  @Column({type: 'int', nullable: true})
+  ui_visible: number;
+}

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

@@ -0,0 +1,42 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { ModuleData } from './entity/module.entity';
+import { UtilsModule } from '../../utils/utils.module';
+import { ModuleAccess } from './entity/module-access.entity';
+import { ModuleAction } from './entity/module-action.entity';
+import { ModuleAccessService } from './service/module-access.service';
+import { MenuController } from './controller/menu.controller';
+import { MenuService } from './service/menu.service';
+import { MenuRepository } from './repository/menu.repository';
+import { MenuData } from './entity/menu.entity';
+import { ModuleAccessRepository } from './repository/module-access.repository';
+import { ModuleAccessController } from './controller/module-access.controller';
+import { UserRoleMapping } from '../user/entity/user-role-mapping.entity';
+import { UserModule } from '../user/user.module';
+import { RoleRepository } from '../user/repository/role.repository';
+import { Role } from '../user/entity/role.entity';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([
+      ModuleData,
+      ModuleAccess,
+      ModuleAction,
+      MenuData,
+      UserRoleMapping,
+      Role
+    ]),
+    UtilsModule,
+    UserModule
+  ],
+  controllers: [MenuController, ModuleAccessController],
+  providers: [
+    ModuleAccessService,
+    MenuService,
+    MenuRepository,
+    ModuleAccessRepository,
+  
+  ],
+  exports: [ModuleAccessService],
+})
+export class ModuleModule {}

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

@@ -0,0 +1,69 @@
+import { Injectable } from '@nestjs/common';
+import { DataSource, Repository } from 'typeorm';
+import { MenuData } from '../entity/menu.entity';
+import { ModuleAccess } from '../entity/module-access.entity';
+import { UserRoleMapping } from 'src/module/user/entity/user-role-mapping.entity';
+import { Role } from 'src/module/user/entity/role.entity';
+
+@Injectable()
+export class MenuRepository extends Repository<MenuData> {
+  constructor(private readonly dataSource: DataSource) {
+    super(MenuData, dataSource.createEntityManager());
+  }
+
+  /**
+   * Get all role IDs assigned to a user.
+   */
+  async getUserRoles(userId: number): Promise<number[]> {
+    const roles = await this.dataSource
+      .getRepository(UserRoleMapping)
+      .createQueryBuilder('userRoleMapping')
+      .select('userRoleMapping.role_id')
+      .where('userRoleMapping.user_id = :userId', { userId })
+      .getMany();
+
+    return roles.map(role => role.role_id);
+  }
+
+  /**
+   * Get module codes that the user has access to based on their role IDs.
+   */
+  async getAccessibleModules(roleIds: number[]): Promise<string[]> {
+    // Get role codes from role IDs
+    const roleCodes = await this.dataSource
+      .getRepository(Role)
+      .createQueryBuilder('role')
+      .select('role.code')
+      .where('role.id IN (:...roleIds)', { roleIds })
+      .getMany();
+  
+    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)
+      .createQueryBuilder('moduleAccess')
+      .select('moduleAccess.module_code')
+      .where('moduleAccess.role_code IN (:...codes)', { codes })
+      .andWhere('moduleAccess.access_flag > 0')
+      .getMany();
+  
+    return modules.map(module => module.module_code);
+  }
+  
+  
+
+  /**
+   * Get menu items based on accessible modules.
+   */
+  async getMenuItems(moduleCodes: string[]): Promise<MenuData[]> {
+    return this.createQueryBuilder('menu')
+      .where('menu.module_code IN (:...moduleCodes)', { moduleCodes })
+      .getMany();
+  }
+  
+}

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

@@ -0,0 +1,66 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository, In } from 'typeorm';
+import { ModuleAccess } from '../entity/module-access.entity';
+import { ModuleData } from '../entity/module.entity';
+import { Role } from 'src/module/user/entity/role.entity';
+
+@Injectable()
+export class ModuleAccessRepository {
+  constructor(
+    @InjectRepository(ModuleAccess)
+    private readonly moduleAccessRepo: Repository<ModuleAccess>,
+    @InjectRepository(Role)
+    private readonly roleRepo: Repository<Role>,
+    @InjectRepository(ModuleData)
+    private readonly moduleRepo: Repository<ModuleData>
+  ) {}
+
+  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 existingEntry = await this.moduleAccessRepo.findOne({
+          where: { role_code, module_code, action_type, app_code },
+        });
+
+        if (existingEntry) {
+          existingEntry.access_flag = access_flag;
+          await this.moduleAccessRepo.save(existingEntry);
+        } else {
+          await this.moduleAccessRepo.save({
+            role_code,
+            module_code,
+            action_type,
+            access_flag,
+            app_code,
+          });
+        }
+      }
+      return true;
+    } catch (error) {
+      console.error('Error updating module access:', error);
+      return false;
+    }
+  }
+
+  async getModuleAccess(roleCode?: string, moduleCode?: string) {
+    const roles = await this.roleRepo.find({ take: 5 }); // Fetch top 5 roles
+    const modules = await this.moduleRepo.find(); // Fetch all modules
+
+    let filteredRoles = roles;
+    if (roleCode) {
+      const roleCodes = roleCode.split(',');
+      filteredRoles = filteredRoles.filter((role) => roleCodes.includes(role.code)); // Use correct property
+    }
+
+    let filteredModules = modules;
+    if (moduleCode) {
+      const moduleCodes = moduleCode.split(',');
+      filteredModules = filteredModules.filter((module) => moduleCodes.includes(module.module_code)); // Use correct property
+    }
+
+    return { roles: filteredRoles, modules: filteredModules };
+  }
+}

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

@@ -0,0 +1,61 @@
+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) {
+    // Step 1: Get the roles of the user
+    const roleCodes = await this.menuRepository.getUserRoles(userId);
+    if (!roleCodes.length) {
+      return { menu: [] }; // Return empty menu if user has no roles
+    }
+
+    // Step 2: Get the modules the user has access to
+    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);
+
+    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;
+  }
+  
+  
+}

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

@@ -0,0 +1,25 @@
+import { Injectable } from '@nestjs/common';
+import { ModuleAccessRepository } from '../repository/module-access.repository';
+
+@Injectable()
+export class ModuleAccessService {
+  constructor(private readonly moduleAccessRepository: ModuleAccessRepository) {}
+
+  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);
+
+    if (result) {
+      return { success: true, msg: 'Module access updated successfully' };
+    } else {
+      return { success: false, msg: 'Failed to update module access' };
+    }
+  }
+
+  async getModuleAccess(roleCode?: string, mainMod?: string) {
+    return this.moduleAccessRepository.getModuleAccess(roleCode, mainMod);
+  }
+}

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

@@ -0,0 +1,55 @@
+import {
+  Body,
+  Controller,
+  Get,
+  HttpStatus,
+  Post,
+  Req,
+  Res,
+  UseGuards,
+} from '@nestjs/common';
+import { LoginService } from '../service/login.service';
+import { GoogleAuthGuard } from '../../../module/auth/guards/google-auth.guard';
+import { JwtAuthGuard } from '../../auth/guards/jwt.guard';
+import { Request, Response } from 'express';
+
+@Controller('auth')
+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)
+  @Post('logout')
+  async logout(
+    @Req() request: Request & { user: any },
+    @Res() response: Response,
+  ) {
+    let requestUser: any = request.user;
+    response
+      .status(HttpStatus.OK)
+      .json(await this.loginService.logout(requestUser.sessionToken));
+  }
+
+  @Get('google')
+  @UseGuards(GoogleAuthGuard)
+  async googleLogin() {
+    // Passport automatically redirects to Google
+  }
+
+  // 2️⃣ Handles Google callback, validates user, creates session, and returns JWT
+  @Get('google/callback')
+  @UseGuards(GoogleAuthGuard)
+  async googleAuthRedirect(@Req() req) {
+    let { email, name } = req.user; // Extracted from Google Strategy
+
+    // Call LoginService to validate user, create session, and return JWT
+    return this.loginService.loginWithGoogle(email, name);
+  }
+}

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

@@ -0,0 +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);
+  }
+}

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

@@ -0,0 +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";
+
+export class CreateUserDto extends BaseEntity {
+    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 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-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;
+
+    @Expose()
+    roles: any[];
+}

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

@@ -0,0 +1,20 @@
+import { BaseEntity } from '../../meta/entity/base-entity.entity';
+import { ENTITYTYPE_ROLE } from '../../../constant/global.constant';
+import { Column, Entity } from 'typeorm';
+
+@Entity({ name: 'cr_role' })
+export class Role extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = ENTITYTYPE_ROLE;
+  }
+
+  @Column({ length: 50, type: 'varchar', nullable: true })
+  app_code: string;
+
+  @Column({ type: 'int', nullable: true })
+  is_system: number;
+
+  @Column({ type: 'varchar', length: 250 })
+  description: string;
+}

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

@@ -0,0 +1,21 @@
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity({ name: 'cr_user_role_mapping' })
+export class UserRoleMapping {
+  constructor(user_id: number, role_id: number) {
+    this.user_id = user_id;
+    this.role_id = role_id;
+  }
+
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ type: 'bigint', nullable: true })
+  user_id: number;
+
+  @Column({ type: 'bigint', nullable: true })
+  role_id: number;
+
+  @Column({ type: 'int', nullable: true })
+  is_default: number;
+}

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

@@ -0,0 +1,61 @@
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity({ name: 'cr_user_session' })
+export class UserSession {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({
+    name: 'is_session_loggedout',
+    nullable: true,
+    type: 'int',
+  })
+  is_session_loggedout: number;
+
+  @Column({
+    name: 'login_id',
+    nullable: true,
+    length: 50,
+  })
+  login_id: string;
+
+  @Column({
+    name: 'login_time',
+    nullable: true,
+  })
+  login_time: Date;
+
+  @Column({
+    name: 'logout_time',
+    nullable: true,
+  })
+  logout_time: Date;
+
+  @Column({
+    name: 'session_key',
+    nullable: true,
+    length: 100,
+  })
+  session_key: string;
+
+  @Column({
+    name: 'user_id',
+    nullable: true,
+    type: 'bigint',
+  })
+  user_id: number;
+
+  @Column({
+    name: 'access_token',
+    nullable: true,
+    type: 'varchar',
+    length: 5000,
+  })
+  access_token: string;
+
+  @Column({
+    name: 'expiry_date',
+    nullable: true,
+  })
+  expiry_date: Date;
+}