Dateiunterstützung in benutzerdefinierten Integrationen

// Gmail-artige E-Mail mit Dateianhängen
const recipient = data.input.mailRecipient;
const subject = data.input.mailSubject;
const body = data.input.mailBody;
const attachments = data.input.attachments || [];

// Multipart-E-Mail erstellen
let email = `To: ${recipient}\r\nSubject: ${subject}\r\n`;

if (attachments.length > 0) {
const boundary = `boundary_${Date.now()}`;
email += `Content-Type: multipart/mixed; boundary="${boundary}"\r\n\r\n`;
email += `--${boundary}\r\nContent-Type: text/html\r\n\r\n${body}\r\n`;

  // Jeden Anhang hinzufügen
  for (const attachment of attachments) {
    email += `--${boundary}\r\n`;
    email += `Content-Type: ${attachment.mimeType}\r\n`;
    email += `Content-Transfer-Encoding: base64\r\n`;
    email += `Content-Disposition: attachment; filename="${attachment.fileName}"\r\n`;
    email += `\r\n${attachment.base64}\r\n`;
  }
  email += `--${boundary}--`;

}

const document = data.input.document;

// Dateityp validieren
if (!document.mimeType.startsWith('application/pdf')) {
  throw new Error('Nur PDF-Dateien werden unterstützt');
}

try {
  const response = await ld.request({
    method: 'POST',
    url: 'https://api.example.com/documents',
    headers: {
      'Authorization': `Bearer ${data.auth.apiKey}`,
      'Content-Type': 'application/json'
    },
    body: {
      filename: document.fileName,
      content: document.base64,
      mimeType: document.mimeType
    }
  });

  return {
    success: true,
    documentId: response.json.id,
    message: `${document.fileName} erfolgreich hochgeladen`
  };
} catch (error) {
  return {
    success: false,
    error: `Fehler beim Hochladen von ${document.fileName}: ${error.message}`
  };
}

const files = data.input.files || [];

if (files.length === 0) {
  return { error: 'Keine Dateien bereitgestellt' };
}

const results = [];

for (const file of files) {
  try {
    const buffer = Buffer.from(file.base64, 'base64');
    
    // Basierend auf Dateityp verarbeiten
    let result;
    if (file.mimeType.startsWith('image/')) {
      result = await processImage(buffer);
    } else if (file.mimeType === 'application/pdf') {
      result = await processPDF(buffer);
    } else {
      throw new Error(`Nicht unterstützter Dateityp: ${file.mimeType}`);
    }
    
    results.push({
      filename: file.fileName,
      status: 'success',
      result: result
    });
    
    ld.log(`${file.fileName} erfolgreich verarbeitet`);
  } catch (error) {
    results.push({
      filename: file.fileName,
      status: 'error',
      error: error.message
    });
    
    ld.log(`Fehler beim Verarbeiten von ${file.fileName}: ${error.message}`);
  }
}

return {
  success: true,
  processed: results.filter(r => r.status === 'success').length,
  failed: results.filter(r => r.status === 'error').length,
  results: results
};

// PDF-Bericht aus Daten generieren
const reportData = await fetchReportData();

// PDF-Inhalt erstellen (mit benutzerdefinierter Funktion / Endpunkt)
const pdfBuffer = await generatePDF({
  title: 'Monatsbericht',
  data: reportData,
  template: 'standard'
});

return {
  files: {
    fileName: `monatsbericht-${new Date().toISOString().slice(0,7)}.pdf`,
    mimeType: 'application/pdf',
    base64: pdfBuffer.toString('base64')
  },
  success: true,
  message: `Bericht mit ${reportData.length} Einträgen generiert`
};

// Daten als CSV mit Text-Abkürzung exportieren
const customers = await fetchCustomers();

// CSV-Inhalt erstellen
const csvHeader = 'Name,Email,Erstellt,Status';
const csvRows = customers.map(c => 
  `"${c.name}","${c.email}","${c.created}","${c.status}"`
);
const csvContent = [csvHeader, ...csvRows].join('\n');

