Code

// Zugriff auf Daten von vorherigen Nodes
const scores = agent.output.structured.scores || [];

// Statistiken berechnen
const average = scores.reduce((a, b) => a + b, 0) / scores.length;
const max = Math.max(...scores);
const min = Math.min(...scores);

// Ergebnis zurückgeben
return {
  average_score: average.toFixed(2),
  highest_score: max,
  lowest_score: min,
  grade: average >= 90 ? "A" : average >= 80 ? "B" : "C"
};

// Zugriff auf Formulardaten
const email = trigger.output.email || "";
const amount = trigger.output.amount || 0;

// Validieren
if (!email.includes("@")) {
  throw new Error("Ungültiges E-Mail-Format");
}

if (amount <= 0) {
  throw new Error("Betrag muss größer als null sein");
}

// Bereinigen und zurückgeben
return {
  email: email.trim().toLowerCase(),
  amount: parseFloat(amount.toFixed(2)),
  validated: true
};

// Zugriff auf Daten von vorherigem Node
const customers = trigger.output.customers || [];

// Aktive Kunden filtern
const activeCustomers = customers.filter(c => c.status === "active");

// Daten transformieren
const processed = activeCustomers.map(customer => ({
  id: customer.id,
  name: `${customer.firstName} ${customer.lastName}`.trim(),
  email: customer.email.toLowerCase(),
  tier: customer.totalSpent > 1000 ? "premium" : "standard"
}));

return {
  customers: processed,
  total: processed.length,
  premiumCount: processed.filter(c => c.tier === "premium").length
};

// Zugriff auf Event-Daten
const events = trigger.output.events || [];
const now = new Date();

const processedEvents = events.map(event => {
  const eventDate = new Date(event.date);
  const daysUntil = Math.ceil((eventDate - now) / (1000 * 60 * 60 * 24));

  return {
    title: event.title,
    date: eventDate.toISOString(),
    formatted: eventDate.toLocaleDateString("de-DE", {
      weekday: "long",
      year: "numeric",
      month: "long",
      day: "numeric"
    }),
    daysUntil: daysUntil,
    isUpcoming: daysUntil >= 0,
    isThisWeek: daysUntil >= 0 && daysUntil <= 7
  };
});

return {
  events: processedEvents,
  upcomingCount: processedEvents.filter(e => e.isUpcoming).length,
  thisWeekCount: processedEvents.filter(e => e.isThisWeek).length
};

// Verschachteltes JSON von API-Response
const apiResponse = http_request.output || {};

// Verschachtelte Daten extrahieren und vereinfachen
const users = apiResponse.data?.users || [];

const flattened = users.map(user => ({
  id: user.id,
  name: `${user.first_name || ""} ${user.last_name || ""}`.trim(),
  email: user.contact?.email || "",
  city: user.address?.city || "Unbekannt",
  isActive: user.status === "active"
}));

return {
  users: flattened,
  total: flattened.length,
  activeCount: flattened.filter(u => u.isActive).length
};

// Verkaufsdaten von vorherigem Node
const sales = http_request.output.sales || [];

// Nach Kategorie gruppieren
const byCategory = {};
sales.forEach(sale => {
  const cat = sale.category || "Sonstiges";
  if (!byCategory[cat]) {
    byCategory[cat] = { total: 0, count: 0, items: [] };
  }
  byCategory[cat].total += sale.amount || 0;
  byCategory[cat].count += 1;
  byCategory[cat].items.push(sale);
});

// Zusammenfassung berechnen
const summary = Object.entries(byCategory).map(([category, data]) => ({
  category,
  totalRevenue: data.total.toFixed(2),
  orderCount: data.count,
  averageOrder: (data.total / data.count).toFixed(2)
}));

// Nach Umsatz sortieren
summary.sort((a, b) => parseFloat(b.totalRevenue) - parseFloat(a.totalRevenue));

return {
  summary: summary,
  topCategory: summary[0]?.category || "Keine",
  grandTotal: sales.reduce((sum, s) => sum + (s.amount || 0), 0).toFixed(2)
};

{{code_node_name.output.customer}}
{{code_node_name.output.total}}
{{code_node_name.output.formatted_date}}
{{code_node_name.output.processed_items[0].name}}