rez_core 1.0.10 → 1.0.12

package/src/module/meta/service/entity-table-column.service.ts

@@ -8,11 +8,24 @@ export class EntityTableColumnService {
   ) {}
 
   async getAttributeJson(parentId: number, parentType: string) {
-    let entityTableColumns = await this.entityTableColumnRepository.findByParentIdAndParentType(parentId, parentType);
+    let entityTableColumns =
+      await this.entityTableColumnRepository.findByParentIdAndParentType(
+        parentId,
+        parentType,
+      );
     let attributeJson = {};
     entityTableColumns.forEach((value) => {
       attributeJson[value.attribute_key] = value.data_type;
     });
     return attributeJson;
   }
+
+  async findByParentIdAndParentType(parentId: number, parentType: string) {
+    let entityTableColumns =
+      await this.entityTableColumnRepository.findByParentIdAndParentType(
+        parentId,
+        parentType,
+      );
+    return entityTableColumns;
+  }
 }

package/src/module/meta/service/entity-table.service.ts

@@ -6,6 +6,13 @@ export class EntityTableService {
   constructor(private entityTableRepository: EntityTableRepository) {}
 
   async findByEntityTypeAndListType(entityType: string, listType: string) {
-    return await this.entityTableRepository.findByEntityTypeAndListType(entityType, listType);
+    return await this.entityTableRepository.findByEntityTypeAndListType(
+      entityType,
+      listType,
+    );
+  }
+
+  async findByEntityTypeAndListTypeAndDisplayType(entityType: string, listType: string, displayType: string) {
+    return await this.entityTableRepository.findByEntityTypeAndListTypeAndDisplayType(entityType, listType, displayType);
   }
 }

package/src/module/meta/service/entity.service.ts

