rez_core 0.0.1

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

@@ -0,0 +1,35 @@
+import { Column, Entity } from 'typeorm';
+import { ENTITYTYPE_USER } from '../../../constant/global.constant';
+import { BaseEntity } from '../../meta/entity/base-entity.entity';
+
+@Entity({ name: 'cr_user' })
+export class UserData extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = ENTITYTYPE_USER;
+  }
+
+  @Column({ type: 'varchar', length: 50, nullable: true })
+  first_name: string;
+
+  @Column({ type: 'varchar', length: 50, nullable: true })
+  last_name: string;
+
+  @Column({ type: 'varchar', length: 200, nullable: true })
+  password: string;
+
+  @Column({ type: 'varchar', length: 200, nullable: true })
+  email_id: string;
+
+  @Column({ type: 'varchar', length: 50, nullable: true })
+  mobile: string;
+
+  @Column({ type: 'int', nullable: true })
+  is_firstlogin: number;
+
+  @Column({ type: 'int', width: 1, nullable: true })
+  is_defaultadmin: number;
+
+  @Column({ type: 'int', width: 1, nullable: true })
+  is_customer: number;
+}

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

@@ -0,0 +1,16 @@
+import { Injectable } from '@nestjs/common';
+import { Repository } from 'typeorm';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Role } from '../entity/role.entity';
+
+@Injectable()
+export class RoleRepository {
+  constructor(
+    @InjectRepository(Role)
+    private readonly roleRepo: Repository<Role>,
+  ) {}
+
+  async findByCode(code: string): Promise<Role | null> {
+    return this.roleRepo.findOne({ where: { code } });
+  }
+}

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

@@ -0,0 +1,44 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { UserRoleMapping } from '../entity/user-role-mapping.entity';
+import { Repository } from 'typeorm';
+
+@Injectable()
+export class UserRoleMappingRepository {
+  constructor(
+    @InjectRepository(UserRoleMapping)
+    private readonly userRoleMappingRepository: Repository<UserRoleMapping>,
+  ) {}
+
+  async save(
+    userRoleMapping: UserRoleMapping,
+  ): Promise<UserRoleMapping | null> {
+    return await this.userRoleMappingRepository.save(userRoleMapping);
+  }
+
+  async findByUserId(userId: number): Promise<UserRoleMapping[] | null> {
+    return await this.userRoleMappingRepository.find({
+      where: { user_id: userId },
+    });
+  }
+
+  async getDefaultForUser(userId: number): Promise<UserRoleMapping | null> {
+    return await this.userRoleMappingRepository.findOne({
+      where: { user_id: userId, is_default: 1 },
+    });
+  }
+
+  async findByUserIdAndRoleId(userId: number, roleId: number): Promise<UserRoleMapping|null> {
+    return await this.userRoleMappingRepository.findOne({
+      where: { user_id: userId, role_id: roleId },
+    });
+  }
+
+  async delete(userId: number, roleId: number){
+    await this.userRoleMappingRepository.delete({user_id: userId, role_id: roleId});
+  }
+
+  async deleteByUserId(userId: number) {
+    await this.userRoleMappingRepository.delete({ user_id: userId });
+  }
+}

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

