rez_core 2.2.143 → 2.2.145

package/package.json

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

package/src/module/dashboard/controller/dashboard.controller.ts

@@ -3,6 +3,7 @@ import {
   Get,
   Param,
   ParseIntPipe,
+  Query,
   Req,
   UseGuards,
 } from '@nestjs/common';
@@ -22,4 +23,14 @@ export class DashboardController {
     const loggedInUser = req.user.userData;
     return this.dashboardService.getDashboardPage(pageId, loggedInUser);
   }
+
+  @Get('pages')
+  @UseGuards(JwtAuthGuard)
+  async getPages(
+    @Query('mapped_entity_type') mapped_entity_type: string,
+    @Req() req: any,
+  ) {
+    const loggedInUser = req.user.userData;
+    return this.dashboardService.getPages(mapped_entity_type, loggedInUser);
+  }
 }

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

@@ -6,11 +6,13 @@ import { DashboardPageData } from './entity/dashboard_page_data.entity';
 import { DashboardController } from './controller/dashboard.controller';
 import { DashboardService } from './service/dashboard.service';
 import { DashboardRepository } from './repository/dashboard.repository';
+import { ModuleModule } from '../module/module.module';
 
 @Module({
   imports: [
     EntityModule,
     TypeOrmModule.forFeature([WidgetMaster, DashboardPageData]),
+    ModuleModule
   ],
   controllers: [DashboardController],
   providers: [DashboardService, DashboardRepository],

package/src/module/dashboard/repository/dashboard.repository.ts

@@ -7,6 +7,10 @@ import { WidgetMaster } from '../entity/widget_master.entity';
 export class DashboardRepository {
   constructor(private readonly dataSource: DataSource) {}
 
+  async getPages(mapped_entity_type:string, loggedInUser:any){
+    return await this.dataSource.query(`SELECT * FROM cr_dashboard_page_data WHERE mapped_entity_type='${ mapped_entity_type}' AND applicable_type='${loggedInUser.level_type}' AND applicable_id='${loggedInUser.level_id}' AND organization_id='${loggedInUser.organization_id}' `);
+  }
+
   async getDashboardPageData(
     pageId: number,
     organization_id: number,

package/src/module/dashboard/service/dashboard.service.ts

@@ -1,10 +1,37 @@
 import { Injectable, NotFoundException } from '@nestjs/common';
 import { DashboardRepository } from '../repository/dashboard.repository';
+import { ModuleAccessService } from 'src/module/module/service/module-access.service';
 
 @Injectable()
 export class DashboardService {
-  constructor(private readonly dashboardRepo: DashboardRepository) {}
+  constructor(private readonly dashboardRepo: DashboardRepository,
+    private readonly moduleAccessService: ModuleAccessService
+  ) {}
 
+  async getPages(mapped_entity_type: string, loggedInUser: any) {
+    const pages = await this.dashboardRepo.getPages(mapped_entity_type, loggedInUser);
+  
+    const access = await this.moduleAccessService.getUserPermissions({
+      userId: loggedInUser.id,
+      appcode: loggedInUser.appcode,
+      level_type: loggedInUser.level_type,
+      level_id: loggedInUser.level_id,
+      organization_id: loggedInUser.organization_id,
+    });
+  
+    // Build a set of accessible codes
+    const allowedCodes = new Set(
+      access
+        .filter(a => a.action === 'VIEW' && a.access === 1)
+        .map(a => a.code)
+    );
+  
+    // Filter pages based on access
+    const filteredPages = pages.filter(page => allowedCodes.has(page.code));
+  
+    return filteredPages ;
+  }
+  
   async getDashboardPage(pageId: number, loggedInUser: any) {
     const organizationId = loggedInUser.organization_id;
     // 1. Get page data

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

@@ -17,6 +17,7 @@ export class EntityDynamicService {
     entityData: Record<string, any>,
     loggedInUser: any,
   ): Promise<any> {
+    
     const organizationId = loggedInUser.organization_id;
 
     const tableName = await this.getTableName(entityType, organizationId);
@@ -41,6 +42,7 @@ export class EntityDynamicService {
         entityData.level_type = loggedInUser.level_type;
       if (!entityData.level_id) entityData.level_id = loggedInUser.level_id;
       if (!entityData.status) entityData.status = statusList[0].id;
+      if( !entityData.entity_type ) entityData.entity_type = entityType;
     }
 
     if (!entityData.code && loggedInUser) {
@@ -90,133 +92,77 @@ export class EntityDynamicService {
 
   // ----------------------------- get entity with relations
 
-  async createEntityWithRelation(
-    entityType: string,
-    data: Record<string, any>,
-    loggedInUser: any,
-  ): Promise<any> {
-    const organizationId = loggedInUser.organization_id;
+// ----------------------------- create entity with relations
+async createEntityWithRelation(
+  entityType: string,
+  data: Record<string, any>,
+  loggedInUser: any,
+): Promise<any> {
+  const organizationId = loggedInUser.organization_id;
+
+  const getRelation = await this.dataSource.query(
+    `SELECT * FROM cr_entity_relation WHERE organization_id = ? AND source_entity_type = ?`,
+    [organizationId, entityType],
+  );
+
+  const { mappedEntities, ...mainData } = data;
+
+  // create main entity
+  const createdEntityData = await this.createEntity(
+    entityType,
+    mainData,
+    loggedInUser,
+  );
+  const mainID = createdEntityData.insertId || createdEntityData.id;
+
+  if (mappedEntities && getRelation.length > 0) {
+    for (const relation of getRelation) {
+      const targetEntityType = relation.target_entity_type;
+      const relationType = relation.relation_type;
+      const relationId = relation.relation_id;
 
-    const getRelation = await this.dataSource.query(
-      `SELECT * FROM cr_entity_relation WHERE organization_id = ? AND source_entity_type = ?`,
-      [organizationId, entityType],
-    );
+      if (!mappedEntities[targetEntityType]) continue;
 
-    const { mappedEntities, ...mainData } = data;
+      // normalize: always array
+      const entityDataArray = Array.isArray(mappedEntities[targetEntityType])
+        ? mappedEntities[targetEntityType]
+        : [mappedEntities[targetEntityType]];
 
-    // create main entity
-    const createdEntityData = await this.createEntity(
-      entityType,
-      mainData,
-      loggedInUser,
-    );
-    const mainID = createdEntityData.insertId || createdEntityData.id;
-
-    // Process related entities
-    const relationResults: any[] = [];
-
-    if (mappedEntities && getRelation.length > 0) {
-      for (const relation of getRelation) {
-        const targetEntityType = relation.target_entity_type;
-        const relationType = relation.relation_type;
-        const relationId = relation.relation_id;
-
-        // Check if we have data for this target entity type
-        if (mappedEntities[targetEntityType]) {
-          const entityData = mappedEntities[targetEntityType];
-
-          // resolve from list_master_items
-          const relationTypeResult = await this.dataSource.query(
-            `SELECT * FROM cr_list_master_items WHERE organization_id = ? AND id = ?`,
-            [organizationId, relationId],
-          );
-
-          if (
-            relationTypeResult[0]?.value == 'ONE_TO_MANY' ||
-            relationTypeResult[0]?.value == 'MANY_TO_ONE'
-          ) {
-            // Expect array of objects
-            if (Array.isArray(entityData)) {
-              for (const item of entityData) {
-                // Add foreign key reference to main entity
-                const itemWithRef = {
-                  ...item,
-                  entity_type: targetEntityType,
-                };
-
-                const createdRelatedEntity = await this.createEntity(
-                  targetEntityType,
-                  itemWithRef,
-                  loggedInUser,
-                );
-
-                // SAVE ENTRY IN cr_entity_relation_data
-
-                await this.dataSource.query(
-                  `INSERT INTO cr_entity_relation_data (source_entity_id, source_entity_type, target_entity_id, target_entity_type, relation_type) VALUES (?, ?, ?, ?, ?)`,
-                  [
-                    mainID,
-                    entityType,
-                    createdRelatedEntity.insertId,
-                    targetEntityType,
-                    relationType,
-                  ],
-                );
-              }
-            } else {
-              throw new Error(
-                `Expected array for ONE_TO_MANY relationship with ${targetEntityType}`,
-              );
-            }
-          } else if (
-            relationTypeResult[0]?.value == 'ONE_TO_ONE' ||
-            relationTypeResult[0]?.value == 'MANY_TO_ONE'
-          ) {
-            // Expect single object
-            if (!Array.isArray(entityData)) {
-              // Add foreign key reference to main entity
-              const entityWithRef = {
-                ...entityData,
-                entity_type: targetEntityType,
-              };
-
-              const createdRelatedEntity = await this.createEntity(
-                targetEntityType,
-                entityWithRef,
-                loggedInUser,
-              );
-
-              // SAVE ENTRY IN cr_entity_relation_data
-              await this.dataSource.query(
-                `INSERT INTO cr_entity_relation_data (source_entity_id, source_entity_type, target_entity_id, target_entity_type, relation_type) VALUES (?, ?, ?, ?, ?)`,
-                [
-                  mainID,
-                  entityType,
-                  createdRelatedEntity.insertId,
-                  targetEntityType,
-                  relationType,
-                ],
-              );
-            } else {
-              throw new Error(
-                `Expected single object for ONE_TO_ONE relationship with ${targetEntityType}`,
-              );
-            }
-          }
-        }
+      for (const item of entityDataArray) {
+        const itemWithRef = {
+          ...item,
+          entity_type: targetEntityType,
+        };
+
+        const createdRelatedEntity = await this.createEntity(
+          targetEntityType,
+          itemWithRef,
+          loggedInUser,
+        );
+
+        await this.dataSource.query(
+          `INSERT INTO cr_entity_relation_data (source_entity_id, source_entity_type, target_entity_id, target_entity_type, relation_type) VALUES (?, ?, ?, ?, ?)`,
+          [
+            mainID,
+            entityType,
+            createdRelatedEntity.insertId,
+            targetEntityType,
+            relationType,
+          ],
+        );
       }
     }
-
-    return {
-      mainEntity: {
-        id: mainID,
-        entityType: entityType,
-        data: createdEntityData,
-      },
-      relatedEntities: relationResults,
-    };
   }
 
+  return {
+    mainEntity: {
+      id: mainID,
+      entityType,
+      data: createdEntityData,
+    },
+  };
+}
+
   // ----------------------------- get entity with relations
   async getEntityWithRelation(
     entityType: string,
@@ -247,204 +193,133 @@ export class EntityDynamicService {
     return response;
   }
 
-  async formatMappedEntities(
-    relatedEntities: any[],
-    loggedInUser: any,
-  ): Promise<any> {
-    const mappedEntities: any = {};
+// ----------------------------- formatMappedEntities
+async formatMappedEntities(
+  relatedEntities: any[],
+  loggedInUser: any,
+): Promise<any> {
+  const mappedEntities: any = {};
 
-    for (const relation of relatedEntities) {
-      const targetEntityType = relation.target_entity_type;
-      const targetEntityId = relation.target_entity_id;
-      const relationType = relation.relation_type;
+  for (const relation of relatedEntities) {
+    const targetEntityType = relation.target_entity_type;
+    const targetEntityId = relation.target_entity_id;
 
-      // Get the actual entity data
-      const entityData = await this.getEntity(
-        targetEntityType,
-        targetEntityId,
-        loggedInUser,
-      );
-
-      if (!mappedEntities[targetEntityType]) {
-        // Initialize based on relation type
-        if (relationType === 'ONE_TO_MANY') {
-          mappedEntities[targetEntityType] = [];
-        } else if (
-          relationType === 'ONE_TO_ONE' ||
-          relationType === 'MANY_TO_ONE'
-        ) {
-          mappedEntities[targetEntityType] = null;
-        }
-      }
+    const entityData = await this.getEntity(
+      targetEntityType,
+      targetEntityId,
+      loggedInUser,
+    );
 
-      if (relationType === 'ONE_TO_MANY') {
-        mappedEntities[targetEntityType].push(entityData);
-      } else if (
-        relationType === 'ONE_TO_ONE' ||
-        relationType === 'MANY_TO_ONE'
-      ) {
-        mappedEntities[targetEntityType] = entityData;
-      }
+    if (!mappedEntities[targetEntityType]) {
+      mappedEntities[targetEntityType] = [];
     }
 
-    return mappedEntities;
+    mappedEntities[targetEntityType].push(entityData);
   }
 
+  return mappedEntities;
+}
+
   // ----------------------------- update with relations
 
-  async updateEntityWithRelations(
-    entityType: string,
-    id: number | string,
-    data: Record<string, any>,
-    loggedInUser: any,
-  ): Promise<any> {
-    const organizationId = loggedInUser.organization_id;
+// ----------------------------- update entity with relations
+async updateEntityWithRelations(
+  entityType: string,
+  id: number | string,
+  data: Record<string, any>,
+  loggedInUser: any,
+): Promise<any> {
+  const organizationId = loggedInUser.organization_id;
+  const { mappedEntities, ...mainData } = data;
 
-    const { mappedEntities, ...mainData } = data;
+  // Update main entity
+  const updatedMainEntity = await this.updateEntity(entityType, id, mainData, loggedInUser);
 
-    // Update the main entity (excluding mappedEntities)
-    await this.updateEntity(entityType, id, mainData, loggedInUser);
+  const updatedRelations: Record<string, any> = {};
+
+  if (mappedEntities) {
+    const getRelationDefs = await this.dataSource.query(
+      `SELECT * FROM cr_entity_relation WHERE organization_id = ? AND source_entity_type = ?`,
+      [organizationId, entityType],
+    );
 
-    // Handle related entities if mappedEntities is provided
-    if (mappedEntities) {
-      // Get existing relations
-      const existingRelations = await this.dataSource.query(
-        `SELECT * FROM cr_entity_relation_data WHERE source_entity_type = ? AND source_entity_id = ?`,
-        [entityType, id],
+    for (const [targetEntityType, rawEntityData] of Object.entries(mappedEntities)) {
+      const relationDef = getRelationDefs.find(
+        (r) => r.target_entity_type === targetEntityType,
       );
+      if (!relationDef) continue;
+
+      const relationType = relationDef.relation_type;
+      const entityArray = Array.isArray(rawEntityData) ? rawEntityData : [rawEntityData];
 
-      // Get relation definitions
-      const getRelationDefs = await this.dataSource.query(
-        `SELECT * FROM cr_entity_relation WHERE organization_id = ? AND source_entity_type = ?`,
-        [organizationId, entityType],
+      // Delete previous relations and related entities
+      const existingRelationsForType = await this.dataSource.query(
+        `SELECT * FROM cr_entity_relation_data WHERE source_entity_type = ? AND source_entity_id = ? AND target_entity_type = ?`,
+        [entityType, id, targetEntityType],
       );
 
-      // Process each target entity type in mappedEntities
-      for (const [targetEntityType, entityData] of Object.entries(
-        mappedEntities,
-      )) {
-        const relationDef = getRelationDefs.find(
-          (r) => r.target_entity_type === targetEntityType,
+      for (const existingRel of existingRelationsForType) {
+        // Delete the related entity
+        await this.deleteEntity(existingRel.target_entity_type, existingRel.target_entity_id, loggedInUser);
+
+        // Delete the relation row
+        await this.dataSource.query(
+          `DELETE FROM cr_entity_relation_data WHERE id = ?`,
+          [existingRel.id],
         );
+      }
 
-        if (!relationDef) {
-          console.warn(
-            `No relation definition found for ${entityType} -> ${targetEntityType}`,
-          );
-          continue;
+      // Create/update new entities & relations
+      const updatedEntities: any[] = [];
+
+      for (const item of entityArray) {
+        let targetEntityId;
+        let entityData;
+
+        if (item.id) {
+          // Update existing entity
+          await this.updateEntity(targetEntityType, item.id, item, loggedInUser);
+          targetEntityId = item.id;
+          entityData = await this.getEntity(targetEntityType, targetEntityId, loggedInUser);
+        } else {
+          // Create new entity
+          const createdEntity = await this.createEntity(targetEntityType, item, loggedInUser);
+          targetEntityId = createdEntity.insertId || createdEntity.id;
+          entityData = await this.getEntity(targetEntityType, targetEntityId, loggedInUser);
         }
 
-        const relationType = relationDef.relation_type;
-        const existingRelationsForType = existingRelations.filter(
-          (r) => r.target_entity_type === targetEntityType,
+        // Insert relation
+        await this.dataSource.query(
+          `INSERT INTO cr_entity_relation_data 
+          (source_entity_id, source_entity_type, target_entity_id, target_entity_type, relation_type) 
+          VALUES (?, ?, ?, ?, ?)`,
+          [id, entityType, targetEntityId, targetEntityType, relationType],
         );
 
         if (relationType === 'ONE_TO_MANY') {
-          // Handle array of entities
-          if (Array.isArray(entityData)) {
-            // Delete existing relations for this type
-
-            for (const existingRel of existingRelationsForType) {
-              await this.dataSource.query(
-                `DELETE FROM cr_entity_relation_data WHERE id = ?`,
-                [existingRel.id],
-              );
-            }
-
-            // Create new relations
-            for (const item of entityData) {
-              let targetEntityId;
-
-              if (item.id) {
-                // Update existing entity
-                await this.updateEntity(
-                  targetEntityType,
-                  item.id,
-                  item,
-                  loggedInUser,
-                );
-                targetEntityId = item.id;
-              } else {
-                // Create new entity
-                const createdEntity = await this.createEntity(
-                  targetEntityType,
-                  item,
-                  loggedInUser,
-                );
-                targetEntityId = createdEntity.insertId || createdEntity.id;
-              }
-
-              // Create relation entry
-              await this.dataSource.query(
-                `INSERT INTO cr_entity_relation_data (source_entity_id, source_entity_type, target_entity_id, target_entity_type, relation_type) VALUES (?, ?, ?, ?, ?)`,
-                [
-                  id,
-                  entityType,
-                  targetEntityId,
-                  targetEntityType,
-                  relationType,
-                ],
-              );
-            }
-          } else {
-            throw new Error(
-              `Expected array for ONE_TO_MANY relationship with ${targetEntityType}`,
-            );
-          }
-        } else if (
-          relationType === 'ONE_TO_ONE' ||
-          relationType === 'MANY_TO_ONE'
-        ) {
-          // Handle single entity
-          if (!Array.isArray(entityData)) {
-            const singleEntityData = entityData as Record<string, any>;
-            let targetEntityId;
-
-            if (singleEntityData.id) {
-              // Update existing entity
-              await this.updateEntity(
-                targetEntityType,
-                singleEntityData.id,
-                singleEntityData,
-                loggedInUser,
-              );
-              targetEntityId = singleEntityData.id;
-            } else {
-              // Create new entity
-              const createdEntity = await this.createEntity(
-                targetEntityType,
-                singleEntityData,
-                loggedInUser,
-              );
-              targetEntityId = createdEntity.insertId || createdEntity.id;
-
-              // Create relation entry if it doesn't exist
-              const existingRel = existingRelationsForType[0];
-              if (!existingRel) {
-                await this.dataSource.query(
-                  `INSERT INTO cr_entity_relation_data (source_entity_id, source_entity_type, target_entity_id, target_entity_type, relation_type) VALUES (?, ?, ?, ?, ?)`,
-                  [
-                    id,
-                    entityType,
-                    targetEntityId,
-                    targetEntityType,
-                    relationType,
-                  ],
-                );
-              }
-            }
-          } else {
-            throw new Error(
-              `Expected single object for ONE_TO_ONE relationship with ${targetEntityType}`,
-            );
-          }
+          updatedEntities.push(entityData);
+        } else if (relationType === 'ONE_TO_ONE' || relationType === 'MANY_TO_ONE') {
+          updatedEntities[0] = entityData; // single object
         }
       }
-    }
 
-    return { success: true };
+      // Assign to response mappedEntities
+      updatedRelations[targetEntityType] =
+        relationType === 'ONE_TO_MANY' ? updatedEntities : updatedEntities[0];
+    }
   }
 
+  return {
+    mainEntity: {
+      id,
+      entityType,
+      data: updatedMainEntity,
+    },
+    relatedEntities: updatedRelations,
+  };
+}
+
+
   // -----------------------------
   async updateEntity(
     entityType: string,
@@ -472,6 +347,21 @@ export class EntityDynamicService {
         entityData.enterprise_id = loggedInUser.enterprise_id;
     }
 
+    if (!entityData.code && loggedInUser) {
+      const result = await this.dataSource.query(
+        `SELECT MAX(CAST(SUBSTRING(code, LENGTH(entity_type) + 1) AS UNSIGNED)) AS max_seq_no
+     FROM ${tableName}
+     WHERE entity_type = ?`,
+        [entityData.entity_type],
+      );
+
+      // result will be like [ { max_seq_no: 12 } ]
+      let maxSeqNo = result?.[0]?.max_seq_no ? Number(result[0].max_seq_no) : 0;
+
+      maxSeqNo += 1;
+      entityData.code = `${entityData.entity_type}${maxSeqNo}`;
+    }
+
     const bypassColumn = [
       'created_date',
       'created_by',

package/src/module/notification/service/email.service.ts

@@ -41,8 +41,8 @@ export class EmailService {
       }
     }
 
-    // fire-and-forget
-    const result = await this.mailerService
+    // fire-and-forget // removed await
+    const result = this.mailerService
       .sendMail({
         to: email,
         subject,

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

@@ -63,7 +63,10 @@ export class LoginController {
     // Call LoginService to validate user, create session, and return JWT
     const data = await this.loginService.loginWithGoogle(email, name);
 
-    if (!('accessToken' in data) || !data.accessToken) return;
+    if (!('accessToken' in data) || !data.accessToken)
+      return res.redirect(
+        `${this.configService.get('BASE_URL')}/auth?email=${email}&error='User not found'`,
+      );
 
     const { accessToken, appcode } = data;
     return res.redirect(

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

@@ -48,6 +48,8 @@ export class TaskController {
       mapped_entity_id: number;
       stage_id: number;
       action_id: number;
+      reason_code: string | number;
+      remark: string;
     },
   ) {
     const loggedInUser = req.user.userData;