rez_core 1.0.47 → 1.0.49

package/src/module/meta/service/section-master.service.ts

@@ -0,0 +1,104 @@
+import { Injectable } from '@nestjs/common';
+import { EntityServiceImpl } from './entity-service-impl.service';
+import { BaseEntity } from '../entity/base-entity.entity';
+import { UserData } from '../../user/entity/user.entity';
+import { EntityManager } from 'typeorm';
+import { ViewMaster } from '../entity/view-master.entity';
+
+@Injectable()
+export class SectionMasterService extends EntityServiceImpl {
+  constructor() {
+    super();
+  }
+
+  async createEntity(
+    entityData: BaseEntity,
+    loggedInUser: UserData | null,
+    manager?: EntityManager,
+  ): Promise<BaseEntity> {
+    const entityMaster = await this.entityMasterService.getEntityData(
+      entityData.entity_type,
+    );
+    entityData.parent_id = entityMaster.id;
+    entityData.parent_type = entityMaster.entity_type;
+
+    const savedEntity = await super.createEntity(
+      entityData,
+      loggedInUser,
+      manager,
+    );
+    return savedEntity;
+  }
+
+  async updateEntity(
+    entityData: ViewMaster,
+    loggedInUserData: UserData | null,
+  ): Promise<BaseEntity> {
+    return entityData;
+  }
+
+  parseLayout(layoutJson: any) {
+    const stepsData: {
+      stepType: string;
+      stepId: string;
+      stepLabel: string;
+      stepPosition: number;
+      fieldsGroup: {
+        type: string;
+        label: string;
+        id: string;
+      }[];
+    }[] = [];
+
+    if (layoutJson?.form?.children && Array.isArray(layoutJson.form.children)) {
+      const firstChild = layoutJson.form.children[0];
+      console.log('First Child:', firstChild);
+
+      if (firstChild.type === 'wizard' && Array.isArray(firstChild.steps)) {
+        console.log('Wizard Steps:', firstChild.steps);
+        let i = 0;
+        for (const step of firstChild.steps) {
+          if (step.type === 'step') {
+            const fields = this.extractFields(step.fields);
+
+            stepsData.push({
+              stepType: step.type,
+              stepId: step.id,
+              stepLabel: step.label,
+              stepPosition: ++i,
+              fieldsGroup: fields,
+            });
+          }
+        }
+      }
+    }
+    return stepsData;
+  }
+
+  extractFields(fieldsArray: any[]): {
+    type: string;
+    label: string;
+    id: string;
+  }[] {
+    const extractedFields: { type: string; label: string; id: string }[] = [];
+
+    function traverse(fields: any[]) {
+      for (const field of fields) {
+        if (field.type === 'field-set') {
+          extractedFields.push({
+            type: field.type || 'Default Type',
+            label: field.label || 'Default Label',
+            id: field.id || 'Default ID',
+          });
+        }
+        if (Array.isArray(field.fields)) {
+          traverse(field.fields);
+        }
+      }
+    }
+
+    traverse(fieldsArray);
+
+    return extractedFields;
+  }
+}

package/src/module/meta/service/view-master.service.ts

@@ -4,10 +4,16 @@ import { BaseEntity } from '../entity/base-entity.entity';
 import { UserData } from '../../user/entity/user.entity';
 import { EntityManager } from 'typeorm';
 import { ViewMaster } from '../entity/view-master.entity';
