Headless-Web-SDK-Ereignisse

Das Headless Web SDK bietet Ereignisse, auf die Sie warten können, um bestimmte Aktionen oder Aktualisierungen in Ihrer Anwendung zu verarbeiten. Mit den Methoden .on und .off können Sie Event-Listener hinzufügen und entfernen.

const handleReady = () => {
  console.log("**** client is ready")
}

client.on("ready", handleReady)

// client.off("ready", handleReady)

Allgemeine Ereignisse

Im Folgenden finden Sie allgemeine Ereignisse für das SDK.

ready

Wird ausgegeben, wenn der Client bereit für die Kommunikation ist.

client.on("ready", () => {
})

authenticated

Wird ausgegeben, wenn der Client mit dem Token des Nutzers authentifiziert wurde.

client.on("authenticated", () => {
})

Chat-Ereignisse

Die folgenden Ereignisse sind spezifisch für Chatsitzungen.

chat.ongoing

Wird ausgegeben, wenn ein Chat läuft.

client.on("chat.ongoing", (chat) => {
  console.log(chat)
})

chat.updated

Wird ausgegeben, wenn die Chat-Instanz aktualisiert wurde.

client.on("chat.updated", (chat) => {
  // the `chat` property on `client` has updated
  console.log(chat)
})

chat.message

Wird ausgegeben, wenn eine neue Nachricht eingeht.

client.on("chat.message", message => {
  console.log(message)
})

Der Nachrichtentyp:

interface MessageResponse {
  $index: number;
  $sid: string;
  $timestamp: Date;
  $userType: string;
  $userId: number;
  type: string;
  content?: string;
  event?: string;
  file?: File;

  // extra parameters

}

chat.memberJoined

Wird ausgegeben, wenn ein neues Mitglied der Unterhaltung beitritt.

client.on("chat.memberJoined", (identity) => {
  console.log(identity)
})

chat.memberLeft

Wird ausgegeben, wenn ein Mitglied die Unterhaltung verlässt.

client.on("chat.memberLeft", (identity) => {
  console.log(identity)
})

chat.typingStarted

Wird ausgegeben, wenn ein Mitglied mit der Eingabe beginnt.

client.on("chat.typingStarted", (identity) => {
  console.log(identity)
})

chat.typingEnded

Wird ausgegeben, wenn ein Mitglied aufhört zu tippen.

client.on("chat.typingEnded", (identity) => {
  console.log(identity)
})

chat.connected

Wird ausgegeben, wenn der Chat mit dem Unterhaltungsanbieter verbunden ist.

client.on("chat.connected", () => {
  console.log("connected")
})

In seltenen Fällen kann es zu Latenzproblemen kommen, die dazu führen, dass eine Nachricht in einem Chat gesendet wird, bevor das SDK dem Chat beitritt. In diesem Fall können Sie mit fetchMessages alle vorhandenen Nachrichten in einer Unterhaltung abrufen, nachdem eine Verbindung hergestellt wurde. Hier ein Codebeispiel:

client.on("chat.connected", async () = {
  const messages = await
client.fetchMessages()
})

chat.disconnected

Wird ausgegeben, wenn die Verbindung des Chats zum Unterhaltungsanbieter getrennt wird.

client.on("chat.disconnected", () => {
  console.log("disconnected")
})

chat.dismissed

Wird ausgegeben, wenn der Status des Chats in dismissed geändert wird.

client.on("chat.dismissed", () => {
  console.log("dismissed")
})

chat.timeout

Wird ausgelöst, wenn der Chat beendet wird. Der Grund dafür ist timeout.

client.on("chat.timeout", () => {
  console.log("timeout")
})

chat.ended

Wird ausgegeben, wenn der Chat beendet wird.

client.on("chat.ended", () => {
  console.log("ended")
})

chat.destroyed

Wird ausgegeben, wenn destroyChat aufgerufen wird.

client.on("chat.destroyed", () => {
  console.log("destroyed")
})

Chat-Check-in

Im Folgenden finden Sie Check-in-Ereignisse für den Chat.

checkIn

