Auf dieser Seite wird erläutert, wie Sie Slash-Befehle für Ihr Google Chat App.
Ein Slash-Befehl ist eine gängige Methode, mit der Nutzer ein Objekt aufrufen und mit ihm interagieren. Chat-App. Außerdem helfen Slash-Befehle, die wichtigsten Funktionen einer Chat-App nutzen.
Um einen Slash-Befehl zu verwenden, geben Nutzer einen Schrägstrich (/
) und dann einen kurzen Textbefehl ein.
wie /about
, um Informationen zur Chat App zu erhalten.
Nutzer können verfügbare Slash-Befehle finden, indem sie
Google Chat, das ein Fenster mit den verfügbaren Befehlen für den
Chat-App:
![Slash-Befehlsfenster](https://developers-dot-devsite-v2-prod.appspot.com/static/workspace/chat/images/slash-command-window.png?authuser=5&hl=de)
Wenn ein Nutzer eine Nachricht sendet, die einen Slash-Befehl enthält, wird die Nachricht für den Nutzer und die Chat App sichtbar.
um zu entscheiden, ob Sie Slash-Befehle einrichten sollten Nutzungsinteraktionen gestalten, siehe Definieren Sie alle Kaufprozesse.
Vorbereitung
Node.js
Eine Google Chat App mit aktivierten interaktiven Funktionen. So erstellen Sie ein Chat-App mit einem HTTP-Dienst verwenden können, führen Sie diese Kurzanleitung aus.
Apps Script
Eine Google Chat App mit aktivierten interaktiven Funktionen. So erstellen Sie ein interaktive Chat-App in Apps Script verwenden möchten, führen Sie diese Kurzanleitung aus.
Python
Eine Google Chat App mit aktivierten interaktiven Funktionen. So erstellen Sie ein Chat-App mit einem HTTP-Dienst verwenden können, führen Sie diese Kurzanleitung aus.
Slash-Befehl einrichten
In diesem Abschnitt wird erläutert, wie Sie mit den folgenden Schritten einen Schrägstrich einrichten. Befehl:
- Geben Sie einen Namen für den Slash-Befehl ein.
- Konfigurieren Sie den Slash-Befehl in der Google Chat API.
Slash-Befehl benennen
Der Name eines Slash-Befehls ist das, was Nutzer in eine Chatnachricht eingeben zum Aufrufen der Chat-App. Eine kurze Beschreibung wird unter dem Namen angezeigt, um die Nutzer zur Verwendung des Befehls aufzufordern:
![Name und Beschreibung des Slash-Befehls](https://developers-dot-devsite-v2-prod.appspot.com/static/workspace/chat/images/slash-command-description.png?authuser=5&hl=de)
Berücksichtigen Sie bei der Auswahl eines Namens und einer Beschreibung für Ihren Slash-Befehl Empfehlungen:
So benennen Sie den Slash-Befehl:
- Verwenden Sie kurze, aussagekräftige und umsetzbare Wörter oder Wortgruppen, um
Befehle einfach und verständlich. Anstatt beispielsweise zu sagen,
/createAReminder
,/remindMe
verwenden. - Wenn Ihr Befehl mehr als ein Wort enthält, helfen Sie Nutzern, den Befehl zu lesen
indem Sie für das erste Wort nur Kleinbuchstaben verwenden und dann das erste großschreiben.
Buchstaben zusätzlicher Wörter. So wird beispielsweise anstelle von
/updatecontact
/updateContact
verwenden. - Überlegen Sie, ob Sie einen eindeutigen oder einen allgemeinen Namen für Ihren Befehl verwenden möchten. Wenn
eine typische Interaktion oder Funktion beschreibt, können Sie
allgemeinen Namen, den Nutzer erkennen und erwarten, z. B.
/settings
oder/feedback
. Verwenden Sie andernfalls eindeutige Befehlsnamen. derselbe Befehlsname für andere Chat-Apps ist, muss der Nutzer Filtere ähnliche Befehle, um deine zu finden und zu verwenden.
- Verwenden Sie kurze, aussagekräftige und umsetzbare Wörter oder Wortgruppen, um
Befehle einfach und verständlich. Anstatt beispielsweise zu sagen,
So beschreiben Sie den Slash-Befehl:
- Die Beschreibung sollte kurz und klar sein, damit Nutzer wissen, was sie erwartet wenn der Befehl aufgerufen wird.
- Teilen Sie den Nutzern mit, ob es Formatierungsanforderungen für den Befehl gibt.
Wenn Sie beispielsweise einen
/remindMe
-Befehl erstellen, für den ein Argument erforderlich ist, Text eingeben, legen Sie die Beschreibung auf etwaRemind me to do [something] at [time]
fest. - Lassen Sie Nutzer wissen, ob die Chat-App auf
oder privat für den Nutzer, der den Befehl aufruft.
Für den Slash-Befehl
/about
könnten Sie ihn beispielsweise so beschreiben:Learn about this app (Only visible to you)
. Um privat auf eine Slash-Befehl verwenden, finden Sie im Abschnitt Mit einer privaten Nachricht antworten.
Slash-Befehl in der Google Chat API konfigurieren
Um einen Slash-Befehl zu erstellen, müssen Sie Informationen über den Befehl in Konfiguration Ihrer Chat-App für die Google Chat API konfigurieren.
So konfigurieren Sie einen Slash-Befehl in der Google Chat API: Schritte:
Klicken Sie in der Google Cloud Console auf das Dreistrich-Menü > APIs und Dienste > Aktivierte APIs und Dienste > Google Chat API
Klicken Sie auf Konfiguration.
Klicken Sie unter Slash-Befehle auf Slash-Befehl hinzufügen.
Geben Sie einen Namen, eine Befehls-ID und eine Beschreibung für den Befehl ein:
- Name:Der Anzeigename für den Befehl und die Nutzereingabe zum Aufrufen Ihrer Anwendung. Muss mit einem Schrägstrich beginnen, darf nur Text enthalten und darf darf maximal 50 Zeichen lang sein.
- Beschreibung:Der Text zur Beschreibung der Verwendung und Formatierung. den Befehl. Beschreibungen dürfen maximal 50 Zeichen lang sein.
- Befehls-ID:Eine Zahl zwischen 1 und 1.000, die in Ihrem Die Chat-App verwendet, um den Slash-Befehl zu erkennen und eine Antwort zurückgeben.
Optional: Wenn Sie möchten, dass Ihre Chat-App auf über ein Dialogfeld den Befehl Kästchen Dialogfeld öffnen
Klicken Sie auf Speichern.
Der Slash-Befehl ist jetzt für die Chat-App konfiguriert.
Auf einen Slash-Befehl antworten
Wenn Nutzer eine Chatnachricht erstellen, die einen Slash-Befehl enthält,
Ihre Chat-App empfängt ein MESSAGE
-Interaktionsereignis.
Die Ereignisnutzlast enthält
Informationen zum Slash-Befehl,
einschließlich slashCommand
und slashCommandMetadata
. Sie verwenden diese Felder, um die Befehls-ID zu identifizieren und eine benutzerdefinierte
Antwort.
Das folgende Beispiel zeigt die JSON-Nutzlast für ein MESSAGE
-Interaktionsereignis
mit dem Slash-Befehl /vote
:
{
...
"message": {
...
"text": "/vote yes",
"argumentText": " yes",
"slashCommand": {
"commandId": 2
},
"annotations": [
{
"length": 5,
"startIndex": 0,
"type": "SLASH_COMMAND",
"slashCommand": {
"commandName":"/vote",
"commandId":1,
"type": "INVOKE",
"bot": {
"avatarUrl": "https://www.example.com/images/vote-app-icon.png",
"displayName": "Voter Chat App",
"name": "users/1234567890987654321",
"type": "BOT"
}
}
}
]
}
}
Um auf einen Slash-Befehl zu reagieren, können Sie ermitteln, ob das Feld slashCommand
in der Ereignisnutzlast vorhanden ist. Ist dies der Fall, wird eine Antwort auf den Befehl zurückgegeben.
Das folgende Codebeispiel zeigt, wie Sie auf ein MESSAGE
-Interaktionsereignis reagieren.
mit einem Slash-Befehl:
Node.js
/**
* Responds to a MESSAGE event in Google Chat.
*
* @param {Object} event the event object from Chat API.
*
* @return {object} function in response to a slash command.
*/
exports.onMessage = function onMessage(req, res) {
// Stores the Google Chat event as a variable.
var event = req.body;
// Checks for the presence of event.message.slashCommand.
if (event.message.slashCommand) {
switch (event.message.slashCommand.commandId) {
case ID: // The ID for your slash command
res.json(runFunction); // The response to the slash command.
}
}
Apps Script
/**
* Responds to a MESSAGE event in Google Chat.
*
* @param {Object} event the event object from Chat API.
*
* @return {object} function in response to a slash command.
*/
function onMessage(event) {
// Checks for the presence of event.message.slashCommand
if (event.message.slashCommand) {
switch (event.message.slashCommand.commandId) {
case ID: // The ID for your slash command
return runFunction; // The response to the slash command.
}
}
}
Python
from typing import Any, Mapping
import flask
import functions_framework
@functions_framework.http
def main(req: flask.Request) -> Mapping[str, Any]:
"""Responds to a MESSAGE event in Google Chat that includes a slash command.
Args:
req (flask.Request): the event object from Chat API.
Returns:
Mapping[str, Any]: function in response to a slash command.
"""
if req.method == 'GET':
return 'Sorry, this function must be called from a Google Chat.'
request = req.get_json(silent=True)
if slash_command := request.get('message', dict()).get('slashCommand'):
command_id = slash_command['commandId']
if command_id == ID:
return runFunction
Ersetzen Sie Folgendes, um den Code zu verwenden:
ID
: ist die Befehls-ID, die Sie angeben, wenn Sie konfigurieren Sie den Slash-Befehl in der Google Chat API.runFunction
: eine Funktion, die eine Antwort auf den Slash-Befehl.
Optional: Mit einer privaten Nachricht antworten
Nachrichten, die Slash-Befehle enthalten, sind nur für den Nutzer sichtbar, der die und der Chat-App, die den Befehl empfängt. Wenn Sie haben die Chat-App so konfiguriert, dass sie zu Gruppenbereichen hinzugefügt wird mit mehreren Personen arbeiten, können Sie auf den Slash-Befehl um die Interaktion zwischen dem Nutzer und dem Chat-App.
Wenn ein Team z. B. eine Chat-App verwendet,
können Nutzer einen Slash-Befehl wie
/myCases
, um die ihnen zugewiesenen Supportanfragen anzusehen. Wenn das Team
Chat-App mit einem Gruppenbereich, einem Nutzer, der diesen Slash-Befehl verwendet
im Gruppenbereich, kann es sein, dass die Chat App nur auf
. Um zu vermeiden, dass die Supportanfragen des Nutzers für alle im Gruppenbereich gepostet werden,
Die Chat-App kann privat antworten.
Informationen zum privaten Antworten auf einen Slash-Befehl finden Sie unter Private Nachrichten an Google Chat-Nutzer senden
Vollständiges Beispiel: Kontakte mit der Rolodex Chat-App einrichten
Das folgende Beispiel zeigt eine Chat-App, die auf folgenden Slash-Befehlen:
- Der Befehl
/help
gibt eine Textnachricht zurück, in der erklärt wird, wie Sie den Befehl mit der Google Chat App. Die Befehls-ID ist festgelegt an1
. - Mit dem Befehl
/createContact
wird ein Dialogfeld geöffnet, in dem Nutzer Details zu einem Kontakt. Die Befehls-ID ist auf2
festgelegt.
Bevor Sie dieses Beispiel ausführen, die Slash-Befehle in der Google Chat API konfigurieren.
Node.js
/**
* Responds to messages that have links whose URLs
* match URL patterns configured for link previews.
*
* @param {Object} event The event object from Chat
* API.
*
* @return {Object} Response from the Chat app
* attached to the message with the previewed link.
*/
exports.onMessage = function onMessage(req, res) {
// Store the Google Chat event as a variable.
const event = req.body;
if (req.method === "GET" || !event.message) {
res.send("Hello! This function is meant to be used in a Google Chat " +
"Space.");
}
// Checks for the presence of event.message.slashCommand.
// If the slash command is "/help", responds with a text message.
// If the slash command is "/createContact", opens a dialog.
if (event.message.slashCommand) {
switch (event.message.slashCommand.commandId) {
case 1: // /help
res.json({"text": "Contact bot helps you update your address book!"});
case 2: // /createContact
res.json(openDialog(event));
}
}
// If the Chat app doesn"t detect a slash command, it responds
// with a card that prompts the user to add a contact
else {
res.json({
"cardsV2": [{
"cardId": "addContact",
"card": {
"header": {
"title": "Rolodex",
"subtitle": "Manage your contacts!",
"imageUrl": "https://www.gstatic.com/images/branding/product/2x/contacts_48dp.png",
"imageType": "CIRCLE"
},
"sections": [
{
"widgets": [
{
"buttonList": {
"buttons": [
{
"text": "Add Contact",
"onClick": {
"action": {
"function": "openDialog",
"interaction": "OPEN_DIALOG"
}
}
}
]
}
}
]
}
]
}
}]
});
}
// Respond to button clicks on attached cards
if (event.type === "CARD_CLICKED") {
if (event.common.invokedFunction === "openDialog") {
res.json(openDialog(event));
}
if (event.common.invokedFunction === "openSequentialDialog") {
res.json(openSequentialDialog(event));
}
if (event.common.invokedFunction === "confirmDialogSuccess") {
res.json(confirmDialogSuccess(event));
}
}
};
/**
* Opens and starts a dialog that lets users add details about a contact.
*
* @param {object} event the event object from Google Chat.
*
* @return {object} open a dialog.
*/
function openDialog(event) {
return {
"action_response": {
"type": "DIALOG",
"dialog_action": {
"dialog": {
"body": {
"sections": [
{
"header": "Add new contact",
"widgets": [
{
"textInput": {
"label": "Name",
"type": "SINGLE_LINE",
"name": "name"
}
},
{
"textInput": {
"label": "Address",
"type": "MULTIPLE_LINE",
"name": "address"
}
},
{
"decoratedText": {
"text": "Add to favorites",
"switchControl": {
"controlType": "SWITCH",
"name": "saveFavorite"
}
}
},
{
"decoratedText": {
"text": "Merge with existing contacts",
"switchControl": {
"controlType": "SWITCH",
"name": "mergeContact",
"selected": true
}
}
},
{
"buttonList": {
"buttons": [
{
"text": "Next",
"onClick": {
"action": {
"function": "openSequentialDialog"
}
}
}
]
}
}
]
}
]
}
}
}
}
};
};
/**
* Opens a second dialog that lets users add more contact details.
*
* @param {object} event the event object from Google Chat.
*
* @return {object} open a dialog.
*/
function openSequentialDialog(event) {
return {
"action_response": {
"type": "DIALOG",
"dialog_action": {
"dialog": {
"body": {
"sections": [
{
"header": "Add new contact",
"widgets": [
{
"textInput": {
"label": "Notes",
"type": "MULTIPLE_LINE",
"name": "notes"
}
},
{
"selectionInput": {
"type": "RADIO_BUTTON",
"label": "Contact type",
"name": "contactType",
"items": [
{
"text": "Work",
"value": "Work",
"selected": false
},
{
"text": "Personal",
"value": "Personal",
"selected": false
}
]
}
},
{
"buttonList": {
"buttons": [
{
"text": "Submit",
"onClick": {
"action": {
"function": "confirmDialogSuccess",
"parameters": [
{
"key": "confirmDialogSuccess",
"value": "confirmDialogSuccess"
}
]
}
}
}
]
},
"horizontalAlignment": "END"
}
]
}
]
}
}
}
}
};
}
/**
* Checks for a form input error, the absence of
* a "name" value, and returns an error if absent.
* Otherwise, confirms successful receipt of a dialog.
*
* Confirms successful receipt of a dialog.
*
* @param {Object} event the event object from Chat API.
*
* @return {object} open a Dialog in Google Chat.
*/
function receiveDialog(event) {
// Checks to make sure the user entered a name
// in a dialog. If no name value detected, returns
// an error message.
if (event.common.formInputs.contactName.stringInputs.value[0] === "") {
return {
"actionResponse": {
"type": "DIALOG",
"dialogAction": {
"actionStatus": {
"statusCode": "OK",
"userFacingMessage": "Don't forget to name your new contact!"
}
}
}
};
// Otherwise the app indicates that it received
// form data from the dialog. Any value other than "OK"
// gets returned as an error. "OK" is interpreted as
// code 200, and the dialog closes.
} else {
return {
"actionResponse": {
"type": "DIALOG",
"dialogAction": {
"actionStatus": "OK"
}
}
};
}
}
Apps Script
In diesem Beispiel wird eine Kartennachricht gesendet, JSON-Karte Sie können auch die Apps Script-Kartendienst
Python
from typing import Any, Mapping
import flask
import functions_framework
@functions_framework.http
def main(req: flask.Request) -> Mapping[str, Any]:
"""Responds to a MESSAGE event in Google Chat that includes the /createContact
slash command by opening a dialog.
Args:
req (flask.Request): the event object from Chat API.
Returns:
Mapping[str, Any]: open a Dialog in response to a card's button click.
"""
if req.method == 'GET':
return 'Sorry, this function must be called from a Google Chat.'
request = req.get_json(silent=True)
if request.get('type') == 'CARD_CLICKED':
invoked_function = request.get('common', dict()).get('invokedFunction')
if invoked_function == 'open_dialog':
return open_dialog(request)
elif invoked_function == 'open_sequential_dialog':
return open_dialog(request)
elif invoked_function == "receive_dialog":
return receive_dialog(request)
else:
return {
'cardsV2': [{
'cardId': 'addContact',
'card': {
'header': {
'title': 'Rolodex',
'subtitle': 'Manage your contacts!',
'imageUrl': 'https://www.gstatic.com/images/branding/product/2x/contacts_48dp.png',
'imageType': 'CIRCLE'
},
'sections': [
{
'widgets': [
{
'buttonList': {
'buttons': [
{
'text': 'Add Contact',
'onClick': {
'action': {
'function': 'open_dialog',
'interaction': 'OPEN_DIALOG'
}
}
}
]
}
}
]
}
]
}
}]
}
def open_dialog(request: Mapping[str, Any]) -> Mapping[str, Any]:
"""Opens a dialog in Google Chat.
Args:
request (Mapping[str, Any]): the event object from Chat API.
Returns:
Mapping[str, Any]: open a Dialog in response to a card's button click.
"""
return {
'action_response': {
'type': 'DIALOG',
'dialog_action': {
'dialog': {
'body': {
'sections': [
{
'header': 'Add new contact',
'widgets': [
{
'textInput': {
'label': 'Name',
'type': 'SINGLE_LINE',
'name': 'name'
}
},
{
'textInput': {
'label': 'Address',
'type': 'MULTIPLE_LINE',
'name': 'address'
}
},
{
'decoratedText': {
'text': 'Add to favorites',
'switchControl': {
'controlType': 'SWITCH',
'name': 'saveFavorite'
}
}
},
{
'decoratedText': {
'text': 'Merge with existing contacts',
'switchControl': {
'controlType': 'SWITCH',
'name': 'mergeContact',
'selected': True
}
}
},
{
'buttonList': {
'buttons': [
{
'text': 'Next',
'onClick': {
'action': {
'function': 'open_sequential_dialog'
}
}
}
]
}
}
]
}
]
}
}
}
}
}
def open_sequential_dialog(request: Mapping[str, Any]) -> Mapping[str, Any]:
"""Opens a second dialog that lets users add more contact details.
Args:
request (Mapping[str, Any]): the event object from Chat API.
Returns:
Mapping[str, Any]: open a Dialog in response to a card's button click.
"""
return {
'action_response': {
'type': 'DIALOG',
'dialog_action': {
'dialog': {
'body': {
'sections': [
{
'header': 'Add new contact',
'widgets': [
{
'textInput': {
'label': 'Notes',
'type': 'MULTIPLE_LINE',
'name': 'notes'
}
},
{
'selectionInput': {
'type': 'RADIO_BUTTON',
'label': 'Contact type',
'name': 'contactType',
'items': [
{
'text': 'Work',
'value': 'Work',
'selected': False
},
{
'text': 'Personal',
'value': 'Personal',
'selected': False
}
]
}
},
{
'buttonList': {
'buttons': [
{
'text': 'Submit',
'onClick': {
'action': {
'function': 'receive_dialog',
'parameters': [
{
'key': 'receiveDialog',
'value': 'receiveDialog'
}
]
}
}
}
]
},
'horizontalAlignment': 'END'
}
]
}
]
}
}
}
}
}
def receive_dialog(event: Mapping[str, Any]) -> Mapping[str, Any]:
"""Checks for a form input error, the absence of a "name" value, and returns
an error if absent. Otherwise, confirms successful receipt of a dialog.
Args:
event (Mapping[str, Any]): the event object from Chat API.
Returns:
Mapping[str, Any]: the response.
"""
if event.get('common', dict()) \
.get('formInputs', dict()).get('contactName', dict()) \
.get('stringInputs').get('value', list()):
return {
'actionResponse': {
'type': 'DIALOG',
'dialogAction': {
'actionStatus': 'OK'
}
}
}
else:
return {
'actionResponse': {
'type': 'DIALOG',
'dialogAction': {
'actionStatus': "Don't forget to name your new contact!"
}
}
}