rez_core 1.0.26 → 1.0.27

package/nest-cli.json

@@ -3,6 +3,12 @@
   "collection": "@nestjs/schematics",
   "sourceRoot": "src",
   "compilerOptions": {
+    "assets": [
+      {
+        "include": "../src/resources/*.yaml",
+        "outDir": "./dist/"
+      }
+    ],
     "deleteOutDir": true
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "1.0.26",
+  "version": "1.0.27",
   "description": "",
   "author": "",
   "private": false,

package/src/config/database.config.ts

@@ -1,17 +1,22 @@
 import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
 import { TypeOrmModuleOptions, TypeOrmOptionsFactory } from '@nestjs/typeorm';
 
 @Injectable()
 export class MySqlConfiguration implements TypeOrmOptionsFactory {
 
+  constructor(
+    private configService: ConfigService,
+  ){}
+
   createTypeOrmOptions(): TypeOrmModuleOptions {
     return {
       type: 'mysql',
-      host: process.env.DB_HOST || '13.234.25.234',
-      port: parseInt(process.env.DB_PORT || '3306', 10),
-      username: process.env.DB_USER || 'root',
-      password: process.env.DB_PASS || 'Rezolut@123',
-      database: process.env.DB_NAME || 'core',
+      host:  this.configService.get('DB_HOST')|| '13.234.25.234',
+      port: parseInt(this.configService.get('DB_PORT') || '3306', 10),
+      username: this.configService.get('DB_USER') || 'root',
+      password: this.configService.get('DB_PASS') || 'Rezolut@123',
+      database: this.configService.get('DB_NAME') || 'core',
       entities: [__dirname + '/../module/**/*.entity.{ts,js}'],
       synchronize: true,
       autoLoadEntities: true,

package/src/constant/global.constant.ts

@@ -4,7 +4,16 @@ export const ENTITYTYPE_ENTITYMASTER = 'EMS';
 export const ENTITYTYPE_ROLE = 'ROL';
 export const ENTITYTYPE_ENTITYTABLE = 'ETB';
 export const ENTITYTYPE_ENTITYTABLECOLUMN = 'ETC';
-export const ENTITYTYPE_PREFERENCEMASTER = 'PRM'
-export const masterKey: string = process.env.master_key || '';
-export const masterIv: string = process.env.master_iv || '';
-export const secretKey: string = process.env.secret_key || '';
+export const ENTITYTYPE_PREFERENCEMASTER = 'PRM';
+export const ENTITYTYPE_VIEWMASTER = 'VMS';
+export const ENTITYTYPE_MEDIA = 'MDA';
+
+export const STORAGETYPE_SINGLEJSON = 'singlejson';
+export const STORAGETYPE_COLUMN = 'column';
+
+// SECRET KEY
+export const secretKey: string = process.env.secret_key || '';
+
+// STATUS
+export const STATUS_ACTIVE = 'ACTIVE';
+export const STATUS_INACTIVE = 'INACTIVE';

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

@@ -5,6 +5,7 @@ import { TypeOrmModule } from '@nestjs/typeorm';
 import { JwtStrategy } from './strategies/jwt.strategy';
 import { JwtAuthService } from './services/jwt.service';
 import { JwtAuthGuard } from './guards/jwt.guard';
+import { secretKey } from '../../constant/global.constant';
 import { PassportModule } from '@nestjs/passport';
 import { UserSession } from '../user/entity/user-session.entity';
 import { GoogleStrategy } from './strategies/google.strategy';
@@ -15,10 +16,10 @@ import { RolesGuard } from './guards/role.guard';
     ConfigModule, // ✅ Ensure ConfigModule is imported
     PassportModule.register({ defaultStrategy: 'jwt' }),
     JwtModule.registerAsync({
-      imports: [ConfigModule], // ✅ Ensure ConfigModule is available
+      imports: [ConfigModule],
       inject: [ConfigService],
       useFactory: async (configService: ConfigService) => ({
-        secret: configService.get<string>('secret_key', 'defaultSecret'), // ✅ Use ConfigService
+        secret:  configService.get('SECRET_KEY'),
         signOptions: { expiresIn: '1800s' },
       }),
     }),

package/src/module/auth/guards/jwt.guard.ts

@@ -1,22 +1,22 @@
-import { ExecutionContext, Injectable } from '@nestjs/common';
-import { AuthGuard } from '@nestjs/passport';
-import { Reflector } from '@nestjs/core';
-import { Observable } from 'rxjs';
-
-@Injectable()
-export class JwtAuthGuard extends AuthGuard('jwt') {
-  constructor(private reflector: Reflector) {
-    super();
-  }
-
-  canActivate(
-    context: ExecutionContext,
-  ): Promise<boolean> | boolean | Observable<boolean> {
-    const isPublic = this.reflector.getAllAndOverride('isPublic', [
-      context.getHandler(),
-      context.getClass(),
-    ]);
-    if (isPublic) return true;
-    return super.canActivate(context);
-  }
-}
+import { ExecutionContext, Injectable } from '@nestjs/common';
+import { AuthGuard } from '@nestjs/passport';
+import { Reflector } from '@nestjs/core';
+import { Observable } from 'rxjs';
+
+@Injectable()
+export class JwtAuthGuard extends AuthGuard('jwt') {
+  constructor(private reflector: Reflector) {
+    super();
+  }
+
+  canActivate(
+    context: ExecutionContext,
+  ): Promise<boolean> | boolean | Observable<boolean> {
+    const isPublic = this.reflector.getAllAndOverride('isPublic', [
+      context.getHandler(),
+      context.getClass(),
+    ]);
+    if (isPublic) return true;
+    return super.canActivate(context);
+  }
+}

package/src/module/auth/guards/role.guard.ts

@@ -1,68 +1,68 @@
-import {
-  CanActivate,
-  ExecutionContext,
-  ForbiddenException,
-  Injectable,
-  UnauthorizedException,
-} from '@nestjs/common';
-import { Reflector } from '@nestjs/core';
-import { UserData } from '../../user/entity/user.entity';
-import { InjectEntityManager } from '@nestjs/typeorm';
-import { EntityManager } from 'typeorm';
-
-@Injectable()
-export class RolesGuard implements CanActivate {
-  constructor(
-    private reflector: Reflector,
-    @InjectEntityManager() private entityManager: EntityManager,
-  ) {}
-
-  async canActivate(context: ExecutionContext) {
-    const request = context
-      .switchToHttp()
-      .getRequest<Request & { user: any }>();
-    const object = request.user;
-
-    const users: UserData = await this.entityManager.query(
-      `SELECT * FROM cr_user WHERE id = ${object.userId} LIMIT 1`,
-    );
-
-    const user = users[0];
-    if (!user || !user['role_id']) {
-      throw new UnauthorizedException('User not authorized');
-    }
-
-    const requiredModule = this.reflector.get<string>(
-      'moduleCode',
-      context.getHandler(),
-    );
-    const requiredActions = this.reflector.get<string>(
-      'actions',
-      context.getHandler(),
-    );
-
-    const roleAccess = await this.entityManager.query(
-      `SELECT *
-             FROM cr_module_access
-             WHERE role_id = ${user['role_id']}
-               AND module_code = '${requiredModule}'`,
-    );
-
-    if (!roleAccess || roleAccess.length === 0) {
-      throw new ForbiddenException(
-        'Access denied: No permissions found for this module',
-      );
-    }
-
-    const hasAccess = roleAccess.some(
-      (access) =>
-        requiredActions.includes(access.action_type) &&
-        access.access_flag === 1,
-    );
-
-    if (!hasAccess) {
-      throw new ForbiddenException('Access denied: Insufficient permissions.');
-    }
-    return true;
-  }
-}
+import {
+  CanActivate,
+  ExecutionContext,
+  ForbiddenException,
+  Injectable,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { UserData } from '../../user/entity/user.entity';
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { EntityManager } from 'typeorm';
+
+@Injectable()
+export class RolesGuard implements CanActivate {
+  constructor(
+    private reflector: Reflector,
+    @InjectEntityManager() private entityManager: EntityManager,
+  ) {}
+
+  async canActivate(context: ExecutionContext) {
+    const request = context
+      .switchToHttp()
+      .getRequest<Request & { user: any }>();
+    const object = request.user;
+
+    const users: UserData = await this.entityManager.query(
+      `SELECT * FROM cr_user WHERE id = ${object.userId} LIMIT 1`,
+    );
+
+    const user = users[0];
+    if (!user || !user['role_id']) {
+      throw new UnauthorizedException('User not authorized');
+    }
+
+    const requiredModule = this.reflector.get<string>(
+      'moduleCode',
+      context.getHandler(),
+    );
+    const requiredActions = this.reflector.get<string>(
+      'actions',
+      context.getHandler(),
+    );
+
+    const roleAccess = await this.entityManager.query(
+      `SELECT *
+             FROM cr_module_access
+             WHERE role_id = ${user['role_id']}
+               AND module_code = '${requiredModule}'`,
+    );
+
+    if (!roleAccess || roleAccess.length === 0) {
+      throw new ForbiddenException(
+        'Access denied: No permissions found for this module',
+      );
+    }
+
+    const hasAccess = roleAccess.some(
+      (access) =>
+        requiredActions.includes(access.action_type) &&
+        access.access_flag === 1,
+    );
+
+    if (!hasAccess) {
+      throw new ForbiddenException('Access denied: Insufficient permissions.');
+    }
+    return true;
+  }
+}

package/src/module/auth/services/auth.service.ts

@@ -1,29 +1,29 @@
-import { BadRequestException, Injectable } from '@nestjs/common';
-import { UserService } from '../../user/service/user.service';
-import { JwtService } from '@nestjs/jwt';
-import { UserData } from '../../user/entity/user.entity';
-
-@Injectable()
-export class AuthService {
-  constructor(
-    private userService: UserService,
-    private jwtService: JwtService,
-  ) {}
-
-  async validateUser(email: string, password: string): Promise<UserData> {
-    const user = await this.userService.findByEmailId(email);
-    if (!user) {
-      throw new BadRequestException('User not found');
-    }
-    const isMatch: boolean = password === user.password;
-    if (!isMatch) {
-      throw new BadRequestException('Password does not match');
-    }
-    return user;
-  }
-
-  async login(user: UserData) {
-    const payload = { email: user.email_id, id: user.id };
-    return { access_token: this.jwtService.sign(payload) };
-  }
-}
+import { BadRequestException, Injectable } from '@nestjs/common';
+import { UserService } from '../../user/service/user.service';
+import { JwtService } from '@nestjs/jwt';
+import { UserData } from '../../user/entity/user.entity';
+
+@Injectable()
+export class AuthService {
+  constructor(
+    private userService: UserService,
+    private jwtService: JwtService,
+  ) {}
+
+  async validateUser(email: string, password: string): Promise<UserData> {
+    const user = await this.userService.findByEmailId(email);
+    if (!user) {
+      throw new BadRequestException('User not found');
+    }
+    const isMatch: boolean = password === user.password;
+    if (!isMatch) {
+      throw new BadRequestException('Password does not match');
+    }
+    return user;
+  }
+
+  async login(user: UserData) {
+    const payload = { email: user.email_id, id: user.id };
+    return { access_token: this.jwtService.sign(payload) };
+  }
+}

package/src/module/auth/services/jwt.service.ts

@@ -1,11 +1,11 @@
-import { Injectable } from '@nestjs/common';
-import { JwtService } from '@nestjs/jwt';
-
-@Injectable()
-export class JwtAuthService {
-  constructor(private readonly jwtService: JwtService) {}
-
-  generateJwt(payload: any): string {
-    return this.jwtService.sign(payload);
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+
+@Injectable()
+export class JwtAuthService {
+  constructor(private readonly jwtService: JwtService) {}
+
+  generateJwt(payload: any): string {
+    return this.jwtService.sign(payload);
+  }
+}

package/src/module/auth/strategies/google.strategy.ts

@@ -1,14 +1,17 @@
 import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
 import { PassportStrategy } from '@nestjs/passport';
 import { Strategy, VerifyCallback } from 'passport-google-oauth20';
 
 @Injectable()
 export class GoogleStrategy extends PassportStrategy(Strategy, 'google') {
-  constructor() {
+  constructor(
+    private configService: ConfigService,
+  ) {
     super({
-      clientID: process.env.clientID,
-      clientSecret: process.env.clientSecret,
-      callbackURL: process.env.callbackURL,
+      clientID: configService.get('CLIENT_ID'),
+      clientSecret: configService.get('CLIENT_SECRET'),
+      callbackURL:configService.get('CALLBACK_URL'),
       scope: ['email', 'profile'],
     });
   }

package/src/module/auth/strategies/jwt.strategy.ts

@@ -1,25 +1,24 @@
 import { ExtractJwt, Strategy } from 'passport-jwt';
 import { PassportStrategy } from '@nestjs/passport';
 import { Injectable, UnauthorizedException } from '@nestjs/common';
+import { secretKey } from '../../../constant/global.constant';
 import { InjectRepository } from '@nestjs/typeorm';
-import { ConfigService } from '@nestjs/config'; // ✅ Import ConfigService
-import { UserSession } from '../../../module/user/entity/user-session.entity';
+import { UserSession } from 'src/module/user/entity/user-session.entity';
 import { Repository } from 'typeorm';
+import { ConfigService } from '@nestjs/config';
 
 @Injectable()
 export class JwtStrategy extends PassportStrategy(Strategy) {
   constructor(
-    private readonly configService: ConfigService, // ✅ Inject ConfigService
     @InjectRepository(UserSession)
     private userSessionRepository: Repository<UserSession>,
+    private configService: ConfigService,
   ) {
     super({
       jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
       ignoreExpiration: false,
-      secretOrKey: configService.get<string>('secret_key'), // ✅ Use ConfigService
+      secretOrKey:configService.get('SECRET_KEY'),
     });
-
-    console.log('Loaded JWT Secret:', configService.get<string>('secret_key')); // Debugging
   }
 
   async validate(payload) {

package/src/module/auth/strategies/local.strategy.ts

@@ -1,13 +1,13 @@
-import { PassportStrategy } from '@nestjs/passport';
-import { AuthService } from '../services/auth.service';
-import { Injectable } from '@nestjs/common';
-import { Strategy } from 'passport-jwt';
-
-@Injectable()
-export class LocalStrategy extends PassportStrategy(Strategy) {
-  constructor(private authService: AuthService) {
-    super({
-      usernameField: 'email',
-    });
-  }
-}
+import { PassportStrategy } from '@nestjs/passport';
+import { AuthService } from '../services/auth.service';
+import { Injectable } from '@nestjs/common';
+import { Strategy } from 'passport-jwt';
+
+@Injectable()
+export class LocalStrategy extends PassportStrategy(Strategy) {
+  constructor(private authService: AuthService) {
+    super({
+      usernameField: 'email',
+    });
+  }
+}

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

@@ -1,12 +1,12 @@
-import { Module } from '@nestjs/common';
-import { EntityModule } from '../meta/entity.module';
-import { UserModule } from '../user/user.module';
-import { ModuleModule } from '../module/module.module';
-import { DevService } from './service/dev.service';
-
-@Module({
-  imports: [EntityModule, UserModule, ModuleModule],
-  controllers: [],
-  providers: [DevService],
-})
-export class DevModule {}
+import { Module } from '@nestjs/common';
+import { EntityModule } from '../meta/entity.module';
+import { UserModule } from '../user/user.module';
+import { ModuleModule } from '../module/module.module';
+import { DevService } from './service/dev.service';
+
+@Module({
+  imports: [EntityModule, UserModule, ModuleModule],
+  controllers: [],
+  providers: [DevService],
+})
+export class DevModule {}

package/src/module/dev/service/dev.service.ts

@@ -1,7 +1,7 @@
-import { Injectable } from '@nestjs/common';
-import { UserService } from '../../user/service/user.service';
-
-@Injectable()
-export class DevService {
-  constructor(private readonly userService: UserService) {}
-}
+import { Injectable } from '@nestjs/common';
+import { UserService } from '../../user/service/user.service';
+
+@Injectable()
+export class DevService {
+  constructor(private readonly userService: UserService) {}
+}

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

@@ -1,37 +1,37 @@
-import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
-
-@Entity({ name: 'cr_enterprise' })
-export class EnterpriseData {
-  @PrimaryGeneratedColumn({ name: 'id', type: 'bigint' })
-  id: number;
-
-  @Column({ name: 'entity_type', type: 'varchar', nullable: true, length: 50 })
-  entityType: string;
-
-  @Column({ name: 'code', type: 'varchar', nullable: true, length: 50 })
-  code: string;
-
-  @Column({ name: 'name', type: 'varchar', nullable: true, length: 50 })
-  name: string;
-
-  @Column({ name: 'status', type: 'varchar', nullable: true, length: 50 })
-  status: string;
-
-  @Column({ name: 'created_by', type: 'int', nullable: true })
-  createdBy: number;
-
-  @Column({ name: 'modified_by', type: 'int', nullable: true })
-  modifiedBy: number;
-
-  @Column({ name: 'created_date', type: 'datetime', nullable: true })
-  createdDate: Date;
-
-  @Column({ name: 'modified_date', type: 'datetime', nullable: true })
-  modifiedDate: Date;
-
-  @Column({ name: 'app_code', type: 'varchar', nullable: true, length: 50 })
-  appCode: string;
-
-  @Column({ name: 'app_url_name', type: 'varchar', nullable: true, length: 50 })
-  appUrlName: string;
-}
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity({ name: 'cr_enterprise' })
+export class EnterpriseData {
+  @PrimaryGeneratedColumn({ name: 'id', type: 'bigint' })
+  id: number;
+
+  @Column({ name: 'entity_type', type: 'varchar', nullable: true, length: 50 })
+  entityType: string;
+
+  @Column({ name: 'code', type: 'varchar', nullable: true, length: 50 })
+  code: string;
+
+  @Column({ name: 'name', type: 'varchar', nullable: true, length: 50 })
+  name: string;
+
+  @Column({ name: 'status', type: 'varchar', nullable: true, length: 50 })
+  status: string;
+
+  @Column({ name: 'created_by', type: 'int', nullable: true })
+  createdBy: number;
+
+  @Column({ name: 'modified_by', type: 'int', nullable: true })
+  modifiedBy: number;
+
+  @Column({ name: 'created_date', type: 'datetime', nullable: true })
+  createdDate: Date;
+
+  @Column({ name: 'modified_date', type: 'datetime', nullable: true })
+  modifiedDate: Date;
+
+  @Column({ name: 'app_code', type: 'varchar', nullable: true, length: 50 })
+  appCode: string;
+
+  @Column({ name: 'app_url_name', type: 'varchar', nullable: true, length: 50 })
+  appUrlName: string;
+}