Zoho Desk, Deluge und Catalyst: Tutorial für automatisierte Ticket-Zuweisung mit Monitoring

Smarte Ticket-Automatisierung in Zoho Desk: Dein Guide für Deluge, Webhooks und Catalyst-Monitoring

Wenn dein Unternehmen wächst, wächst auch dein Support-Aufkommen. Die manuelle Zuweisung von Tickets in Zoho Desk wird schnell zum Flaschenhals: Sie ist zeitaufwendig, fehleranfällig und berücksichtigt oft nicht die tatsächliche Verfügbarkeit deiner Agenten. Was passiert, wenn ein Kollege krank wird oder im Urlaub ist? Die ihm zugewiesenen Tickets bleiben liegen und die Kundenzufriedenheit sinkt. Genau hier setzt eine intelligente Automatisierung an. In diesem Fachartikel zeigen wir dir, wie du einen robusten Prozess zur automatischen Zuweisung und zum Entzug von Tickets aufbaust. Wir nutzen dafür nicht nur die Bordmittel von Zoho Desk, sondern kombinieren sie geschickt mit der Power von Deluge Custom Functions und dem serverless Monitoring über Zoho Catalyst.

Das Praxisbeispiel: Die Herausforderung der dynamischen Ticket-Verteilung

Stell dir ein mittelständisches E-Commerce-Unternehmen vor. Das Support-Team arbeitet in Schichten und bearbeitet täglich Hunderte von Anfragen über verschiedene Kanäle. Die Herausforderung ist klar: Wie stellt man sicher, dass jedes neu eintreffende Ticket schnellstmöglich dem richtigen, verfügbaren Agenten zugewiesen wird? Und was noch wichtiger ist: Wie werden Tickets, die einem abwesenden Mitarbeiter zugewiesen wurden, automatisch wieder in den allgemeinen Pool zurückgeführt, um von aktiven Kollegen bearbeitet zu werden?

Eine einfache Round-Robin-Zuweisung reicht hier nicht aus. Sie berücksichtigt weder die aktuelle Auslastung noch die Online-Zeiten der Mitarbeiter. Eine naive Automatisierung, die Tickets nach 24 Stunden Inaktivität einfach wieder entzieht, kann zudem zu einer Endlosschleife führen: Das System entzieht Agent A ein Ticket, nur um es fünf Minuten später wieder Agent A zuzuweisen, da er formal als "verfügbar" gilt. Wir brauchen also eine smartere Lösung.

Schritt-für-Schritt-Anleitung zur smarten Automatisierung

Unsere Lösung basiert auf einer Kombination aus Workflow-Regeln, benutzerdefinierten Feldern und zwei zentralen Deluge Custom Functions in Zoho Desk, die von einem externen Scheduler (z. B. über Zoho Flow oder eine Catalyst-Funktion) regelmäßig aufgerufen werden.

1. Vorbereitung: Benutzerdefinierte Felder in Zoho Desk anlegen

Damit unsere Logik funktioniert, benötigen wir im Ticket-Modul zwei zusätzliche Felder, um uns den Status der letzten Zuweisung zu "merken":

• Letzter Agent (API-Name: Custom_LastAgent): Ein Nachschlagefeld (Lookup) zum Benutzer-Modul. Hier speichern wir, wem das Ticket zuletzt entzogen wurde.
• Entzugs-Zeitstempel (API-Name: Custom_WithdrawalTimestamp): Ein Datums-/Uhrzeitfeld. Hier speichern wir den genauen Zeitpunkt des Entzugs.

Diese Felder sind das Gedächtnis unserer Automatisierung und der Schlüssel zur Vermeidung von Endlosschleifen.

2. Die Logik per Deluge Custom Function: Zuweisung und Entzug

Wir erstellen zwei separate Custom Functions. Die erste ist für den Entzug von Tickets zuständig, die zweite für die Neuverteilung.

Funktion 1: Ticket-Entzug bei Inaktivität (withdrawInactiveTickets)

Diese Funktion durchsucht alle offenen Tickets, die einem Agenten zugewiesen sind und seit mehr als 24 Stunden nicht mehr aktualisiert wurden. Findet sie ein solches Ticket, entzieht sie es dem Agenten.

Funktion 2: Zuweisung von unverteilten Tickets (assignQueuedTickets)

Diese Funktion sucht nach allen unzugewiesenen Tickets, sortiert sie nach Alter (älteste zuerst) und weist sie einem verfügbaren Online-Agenten zu. Hier kommt unsere Karenzzeit-Logik ins Spiel: Sie prüft die von uns erstellten benutzerdefinierten Felder, um eine sofortige Wiederzuweisung an denselben Agenten zu verhindern.

3. Professionelles Monitoring mit Zoho Catalyst

