rez_core 2.2.8 → 2.2.10

package/package.json

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

package/src/constant/global.constant.ts

@@ -46,7 +46,9 @@ export const STAGE = 'STG';
 export const STAGE_GROUP = 'STGP';
 export const ACTION_CATEGORY = 'ACTC';
 export const STAGE_ACTION_MAPPING = 'STGM';
-export const COMM_TEMPLATE = 'CTPL';
+export const COMM_TEMPLATE = 'TEM';
 export const ACTION_TEMPLATE_MAPPING = 'ATMP';
 export const WORKFLOW_DATA = 'WFDT';
 export const STAGE_MOVEMENT_DATA = 'STMV';
+
+export const ENTITY_MODIFICATION = 'ENMD';

package/src/module/filter/controller/filter.controller.ts

@@ -26,11 +26,16 @@ export class FilterController {
   @UseGuards(JwtAuthGuard)
   async applyFilter(
     @Body() body: any,
-    @Query('page', ParseIntPipe) page: number = 1,
-    @Query('size', ParseIntPipe) size: number = 10,
+    @Query('page', ParseIntPipe) page = 1,
+    @Query('size', ParseIntPipe) size = 10,
     @Req() req: Request & { user: any },
+    @Query() queryParams: Record<string, string>,
   ) {
-    const userData = req.user.userData;
+    const loggedInUser = req.user.userData;
+
+    // Remove page and size from queryParams
+    const { page: _p, size: _s, ...otherQueryParams } = queryParams;
+
     const {
       entity_type,
       quickFilter,
@@ -49,7 +54,8 @@ export class FilterController {
       sortby,
       page,
       size,
-      loggedInUser: userData,
+      loggedInUser,
+      queryParams: otherQueryParams, // only remaining query params
     });
   }
 

package/src/module/filter/dto/filter-request.dto.ts

@@ -26,4 +26,5 @@ export interface FilterRequestDto {
   page?: number;
   size?: number;
   loggedInUser: UserData;
+  queryParams?: Record<string, string>;
 }

package/src/module/filter/service/filter.service.ts

@@ -78,8 +78,10 @@ export class FilterService {
       tabs,
       sortby,
       loggedInUser,
+      queryParams,
     } = dto;
 
+    // abstract user details
     const {
       level_type,
       level_id,
@@ -88,15 +90,18 @@ export class FilterService {
       organization_id,
     } = loggedInUser || {};
 
-    // Fetch meta
+    // Fetch meta from entity table service
     const entityMeta = await this.entityTableService.getEntityData(
       entity_type,
       loggedInUser,
     );
     const tableName = entityMeta?.data_source; // data_souce is the table name
-    if (!tableName)
+
+    if (!tableName) {
       throw new BadRequestException(`Invalid entity_type: ${entity_type}`);
+    }
 
+    // get table meta from cr_entity_table
     const getTableMeta =
       await this.entityTableService.findByEntityTypeAndListTypeAndDisplayType(
         entity_type,
@@ -110,6 +115,7 @@ export class FilterService {
         `Table meta not found for entity_type: ${entity_type}`,
       );
     }
+
     const getTableColumnMeta =
       await this.entityTableColumnService.findByParentIdAndParentType(
         getTableMeta.id,
@@ -153,6 +159,32 @@ export class FilterService {
       });
     }
 
+    // andWhere search with attributeName && attributeValue
+    if (queryParams) {
+      Object.entries(queryParams).forEach(([key, value]) => {
+        if (!value) return;
+
+        // Handle custom attributeName/attributeValue
+        if (key === 'attributeName' && queryParams['attributeValue']) {
+          const attrName = value;
+          const attrValue = queryParams['attributeValue'];
+
+          baseWhere.push({
+            query: `e.${attrName} = :${attrName}`,
+            params: { [attrName]: attrValue },
+          });
+        }
+
+        // Ignore attributeValue itself from being added again
+        else if (key !== 'attributeValue') {
+          baseWhere.push({
+            query: `e.${key} = :${key}`,
+            params: { [key]: value },
+          });
+        }
+      });
+    }
+
     // if (!this.skipAppCodeFilterEntities.includes(entity_type)) {
     //   baseWhere.push({
     //     query: 'e.appcode = :appcode',
@@ -164,10 +196,12 @@ export class FilterService {
     const layoutPreference = await this.dataSource.query(
       `SELECT layout_json
       FROM cr_entity_layout_pref
-      WHERE user_id = ? AND mapped_entity_type = ?`,
-      [user_id, entity_type],
+      WHERE user_id = ? AND mapped_entity_type = ? AND mapped_level_id = ? AND mapped_level_type = ?`,
+      [user_id, entity_type, level_id, level_type],
     );
 
+    console.log('found layoutPreference', layoutPreference);
+
     // Extract layout preference
     const layout = layoutPreference?.[0]?.layout_json?.quick_tab || {};
 

package/src/module/layout_preference/controller/layout_preference.controller.ts

@@ -15,11 +15,13 @@ export class LayoutPreferenceController {
     @Query('entity_type') entity_type: string,
     @Req() req: Request & { user: any },
   ) {
-    const userId = req.user.userData.id;
+    const userDat = req.user.userData;
 
     return this.layoutPreferenceService.getLayoutPreferenceByUserID(
-      userId,
+      userDat.id,
       entity_type,
+      userDat.level_id,
+      userDat.level_type,
     );
   }
 
@@ -31,13 +33,13 @@ export class LayoutPreferenceController {
     @Query('sort_by') sort_by: string,
     @Req() req: Request & { user: any },
   ) {
-    const userData = req.user.userData;
+    const loggedInUser = req.user.userData;
 
     return this.layoutPreferenceService.getColumnValue(
       entity_type,
       column,
       sort_by,
-      userData,
+      loggedInUser,
     );
   }
 }

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

@@ -14,4 +14,15 @@ export class LayoutPreference extends BaseEntity {
 
   @Column({ nullable: true, type: 'json' })
   navigation_tabs_json: any;
+
+  @Column({
+    name: 'mapped_level_id',
+    type: 'varchar',
+    length: 100,
+    nullable: true,
+  })
+  mapped_level_id: string;
+
+  @Column({ name: 'mapped_level_type', type: 'varchar', nullable: true })
+  mapped_level_type: string;
 }

package/src/module/layout_preference/repository/layout_preference.repository.ts

@@ -11,13 +11,17 @@ export class LayoutPreferenceRepository {
   ) {}
 
   async findByEntityUserId(
-    entity_type: string,
+    mapped_entity_type: string,
+    mapped_level_id: string,
+    mapped_level_type: string,
     userId: number,
   ): Promise<LayoutPreference | null> {
     return this.layoutPreferenceRepo.findOne({
       where: {
         user_id: userId.toString(),
-        mapped_entity_type: entity_type,
+        mapped_entity_type: mapped_entity_type,
+        mapped_level_id: mapped_level_id,
+        mapped_level_type: mapped_level_type,
       },
     });
   }

package/src/module/layout_preference/service/layout_preference.service.ts

@@ -27,6 +27,8 @@ export class LayoutPreferenceService extends EntityServiceImpl {
     const existingLayoutPreference =
       await this.layoutPreferenceRepository.findByEntityUserId(
         mapped_entity_type,
+        loggedInUser.level_id,
+        loggedInUser.level_type,
         userId,
       );
 
@@ -38,16 +40,31 @@ export class LayoutPreferenceService extends EntityServiceImpl {
     }
 
     return await super.createEntity(
-      { ...entityData, user_id: userId } as any,
+      {
+        ...entityData,
+        user_id: userId,
+        mapped_level_id: loggedInUser.level_id,
+        mapped_level_type: loggedInUser.level_type,
+      } as any,
       loggedInUser,
     );
   }
 
-  async getLayoutPreferenceByUserID(user_id, mapped_entity_type) {
-    return await this.layoutPreferenceRepository.findByEntityUserId(
-      mapped_entity_type,
-      user_id,
-    );
+  async getLayoutPreferenceByUserID(
+    user_id,
+    mapped_entity_type,
+    mapped_level_id,
+    mapped_level_type,
+  ) {
+    const layoutPreference =
+      await this.layoutPreferenceRepository.findByEntityUserId(
+        mapped_entity_type,
+        mapped_level_id,
+        mapped_level_type,
+        user_id,
+      );
+
+    return layoutPreference;
   }
 
   async getColumnValue(
@@ -65,6 +82,7 @@ export class LayoutPreferenceService extends EntityServiceImpl {
       );
 
     const tableName = getTableMeta?.data_source;
+
     if (!tableName) {
       throw new Error('Invalid or missing table name in metadata');
     }
@@ -77,6 +95,13 @@ export class LayoutPreferenceService extends EntityServiceImpl {
         .addSelect(`COUNT(*) AS count`)
         .from(tableName, tableName)
         .where(`${column} IS NOT NULL`)
+        .andWhere(`organization_id = :organizationId`, {
+          organizationId: loggedInUser?.organization_id,
+        })
+        .andWhere(`level_id = :levelId`, { levelId: loggedInUser?.level_id })
+        .andWhere(`level_type = :levelType`, {
+          levelType: loggedInUser?.level_type,
+        })
         .groupBy(column)
         .getRawMany();
 

package/src/module/listmaster/entity/list-master-items.entity.ts

@@ -12,19 +12,19 @@ export class ListMasterItems extends BaseEntity {
   @PrimaryGeneratedColumn()
   id: number;
 
-  @Column()
+  @Column({ nullable: true })
   listtype: string;
 
-  @Column()
+  @Column({ nullable: true })
   name: string;
 
-  @Column()
+  @Column({ nullable: true })
   parent_code: string;
 
-  @Column()
+  @Column({ nullable: true })
   value: string;
 
-  @Column()
+  @Column({ nullable: true })
   status: string;
 
   @Column({ default: 0 })

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

@@ -1,19 +1,17 @@
 import {
   Body,
   Controller,
+  Get,
   HttpStatus,
+  Param,
   Post,
+  Req,
   Res,
-  Get,
-  Param,
   UseGuards,
-  Req,
 } from '@nestjs/common';
-import { MediaDataService } from '../service/media-data.service';
+import { Response } from 'express';
 import { JwtAuthGuard } from '../../auth/guards/jwt.guard';
-import e, { Response } from 'express';
-import { ENTITYTYPE_MEDIA } from 'src/constant/global.constant';
-import { MediaData } from '../entity/media-data.entity';
+import { MediaDataService } from '../service/media-data.service';
 
 @Controller('media')
 @UseGuards(JwtAuthGuard)

package/src/module/meta/entity/base-entity.entity.ts

@@ -49,7 +49,7 @@ export class BaseEntity {
   @Expose()
   modified_by: number;
 
-  @Column({ name: 'modified_date',  nullable: true })
+  @Column({ name: 'modified_date', nullable: true })
   @Expose()
   modified_date: Date;
 

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

@@ -23,16 +23,21 @@ export class ModuleAccessController {
     private readonly menuService: MenuService,
   ) {}
 
+
   @Get('roles')
-  async getRoles(@Query('appcode') appcode: string, @Request() req) {
-    let level_type = req.user.userData.level_type;
-    let level_id = req.user.userData.level_id;
-    let organization_id = req.user.userData.organization_id;
+  async getRoles(
+    @Query('appcode') appcode: string,
+    @Query('include') include: string, // ✅ declare it as boolean
+    @Request() req
+  ) {
+    const { level_type, level_id, organization_id } = req.user.userData;
+
     return this.moduleAccessService.getRoles({
       appcode,
       level_type,
       level_id,
       organization_id,
+      include: include === "true", // ensure it's either true or false
     });
   }
 

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

@@ -33,42 +33,49 @@ export class ModuleAccessService {
     level_type,
     level_id,
     organization_id,
+    include 
   }: {
     appcode: string;
     level_type?: string;
     level_id?: number;
     organization_id?: number;
+    include?: boolean;
   }) {
     const query = this.dataSource
       .createQueryBuilder()
       .select('*')
       .from('cr_role', 'role')
-      .where('role.appcode = :appcode', { appcode })
-      .andWhere('(role.is_factory IS NULL OR role.is_factory != 1)');
-
+      .where('role.appcode = :appcode', { appcode });
+  
+    // Only add this condition if `include` is false (exclude factory roles)
+    if (!include) {
+      query.andWhere('(role.is_factory IS NULL OR role.is_factory != 1)');
+    }
+  
     if (level_type) {
       query.andWhere('role.level_type = :level_type', { level_type });
     }
-
+  
     if (organization_id) {
       query.andWhere('role.organization_id = :organization_id', {
         organization_id,
       });
     }
-
+  
     if (level_id !== undefined) {
       query.andWhere('role.level_id = :level_id', {
         level_id: String(level_id),
       });
     }
-
-    const roles = await query.getRawMany(); // use getRawMany since you're selecting from a raw table
-
+  
+    const roles = await query.getRawMany();
+  
     return roles.map((role) => ({
       label: role.name,
       value: role.id,
     }));
   }
+  
 
   async getAccessListing(
     roleIds: number[],

package/src/module/workflow/controller/action-category.controller.ts

@@ -0,0 +1,35 @@
+import {
+  Body,
+  Controller,
+  HttpCode,
+  HttpStatus,
+  Inject,
+  Post,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+import { ActionCategoryService } from '../service/action-category.service';
+
+@Controller('/actionCategory')
+@UseGuards(JwtAuthGuard)
+export class ActionCategoryController {
+  constructor(
+    @Inject('ActionCategoryService')
+    private readonly actionCategoryService: ActionCategoryService,
+  ) {}
+
+  @Post('/getActionsCategory')
+  @HttpCode(HttpStatus.OK)
+  async getActionsCat(
+    @Req() req: Request & { user: any },
+    @Body('entity_type') entity_type: string,
+  ) {
+    const loggedInUser = req.user.userData;
+    const result = this.actionCategoryService.getActionsCat(
+      loggedInUser,
+      entity_type,
+    );
+    return result;
+  }
+}

package/src/module/workflow/controller/action.controller.ts

@@ -0,0 +1,73 @@
+import {
+  Body,
+  Controller,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Inject,
+  Post,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+import { ActionService } from '../service/action.service';
+
+@Controller('/action')
+@UseGuards(JwtAuthGuard)
+export class ActionController {
+  constructor(
+    @Inject('ActionService')
+    private readonly actionService: ActionService,
+  ) {}
+
+  @Get('/getReasonCode')
+  @HttpCode(HttpStatus.OK)
+  async getReasonCode(@Req() req: Request & { user: any }) {
+    const loggedInUser = req.user.userData;
+    const result = this.actionService.getReasonCode(loggedInUser);
+    return result;
+  }
+
+  @Post('/defaultReasonCode')
+  @HttpCode(HttpStatus.OK)
+  async defaultReasonCode(
+    @Req() req: Request & { user: any },
+    @Body() body: { list_type: string },
+  ) {
+    const loggedInUser = req.user.userData;
+    const result = this.actionService.defaultReasonCode(
+      body.list_type,
+      loggedInUser,
+    );
+    return result;
+  }
+
+  @Post('/getactions')
+  @HttpCode(HttpStatus.OK)
+  async getActions(
+    @Req() req: Request & { user: any },
+    @Body('stage_id') stage_id: number,
+  ) {
+    const loggedInUser = req.user.userData;
+    const result = this.actionService.getActions(loggedInUser, stage_id);
+    return result;
+  }
+
+  @Post('/getaction')
+  @HttpCode(HttpStatus.OK)
+  async getAction(
+    @Req() req: Request & { user: any },
+    @Body('stage_id') stage_id: number,
+    @Body('mapped_entity_id') mapped_entity_id: number,
+    @Body('mapped_entity_type') mapped_entity_type: string,
+  ) {
+    const loggedInUser = req.user.userData;
+    const result = this.actionService.getAction(
+      loggedInUser,
+      stage_id,
+      mapped_entity_id,
+      mapped_entity_type,
+    );
+    return result;
+  }
+}

package/src/module/workflow/controller/comm-template.controller.ts

@@ -0,0 +1,32 @@
+import {
+  Body,
+  Controller,
+  HttpCode,
+  HttpStatus,
+  Post,
+  Query,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+import { CommTemplateService } from '../service/comm-template.service';
+
+@Controller('/templates')
+@UseGuards(JwtAuthGuard)
+export class CommTemplateController {
+  constructor(private readonly commTemplateService: CommTemplateService) {}
+
+  @Post('/getTemplates')
+  @HttpCode(HttpStatus.OK)
+  async getTemplate(
+    @Req() req: Request & { user: any },
+    @Body('entity_type') entity_type: string,
+  ) {
+    const loggedInUser = req.user.userData;
+    const result = this.commTemplateService.getAllCommTemplate(
+      entity_type || '',
+      loggedInUser,
+    );
+    return result;
+  }
+}

package/src/module/workflow/controller/entity-modification.controller.ts

@@ -0,0 +1,35 @@
+import {
+  Body,
+  Controller,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Inject,
+  Post,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+import { EntityModificationService } from '../service/entity-modification.service';
+
+@Controller('/entity-modification')
+@UseGuards(JwtAuthGuard)
+export class EntityModificationController {
+  constructor(
+    @Inject('EntityModificationService')
+    private readonly entityModificationService: EntityModificationService,
+  ) {}
+
+  @Post('/logModification')
+  @HttpCode(HttpStatus.OK)
+  async logModification(
+    @Body() modificationData: any,
+    @Req() req: Request & { user: any },
+  ) {
+    const loggedInUser = req.user.userData;
+    return await this.entityModificationService.logModification(
+      modificationData,
+      loggedInUser,
+    );
+  }
+}

package/src/module/workflow/controller/stage-group.controller.ts

@@ -0,0 +1,33 @@
+import {
+  Body,
+  Controller,
+  Get,
+  Inject,
+  Post,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+import { StageGroupService } from '../service/stage-group.service';
+
+@Controller('/stage-group')
+@UseGuards(JwtAuthGuard)
+export class StageGroupController {
+  constructor(
+    @Inject('StageGroupService')
+    private readonly stageGroupService: StageGroupService,
+  ) {}
+
+  @Post('/getAllStageGroup')
+  async getAllStageGroup(
+    @Req() req: Request & { user: any },
+    @Body() body: { workflow_id: number },
+  ) {
+    const { level_id, level_type } = req.user.userData;
+    return this.stageGroupService.getAllStageGroup(
+      body.workflow_id,
+      level_id,
+      level_type,
+    );
+  }
+}