@@ -0,0 +1,33 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { UserData } from '../entity/user.entity';
+import { Inject, Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+
+@Injectable()
+export class UserRepository {
+  constructor(
+    @InjectRepository(UserData) private userRepository: Repository<UserData>,
+  ) {}
+
+  async findByEmailId(email: string): Promise<UserData | null> {
+    if (email) {
+      return this.userRepository.findOne({ where: { email_id: email } });
+    }
+    return null;
+  }
+
+  async findById(userId: number): Promise<UserData | null> {
+    return this.userRepository.findOne({ where: { id: userId } });
+  }
+
+  async findByMobile(mobile: string): Promise<UserData | null> {
+    if (mobile) {
+      return this.userRepository.findOne({ where: { mobile: mobile } });
+    }
+    return null;
+  }
+
+  async saveUser(user: UserData): Promise<UserData> {
+    return this.userRepository.save(user);
+  }
+}

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

@@ -0,0 +1,33 @@
+import { Repository } from 'typeorm';
+import { UserSession } from '../entity/user-session.entity';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+
+@Injectable()
+export class UserSessionRepository {
+  constructor(
+    @InjectRepository(UserSession)
+    private userSessionRepo: Repository<UserSession>,
+  ) {}
+
+  async findBySessionKey(sessionKey: string): Promise<UserSession | null> {
+    return this.userSessionRepo.findOne({ where: { session_key: sessionKey } });
+  }
+
+  async findActiveSessionByUserId(userId: number): Promise<UserSession | null> {
+    return this.userSessionRepo.findOne({
+      where: { user_id: userId, is_session_loggedout: 0 },
+    });
+  }
+
+  async saveSession(session: UserSession): Promise<UserSession> {
+    return this.userSessionRepo.save(session);
+  }
+
+  async logoutSession(sessionKey: string): Promise<void> {
+    await this.userSessionRepo.update(
+      { session_key: sessionKey },
+      { is_session_loggedout: 1, logout_time: new Date() },
+    );
+  }
+}

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

@@ -0,0 +1,66 @@
+import { BadRequestException, Inject, Injectable } from '@nestjs/common';
+import { EncryptUtilService } from '../../../utils/service/encryptUtil.service';
+import { UserData } from '../entity/user.entity';
+import { UserSessionService } from './user-session.service';
+import { UserService } from './user.service';
+
+
+@Injectable()
+export class LoginService {
+  constructor(
+    @Inject('UserService') private readonly userService: UserService,
+    private userSessionService: UserSessionService,
+  ) {}
+  
+  masterKey: string = process.env.master_key || '';
+  masterIv: string = process.env.master_iv || '';
+  
+  async login(email: string, password: string) {
+    console.log(process.env.master_key)
+    const user = await this.userService.findByEmailId(email);
+    if (!user) throw new BadRequestException('Invalid email or password');
+
+    const encryptedPassword = EncryptUtilService.encryptGCM(
+      password,
+      this.masterKey,
+      this.masterIv,
+    );
+
+    if (encryptedPassword !== user.password) {
+      throw new BadRequestException('Invalid email or password');
+    }
+
+    return this.userSessionService.createSession(user);
+  }
+
+  async loginWithGoogle(email: string, name) {
+    let user = await this.userService.findByEmailId(email);
+
+    if (!user) {
+      // If user doesn't exist, create a new user record
+      user = new UserData();
+      user.email_id = email;
+      user.first_name = name.givenName;
+      user.last_name = name.familyName;
+
+      user.name = user.first_name + ' ' + user.last_name;
+      let savedUser = await this.userService.createEntity(user, null);
+
+      user = savedUser as UserData;
+    }
+
+    // Create session (Same as JWT login flow)
+    return this.userSessionService.createSession(user);
+  }
+
+  async logout(sessionKey: string) {
+    let userSession =
+      await this.userSessionService.findBySessionKey(sessionKey);
+    if (userSession) {
+      userSession.is_session_loggedout = 1;
+      userSession.logout_time = new Date();
+      await this.userSessionService.updateSession(userSession);
+      return { message: 'Logged out successfully' };
+    }
+  }
+}

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

@@ -0,0 +1,29 @@
+import { Injectable } from '@nestjs/common';
+import { EntityServiceImpl } from '../../meta/service/entity-service-impl.service';
+import { EntityMasterService } from '../../meta/service/entity-master.service';
+import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
+import { LoggingService } from '../../../utils/service/loggingUtil.service';
+import { BaseEntity } from '../../meta/entity/base-entity.entity';
+import { UserData } from '../entity/user.entity';
+import { Role } from '../entity/role.entity';
+
+@Injectable()
+export class RoleService extends EntityServiceImpl {
+  constructor(
+    entityMasterService: EntityMasterService,
+    reflectionHelper: ReflectionHelper,
+    loggingService: LoggingService,
+  ) {
+    super(entityMasterService, reflectionHelper, loggingService);
+  }
+
+  async createEntity(
+    entityData: BaseEntity,
+    loggedInUser: UserData | null,
+  ): Promise<BaseEntity> {
+    let role = entityData as Role;
+    return await super.createEntity(role, loggedInUser);
+  }
+
+
+}

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

@@ -0,0 +1,29 @@
+import { Injectable } from '@nestjs/common';
+import { UserRoleMappingRepository } from '../repository/user-role-mapping.repository';
+import { UserRoleMapping } from '../entity/user-role-mapping.entity';
+
+@Injectable()
+export class UserRoleMappingService {
+  constructor(
+    private readonly userRoleMappingRepository: UserRoleMappingRepository,
+  ) {}
+
+  async assignUserRole(userRoleMapping: UserRoleMapping) {
+    const existing = await this.userRoleMappingRepository.findByUserIdAndRoleId(
+      userRoleMapping.user_id,
+      userRoleMapping.role_id,
+    );
+
+    if (!existing) {
+      return await this.userRoleMappingRepository.save(userRoleMapping);
+    }
+  }
+
+  async findByUserId(userId: number): Promise<UserRoleMapping[] | null> {
+    return await this.userRoleMappingRepository.findByUserId(userId);
+  }
+
+  async deleteByUserId(userId: number){
+    await this.userRoleMappingRepository.deleteByUserId(userId);
+  }
+}

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

@@ -0,0 +1,41 @@
+import { UserSession } from '../entity/user-session.entity';
+import { ClockIDGenService } from '../../../utils/service/clockIDGenUtil.service';
+import { Injectable } from '@nestjs/common';
+import { UserSessionRepository } from '../repository/userSession.repository';
+import { JwtAuthService } from '../../../module/auth/services/jwt.service';
+
+@Injectable()
+export class UserSessionService {
+  constructor(
+    private readonly userSessionRepository: UserSessionRepository,
+    private readonly jwtAuthService: JwtAuthService,
+  ) {}
+  async createSession(user) {
+    const sessionToken = ClockIDGenService.idGenerator('SES');
+
+    const userSession: any = new UserSession();
+    userSession.user_id = user.id;
+    userSession.session_key = sessionToken;
+    userSession.is_session_loggedout = 0;
+    userSession.login_time = new Date();
+    userSession.expiry_date = new Date(Date.now() + 60 * 60 * 1000); // 1-hour expiry
+
+    await this.userSessionRepository.saveSession(userSession);
+
+    const payload = { userId: user.id, sessionToken };
+    const accessToken = this.jwtAuthService.generateJwt(payload);
+
+    userSession.access_token = accessToken;
+    await this.userSessionRepository.saveSession(userSession);
+
+    return { accessToken };
+  }
+
+  async findBySessionKey(sessionKey: string): Promise<UserSession | null> {
+    return await this.userSessionRepository.findBySessionKey(sessionKey);
+  }
+
+  async updateSession(userSession: UserSession) {
+    await this.userSessionRepository.saveSession(userSession);
+  }
+}

package/src/module/user/service/user.service.ts

@@ -0,0 +1,141 @@
+import { BadRequestException, Injectable } from '@nestjs/common';
+import { EntityServiceImpl } from '../../meta/service/entity-service-impl.service';
+import { EntityMasterService } from '../../meta/service/entity-master.service';
+import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
+import { LoggingService } from '../../../utils/service/loggingUtil.service';
+import { UserData } from '../entity/user.entity';
+import { BaseEntity } from '../../meta/entity/base-entity.entity';
+import { UserRepository } from '../repository/user.repository';
+import { StatusType } from '../../../constant/status.constant';
+import { EncryptUtilService } from '../../../utils/service/encryptUtil.service';
+import { ClockIDGenService } from '../../../utils/service/clockIDGenUtil.service';
+import {
+  ENTITYTYPE_ROLE,
+  masterIv,
+  masterKey,
+} from '../../../constant/global.constant';
+import { CreateUserDto } from '../dto/create-user.dto';
+import { UserRoleMappingService } from './user-role-mapping.service';
+import { UserRoleMapping } from '../entity/user-role-mapping.entity';
+import {plainToInstance} from "class-transformer";
+
+@Injectable()
+export class UserService extends EntityServiceImpl {
+  constructor(
+    entityMasterService: EntityMasterService,
+    reflectionHelper: ReflectionHelper,
+    loggingService: LoggingService,
+    private userRepository: UserRepository,
+    private userRoleMappingService: UserRoleMappingService,
+  ) {
+    super(entityMasterService, reflectionHelper, loggingService);
+  }
+
+  async createEntity(
+    entityData: BaseEntity,
+    loggedInUser: UserData | null,
+  ): Promise<BaseEntity> {
+    let userData = entityData as CreateUserDto;
+    let existingUser = await this.userRepository.findByEmailId(
+      userData.email_id,
+    );
+    if (existingUser) {
+      throw new BadRequestException('User already exists');
+    }
+
+    existingUser = await this.userRepository.findByMobile(userData.mobile);
+    if (existingUser) {
+      throw new BadRequestException('User already exists');
+    }
+    userData.name =
+      userData.first_name + userData.last_name ? userData.last_name : '';
+    let password;
+    if (userData.password) {
+      password = EncryptUtilService.encryptGCM(
+        userData.password,
+        masterKey,
+        masterIv,
+      );
+    } else {
+      password = EncryptUtilService.encryptGCM(
+        ClockIDGenService.idGenerator(''),
+        masterKey,
+        masterIv,
+      );
+    }
+    userData.password = password;
+
+    let savedData = await super.createEntity(userData, loggedInUser);
+    if (userData.roles) {
+      let roles = userData.roles;
+      this.userRoleMappingService.deleteByUserId(userData.id);
+      for (const role in roles) {
+        let userRoleMapping = new UserRoleMapping(
+          savedData.id,
+          Number(roles[role]),
+        );
+        await this.userRoleMappingService.assignUserRole(userRoleMapping);
+      }
+    }
+
+    return savedData;
+  }
+
+  async getEntityData(
+    entityType: string,
+    id: number,
+  ): Promise<BaseEntity | null> {
+    const user = await this.userRepository.findById(id);
+    if (user) {
+      let userRoleMappings: UserRoleMapping[] | null =
+        await this.userRoleMappingService.findByUserId(id);
+      if (userRoleMappings) {
+        let userDto = user as unknown as CreateUserDto;
+        let roles: any[] = [];
+        for (let i in userRoleMappings) {
+          const userRoleMapping = userRoleMappings[i];
+          const roleId = userRoleMapping.role_id;
+          const role = await super.getEntityData(ENTITYTYPE_ROLE, roleId);
+          roles.push(role);
+        }
+        userDto.roles = roles;
+      }
+      return user;
+    }
+    return null;
+  }
+
+  async updateEntity(
+    entityData: BaseEntity,
+    loggedInUserData: UserData,
+  ): Promise<BaseEntity> {
+    let userDto = entityData as CreateUserDto;
+
+    if (userDto.password) {
+      const password = EncryptUtilService.encryptGCM(
+        userDto.password,
+        masterKey,
+        masterIv,
+      );
+      userDto.password = password;
+    }
+
+    let userData = plainToInstance(UserData, userDto, {excludeExtraneousValues: true});
+    let savedData = await super.updateEntity(userData, loggedInUserData);
+    if (userDto.roles) {
+      let roles = userDto.roles;
+      for (const role in roles) {
+        let userRoleMapping = new UserRoleMapping(
+            savedData.id,
+            Number(roles[role]),
+        );
+        await this.userRoleMappingService.assignUserRole(userRoleMapping);
+      }
+    }
+    return savedData;
+  }
+
+  async findByEmailId(email_id: string): Promise<UserData | null> {
+    return await this.userRepository.findByEmailId(email_id);
+  }
+}

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

@@ -0,0 +1,51 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { UserData } from './entity/user.entity';
+import { UserService } from './service/user.service';
+import { UtilsModule } from '../../utils/utils.module';
+import { EntityModule } from '../meta/entity.module';
+import { UserRepository } from './repository/user.repository';
+import { UserSessionService } from './service/user-session.service';
+import { UserSession } from './entity/user-session.entity';
+import { LoginController } from './controller/login.controller';
+import { LoginService } from './service/login.service';
+import { UserSessionRepository } from './repository/userSession.repository';
+import { JwtService } from '@nestjs/jwt';
+import { AuthModule } from '../auth/auth.module';
+import { UserController } from './controller/user.controller';
+import { Role } from './entity/role.entity';
+import { RoleService } from './service/role.service';
+import { UserRoleMapping } from './entity/user-role-mapping.entity';
+import { UserRoleMappingRepository } from './repository/user-role-mapping.repository';
+import { UserRoleMappingService } from './service/user-role-mapping.service';
+import { RoleRepository } from './repository/role.repository';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([UserData, UserSession, Role, UserRoleMapping]),
+    EntityModule,
+    UtilsModule,
+    AuthModule,
+  ],
+  providers: [
+    { provide: 'UserService', useClass: UserService },
+    { provide: 'RoleService', useClass: RoleService },
+    UserRepository,
+    UserSessionService,
+    LoginService,
+    UserSessionRepository,
+    JwtService,
+    UserRoleMappingRepository,
+    UserRoleMappingService,
+    RoleRepository
+  ],
+  exports: [
+    'UserService',
+    UserSessionService,
+    'RoleService',
+    UserRoleMappingService,
+    RoleRepository
+  ],
+  controllers: [LoginController, UserController],
+})
+export class UserModule {}