@@ -4,7 +4,11 @@ import { EntityListData } from '../dto/entity-list-data.dto';
 import { EntityManager } from 'typeorm';
 
 export interface EntityService<T extends BaseEntity> {
-  createEntity(entityData: T, loggedInUser: UserData, manager?: EntityManager): Promise<BaseEntity>;
+  createEntity(
+    entityData: T,
+    loggedInUser: UserData,
+    manager?: EntityManager,
+  ): Promise<BaseEntity>;
 
   getEntityData(
     entityType: string,
@@ -32,4 +36,11 @@ export interface EntityService<T extends BaseEntity> {
     pageNumber: number,
     pageSize: number,
   ): Promise<EntityListData>;
+
+  generateExcelReport(
+    entityType: string,
+    filterCriteria: Record<string, any>,
+    listEntityType: string,
+    displayType: string,
+  ): Promise<string | null>;
 }

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

@@ -1,26 +1,11 @@
 import { EntityServiceImpl } from './entity-service-impl.service';
 import { Injectable } from '@nestjs/common';
 import { PreferenceRepository } from '../repository/preference.repository';
-import { EntityMasterService } from './entity-master.service';
-import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
-import { LoggingService } from '../../../utils/service/loggingUtil.service';
-import { EntityListService } from './entity-list.service';
 
 @Injectable()
 export class PreferenceService extends EntityServiceImpl {
-  constructor(
-    entityMasterService: EntityMasterService,
-    reflectionHelper: ReflectionHelper,
-    loggingService: LoggingService,
-    entityListService: EntityListService,
-    private readonly preferenceRepository: PreferenceRepository,
-  ) {
-    super(
-      entityMasterService,
-      reflectionHelper,
-      entityListService,
-      loggingService,
-    );
+  constructor(private readonly preferenceRepository: PreferenceRepository) {
+    super();
   }
 
   async getPreferenceValue(preferenceKey: string): Promise<string | undefined> {

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

@@ -2,7 +2,7 @@ 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')
+@Controller('api/menu')
 export class MenuController {
   constructor(private readonly menuService: MenuService) {}
 

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

@@ -1,7 +1,7 @@
-import { Controller, Get, Post, Body, Query } from '@nestjs/common';
+import { Body, Controller, Get, Post, Query } from '@nestjs/common';
 import { ModuleAccessService } from '../service/module-access.service';
 
-@Controller('module-access')
+@Controller('api/module-access')
 export class ModuleAccessController {
   constructor(private readonly moduleAccessService: ModuleAccessService) {}
 

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

@@ -9,30 +9,30 @@ export class MenuData {
   @Column({ type: 'varchar', length: 100, nullable: true })
   name: string;
 
-  @Column({type: 'varchar', length: 100, nullable: true })
+  @Column({ type: 'varchar', length: 100, nullable: true })
   module_code: string;
 
-  @Column({type: 'varchar', length: 100, nullable: true })
+  @Column({ type: 'varchar', length: 100, nullable: true })
   status: StatusType;
 
-  @Column({type: 'varchar', length: 100, nullable: true })
+  @Column({ type: 'varchar', length: 100, nullable: true })
   wbs_code: string;
 
-  @Column({type: 'varchar', nullable: true })
+  @Column({ type: 'varchar', nullable: true })
   path: string;
 
-  @Column({type: 'varchar', length: 100, nullable: true })
+  @Column({ type: 'varchar', length: 100, nullable: true })
   icon: string;
 
-  @Column({type: 'varchar', length: 100, nullable: true })
+  @Column({ type: 'varchar', length: 100, nullable: true })
   module_level: string;
 
-  @Column({type: 'int', nullable: true})
+  @Column({ type: 'int', nullable: true })
   parent_id: number;
 
-  @Column({type: 'varchar', length: 100, nullable: true })
+  @Column({ type: 'varchar', length: 100, nullable: true })
   parent_code: string;
 
-  @Column({type: 'int', nullable: true})
+  @Column({ type: 'int', nullable: true })
   ui_visible: number;
 }

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

@@ -6,27 +6,27 @@ export class ModuleData {
   @PrimaryGeneratedColumn({ type: 'int' })
   id: number;
 
-  @Column({type: 'varchar', length: 100, nullable: true })
+  @Column({ type: 'varchar', length: 100, nullable: true })
   name: string;
 
-  @Column({type: 'varchar', length: 100, nullable: true })
+  @Column({ type: 'varchar', length: 100, nullable: true })
   module_code: string;
 
-  @Column({type: 'varchar', length: 100, nullable: true })
+  @Column({ type: 'varchar', length: 100, nullable: true })
   wbs_code: string;
 
-  @Column({type: 'varchar', length: 100, nullable: true })
+  @Column({ type: 'varchar', length: 100, nullable: true })
   status: StatusType;
 
-  @Column({type: 'varchar', length: 100, nullable: true })
+  @Column({ type: 'varchar', length: 100, nullable: true })
   module_level: string;
 
-  @Column({type: 'int', nullable: true })
+  @Column({ type: 'int', nullable: true })
   parent_id: number;
 
-  @Column({type: 'varchar', length: 100, nullable: true })
+  @Column({ type: 'varchar', length: 100, nullable: true })
   parent_code: string;
 
-  @Column({type: 'int', nullable: true})
+  @Column({ type: 'int', nullable: true })
   ui_visible: number;
 }

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

@@ -13,7 +13,6 @@ 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({
@@ -24,10 +23,10 @@ import { Role } from '../user/entity/role.entity';
       ModuleAction,
       MenuData,
       UserRoleMapping,
-      Role
+      Role,
     ]),
     UtilsModule,
-    UserModule
+    UserModule,
   ],
   controllers: [MenuController, ModuleAccessController],
   providers: [
@@ -35,7 +34,6 @@ import { Role } from '../user/entity/role.entity';
     MenuService,
     MenuRepository,
     ModuleAccessRepository,
-  
   ],
   exports: [ModuleAccessService],
 })

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,27 @@
+import { BadRequestException, Controller, HttpCode, HttpStatus, Post, Query } from '@nestjs/common';
+import { OtpService } from '../service/otp.service';
+
+@Controller('api/otp')
+export class OtpController{
+  otpExpiry = process.env.otp_expiry || '2';
+  otpLength = process.env.otp_length || '6';
+  constructor(private readonly otpService: OtpService) {
+  }
+
+  @Post('generate')
+  @HttpCode(HttpStatus.OK)
+  async generateOtp(@Query('identifier') identifier: string, @Query('service') service: string) {
+    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(@Query('otp') otp: string, @Query('otp_id') otpId: string) {
+    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,50 @@
+import { Injectable } from '@nestjs/common';
+import { OtpRepository } from '../repository/otp.repository';
+import { Otp } from '../entity/otp.entity';
+import { ClockIDGenService } from '../../../utils/service/clockIDGenUtil.service';
+
+@Injectable()
+export class OtpService {
+  constructor(
+    private readonly otpRepository: OtpRepository,
+    private readonly idGen: ClockIDGenService,
+  ) {
+  }
+
+  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 = this.generateOtp(otpLength);
+    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

@@ -13,7 +13,7 @@ import { GoogleAuthGuard } from '../../../module/auth/guards/google-auth.guard';
 import { JwtAuthGuard } from '../../auth/guards/jwt.guard';
 import { Request, Response } from 'express';
 
-@Controller('auth')
+@Controller('api/auth')
 export class LoginController {
   constructor(private loginService: LoginService) {}