rez_core 3.1.198 → 3.1.200

package/package.json

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

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

@@ -79,4 +79,14 @@ export class MediaController {
       });
     }
   }
+
+  @Post('generateUploadPath')
+  async generateUploadPath(@Req() req: Request & { user: any }, @Query('mapped_entity_type') mapped_entity_type: string,
+                           @Query('mapped_entity_id') mapped_entity_id?: number,
+                           @Query('parent_id') parent_id?: number,
+                           @Query('parent_type') parent_type?: string,
+                           ) {
+    const loggedInUser = req.user.userData;
+    return this.mediaDataService.buildUploadPathGeneric(mapped_entity_type, loggedInUser, mapped_entity_id,parent_id, parent_type)
+  }
 }

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

@@ -75,4 +75,10 @@ export class EntityMaster extends BaseEntity {
 
   @Column({ name: 'is_workflow', nullable: true })
   is_workflow: boolean;
+
+  @Column({ name: 'doc_upload_path', nullable: true, length:50 })
+  doc_upload_path: string;
+
+  @Column({name: 'overwrite_path', type: 'tinyint', nullable: true})
+  overwrite_path: number;
 }

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

@@ -9,12 +9,16 @@ import {
   STATUS_PENDING,
 } from '../../../constant/global.constant';
 import { v4 as uuidv4 } from 'uuid';
+import { OrganizationService } from '../../enterprise/service/organization.service';
+import { EntityMasterService } from './entity-master.service';
+import { DataSource } from 'typeorm';
 
 @Injectable()
 export class MediaDataService extends EntityServiceImpl {
   constructor(
     private readonly configService: ConfigService,
     private readonly mediaRepository: MediaDataRepository,
+    private dataSource: DataSource,
   ) {
     super();
   }
@@ -44,6 +48,8 @@ export class MediaDataService extends EntityServiceImpl {
     const ext = fileName.split('.').pop()?.toLowerCase() ?? '';
 
     const id = uuidv4();
+
+    //TODO:
     const s3Key = `uploads/${id}.${ext}`;
 
     const uploadUrl = await this.s3.getSignedUrlPromise('putObject', {
@@ -140,10 +146,95 @@ export class MediaDataService extends EntityServiceImpl {
         Key: mediaData.media_url,
         Expires: Number(expiresIn) || 60 * 5,
       });
-      return { signedUrl, fileName: mediaData.file_name, id: mediaData.id, size: fileSize};
+      return { signedUrl, fileName: mediaData.file_name, id: mediaData.id, size: fileSize };
     } catch (error) {
       console.error('Error generating signed URL for media:', error);
       throw new Error('Failed to generate signed URL');
     }
   }
+
+  public async buildUploadPathGeneric(
+    mappedEntityType: string,
+    loggedInUser,
+    mappedEntityId?: number,
+    parentId?: number,
+    parentType?: string,
+  ) {
+    // 1️⃣ Fetch entity metadata
+    const entityMaster = await this.entityMasterService.getEntityData(mappedEntityType, loggedInUser);
+    if (!entityMaster) {
+      throw new Error(`Entity master not found for ${mappedEntityType}`);
+    }
+
+    let pathTemplate = entityMaster.doc_upload_path ?? '';
+    const entityOverwrite = entityMaster.overwrite_path ?? 0;
+
+    if (!pathTemplate) {
+      throw new Error(`doc_upload_path not defined for ${mappedEntityType}`);
+    }
+
+    // 2️⃣ Prepare replacement map
+    const replacements: Record<string, string | null> = {};
+
+    // --- ORG ---
+    let organizationData = await this.dataSource.query('SELECT * FROM sso_organization WHERE id = ?', [loggedInUser.organization_id]);
+    replacements['org_code'] = organizationData[0].code;
+
+    // --- LEVEL CODE ---
+    // Determine which entity to use for level_code
+    const levelEntityId = entityOverwrite ? mappedEntityId : loggedInUser.level_id;
+    const levelEntityData = await super.getEntityData(loggedInUser.level_type, levelEntityId, loggedInUser);
+    if (levelEntityData?.code) {
+      replacements['level_code'] = levelEntityData.code; // universal alias
+    }
+
+    // --- Dynamic variables inside path ---
+    const matches = pathTemplate.match(/\$\{(\w+)\}/g) || [];
+
+    for (const variable of matches) {
+      const key = variable.replace(/\$\{|\}/g, '');
+      if (replacements[key]) continue; // already resolved
+
+      if (key === 'org_code') continue; // already set
+      if (key.endsWith('_code')) {
+        // derive entity type dynamically
+        const entityType = key.replace('_code', '').toUpperCase();
+
+        let entityId: number | undefined;
+        if (parentType?.toUpperCase() === entityType && parentId) {
+          entityId = parentId;
+        } else {
+          entityId = mappedEntityId;
+        }
+
+        // Generic lookup
+        if (entityId) {
+          const entityData = await super.getEntityData(entityType, entityId, loggedInUser);
+          replacements[key] = entityData?.code ?? null;
+        }
+      }
+    }
+
+    // --- ORG special case ---
+    // If ORG level & overwrite = 0 → remove level_code variable
+    if (loggedInUser.level_type === 'ORG' && entityOverwrite === 0) {
+      replacements['level_code'] = null;
+    }
+
+    // 3️⃣ Final substitution and cleanup
+    if (pathTemplate) {
+      const finalPath = this.resolveUploadPath(pathTemplate, replacements);
+      return finalPath;
+    }
+    return null;
+  }
+
+  /**
+   * Replace placeholders with actual values, remove missing variables
+   */
+  private resolveUploadPath(template: string, replacements: Record<string, string | null>) {
+    let path = template;
+    path = path.replace(/\$\{(\w+)\}/g, (_, key) => replacements[key] || '');
+    return path.replace(/\/+/g, '/').replace(/\/$/, '');
+  }
 }

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

@@ -70,12 +70,19 @@ export class OtpService {
     // Find OTP entity by ID
     const otpEntity = await this.findByOtpId(otp_id);
     if (!otpEntity) {
-      throw new BadRequestException('OTP not found!');
+      // throw new BadRequestException('OTP not found!');
+      return {
+        sucess: false,
+        message: 'OTP not found!',
+      };
     }
 
     // Validate the identifier against the OTP entity
     if (otpEntity.identifier !== identifier) {
-      throw new BadRequestException('Invalid OTP identifier!');
+      return {
+        sucess: false,
+        message: 'Invalid OTP identifier!',
+      };
     }
 
     // OTP validation logic