-
+import { SectionMasterService } from './section-master.service';
+import { SectionMaster } from '../entity/section-master.entity';
+import { FieldGroup } from '../entity/field-group.entity';
+import { FieldGroupService } from './field-group.service';
 @Injectable()
 export class ViewMasterService extends EntityServiceImpl {
-  constructor() {
+  constructor(
+    private readonly sectionMasterService: SectionMasterService,
+    private readonly fieldGroupService: FieldGroupService,
+  ) {
     super();
   }
 
@@ -27,6 +33,40 @@ export class ViewMasterService extends EntityServiceImpl {
       loggedInUser,
       manager,
     );
+    let viewMaster = savedEntity as ViewMaster;
+
+    let layout = viewMaster.published_form_layout;
+
+    const stepsData = this.sectionMasterService.parseLayout(layout);
+    for (var step of stepsData) {
+      let sectionMaster = new SectionMaster();
+      sectionMaster.name = step.stepLabel;
+      sectionMaster.position = step.stepPosition;
+      sectionMaster.description = step.stepLabel;
+      sectionMaster.parent_id = viewMaster.id;
+      sectionMaster.parent_type = viewMaster.entity_type;
+
+      const savedSectionMaster = await this.sectionMasterService.createEntity(
+        sectionMaster,
+        loggedInUser,
+        manager,
+      );
+
+      const fieldGroups = step.fieldsGroup;
+      console.log('fieldGroups', fieldGroups);
+
+      for (var fieldGroup of fieldGroups) {
+        let fieldsGroup = new FieldGroup();
+        fieldsGroup.view_id = viewMaster.id;
+        fieldsGroup.parent_id = savedSectionMaster.id;
+        fieldsGroup.field_type = fieldGroup.type;
+        fieldsGroup.label = fieldGroup.label;
+        fieldsGroup.description = fieldGroup.label;
+
+        this.fieldGroupService.createEntity(fieldsGroup, loggedInUser, manager);
+      }
+    }
+
     return savedEntity;
   }
 
@@ -34,8 +74,6 @@ export class ViewMasterService extends EntityServiceImpl {
     entityData: ViewMaster,
     loggedInUserData: UserData | null,
   ): Promise<BaseEntity> {
-
     return entityData;
   }
-
 }

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

@@ -1,10 +1,18 @@
-import { Injectable } from '@nestjs/common';
+import { BadRequestException, Inject, Injectable } from '@nestjs/common';
 import { ModuleAccessRepository } from '../repository/module-access.repository';
+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() {
@@ -40,33 +48,64 @@ 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(id: number, body: {
-    name?: string;
-    description?: string;
-    status?: 'ACTIVE' | 'INACTIVE';
-    copyFromRoleId?: number;
-  }) {
+  async updateRole(
+    id: number,
+    body: {
+      name?: string;
+      description?: string;
+      status?: 'ACTIVE' | 'INACTIVE';
+      copyFromRoleId?: number;
+    },
+    loggedInUser: UserData,
+  ) {
     if (!body.name) {
-      throw new Error('Role name is required');
+      throw new BadRequestException('Role name is required');
     }
-  
+
+    if (body.status === 'INACTIVE') {
+      //get role by id
+      const entityData = await this.roleService.getEntityData(
+        ENTITYTYPE_ROLE,
+        id,
+      );
+
+      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 (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,21 +1,26 @@
-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;
-}
+import { ENTITYTYPE_USRROLMAP } from 'src/constant/global.constant';
+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;
+    this.entity_type = ENTITYTYPE_USRROLMAP;
+  }
+
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({type: 'varchar'})
+  entity_type: string;
+
+  @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/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,9 @@ OTP_EXPIRY: "10"
 OTP_LENGTH: "6"
 VERIFY_OTP: "false"
 DEFAULT_OTP: "123456"
-AWS:
-  S3:
-    AWS_ACCESS_KEY_ID: "AKIAYYKIBDDSVJMYCJUV"
-    AWS_SECRET_KEY: "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"
-    AWS_REGION: "ap-south-1"
-    BUCKET_NAME: "testether"
+#AWS:
+#  S3:
+#    AWS_ACCESS_KEY_ID: "AKIAYYKIBDDSQF3KILGE"
+#    AWS_SECRET_KEY: "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"
+#    AWS_REGION: "ap-south-1"
+#    BUCKET_NAME: "testether"