package/src/utils/service/base64util.service.ts

@@ -0,0 +1,19 @@
+export class Base64Util{
+    
+    static encode(byteArray: Uint8Array): string {
+        return Buffer.from(byteArray).toString('base64');
+    }
+
+    static decode(base64String: string): Uint8Array {
+        if (typeof Buffer !== 'undefined') {
+            return Uint8Array.from(Buffer.from(base64String, 'base64'));
+        }
+        
+        const binaryString = atob(base64String);
+        const byteArray = new Uint8Array(binaryString.length);
+        for (let i = 0; i < binaryString.length; i++) {
+            byteArray[i] = binaryString.charCodeAt(i);
+        }
+        return byteArray;
+    } 
+}

package/src/utils/service/clockIDGenUtil.service.ts

@@ -0,0 +1,21 @@
+import { Injectable } from "@nestjs/common";
+
+@Injectable()
+export class ClockIDGenService{
+
+    static _counter = 0n;
+    static timestampBits = 42;
+    static timestampMask = BigInt(Math.floor(Math.pow(2, ClockIDGenService.timestampBits)) - 1);
+    static counterBits = 10;
+    static counterMask = BigInt(Math.floor(Math.pow(2, ClockIDGenService.counterBits)) - 1);
+
+    static idGenerator(prefix?: string) {
+        const timestamp = BigInt(Date.now()) & this.timestampMask;
+        const counter = BigInt(this._counter++) & this.counterMask;
+        let now = timestamp << BigInt(this.counterBits)
+        now = now | counter;
+        const id = now.toString(36).toUpperCase();
+        return prefix + id;
+    }
+
+}