Eine Automatisierung, die im Hintergrund läuft, muss überwacht werden. Was passiert, wenn ein API-Aufruf fehlschlägt oder die Logik unerwartetes Verhalten zeigt? Statt uns auf E-Mail-Benachrichtigungen zu verlassen, bauen wir ein sauberes Logging mit Zoho Catalyst.

1. Erstelle eine Catalyst Basic I/O-Funktion: Im Catalyst-Projekt erstellst du eine einfache Node.js- oder Java-Funktion, die einen POST-Request mit Log-Daten entgegennimmt und diese in die Catalyst Logs schreibt. Diese Funktion hat einen eindeutigen API-Endpunkt.
2. Integriere Logging in Deluge: Innerhalb unserer Deluge-Funktionen in Zoho Desk rufen wir nach jeder wichtigen Aktion (z.B. "Ticket X wurde Agent Y zugewiesen") diesen Endpunkt per invokeurl auf und übergeben eine strukturierte JSON-Nachricht.

So erhalten wir ein zentrales, durchsuchbares Log all unserer Automatisierungsaktivitäten, ohne unser Zoho Desk zu belasten. Das ist entscheidend für die Fehlersuche und Optimierung.

Codebeispiele: Deluge in Aktion

Hier sind die grundlegenden Deluge-Skripte für die beiden Funktionen. Beachte, dass dies vereinfachte Beispiele sind, die du an deine spezifischen Anforderungen (z.B. Abteilungen, Prioritäten) anpassen musst.

Deluge-Funktion: withdrawInactiveTickets

// Funktion zum Entziehen von Tickets, die länger als 24 Stunden inaktiv sind
void withdrawInactiveTickets()
{
	// Zeitstempel für "vor 24 Stunden" berechnen
	twentyFourHoursAgo = zoho.currenttime.subHour(24);
	
	// Alle offenen Tickets abrufen, die einem Agenten zugewiesen sind und vor mehr als 24h zuletzt geändert wurden
	searchCriteria = "((Status:equals:Open) and (Owner:isnot:null) and (Modified Time:less_than:" + twentyFourHoursAgo + "))";
	response = zoho.desk.searchRecords("tickets", {"searchStr":searchCriteria});
	
	// Prüfen, ob Tickets gefunden wurden
	if(response.get("data") != null)
	{
		ticketList = response.get("data");
		for each  ticket in ticketList
		{
			ticketId = ticket.get("id");
			ownerId = ticket.get("owner").get("id");
			
			// Parameter für das Update vorbereiten
			updateMap = Map();
			updateMap.put("ownerId", null); // Besitzer entfernen
			updateMap.put("customFields", {"Letzter Agent":ownerId, "Entzugs-Zeitstempel":zoho.currenttime});
			
			// Ticket aktualisieren
			updateResponse = zoho.desk.update("tickets", ticketId, updateMap);
			
			// Logging an Zoho Catalyst senden
			logToCatalyst("Ticket entzogen", {"ticketId":ticketId, "previousOwnerId":ownerId});
		}
	}
}

// Helper-Funktion für das Catalyst Logging
void logToCatalyst(String message, Map details)
{
	catalyst_webhook_url = "DEINE_CATALYST_ENDPOINT_URL"; // Ersetze dies durch deine URL
	logPayload = Map();
	logPayload.put("source", "ZohoDeskAutomation");
	logPayload.put("message", message);
	logPayload.put("details", details);
	
	// Sende die Log-Daten via POST-Request
	invokeurl
	[
		url :catalyst_webhook_url
		type :POST
		parameters:logPayload.toString()
		connection:"my_catalyst_connection" // Eine Verbindung muss konfiguriert werden
	];
}

Deluge-Funktion: assignQueuedTickets

