rez_core 1.0.48 → 1.0.50

package/package.json

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

package/src/constant/global.constant.ts

@@ -11,6 +11,8 @@ export const ENTITYTYPE_LISTMASTER = 'LMS';
 export const ENTITYTYPE_LISTMASTERITEMS = 'LMI';
 export const ENTITYTYPE_SECTIONMASTER = 'SEC';
 export const ENTITYTYPE_FIELDMASTER = 'FLD';
+export const ENTITYTYPE_USRROLMAP = 'URM';
+
 
 export const STORAGETYPE_SINGLEJSON = 'singlejson';
 export const STORAGETYPE_COLUMN = 'column';

package/src/module/master/service/master.service.ts

@@ -48,6 +48,18 @@ export class MasterService {
   ];
 
   private readonly dataSequence = [
+    {
+      table: 'cr_user',
+      unique_fields: ['code'],
+    },
+    {
+      table: 'cr_role',
+      unique_fields: ['code'],
+    },
+    {
+      table: 'cr_user_role_mapping',
+      unique_fields: ['user_id', 'role_id'],
+    },
     {
       table: 'eth_school',
       unique_fields: ['code'],
@@ -127,6 +139,7 @@ export class MasterService {
           entityMasterData?.mapped_entity_type,
         );
 
+        console.log(attributes,"((((((((((((((((((((((((((")
       for (const row of sheetData) {
         if (row.parent_type !== undefined && row.parent_id !== undefined) {
           this.resolveParent(row);
@@ -134,6 +147,7 @@ export class MasterService {
 
         for (const attribute of attributes) {
           if (attribute.data_source_type === 'entity') {
+            console.log(attribute.data_source_type)
             let entityMaster = await this.entityMasterService.getEntityData(
               attribute.datasource_list,
             );

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

@@ -8,7 +8,8 @@ import {
   Post,
   Query,
   Res,
-  UseGuards,
+  Req,
+  UseGuards, Inject,
 } from '@nestjs/common';
 import { EntityServiceImpl } from '../service/entity-service-impl.service';
 import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
@@ -18,6 +19,9 @@ import { BaseEntity } from '../entity/base-entity.entity';
 import { JwtAuthGuard } from '../../auth/guards/jwt.guard';
 import * as fs from 'fs';
 import * as path from 'path';
+import { UserService } from '../../user/service/user.service';
+import { ENTITYTYPE_USER } from '../../../constant/global.constant';
+import { UserData } from '../../user/entity/user.entity';
 
 @UseGuards(JwtAuthGuard)
 @Controller('entity')
@@ -58,7 +62,11 @@ export class EntityController {
     @Body() entityData: BaseEntity,
     @Query('entity_type') entityType: string,
     @Res() res: Response,
+    @Req() req: Request & {user: any}
   ) {
+    let requestedUser = req.user;
+    let loggedInUser = await this.entityService.getEntityData(ENTITYTYPE_USER,requestedUser.id);
+
     if (!entityType) {
       throw new BadRequestException(
         'Query parameter "entity_type" is required',
@@ -75,7 +83,7 @@ export class EntityController {
     if (entityService) {
       return res
         .status(HttpStatus.OK)
-        .json(await entityService.createEntity(entityData, null));
+        .json(await entityService.createEntity(entityData, loggedInUser as UserData));
     }
   }
 
@@ -85,7 +93,10 @@ export class EntityController {
     @Body() entityData: BaseEntity,
     @Query('entity_type') entityType: string,
     @Res() response: Response,
+    @Req() req: Request & {user: any}
   ) {
+    let requestedUser = req.user;
+    let loggedInUser = await this.entityService.getEntityData(ENTITYTYPE_USER,requestedUser.id);
     if (!entityType) {
       throw new BadRequestException(
         'Query parameter "entity_type" is required',
@@ -106,7 +117,7 @@ export class EntityController {
       }
       // let mergeEntity = JsonUtil.merge(existingEntity, entityData);
 
-      entityData = await entityService.updateEntity(entityData, null);
+      entityData = await entityService.updateEntity(entityData, loggedInUser as UserData);
       return response.status(HttpStatus.OK).json(entityData);
     }
   }

package/src/module/meta/controller/media.controller.ts

@@ -53,9 +53,8 @@ export class MediaController {
   async getDownloadUrl(@Param('id') id: number, @Res() res: Response) {
     try {
       
-      const entityData = await this.mediaDataService.getEntityData(ENTITYTYPE_MEDIA, id);
-      let mediaData = entityData as MediaData;
-      const downloadUrl = await this.mediaDataService.getMediaDownloadUrl(mediaData.media_url);
+  
+      const downloadUrl = await this.mediaDataService.getMediaDownloadUrl(id);
       res.status(HttpStatus.OK).json({
         message: 'Download URL fetched successfully',
         success: true,

package/src/module/meta/service/media-data.service.ts

@@ -4,7 +4,7 @@ import { MediaDataRepository } from '../repository/media-data.repository';
 import { ConfigService } from '@nestjs/config';
 import { S3 } from 'aws-sdk';
 import { MediaData } from '../entity/media-data.entity';
-import { STATUS_PENDING } from '../../../constant/global.constant';
+import { ENTITYTYPE_MEDIA, STATUS_PENDING } from '../../../constant/global.constant';
 import { v4 as uuidv4 } from 'uuid';
 
 @Injectable()
@@ -115,11 +115,13 @@ export class MediaDataService extends EntityServiceImpl {
   }
 
   // New method to get the signed URL for the media (download link)
-  async getMediaDownloadUrl(s3Key: string): Promise<string> {
+  async getMediaDownloadUrl(id: number): Promise<string> {
     try {
+      const entityData = await this.getEntityData(ENTITYTYPE_MEDIA, id);
+      let mediaData = entityData as MediaData;
       const signedUrl = await this.s3.getSignedUrlPromise('getObject', {
         Bucket: this.bucketName,
-        Key: s3Key,
+        Key: mediaData.media_url,
         Expires: 60 * 5, // URL valid for 5 mins
       });
       return signedUrl;

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

@@ -1,11 +1,16 @@
-import { Body, Controller, Get, Param, Post, Query, UseGuards } from '@nestjs/common';
+import { Body, Controller, Get, Inject, Param, Post, Query, Req, UseGuards } from '@nestjs/common';
 import { ModuleAccessService } from '../service/module-access.service';
 import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+import { ENTITYTYPE_USER } from '../../../constant/global.constant';
+import { UserService } from '../../user/service/user.service';
+import { UserData } from '../../user/entity/user.entity';
 
 @Controller('module-access')
 @UseGuards(JwtAuthGuard)
 export class ModuleAccessController {
-  constructor(private readonly moduleAccessService: ModuleAccessService) {}
+  constructor(private readonly moduleAccessService: ModuleAccessService,
+              @Inject('UserService') private readonly userService: UserService,
+              ) {}
 
   @Get('roles')
   async getRoles() {
@@ -43,8 +48,12 @@ export class ModuleAccessController {
       status?: 'ACTIVE' | 'INACTIVE';
       copyFromRoleId?: number;
     },
+    @Req() req: Request & {user: any}
   ) {
-    return this.moduleAccessService.createRole(body);
+
+    let requestedUser = req.user;
+    let loggedInUser = await this.userService.getEntityData(ENTITYTYPE_USER,requestedUser.id);
+    return this.moduleAccessService.createRole(body, loggedInUser as UserData);
   }
 
   @Post('update-role/:id')
@@ -57,8 +66,11 @@ export class ModuleAccessController {
       status?: 'ACTIVE' | 'INACTIVE';
       copyFromRoleId?: number; // <-- ADD THIS
     },
+    @Req() req: Request & {user: any}
   ) {
-    return this.moduleAccessService.updateRole(id, body);
+    let requestedUser = req.user;
+    let loggedInUser = await this.userService.getEntityData(ENTITYTYPE_USER,requestedUser.id);
+    return this.moduleAccessService.updateRole(id, body, loggedInUser as UserData);
   }
   
 

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

@@ -6,6 +6,7 @@ import { ModuleAccess } from '../entity/module-access.entity';
 import { ModuleAction } from '../entity/module-action.entity';
 import { ModuleData } from '../entity/module.entity';
 import { ClockIDGenService } from 'src/utils/service/clockIDGenUtil.service';
+import { UserData } from 'src/module/user/entity/user.entity';
 
 @Injectable()
 export class ModuleAccessRepository {
@@ -18,27 +19,26 @@ export class ModuleAccessRepository {
     private readonly moduleAccessRepo: Repository<ModuleAccess>,
     @InjectRepository(ModuleAction)
     private readonly moduleActionRepo: Repository<ModuleAction>,
-        private readonly clockIDGenService: ClockIDGenService,
-    
+    private readonly clockIDGenService: ClockIDGenService,
   ) {}
 
   async getRoles() {
     const roles = await this.roleRepo.find();
-    return roles.map(role => ({
+    return roles.map((role) => ({
       label: role.name,
       value: role.id,
     }));
   }
-  
 
   async getModules() {
-    const modules = await this.moduleRepo.find({ where: { module_level: 'MAINMOD' } });
-    return modules.map(mod => ({
+    const modules = await this.moduleRepo.find({
+      where: { module_level: 'MAINMOD' },
+    });
+    return modules.map((mod) => ({
       label: mod.name,
       value: mod.id,
     }));
   }
-  
 
   async getAccessListing(roleIds: number[]) {
     // Fetch roles using role IDs
@@ -68,21 +68,23 @@ export class ModuleAccessRepository {
 
   async getMenuListing(mainModIds: string[]) {
     let mainModules: ModuleData[] = [];
-  
+
     if (mainModIds.length === 1 && mainModIds[0] === '-1') {
       // Fetch ALL MAINMOD modules if "-1" is passed
-      mainModules = await this.moduleRepo.find({ where: { module_level: 'MAINMOD' } });
+      mainModules = await this.moduleRepo.find({
+        where: { module_level: 'MAINMOD' },
+      });
     } else {
       // Fetch selected MAINMOD modules
       mainModules = await this.moduleRepo.find({
         where: { id: In(mainModIds), module_level: 'MAINMOD' },
       });
     }
-  
+
     if (!mainModules.length) return [];
-  
+
     const wbsCodes = mainModules.map((mod) => mod.wbs_code);
-  
+
     const modules = await this.moduleRepo
       .createQueryBuilder('module')
       .where(
@@ -92,14 +94,15 @@ export class ModuleAccessRepository {
         Object.fromEntries(wbsCodes.map((code) => [`code${code}`, `${code}%`])),
       )
       .getMany();
-  
+
     const moduleActions = await this.moduleActionRepo.find();
-  
+
     const buildHierarchy = (parentWbs: string) => {
       return modules
-        .filter(mod => 
-          mod.wbs_code.startsWith(parentWbs + '.') &&
-          mod.wbs_code.split('.').length === parentWbs.split('.').length + 1
+        .filter(
+          (mod) =>
+            mod.wbs_code.startsWith(parentWbs + '.') &&
+            mod.wbs_code.split('.').length === parentWbs.split('.').length + 1,
         )
         .map((mod) => ({
           name: mod.name,
@@ -113,7 +116,7 @@ export class ModuleAccessRepository {
           submod: buildHierarchy(mod.wbs_code),
         }));
     };
-  
+
     return mainModules.map((mod) => ({
       name: mod.name,
       code: mod.module_code,
@@ -126,7 +129,7 @@ export class ModuleAccessRepository {
       submod: buildHierarchy(mod.wbs_code),
     }));
   }
-  
+
   async updateModuleAccess(moduleAccessData: any[]): Promise<boolean> {
     try {
       for (const access of moduleAccessData) {
@@ -157,30 +160,44 @@ export class ModuleAccessRepository {
     }
   }
 
-  async createRole(body: { name: string; description?: string; status?: 'ACTIVE' | 'INACTIVE'; copyFromRoleId?: number }) {
+  async createRole(
+    body: {
+      name: string;
+      description?: string;
+      status?: 'ACTIVE' | 'INACTIVE';
+      copyFromRoleId?: number;
+    },
+    loggedInUser: UserData,
+  ) {
     const { name, description, status, copyFromRoleId } = body;
-  
+
     const nameExists = await this.isRoleNameExists(name);
     if (nameExists) {
       throw new BadRequestException('Role name already exists.');
     }
-  
+
     const code = this.clockIDGenService.idGenerator('ROL');
     const newRole = this.roleRepo.create({
       name,
       code,
       description,
       status: status || 'ACTIVE',
+      created_by: loggedInUser.id,
+      created_date: new Date(),
     });
-  
+
     const savedRole = await this.roleRepo.save(newRole);
-  
+
     if (copyFromRoleId) {
-      const sourceRole = await this.roleRepo.findOne({ where: { id: copyFromRoleId } });
+      const sourceRole = await this.roleRepo.findOne({
+        where: { id: copyFromRoleId },
+      });
       if (!sourceRole) {
         throw new BadRequestException('Source role not found');
       }
-      const sourcePermissions = await this.moduleAccessRepo.find({ where: { role_code: sourceRole.code } });
+      const sourcePermissions = await this.moduleAccessRepo.find({
+        where: { role_code: sourceRole.code },
+      });
       const clonedPermissions = sourcePermissions.map((perm) =>
         this.moduleAccessRepo.create({
           role_code: code,
@@ -188,11 +205,11 @@ export class ModuleAccessRepository {
           action_type: perm.action_type,
           access_flag: perm.access_flag,
           app_code: perm.app_code,
-        })
+        }),
       );
       await this.moduleAccessRepo.save(clonedPermissions);
     }
-  
+
     return {
       success: true,
       msg: 'Role created successfully',
@@ -204,35 +221,49 @@ export class ModuleAccessRepository {
       },
     };
   }
-  
 
-  async updateRole(roleId: number, body: { name: string; description?: string; status?: 'ACTIVE' | 'INACTIVE'; copyFromRoleId?: number }) {
+  async updateRole(
+    roleId: number,
+    body: {
+      name: string;
+      description?: string;
+      status?: 'ACTIVE' | 'INACTIVE';
+      copyFromRoleId?: number;
+    },
+    loggedInUser: UserData,
+  ) {
     const { name, description, status, copyFromRoleId } = body;
-  
+
     const nameExists = await this.isRoleNameExists(name, roleId);
     if (nameExists) {
       throw new BadRequestException('Role name already exists.');
     }
-  
+
     const role = await this.roleRepo.findOne({ where: { id: roleId } });
     if (!role) {
       throw new BadRequestException('Source role not found');
     }
-  
+
     role.name = name;
-    role.description = description || "";
+    role.description = description || '';
     role.status = status || 'ACTIVE';
+    role.modified_date = new Date();
+    role.modified_by = loggedInUser.id;
     await this.roleRepo.save(role);
-  
+
     if (copyFromRoleId) {
       await this.moduleAccessRepo.delete({ role_code: role.code });
-  
-      const sourceRole = await this.roleRepo.findOne({ where: { id: copyFromRoleId } });
+
+      const sourceRole = await this.roleRepo.findOne({
+        where: { id: copyFromRoleId },
+      });
       if (!sourceRole) {
         throw new BadRequestException('Source role not found');
       }
-  
-      const sourcePermissions = await this.moduleAccessRepo.find({ where: { role_code: sourceRole.code } });
+
+      const sourcePermissions = await this.moduleAccessRepo.find({
+        where: { role_code: sourceRole.code },
+      });
       const clonedPermissions = sourcePermissions.map((perm) =>
         this.moduleAccessRepo.create({
           role_code: role.code,
@@ -240,11 +271,11 @@ export class ModuleAccessRepository {
           action_type: perm.action_type,
           access_flag: perm.access_flag,
           app_code: perm.app_code,
-        })
+        }),
       );
       await this.moduleAccessRepo.save(clonedPermissions);
     }
-  
+
     return {
       success: true,
       msg: 'Role updated successfully',
@@ -256,17 +287,20 @@ export class ModuleAccessRepository {
       },
     };
   }
-  
-  async isRoleNameExists(name: string, excludeRoleId?: number): Promise<boolean> {
-    const query = this.roleRepo.createQueryBuilder('role')
+
+  async isRoleNameExists(
+    name: string,
+    excludeRoleId?: number,
+  ): Promise<boolean> {
+    const query = this.roleRepo
+      .createQueryBuilder('role')
       .where('role.name = :name', { name });
-  
+
     if (excludeRoleId) {
       query.andWhere('role.id != :excludeRoleId', { excludeRoleId });
     }
-  
+
     const existingRole = await query.getOne();
     return !!existingRole;
   }
-  
 }

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

@@ -4,12 +4,15 @@ import { RoleRepository } from 'src/module/user/repository/role.repository';
 import { RoleService } from '../../user/service/role.service';
 import { ENTITYTYPE_ROLE } from '../../../constant/global.constant';
 import { Role } from '../../user/entity/role.entity';
+import { EntityManager } from 'typeorm';
+import { UserData } from 'src/module/user/entity/user.entity';
 
 @Injectable()
 export class ModuleAccessService {
   constructor(
     private readonly moduleAccessRepository: ModuleAccessRepository,
     @Inject('RoleService') private readonly roleService: RoleService,
+    private readonly entityManager: EntityManager,
   ) {}
 
   async getRoles() {
@@ -45,13 +48,16 @@ export class ModuleAccessService {
     }
   }
 
-  async createRole(body: {
-    name: string;
-    description?: string;
-    status?: 'ACTIVE' | 'INACTIVE';
-    copyFromRoleId?: number;
-  }) {
-    return this.moduleAccessRepository.createRole(body);
+  async createRole(
+    body: {
+      name: string;
+      description?: string;
+      status?: 'ACTIVE' | 'INACTIVE';
+      copyFromRoleId?: number;
+    },
+    loggedInUser: UserData,
+  ) {
+    return this.moduleAccessRepository.createRole(body, loggedInUser);
   }
 
   async updateRole(
@@ -62,30 +68,44 @@ export class ModuleAccessService {
       status?: 'ACTIVE' | 'INACTIVE';
       copyFromRoleId?: number;
     },
+    loggedInUser: UserData,
   ) {
     if (!body.name) {
       throw new BadRequestException('Role name is required');
     }
 
-    //get role by id
-    const entityData = await this.roleService.getEntityData(ENTITYTYPE_ROLE,id);
+    if (body.status === 'INACTIVE') {
+      //get role by id
+      const entityData = await this.roleService.getEntityData(
+        ENTITYTYPE_ROLE,
+        id,
+      );
 
-    if (!entityData) {
-      throw new BadRequestException('Role not found');
-    }
-    const role = entityData as Role;
-    if (body.status === 'INACTIVE' && role.is_system === 1) {
-      throw new BadRequestException('Cannot deactivate system role');
-    }
+      const associatedUsers = await this.entityManager.query(`SELECT 	map.* 
+      FROM 	cr_user_role_mapping map 
+		  JOIN cr_user usr ON map.user_id = usr.id
+      WHERE usr.status = 'ACTIVE' and map.role_id = ${entityData?.id}`);
 
-    //if body.status =="INACTIVE" and role.is_system==1:
-    //  throw new Error('Cannot deactivate system role');
+      if (associatedUsers.length > 0) {
+        throw new BadRequestException(
+          'Cannot deactivate role as it is associated with active users',
+        );
+      }
+
+      if (!entityData) {
+        throw new BadRequestException('Role not found');
+      }
+      const role = entityData as Role;
+      if (role.is_system === 1) {
+        throw new BadRequestException('Cannot deactivate system role');
+      }
+    }
 
     return this.moduleAccessRepository.updateRole(id, {
       name: body.name,
       description: body.description,
       status: body.status,
       copyFromRoleId: body.copyFromRoleId,
-    });
+    }, loggedInUser);
   }
 }

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

@@ -1,3 +1,4 @@
+import { ENTITYTYPE_USRROLMAP } from 'src/constant/global.constant';
 import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
 
 @Entity({ name: 'cr_user_role_mapping' })
@@ -5,11 +6,15 @@ export class UserRoleMapping {
   constructor(user_id: number, role_id: number) {
     this.user_id = user_id;
     this.role_id = role_id;
+    this.entity_type = ENTITYTYPE_USRROLMAP;
   }
 
   @PrimaryGeneratedColumn()
   id: number;
 
+  @Column({type: 'varchar'})
+  entity_type: string;
+
   @Column({ type: 'bigint', nullable: true })
   user_id: number;
 

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

@@ -15,6 +15,7 @@ export class RoleService extends EntityServiceImpl {
     loggedInUser: UserData | null,
   ): Promise<BaseEntity> {
     let role = entityData as Role;
+
     return await super.createEntity(role, loggedInUser);
   }
 }

package/src/resources/dev.properties.yaml

@@ -13,9 +13,3 @@ OTP_EXPIRY: "10"
 OTP_LENGTH: "6"
 VERIFY_OTP: "false"
 DEFAULT_OTP: "123456"
-AWS:
-  S3:
-    AWS_ACCESS_KEY_ID: "AKIAYYKIBDDSQF3KILGE"
-    AWS_SECRET_KEY: "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"
-    AWS_REGION: "ap-south-1"
-    BUCKET_NAME: "testether"