port-nimara-client-portal/server/api/eoi/upload-document.ts

import { uploadFile, createBucketIfNotExists, getMinioClient } from '~/server/utils/minio';
import { updateInterestEOIDocument } from '~/server/utils/nocodb';
import formidable from 'formidable';
import { promises as fs } from 'fs';
import mime from 'mime-types';

export default defineEventHandler(async (event) => {
  const xTagHeader = getRequestHeader(event, "x-tag");

  if (!xTagHeader || (xTagHeader !== "094ut234" && xTagHeader !== "pjnvü1230")) {
    throw createError({ statusCode: 401, statusMessage: "unauthenticated" });
  }

  try {
    // Get interestId from query params
    const query = getQuery(event);
    const interestId = query.interestId as string;
    
    if (!interestId) {
      throw createError({
        statusCode: 400,
        statusMessage: 'Interest ID is required',
      });
    }

    // Ensure bucket exists
    await createBucketIfNotExists('client-portal');
    
    // Parse multipart form data
    const form = formidable({
      maxFileSize: 50 * 1024 * 1024, // 50MB limit
      keepExtensions: true,
    });
    
    const [fields, files] = await form.parse(event.node.req);
    
    // Handle the uploaded file
    const uploadedFile = Array.isArray(files.file) ? files.file[0] : files.file;
    
    if (!uploadedFile) {
      throw createError({
        statusCode: 400,
        statusMessage: 'No file uploaded',
      });
    }
    
    // Read file buffer
    const fileBuffer = await fs.readFile(uploadedFile.filepath);
    
    // Generate filename with timestamp
    const timestamp = Date.now();
    const sanitizedName = uploadedFile.originalFilename?.replace(/[^a-zA-Z0-9.-]/g, '_') || 'eoi-document.pdf';
    const fileName = `EOIs/${interestId}-${timestamp}-${sanitizedName}`;
    
    // Get content type
    const contentType = mime.lookup(uploadedFile.originalFilename || '') || 'application/pdf';
    
    // Upload to MinIO client-portal bucket
    const client = getMinioClient();
    await client.putObject('client-portal', fileName, fileBuffer, fileBuffer.length, {
      'Content-Type': contentType,
    });
    
    // Clean up temp file
    await fs.unlink(uploadedFile.filepath);
    
    // Get download URL for the uploaded file
    const url = await client.presignedGetObject('client-portal', fileName, 24 * 60 * 60); // 24 hour expiry
    
    // Prepare document data for database
    const documentData = {
      title: uploadedFile.originalFilename || 'EOI Document',
      filename: fileName,
      url: url,
      size: uploadedFile.size,
      uploadedAt: new Date().toISOString()
    };
    
    // Update interest with EOI document information
    await updateInterestEOIDocument(interestId, documentData);
    
    // Also update the status fields
    const updateData: any = {
      'EOI Status': 'Waiting for Signatures',
      'EOI Time Sent': new Date().toISOString()
    };
    
    // Update Sales Process Level if it's below "LOI and NDA Sent"
    const currentLevel = await getCurrentSalesLevel(interestId);
    if (shouldUpdateSalesLevel(currentLevel)) {
      updateData['Sales Process Level'] = 'LOI and NDA Sent';
    }
    
    // Update the interest
    await $fetch('/api/update-interest', {
      method: 'POST',
      headers: {
        'x-tag': xTagHeader,
      },
      body: {
        id: interestId,
        data: updateData
      }
    });
    
    return {
      success: true,
      document: documentData,
      message: 'EOI document uploaded successfully',
    };
  } catch (error: any) {
    console.error('Failed to upload EOI document:', error);
    throw createError({
      statusCode: 500,
      statusMessage: error.message || 'Failed to upload EOI document',
    });
  }
});

async function getCurrentSalesLevel(interestId: string): Promise<string> {
  try {
    const interest = await $fetch(`/api/get-interest-by-id`, {
      headers: {
        'x-tag': '094ut234',
      },
      params: {
        id: interestId,
      },
    });
    return interest['Sales Process Level'] || '';
  } catch (error) {
    console.error('Failed to get current sales level:', error);
    return '';
  }
}

function shouldUpdateSalesLevel(currentLevel: string): boolean {
  const levelsBeforeLOI = [
    'General Qualified Interest',
    'Specific Qualified Interest'
  ];
  return levelsBeforeLOI.includes(currentLevel);
}