Nutzerdefinierte Integrationen erstellen

return `https://accounts.google.com/o/oauth2/v2/auth?client_id=${env.CLIENT_ID}&response_type=code&scope=${data.input.scope}&access_type=offline&redirect_uri=${encodeURIComponent(data.input.redirectUrl)}&state=${data.input.state}&prompt=consent`;

https://www.googleapis.com/auth/calendar.events https://www.googleapis.com/auth/userinfo.email https://www.googleapis.com/auth/userinfo.profile

url: 'https://people.googleapis.com/v1/people/me?personFields=names,emailAddresses'

// Erforderliche Eingaben validieren
if (!data.input.title) {
  return { error: 'Titel ist erforderlich' };
}

// Anfrage erstellen
const options = {
  method: 'POST',
  url: 'https://api.ticketing-service.com/tickets',
  headers: {
    'Authorization': `Bearer ${data.auth.api_key}`,
    'Content-Type': 'application/json',
  },
  body: {
    title: data.input.title,
    description: data.input.description || '',
    priority: data.input.priority || 'medium',
    assignee: data.input.assignee
  }
};

try {
  const response = await ld.request(options);

  if (response.status === 201) {
    return {
      success: true,
      ticketId: response.json.id,
      url: response.json.url,
      message: `Ticket #${response.json.id} erstellt: ${data.input.title}`
    };
  } else {
    throw new Error(`API hat Status ${response.status} zurückgegeben`);
  }
} catch (error) {
  ld.log('Fehler beim Erstellen des Tickets:', error.message);
  return {
    success: false,
    error: `Ticket konnte nicht erstellt werden: ${error.message}`
  };
}

// Datei-Uploads verarbeiten (erfordert FILE-Eingabefeld)
const document = data.input.document; // FileData-Objekt

if (!document) {
  return { error: 'Bitte hänge ein Dokument an' };
}

// Dateityp validieren
const allowedTypes = ['application/pdf', 'image/jpeg', 'image/png'];
if (!allowedTypes.includes(document.mimeType)) {
  return {
    error: `Nicht unterstützter Dateityp: ${document.mimeType}. Erlaubt: ${allowedTypes.join(', ')}`
  };
}

const options = {
  method: 'POST',
  url: 'https://api.example.com/documents',
  headers: {
    'Authorization': `Bearer ${data.auth.api_key}`,
    'Content-Type': 'application/json'
  },
  body: {
    filename: document.fileName,
    content: document.base64,
    mimeType: document.mimeType
  }
};

const response = await ld.request(options);
return {
  success: true,
  documentId: response.json.id,
  message: `${document.fileName} erfolgreich hochgeladen`
};

// CSV-Export generieren
const data = await fetchCustomerData();

const csvHeader = 'Name,Email,Erstellt';
const csvRows = data.map(customer =>
  `"${customer.name}","${customer.email}","${customer.created}"`
);
const csvContent = [csvHeader, ...csvRows].join('\n');

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

return [
  {
    id: "unique_event_id",        // Required: Unique identifier
    timestamp: "2024-01-15T...",  // Required: Event timestamp (ISO string)
    data: {
      // Your event data here
      eventType: "new_email",
      subject: "Important message",
      from: "sender@example.com",
      // ... other event properties
    }
  }
];

// Fetch recent emails
const options = {
  method: 'GET',
  url: 'https://api.email-service.com/messages',
  headers: {
    'Authorization': `Bearer ${data.auth.access_token}`,
  },
  params: {
    since: new Date(Date.now() - 60 * 60 * 1000).toISOString(), // Last hour
    limit: 10
  }
};

try {
  const response = await ld.request(options);
  const emails = response.json.messages || [];

  // Transform to required format
  const results = emails.map(email => ({
    id: email.id,
    timestamp: email.receivedAt,
    data: {
      messageId: email.id,
      subject: email.subject,
      from: email.from,
      to: email.to,
      body: email.body,
      isRead: email.isRead
    }
  }));

  return results;
} catch (error) {
  ld.log('Error fetching emails:', error.message);
  return [];
}

const results = [];

for (const email of emails) {
  const attachments = [];

  // Process email attachments
  if (email.attachments && email.attachments.length > 0) {
    for (const attachment of email.attachments) {
      const content = await downloadAttachment(attachment.id);

      attachments.push({
        fileName: attachment.filename,
        mimeType: attachment.mimeType,
        base64: content.toString('base64')
      });
    }
  }

  results.push({
    id: email.id,
    timestamp: email.receivedAt,
    data: {
      subject: email.subject,
      from: email.from,
      body: email.body,
      files: attachments  // Files go inside data object
    }
  });
}

return results;

// Transform incoming webhook data
const webhookData = data.input.webhookPayload;

return [
  {
    id: webhookData.event_id || crypto.randomUUID(),
    timestamp: webhookData.timestamp || new Date().toISOString(),
    data: {
      eventType: webhookData.type,
      resourceId: webhookData.resource_id,
      action: webhookData.action,
      changes: webhookData.changes,
      // Transform webhook format to your preferred structure
    }
  }
];

{
  url: string,
  documentId: string,
  title: string,
  author?: {
    id: string,
    name: string,
    imgUrl?: string,
  },
  mimeType: string,
  lastSeenByUser: Date,
  createdDate: Date,
  lastModifiedByAnyone: Date,
  lastModifiedByUserId?: {
    id?: string,
    name?: string,
    lastModifiedByUserIdDate: Date,
  },
  parent?: {
    id: string,
    title?: string,
    url?: string,
    type?: string,
    driveId?: string,
    siteId?: string,
    listId?: string,
    listItemId?: string,
  }
}

{
  data: response.data,
  fileName: string,
  mimeType: string,
  buffer: response.buffer, // Conditional
  url: string,
  lastModified: Date,
  text: string // Conditional
}

const options = {
  method: 'GET',
  url: `https://www.googleapis.com/calendar/v3/calendars/${data.input.calendarId}/events/${data.input.eventId}`,
  headers: {
    'Authorization': 'Bearer ' + data.auth.access_token,
    'Accept': 'application/json',
  },
};

const response = await ld.request(options);

return response.json;

const properties = data.input.properties
  ? JSON.parse(data.input.properties)
  : {};

const options = {
  method: "PATCH",
  url: `https://api.hubapi.com/crm/v3/objects/companies/${data.input.companyId}`,
  headers: {
    Authorization: "Bearer " + data.auth.access_token,
    "Content-Type": "application/json",
  },
  body: {
    properties: properties,
  },
};

const auth = btoa(`${env.CLIENT_ID}:${env.CLIENT_SECRET}`);