इस पेज पर बताया गया है कि आपका Chat ऐप्लिकेशन, डायलॉग बॉक्स कैसे खोल सकता है और उनके कैसे जवाब दे सकता है.
डायलॉग, कार्ड पर आधारित विंडो होते हैं. ये चैट ऐप्लिकेशन, उपयोगकर्ताओं के साथ इंटरैक्ट करने के लिए खोले जाते हैं. उपयोगकर्ताओं को कई चरण वाली प्रोसेस पूरी करने में मदद करने के लिए, Chat ऐप्लिकेशन क्रम से चलने वाले डायलॉग खोल सकता है.
डायलॉग इस तरह के उपयोगकर्ता इंटरैक्शन के लिए काम के होते हैं:
- उपयोगकर्ताओं से जानकारी इकट्ठा करना
- वेब सेवाओं की मदद से उपयोगकर्ताओं की पुष्टि करना
- Chat ऐप्लिकेशन की सेटिंग कॉन्फ़िगर करना
डायलॉग बॉक्स को खोलने, सबमिट करने या रद्द करने के लिए, DialogEventType
वाले Chat ऐप्लिकेशन से सिंक करने के जवाब की ज़रूरत होती है.
एसिंक्रोनस आर्किटेक्चर, जैसे Pub/Sub या create
मैसेज तरीके के साथ बनाए गए चैट ऐप्लिकेशन पर डायलॉग काम नहीं करते हैं. अगर आपका Chat ऐप्लिकेशन एसिंक्रोनस आर्किटेक्चर का इस्तेमाल करता है, तो डायलॉग के बजाय कार्ड मैसेज का इस्तेमाल करें.
ज़रूरी शर्तें
Node.js
- आपके पास Google Workspace खाता हो, जिसमें Google Chat का ऐक्सेस हो.
- चैट ऐप्लिकेशन. चैट ऐप्लिकेशन बनाने के लिए, इस quickstart को फ़ॉलो करें.
- अगर स्लैश कमांड के जवाब में कोई डायलॉग खोला जा रहा है, तो एक स्लैश कमांड चुना जा सकता है. इसे डायलॉग खोलें विकल्प को चुनकर कॉन्फ़िगर किया गया है.
Node.js कोड के सैंपल, Cloud Function के तौर पर चलाए जाने के लिए लिखे जाते हैं.
Apps Script
- आपके पास Google Workspace खाता हो, जिसमें Google Chat का ऐक्सेस हो.
- चैट ऐप्लिकेशन. चैट ऐप्लिकेशन बनाने के लिए, इस quickstart को फ़ॉलो करें.
- अगर स्लैश कमांड के जवाब में कोई डायलॉग खोला जा रहा है, तो एक स्लैश कमांड चुना जा सकता है. इसे डायलॉग खोलें विकल्प को चुनकर कॉन्फ़िगर किया गया है.
Python
- आपके पास Google Workspace खाता हो, जिसमें Google Chat का ऐक्सेस हो.
- चैट ऐप्लिकेशन. चैट ऐप्लिकेशन बनाने के लिए, इस quickstart को फ़ॉलो करें.
- अगर स्लैश कमांड के जवाब में कोई डायलॉग खोला जा रहा है, तो एक स्लैश कमांड चुना जा सकता है. इसे डायलॉग खोलें विकल्प को चुनकर कॉन्फ़िगर किया गया है.
Python कोड के सैंपल, Python 3.9 का इस्तेमाल करके Cloud Function के तौर पर चलने के लिए लिखे जाते हैं.
कोई संवाद खोलें
अगर कोई उपयोगकर्ता कार्ड वाले मैसेज पर मौजूद बटन पर क्लिक करता है, तो Chat ऐप्लिकेशन एक डायलॉग बॉक्स खोल सकता है.
जब कोई उपयोगकर्ता स्लैश निर्देश देता है, तो Chat ऐप्लिकेशन एक डायलॉग बॉक्स खोल सकता है.
जब कोई उपयोगकर्ता कोई डायलॉग बॉक्स खोलता है, तो आपके Chat ऐप्लिकेशन को यह इंटरैक्शन इवेंट मिलता है. इस इवेंट में यह जानकारी शामिल होती है:
isDialogEvent
true
है.DialogEventType
से पता चलता है कि उपयोगकर्ता ने इनमें से कौनसी कार्रवाई की है:REQUEST_DIALOG
: कोई डायलॉग खोला गया.SUBMIT_DIALOG
: डायलॉग बॉक्स में एक बटन पर क्लिक किया.CANCEL_DIALOG
: डायलॉग बॉक्स रद्द किया गया.
उदाहरण के लिए, जब कोई उपयोगकर्ता कोई डायलॉग बॉक्स खोलता है, तो आपके चैट ऐप्लिकेशन को इससे मिलता-जुलता इंटरैक्शन इवेंट मिलता है:
JSON
{
"type": enum (EventType),
"eventTime": string,
"threadKey": string,
"message": {
object (Message)
},
"user": {
object (User)
},
"space": {
object (Space)
},
"action": {
object (FormAction)
},
"configCompleteRedirectUrl": string,
"isDialogEvent": true,
"dialogEventType": "REQUEST_DIALOG",
"common": {
object (CommonEventObject)
}
}
आपका Chat ऐप्लिकेशन, "type": "DIALOG"
वाले ActionResponse
का डायलॉग बॉक्स खोल सकता है. इसके लिए, DialogAction
का इस्तेमाल करना होगा, जिसमें डायलॉग का JSON ब्यौरा शामिल होगा:
JSON
{
"action_response": {
"type": "DIALOG",
"dialog_action": {
"dialog": {
"body": {
"sections": [
{
"header": "Add new contact",
"widgets": [
{
"textInput": {
"label": "Name",
"type": "SINGLE_LINE",
"name": "contactName"
}
},
{
"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"
}
}
}
]
}
}
]
}
]
}
}
}
}
}
कार्ड बटन क्लिक के जवाब में एक डायलॉग खोलें
कार्ड बटन से डायलॉग खोलने के लिए, यह जानकारी दें:
onClick.action.function
का इस्तेमाल, उस फ़ंक्शन के नाम के तौर पर किया जा सकता है जिससे डायलॉग बॉक्स खुलता है.OPEN_DIALOG
के तौर परonClick.action.interaction
. इस प्रॉपर्टी से Chat को पता चलता है कि Chat ऐप्लिकेशन एक डायलॉग बॉक्स खोलना चाहता है.
जब कोई उपयोगकर्ता कार्ड पर मौजूद किसी बटन पर क्लिक करता है, तो आपके चैट ऐप्लिकेशन को एक इंटरैक्शन इवेंट मिलता है. इस इंटरैक्शन में यह जानकारी शामिल होती है:
EventType
CARD_CLICKED
है.DialogEventType
अबREQUEST_DIALOG
है.common.invokedFunction
, क्लिक किए गए कार्ड बटन कीonClick
प्रॉपर्टी में मौजूद फ़ंक्शन का नाम है.
डायलॉग खोलने के लिए, इनके साथ जवाब दें:
"type": "DIALOG"
काActionResponse
.DialogAction
, जिसमें डायलॉग के JSON की जानकारी शामिल होती है.
इस उदाहरण में, कोई Chat ऐप्लिकेशन ऐसे कार्ड के साथ होने वाले MESSAGE
इंटरैक्शन इवेंट का जवाब देता है जिसमें एक बटन मौजूद है, जिससे डायलॉग बॉक्स खुलता है:
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.");
}
// 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") {
openDialog(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) {
res.json({
"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"
}
}
}
]
}
}
]
}
]
}
}
}
}
});
};
}
}
Apps Script
यह उदाहरण कार्ड JSON लौटाकर कार्ड मैसेज भेजता है. Apps Script कार्ड सेवा का इस्तेमाल भी किया जा सकता है.
/**
* Responds to a MESSAGE event in Google Chat with a card with a button
* that opens a dialog.
*
* @param {Object} event the event object from Chat API.
*
* @return {object} open a Dialog in response to a card's button click.
*/
function onMessage(event) {
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": "openDialog",
"interaction": "OPEN_DIALOG"
}
}
}
]
},
"horizontalAlignment": "CENTER"
}
]
}
]
}
}]
};
}
/**
* Responds to a CARD_CLICKED event in Google Chat.
*
* @param {Object} event the event object from Google Chat
*/
function onCardClick(event) {
if (event.common.invokedFunction === "openDialog") {
return openDialog(event);
}
}
/**
* Opens a dialog in Google Chat.
*
* @param {Object} event the event object from Chat API.
*
* @return {object} open a Dialog in Google Chat.
*/
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": "contactName"
}
},
{
"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"
}
}
}
]
}
}
]
}
]
}
}
}
}
};
}
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':
if request.get('common', dict()).get('invokedFunction') == 'open_dialog':
return open_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'
}
}
}
]
}
}
]
}
]
}
}
}
}
}
स्लैश निर्देश के जवाब में एक डायलॉग खोलें
जब कोई उपयोगकर्ता किसी डायलॉग बॉक्स को खोलने के लिए कॉन्फ़िगर किए गए स्लैश कमांड के साथ एक डायलॉग खोलता है, तो आपके Chat ऐप्लिकेशन को यह जानकारी वाला एक इंटरैक्शन इवेंट मिलता है:
EventType
MESSAGE
है.DialogEventType
REQUEST_DIALOG
है.
डायलॉग खोलने के लिए, इनके साथ जवाब दें:
"type": "DIALOG"
काActionResponse
.DialogAction
, जिसमें डायलॉग के JSON की जानकारी शामिल होती है.
इस उदाहरण में, कोई Chat ऐप्लिकेशन एक डायलॉग खोलकर
/createContact
स्लैश कमांड का जवाब देता है:
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
openDialog(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) {
res.json({
"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"
}
}
}
]
}
}
]
}
]
}
}
}
}
});
};
Apps Script
यह उदाहरण कार्ड JSON लौटाकर कार्ड मैसेज भेजता है. Apps Script कार्ड सेवा का इस्तेमाल भी किया जा सकता है.
/**
* Responds to a MESSAGE event in Google Chat that includes the /createContact
* slash command by opening a dialog.
*
* @param {Object} event the event object from Chat API.
*
* @return {object} open a Dialog in response to a slash command.
*/
function onMessage(event) {
// 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
return {"text": "Contact bot helps you update your address book!"}
case 2: // /createContact
return openDialog(event);
}
}
}
/**
* Opens a dialog in Google Chat.
*
* @param {Object} event the event object from Chat API.
*
* @return {object} open a Dialog in Google Chat.
*/
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": "contactName"
}
},
{
"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"
}
}
}
]
}
}
]
}
]
}
}
}
}
};
}
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 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 == 1:
return {'text': 'Contact bot helps you update your address book!'}
elif command_id == 2:
return open_dialog(request)
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 slash command.
"""
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'
}
}
}
]
}
}
]
}
]
}
}
}
}
}
क्रम से चलने वाले डायलॉग बॉक्स खोलें
जब उपयोगकर्ता इंटरैक्शन के लिए एक से ज़्यादा डायलॉग की ज़रूरत हो, तो किसी SUBMIT_DIALOG
DialogEventType
के जवाब में, क्रम में अगले डायलॉग को लौटाकर दूसरा डायलॉग खोला जा सकता है.
डायलॉग को अपडेट करने वाले कार्ड बटन में, onClick.action.function
को उस फ़ंक्शन के नाम के तौर पर दिखाएं जिससे अगला डायलॉग बॉक्स खुलता है और onClick.action.interaction
के बारे में जानकारी नहीं दी जाती है.
प्रोसेस पूरी होने के बाद, Chat ऐप्लिकेशन को वे वैल्यू मिलेंगी जिन्हें उपयोगकर्ताओं ने डायलॉग में JSON के तौर पर डाला है. उपयोगकर्ताओं को सूचित करें कि टेक्स्ट या कार्ड मैसेज का जवाब देकर उनका इंटरैक्शन पूरा हो गया है.
जब उपयोगकर्ता किसी डायलॉग बॉक्स में मौजूद बटन पर क्लिक करते हैं, तब आपके Chat ऐप्लिकेशन को एक इंटरैक्शन इवेंट मिलता है. इस इवेंट में यह जानकारी शामिल होती है:
EventType
CARD_CLICKED
है.DialogEventType
SUBMIT_DIALOG
है.
इस उदाहरण में, Chat ऐप्लिकेशन किसी डायलॉग बटन पर क्लिक करके CARD_CLICKED
इंटरैक्शन इवेंट का जवाब देता है. इसके लिए, कोई दूसरा डायलॉग बॉक्स खोला जाता है:
Node.js
// Respond to button clicks on attached cards
if (event.type === "CARD_CLICKED") {
// Open the first dialog.
if (event.common.invokedFunction === "openDialog") {
openDialog(event);
}
// Open the second dialog.
if (event.common.invokedFunction === "openSequentialDialog") {
openSequentialDialog(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) {
res.json({
"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) {
res.json({
"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"
}
]
}
]
}
}
}
}
});
}
Apps Script
यह उदाहरण कार्ड JSON लौटाकर कार्ड मैसेज भेजता है. Apps Script कार्ड सेवा का इस्तेमाल भी किया जा सकता है.
/**
* Responds to a CARD_CLICKED event in Google Chat.
*
* @param {Object} event the event object from Google Chat
*/
function onCardClick(event) {
// When a user clicks a card, the Chat app checks to see which function to run.
if (event.common.invokedFunction === "openDialog") {
return openDialog(event);
}
if (event.common.invokedFunction === "openSequentialDialog") {
return openSequentialDialog(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": "contactName"
}
},
{
"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": {
// Specifies which function to run
// in response to the card click.
"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": {
// Specifies which function to run
// in response to the card click.
"function": "receiveDialog",
"parameters": [
{
"key": "receiveDialog",
"value": "receiveDialog"
}
]
}
}
}
]
},
"horizontalAlignment": "END"
}
]
}
]
}
}
}
}
};
}
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':
if 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)
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': 'receiveDialog',
'parameters': [
{
'key': 'receiveDialog',
'value': 'receiveDialog'
}
]
}
}
}
]
},
'horizontalAlignment': 'END'
}
]
}
]
}
}
}
}
}
ऐप्लिकेशन के होम कार्ड पर दिखने वाले मैसेज के जवाब में डायलॉग बॉक्स खोलें
सिर्फ़ ऐप्लिकेशन के होम कार्ड मैसेज के लिए,
action_response
के बजाय render_actions
का इस्तेमाल करके डायलॉग खोलें:
Apps Script
यह उदाहरण कार्ड JSON लौटाकर कार्ड मैसेज भेजता है. Apps Script कार्ड सेवा का इस्तेमाल भी किया जा सकता है.
function openDialog() {
return {
render_actions: {
action: {
navigations: [{
update_card: {
"sections": [
{
"header": "Add new contact",
"widgets": [
{
"textInput": {
"label": "Name",
"type": "SINGLE_LINE",
"name": "contactName"
}
},
{
"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"
}
}
}
]
}
}]
}]
}
}]
}
}
}
}
डायलॉग से फ़ॉर्म का डेटा पाएं
जब उपयोगकर्ता किसी डायलॉग बॉक्स में मौजूद बटन पर क्लिक करते हैं, तब उनका डाला गया डेटा, Chat ऐप्लिकेशन में सबमिट हो जाता है. साथ ही, आपके Chat ऐप्लिकेशन को एक इंटरैक्शन इवेंट मिलता है, जिसमें यह जानकारी होती है:
EventType
CARD_CLICKED
है.DialogEventType
SUBMIT_DIALOG
है.
उपयोगकर्ता जो डेटा डायलॉग बॉक्स में डालते हैं वह इंटरैक्शन इवेंट में Event.common.formInputs
के तौर पर उपलब्ध होता है. यह एक मैप है. इसमें हर डायलॉग विजेट के लिए असाइन किए गए स्ट्रिंग आईडी कुंजी होती हैं. साथ ही, इसमें वैल्यू, हर विजेट के लिए उपयोगकर्ता के इनपुट को दिखाती हैं. अलग-अलग ऑब्जेक्ट अलग-अलग
इनपुट डेटा टाइप को दिखाते हैं. उदाहरण के लिए, Event.common.formInputs.stringInputs
स्ट्रिंग इनपुट दिखाता है.
जब कोई उपयोगकर्ता कोई डायलॉग सबमिट करता है, तो आपके Chat ऐप्लिकेशन को Chat से इस तरह का इंटरैक्शन इवेंट मिलता है:
JSON
{
"type": enum (EventType),
"eventTime": string,
"threadKey": string,
"message": {
object (Message)
},
"user": {
object (User)
},
"space": {
object (Space)
},
"action": {
object (FormAction)
},
"configCompleteRedirectUrl": string,
// Indicates that this event is dialog-related.
"isDialogEvent": true,
// Indicates that a user clicked a button, and all data
// they entered in the dialog is included in Event.common.formInputs.
"dialogEventType": "SUBMIT_DIALOG",
"common": {
"userLocale": string,
"hostApp": enum (HostApp),
"platform": enum (Platform),
"timeZone": {
object (TimeZone)
},
// Represents user data entered in a dialog.
"formInputs": {
// Represents user data entered for a specific field in a dialog.
"NAME": {
// Represents string data entered in a dialog, like text input fields
// and check boxes.
"stringInputs": {
// An array of strings entered by the user in a dialog.
"value": [
string
]
}
}
},
"parameters": {
string: string,
...
},
"invokedFunction": string
}
}
आपका Chat ऐप्लिकेशन, event.common.formInputs.NAME.stringInputs.value[0]
पर उपयोगकर्ता की डाली गई पहली वैल्यू को ऐक्सेस कर सकता है. यहां NAME, TextInput
विजेट का name
फ़ील्ड है.
डायलॉग फ़ॉर्म का डेटा मिलने के बाद, Chat ऐप्लिकेशन को ActionResponse
से जवाब देना चाहिए:
- मैसेज मिलने की पुष्टि करने के लिए,
"actionStatus": "OK"
वालेActionResponse
का इस्तेमाल करके जवाब दें. इससे जवाब पोस्ट किए बिना ही डायलॉग बंद हो जाता है. - मैसेज या कार्ड मैसेज के ज़रिए जवाब देने के लिए,
ActionResponse
का इस्तेमाल करके जवाब दें, जिसमेंNEW_MESSAGE
,UPDATE_MESSAGE
याUPDATE_USER_MESSAGE_CARDS
काResponseType
हो. ज़्यादा जानकारी के लिए, डायलॉग का जवाब देना लेख देखें. - कोई गड़बड़ी दिखाने के लिए, ऐसे
ActionResponse
का इस्तेमाल करके जवाब दें जिसमें"actionStatus": "ERROR MESSAGE"
हो.
यहां दिए गए उदाहरण में, name
वैल्यू की मौजूदगी का पता लगाया गया है. अगर यह मौजूद नहीं है,
तो Chat ऐप्लिकेशन गड़बड़ी का मैसेज दिखाता है. फ़ॉर्म होने पर, Chat ऐप्लिकेशन फ़ॉर्म का डेटा मिलने की पुष्टि करता है और डायलॉग बॉक्स बंद कर देता है.
Node.js
/**
* 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. Any "actionStatus" value other than "OK"
// gets returned as an error.
if (event.common.formInputs.WIDGET_NAME.stringInputs.value[0] === "") {
res.json({
"actionResponse": {
"type": "DIALOG",
"dialogAction": {
"actionStatus": "Don't forget to name your new contact!"
}
}
});
// Otherwise the Chat app indicates that it received
// form data from the dialog. An "actionStatus" of "OK" is
// interpreted as code 200, and the dialog closes.
} else {
res.json({
"actionResponse": {
"type": "DIALOG",
"dialogAction": {
"actionStatus": "OK"
}
}
});
}
}
Apps Script
यह उदाहरण कार्ड JSON लौटाकर कार्ड मैसेज भेजता है. Apps Script कार्ड सेवा का इस्तेमाल भी किया जा सकता है.
/**
* 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. Any "actionStatus" value other than "OK"
// gets returned as an error.
if (event.common.formInputs.WIDGET_NAME[""].stringInputs.value[0] === "") {
return {
"actionResponse": {
"type": "DIALOG",
"dialogAction": {
"actionStatus": "Don't forget to name your new contact!"
}
}
};
// Otherwise the Chat app indicates that it received
// form data from the dialog. An "actionStatus" of "OK" is
// interpreted as code 200, and the dialog closes.
} else {
return {
"actionResponse": {
"type": "DIALOG",
"dialogAction": {
"actionStatus": "OK"
}
}
};
}
}
Python
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 common := event.get('common'):
if form_inputs := common.get('formInputs'):
if contact_name := form_inputs.get('WIDGET_NAME'):
if string_inputs := contact_name.get('stringInputs'):
if name := string_inputs.get('value')[0]:
return {
'actionResponse': {
'type': 'DIALOG',
'dialogAction': {
'actionStatus': 'OK'
}
}
}
else:
return {
'actionResponse': {
'type': 'DIALOG',
'dialogAction': {
'actionStatus': 'Don\'t forget to name your new contact!'
}
}
}
डायलॉग का जवाब दें
डायलॉग बॉक्स का जवाब देने के लिए, नया मैसेज भेजा जा सकता है या किसी मौजूदा मैसेज को अपडेट किया जा सकता है.
नए मैसेज के साथ डायलॉग का जवाब दें
नए मैसेज के साथ डायलॉग फ़ॉर्म सबमिट करने पर, Chat ऐप्लिकेशन एक ActionResponse
टाइप NEW_MESSAGE
दिखाता है. साथ ही, मार्कअप भी दिखाता है, जो नए मैसेज के कॉन्टेंट के बारे में बताता है. यह जवाब मिलने पर, डायलॉग
बंद हो जाता है और नया मैसेज पोस्ट हो जाता है.
नीचे दिया गया कोड एक डायलॉग के JSON जवाब का उदाहरण है, जिसे Chat ऐप्लिकेशन ने नया जवाब देने के लिए भेजा है:
JSON
{
"actionResponse": {
"type": "NEW_MESSAGE",
},
"text": "This message is a reply to a dialog form submission.",
"cardsV2": [
{
"cardId": "reply-card-id",
"card": {
"header": {
"title": "Reply card title"
},
"sections": [
{
"widgets": [
{
"textParagraph": {
"text": "Reply card message"
}
}
]
}
]
}
}
]
}
Chat ऐप्लिकेशन, टेक्स्ट या कार्ड मैसेज का इस्तेमाल करके, एसिंक्रोनस तरीके से जवाब भी दे सकता है.
अपडेट किए गए मैसेज के साथ डायलॉग का जवाब देना
अपडेट किए गए मैसेज वाले डायलॉग का जवाब देते समय, किसी मौजूदा Chat ऐप्लिकेशन मैसेज को अपडेट किया जा सकता है या लिंक की झलक को अपडेट किया जा सकता है.
Chat ऐप्लिकेशन के मैसेज
Chat ऐप्लिकेशन से भेजे गए किसी मौजूदा मैसेज में अपडेट के साथ डायलॉग फ़ॉर्म सबमिशन का जवाब देने के लिए, यह UPDATE_MESSAGE
टाइप का ActionResponse
दिखाता है.
इस जवाब में मार्कअप शामिल होता है, जो अपडेट किए गए मैसेज के कॉन्टेंट के बारे में बताता है. यह जवाब मिलने के बाद, डायलॉग बॉक्स बंद हो जाता है और मैसेज में नया कॉन्टेंट अपडेट हो जाता है.
नीचे दिया गया कोड, एक डायलॉग के JSON जवाब का एक उदाहरण है. इसे Chat ऐप्लिकेशन ने, Chat ऐप्लिकेशन के किसी मौजूदा मैसेज को अपडेट करने के लिए भेजा है:
JSON
{
"actionResponse": {
"type": "UPDATE_MESSAGE",
},
"text": "This message has been updated with new content in response to a dialog form submission.",
"cardsV2": [
{
"cardId": "updated-card-id",
"card": {
"header": {
"title": "Updated card title"
},
"sections": [
{
"widgets": [
{
"textParagraph": {
"text": "Updated card message"
}
}
]
}
]
}
}
]
}
Chat ऐप्लिकेशन, Google Chat API का इस्तेमाल करके एसिंक्रोनस रूप से Chat ऐप्लिकेशन के मैसेज को अपडेट भी कर सकता है.
लिंक की झलक
डायलॉग फ़ॉर्म सबमिशन के जवाब में नए कॉन्टेंट के साथ लिंक की झलक को अपडेट करने के लिए, Chat ऐप्लिकेशन, UPDATE_USER_MESSAGE_CARDS
टाइप का ActionResponse
दिखाता है. इस जवाब में उन नए कार्ड मैसेज के लिए मार्कअप शामिल होता है जिनकी मदद से लिंक की झलक अपडेट की जाती हैं. यह जवाब मिलने के बाद, डायलॉग बॉक्स बंद हो जाता है और लिंक की झलक नए कार्ड मैसेज के साथ अपडेट हो जाती हैं.
JSON रिस्पॉन्स का यह उदाहरण, लिंक की झलक को नए कार्ड मैसेज के साथ अपडेट करता है:
JSON
{
"actionResponse": "UPDATE_USER_MESSAGE_CARDS",
"cardsV2": [
{
"cardId" : "updated-card-id",
"card" : {
"header": {
"title": "Updated card title"
},
"sections": [
{
"widgets" : [
{
"textParagraph": {
"text": "Updated card message"
}
}
]
}
]
}
}
]
}
ऐप्लिकेशन के होम कार्ड पर मौजूद मैसेज के लिए, डायलॉग का जवाब दें
सिर्फ़ ऐप्लिकेशन के होम कार्ड मैसेज के लिए, डायलॉग को बंद करने के दो अलग-अलग तरीके हैं:
CLOSE_DIALOG
: डायलॉग बॉक्स को बंद करता है और ऐप्लिकेशन के होम कार्ड पर दिखने वाले मैसेज पर वापस आ जाता है.CLOSE_DIALOG_AND_EXECUTE
: डायलॉग बॉक्स को बंद करता है और ऐप्लिकेशन के होम कार्ड के मैसेज को रीफ़्रेश करता है.
Python
नीचे दिया गया कोड सैंपल, CLOSE_DIALOG
का इस्तेमाल करके किसी डायलॉग को बंद करता है और ऐप्लिकेशन के होम कार्ड पर
मैसेज पर वापस जाता है:
def close_dialog():
"""Handles dismiss dialog request from Chat."""
return {
'render_actions': {
'action': {
'navigations': [{
'end_navigation': {'action': 'CLOSE_DIALOG'}
}]
}
}
}
Apps Script
यह उदाहरण कार्ड JSON लौटाकर कार्ड मैसेज भेजता है. Apps Script कार्ड सेवा का इस्तेमाल भी किया जा सकता है.
नीचे दिया गया कोड सैंपल, CLOSE_DIALOG
का इस्तेमाल करके किसी डायलॉग को बंद करता है और ऐप्लिकेशन के होम कार्ड पर
मैसेज पर वापस जाता है:
function closeDialog(event) {
return {
render_actions: {
action:{
navigations:[{
end_navigation:{
action: "CLOSE_DIALOG"
}
}]
}
}
};
}
उदाहरण के लिए: चैट ऐप्लिकेशन को मैनेज करने वाला संपर्क Rolodex
इस उदाहरण में, किसी चैट ऐप्लिकेशन से एक डायलॉग बॉक्स खुलता है, ताकि उपयोगकर्ता किसी संपर्क के बारे में नाम, ईमेल, और पता जैसी जानकारी जोड़ सके:
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
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") {
openDialog(event);
}
if (event.common.invokedFunction === "openSequentialDialog") {
openSequentialDialog(event);
}
if (event.common.invokedFunction === "confirmDialogSuccess") {
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) {
res.json({
"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) {
res.json({
"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. Any "actionStatus" value other than "OK"
// gets returned as an error.
if (event.common.formInputs.contactName.stringInputs.value[0] === "") {
res.json({
"actionResponse": {
"type": "DIALOG",
"dialogAction": {
"actionStatus": "Don't forget to name your new contact!"
}
}
});
// Otherwise the Chat app indicates that it received
// form data from the dialog. An "actionStatus" of "OK" is
// interpreted as code 200, and the dialog closes.
} else {
res.json({
"actionResponse": {
"type": "DIALOG",
"dialogAction": {
"actionStatus": "OK"
}
}
});
}
}
Apps Script
यह उदाहरण कार्ड JSON लौटाकर कार्ड मैसेज भेजता है. Apps Script कार्ड सेवा का इस्तेमाल भी किया जा सकता है.
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!"
}
}
}
समस्या हल करें
जब Google Chat ऐप्लिकेशन या कार्ड की ओर से गड़बड़ी का मैसेज मिलता है, तो Chat के इंटरफ़ेस पर "कोई गड़बड़ी हुई" मैसेज दिखता है. या "आपका अनुरोध प्रोसेस नहीं किया जा सका." कभी-कभी चैट के यूज़र इंटरफ़ेस (यूआई) में गड़बड़ी का कोई मैसेज नहीं दिखता, लेकिन Chat ऐप्लिकेशन या कार्ड अचानक कोई ऐसा नतीजा देता है जिसकी उम्मीद नहीं थी. उदाहरण के लिए, हो सकता है कि कार्ड का मैसेज न दिखे.
हालांकि, हो सकता है कि Chat के यूज़र इंटरफ़ेस (यूआई) में गड़बड़ी का मैसेज न दिखे. हालांकि, चैट ऐप्लिकेशन के लिए गड़बड़ी लॉग करने की सुविधा चालू होने पर, गड़बड़ी के मैसेज और लॉग डेटा की मदद से गड़बड़ियों को ठीक किया जा सकता है. गड़बड़ियों को देखने, डीबग करने, और ठीक करने में मदद के लिए, Google Chat की गड़बड़ियों को ठीक करना और समस्या हल करना देखें.