// Funktion zur Zuweisung von Tickets in der Warteschlange
void assignQueuedTickets()
{
	// 1. Hole alle verfügbaren Online-Agenten
	// Dies ist eine Vereinfachung. In der Praxis würdest du die Agentenverfügbarkeit prüfen.
	// z.B. über eine API oder eine Custom-Logik in Zoho People/Shifts.
	availableAgents = zoho.desk.getRecords("agents", {"status":"ACTIVE"}).get("data");
	
	if (availableAgents.size() > 0)
	{
		// 2. Hole alle unzugewiesenen Tickets, älteste zuerst
		searchCriteria = "(Owner:is:null) and (Status:equals:Open)";
		unassignedTickets = zoho.desk.searchRecords("tickets", {"searchStr":searchCriteria, "sort_by":"createdTime", "order":"asc"});
		
		if(unassignedTickets.get("data") != null)
		{
			// Round-Robin-Index initialisieren
			agentIndex = 0;
			
			for each ticket in unassignedTickets.get("data")
			{
				ticketId = ticket.get("id");
				lastAgentId = ticket.get("Custom_LastAgent") != null ? ticket.get("Custom_LastAgent").get("id") : null;
				withdrawalTime = ticket.get("Custom_WithdrawalTimestamp");
				
				// 3. Wähle den nächsten Agenten aus
				nextAgent = availableAgents.get(agentIndex);
				nextAgentId = nextAgent.get("id");
				
				// 4. Prüfe die Karenzzeit-Logik
				isCooldownActive = false;
				if(lastAgentId != null && withdrawalTime != null)
				{
					// Prüfe, ob weniger als 24 Stunden seit dem Entzug vergangen sind
					if(zoho.currenttime.subHour(24).compareTo(withdrawalTime) < 0)
					{
						if(lastAgentId == nextAgentId)
						{
							isCooldownActive = true;
						}
					}
				}
				
				// 5. Weise das Ticket zu, wenn keine Karenzzeit aktiv ist
				if(!isCooldownActive)
				{
					updateMap = Map();
					updateMap.put("ownerId", nextAgentId);
					updateResponse = zoho.desk.update("tickets", ticketId, updateMap);
					logToCatalyst("Ticket zugewiesen", {"ticketId":ticketId, "newOwnerId":nextAgentId});
					
					// Gehe zum nächsten Agenten für das nächste Ticket
					agentIndex = (agentIndex + 1) % availableAgents.size();
				}
				else
				{
					logToCatalyst("Zuweisung übersprungen (Karenzzeit)", {"ticketId":ticketId, "agentId":nextAgentId});
				}
			}
		}
	}
}

Tipps und Best Practices

• Fehlerbehandlung einbauen: Umwickle deine API-Aufrufe (zoho.desk.update, invokeurl) mit try-catch-Blöcken, um auf Fehler zu reagieren und diese ebenfalls an dein Catalyst-Logging zu senden.
• Skalierbarkeit für Teams: Erweitere die Logik, um Tickets nur an Agenten innerhalb der jeweiligen Abteilung (Department) zuzuweisen. Du kannst die Abteilungs-ID als Kriterium sowohl bei der Ticketsuche als auch bei der Agentenauswahl verwenden. Dies ist der erste Schritt in Richtung "Teamwarteschlangen".
• API-Limits beachten: Sei dir der API-Limits deines Zoho-Plans bewusst. Wenn du Tausende von Tickets hast, optimiere deine Skripte, indem du mit Massen-API-Aufrufen (Bulk APIs) arbeitest, anstatt jedes Ticket einzeln zu aktualisieren.
• Benachrichtigungen via Zoho Cliq: Verbessere die User Experience, indem du dem Agenten nach einer erfolgreichen Zuweisung eine automatische Nachricht über Zoho Cliq schickst. Das geht einfach mit der zoho.cliq.postToBot oder zoho.cliq.postToChannel Integration Task.
• Vermeide geteilte Benutzerkonten: Im Kontext von Automatisierung und Nachvollziehbarkeit ist es entscheidend, geteilte Logins (wie z.B. einen allgemeinen "Support"-Benutzer) zu vermeiden. Jede Aktion im System sollte eindeutig einem Mitarbeiter zugeordnet werden können. Das ist nicht nur für das Reporting in Zoho Analytics wichtig, sondern auch für die Funktionsweise solcher Zuweisungslogiken. Investiere lieber in eine kostengünstige Lizenz, z. B. als "Light Agent" in Desk oder eine volle Lizenz in Zoho CRM, um die Datenintegrität zu wahren.

Fazit

Die Automatisierung der Ticket-Zuweisung in Zoho Desk ist mehr als nur eine nette Spielerei. Es ist eine strategische Notwendigkeit für wachsende Support-Teams, um Effizienz zu steigern und eine konstant hohe Servicequalität zu gewährleisten. Indem du die Standard-Workflows von Zoho Desk mit der Flexibilität von Deluge und der Überwachungsstärke von Zoho Catalyst kombinierst, schaffst du eine maßgeschneiderte und widerstandsfähige Lösung.

Du reduzierst nicht nur manuellen Aufwand, sondern stellst auch sicher, dass kein Kunde aufgrund von internen Abwesenheiten vergessen wird. Trau dich, über den Tellerrand der Standardfunktionen hinauszuschauen – das Zoho-Ökosystem bietet dir alle Werkzeuge, die du dafür benötigst.

Verwendete Zoho Apps in diesem Szenario:

• Zoho Desk: Das Kernsystem für das Ticket-Management.
• Zoho Catalyst: Für serverseitiges Logging und Monitoring der Automatisierung.
• Zoho Flow (optional): Als externer Scheduler zum regelmäßigen Anstoßen der Deluge-Funktionen.
• Zoho Cliq (optional): Für Echtzeit-Benachrichtigungen an die Agenten.