return {
  files: {
    fileName: `kunden-export-${new Date().toISOString().slice(0,10)}.csv`,
    mimeType: 'text/csv',
    text: csvContent  // Text für UTF-8-Inhalt verwenden
  },
  success: true,
  exported: customers.length
};

// Datei von externer API herunterladen
const fileId = data.input.fileId;

try {
  const response = await ld.request({
    method: 'GET',
    url: `https://api.example.com/files/${fileId}`,
    headers: {
      'Authorization': `Bearer ${data.auth.apiKey}`
    }
  });
  
  // Dateinamen aus Response-Headers oder API erhalten
  const filename = response.headers['content-disposition']
    ?.match(/filename="(.+)"/)?.[1] || `datei-${fileId}`;
  
  return {
    files: {
      fileName: filename,
      mimeType: response.headers['content-type'] || 'application/octet-stream',
      base64: response.body  // Annahme: API gibt base64 zurück
    },
    success: true,
    message: `${filename} heruntergeladen`
  };
} catch (error) {
  return {
    success: false,
    error: `Fehler beim Herunterladen der Datei: ${error.message}`
  };
}

// Eingabedateien verarbeiten und modifizierte Versionen zurückgeben
const inputFiles = data.input.documents || [];
const outputFiles = [];

for (const file of inputFiles) {
  try {
    const buffer = Buffer.from(file.base64, 'base64');
    
    // Datei verarbeiten (z.B. komprimieren, konvertieren, etc.)
    const processedBuffer = await processFile(buffer, file.mimeType);
    
    outputFiles.push({
      fileName: `verarbeitet-${file.fileName}`,
      mimeType: file.mimeType,
      base64: processedBuffer.toString('base64')
    });
  } catch (error) {
    ld.log(`Fehler beim Verarbeiten von ${file.fileName}: ${error.message}`);
  }
}

return {
  files: outputFiles,
  success: true,
  processed: outputFiles.length,
  message: `${outputFiles.length} von ${inputFiles.length} Dateien verarbeitet`
};

// Gmail-Trigger verarbeitet eingehende E-Mails
const emails = await fetchNewEmails();
const results = [];

for (const email of emails) {
  const attachments = [];
  
  // E-Mail-Anhänge verarbeiten, falls vorhanden
  if (email.attachments && email.attachments.length > 0) {
    for (const attachment of email.attachments) {
      // Anhanginhalt herunterladen
      const content = await downloadAttachment(attachment.id);
      
      attachments.push({
        fileName: attachment.filename,
        mimeType: attachment.mimeType,
        base64: content.toString('base64')
      });
    }
  }
  
  results.push({
    id: email.id,                     // Erforderlich: eindeutige Ereignis-ID
    timestamp: email.date,            // Erforderlich: Ereignis-Zeitstempel
    data: {
      from: email.from,
      subject: email.subject,
      body: email.body,
      receivedAt: email.date,
      messageId: email.id,
      threadId: email.threadId,
      files: attachments              // Dateien innerhalb des data-Objekts
    }
  });
}

return results;  // Array von Trigger-Ereignissen zurückgeben

// Auf neue Dateien in einem Verzeichnis überwachen
const newFiles = await checkForNewFiles(data.input.directory);
const results = [];

for (const file of newFiles) {
  try {
    // Dateiinhalt herunterladen
    const content = await downloadFile(file.path);
    
    results.push({
      id: file.id || file.path,         // Erforderlich: eindeutiger Dateibezeichner
      timestamp: file.lastModified,     // Erforderlich: Ereignis-Zeitstempel
      data: {
        filePath: file.path,
        fileName: file.name,
        size: file.size,
        modifiedAt: file.lastModified,
        event: 'file_created',
        files: [                        // Dateien-Array innerhalb des data-Objekts
          {
            fileName: file.name,
            mimeType: file.mimeType || 'application/octet-stream',
            base64: content.toString('base64')
          }
        ]
      }
    });
  } catch (error) {
    ld.log(`Fehler beim Verarbeiten der Datei ${file.name}: ${error.message}`);
  }
}

return results;  // Array von Trigger-Ereignissen zurückgeben