package/src/utils/service/dateUtil.service.ts

@@ -0,0 +1,17 @@
+import { Injectable } from "@nestjs/common";
+
+@Injectable()
+export class DateUtil {
+  static formatDate(date: Date, format: string): string {
+    const map: { [key: string]: string } = {
+        dd: String(date.getDate()).padStart(2, '0'),
+        MM: String(date.getMonth() + 1).padStart(2, '0'),
+        yyyy: String(date.getFullYear()),
+        HH: String(date.getHours()).padStart(2, '0'),
+        mm: String(date.getMinutes()).padStart(2, '0'),
+        ss: String(date.getSeconds()).padStart(2, '0')
+    };
+
+    return format.replace(/dd|MM|yyyy|HH|mm|ss/g, (matched) => map[matched]);
+  }
+}

package/src/utils/service/encryptUtil.service.ts

@@ -0,0 +1,97 @@
+import { Injectable, InternalServerErrorException } from '@nestjs/common';
+import * as crypto from 'crypto';
+
+const CryptoJS = require('crypto-js');
+const encryptionType = 'aes-256-cbc';
+
+@Injectable()
+export class EncryptUtilService {
+  constructor() {}
+
+  static encryptGCM(data: any, Datakey: string, Dataiv: string) {
+    try {
+      const cipher = crypto.createCipheriv('aes-256-gcm', Datakey, Dataiv);
+      let encrypted = Buffer.concat([
+        cipher.update(data, 'utf8'),
+        cipher.final(),
+      ]);
+      const tag = cipher.getAuthTag();
+      return Buffer.concat([encrypted, tag]).toString('base64');
+    } catch (error) {
+      throw new InternalServerErrorException('Encryption process failed');
+    }
+  }
+
+  static decryptGCM(data: any, Datakey: any, Dataiv: any) {
+    try {
+      data = Buffer.from(data, 'base64');
+      const decipher = crypto.createDecipheriv('aes-256-gcm', Datakey, Dataiv);
+      const tag = data.slice(data.length - 16);
+      decipher.setAuthTag(tag);
+      data = data.slice(0, data.length - 16);
+      let decrypted = decipher.update(data, 'utf8') + decipher.final('utf8');
+      return decrypted;
+    } catch (error) {
+      throw new InternalServerErrorException('Encryption process failed');
+    }
+  }
+
+  static encryptCBC(data: any, Datakey: any, Dataiv: any) {
+    let encryptedRequest;
+    try {
+      let cipher = CryptoJS.AES.encrypt(data, Datakey, {
+        iv: Dataiv,
+        mode: CryptoJS.mode.CBC,
+      });
+      encryptedRequest = cipher.toString();
+    } catch (error) {
+      console.log(error);
+      throw new InternalServerErrorException('Encryption process failed');
+    }
+    return encryptedRequest;
+  }
+
+  static decryptCBC(data: any, Datakey: any, Dataiv: any) {
+    let decryptRequest;
+    try {
+      let cipher = CryptoJS.AES.decrypt(data, Datakey, {
+        iv: Dataiv,
+        mode: CryptoJS.mode.CBC,
+      });
+      decryptRequest = cipher.toString(CryptoJS.enc.Utf8);
+    } catch (error) {
+      throw new InternalServerErrorException('Encryption process failed');
+    }
+    return decryptRequest;
+  }
+
+  static encryptRequest(data: any, Datakey: any, Dataiv: any, type?: any) {
+    try {
+      switch (type) {
+        case 'GCM':
+          return this.encryptGCM(data, Datakey, Dataiv);
+        case 'CBC':
+          return this.encryptCBC(data, Datakey, Dataiv);
+        default:
+          return this.encryptCBC(data, Datakey, Dataiv);
+      }
+    } catch (error) {
+      throw new InternalServerErrorException('Encryption process failed');
+    }
+  }
+
+  static decryptRequest(data: any, Datakey: any, Dataiv: any, type?: any) {
+    try {
+      switch (type) {
+        case 'GCM':
+          return this.decryptGCM(data, Datakey, Dataiv);
+        case 'CBC':
+          return this.decryptCBC(data, Datakey, Dataiv);
+        default:
+          return this.decryptCBC(data, Datakey, Dataiv);
+      }
+    } catch (error) {
+      throw new InternalServerErrorException('Encryption process failed');
+    }
+  }
+}