Bestätigt die Anwesenheit des Endnutzers in der Warteschlange.

Methodensignatur

checkIn(): Promise<CheckInResponse>

Rückgabewert

Gibt ein CheckInResponse-Objekt zurück.

Schnittstellen

interface CheckInResponse {
  chat_id: number;
  check_in_status: CheckInStatus;
  check_in_at?: string;
}
enum CheckInStatus {
  CONFIRMED = 'confirmed',
  EXITED = 'exited',
  PENDING = 'pending',
  REQUESTED = 'requested',
  SKIPPED = 'skipped',
  TIMED_OUT = 'timed_out',
}

Beispiel

try {
  const response = await client.checkIn()
} catch (error) {
  // handle error
}

exitCheckIn

Entfernt den Nutzer aus der Check-in-Warteschlange.

Methodensignatur

exitCheckIn(): Promise<CheckInResponse>

Rückgabewert

Gibt ein CheckInResponse-Objekt zurück.

Schnittstellen

interface CheckInResponse {
  chat_id: number;
  check_in_status: CheckInStatus;
  check_in_at?: string;
}
enum CheckInStatus {
  CONFIRMED = 'confirmed',
  EXITED = 'exited',
  PENDING = 'pending',
  REQUESTED = 'requested',
  SKIPPED = 'skipped',
  TIMED_OUT = 'timed_out',
}

notifyCheckInState

Benachrichtigt das Backend über den Sichtbarkeitsstatus des Check-in-Dialogfelds.

Methodensignatur

notifyCheckInState(data: CheckInVisibilityStateRequest): Promise<void>

Schnittstellen

interface CheckInVisibilityStateRequest {
  widget_minimized?: boolean;
  tab_inactive?: boolean;
}
**Example**

try {
  const visibilityState = {
    widget_minimized: true,
    tab_inactive: false,
  }
  await client.notifyCheckInState(visibilityState)
} catch (error) {
  // handle error
}

rejoinChat

Der Nutzer wird wieder in die Warteschlange eingereiht, wenn er den Check-in nicht bestätigt.

Methodensignatur

rejoinChat(): Promise<CheckInResponse>

Rückgabewert

Gibt ein CheckInResponse-Objekt zurück.

Schnittstellen

interface CheckInResponse {
  chat_id: number;
  check_in_status: CheckInStatus;
  check_in_at?: string;
}
enum CheckInStatus {
  CONFIRMED = 'confirmed',
  EXITED = 'exited',
  PENDING = 'pending',
  REQUESTED = 'requested',
  SKIPPED = 'skipped',
  TIMED_OUT = 'timed_out',
}

Beispiel

try {
  const response = await client.rejoinChat()
} catch (error) {
  // handle error

trackCheckInEvent

Signale an das Backend, wenn Check-in-Ereignisse durch die Benutzeroberfläche ausgelöst wurden. Wird verwendet, wenn der Check-in-Dialog dem Endnutzer angezeigt wurde.

Methodensignatur

trackCheckInEvent(): Promise<void>

Beispiel

try {
  await client.trackCheckInEvent()
} catch (error) {
  // handle error

Cobrowse-Ereignisse

Im Folgenden finden Sie Ereignisse, die speziell für die gemeinsame Navigation gelten:

cobrowse.request

Wird ausgegeben, wenn ein Endnutzer oder Kundenservicemitarbeiter eine gemeinsame Browsersitzung starten möchte.

client.on("cobrowse.request", { from } => {
  console.log("request by", from)
})

cobrowse.loaded

Wird ausgegeben, wenn eine gemeinsame Browsersitzung geladen wird.

client.on("cobrowse.loaded", session => {
  console.log("cobrowse session", session)
})

cobrowse.updated

Wird ausgegeben, wenn eine Co-Browsing-Sitzung aktualisiert wird.

client.on("cobrowse.updated", session => {
  console.log("cobrowse session", session)
})

cobrowse.ended

Wird ausgegeben, wenn eine Co-Browsing-Sitzung beendet wird.

client.on("cobrowse.ended", session => {
  console.log("cobrowse session", session)
})