Odpowiadanie na polecenia aplikacji Google Chat

Z tego artykułu dowiesz się, jak skonfigurować aplikację Google Chat i odpowiadać na polecenia.

Polecenia pomagają użytkownikom odkrywać i korzystać z kluczowych funkcji aplikacji do obsługi czatu. Tylko aplikacje do obsługi czatu mogą wyświetlać treść polecenia. Jeśli na przykład użytkownik wyśle wiadomość z poleceniem zaczynającym się od ukośnika, będzie ona widoczna tylko dla niego i aplikacji Chat.

Aby zdecydować, czy chcesz tworzyć polecenia, i dowiedzieć się, jak projektować interakcje z użytkownikami, zapoznaj się z artykułem Określanie wszystkich ścieżek użytkownika.

Typy poleceń aplikacji do obsługi Google Chat

1. Polecenia po ukośniku: użytkownicy mogą wybrać polecenie po ukośniku z menu lub wpisać ukośnik (/), a następnie zdefiniowany tekst, np. /about. Aplikacje do obsługi czatu zwykle wymagają tekstu argumentu polecenia po ukośniku.

   Utwórz polecenie po ukośniku, jeśli aplikacja do obsługi czatu wymaga dodatkowych danych wejściowych od użytkownika. Możesz na przykład utworzyć polecenie po ukośniku o nazwie /search, które będzie uruchamiane po wpisaniu przez użytkownika frazy do wyszukania, np. /search receipts.

2. Szybkie polecenia: użytkownicy używają poleceń, otwierając menu w obszarze odpowiedzi wiadomości na czacie. Aby użyć polecenia, klikają Dodaj i wybierają polecenie z menu.

   Utwórz szybkie polecenie, jeśli aplikacja do czatu może od razu odpowiedzieć użytkownikowi bez czekania na dodatkowe dane wejściowe. Możesz na przykład utworzyć szybkie polecenie o nazwie Losowy obraz, które od razu odpowie obrazem.

3. Działania związane z wiadomościami: użytkownicy mogą korzystać z działań związanych z wiadomościami, najeżdżając kursorem na wiadomość i klikając menu z 3 kropkami. Aby użyć polecenia, otwórz menu z 3 kropkami i wybierz polecenie z menu.

   Utwórz sugerowane działanie, jeśli aplikacja do obsługi czatu może wykonywać działania na podstawie kontekstu wiadomości.

Na poniższych obrazach pokazujemy, jak użytkownicy odkrywają menu poleceń po ukośniku i szybkich oraz działań związanych z wiadomościami:

Wymagania wstępne

Konfigurowanie polecenia

W tej sekcji dowiesz się, jak wykonać te czynności, aby skonfigurować polecenie:

1. Utwórz nazwę i opis polecenia.
2. Skonfiguruj polecenie w konsoli Google Cloud.
3. Opcjonalnie: przypisz polecenia do promptów początkowych.

Nazwij i opisz polecenie

Nazwa polecenia to tekst, który użytkownicy wpisują lub wybierają, aby wywołać aplikację Chat. Pod nazwą wyświetla się też krótki opis, który podpowiada użytkownikom, jak używać polecenia:

Wybierając nazwę i opis polecenia, weź pod uwagę te rekomendacje:

Aby nazwać polecenie:

• Używaj krótkich, opisowych i zachęcających do działania słów lub zwrotów, aby polecenia były jasne dla użytkownika. Na przykład zamiast nazwy Create a reminder użyj Remind me.
• Użyj unikalnej lub powszechnie znanej nazwy polecenia. Jeśli polecenie opisuje typową interakcję lub funkcję, możesz użyć powszechnie znanej nazwy, której użytkownicy oczekują, np. Settings lub Feedback. W przeciwnym razie staraj się używać unikalnych nazw poleceń, ponieważ jeśli nazwa polecenia jest taka sama jak w przypadku innych aplikacji do obsługi czatu, użytkownik musi filtrować podobne polecenia, aby znaleźć i użyć Twojego.

Aby opisać polecenie:

• Opis powinien być krótki i jasny, aby użytkownicy wiedzieli, czego mogą się spodziewać po użyciu polecenia.
• Poinformuj użytkowników, czy polecenie ma jakieś wymagania dotyczące formatowania. Jeśli na przykład utworzysz polecenie po ukośniku, które wymaga tekstu argumentu, ustaw opis na coś w rodzaju Remind me to do [something] at [time].
• Poinformuj użytkowników, czy aplikacja na czacie odpowiada wszystkim osobom w pokoju, czy prywatnie użytkownikowi, który wywołał polecenie. Na przykład w przypadku szybkiego polecenia About możesz podać opis Learn about this app (Only visible to you).

Konfigurowanie polecenia w konsoli Google Cloud

Aby utworzyć polecenie po ukośniku, szybkie polecenie lub sugerowane działanie, musisz podać informacje o poleceniu lub działaniu w konfiguracji aplikacji do Google Chat dla interfejsu Google Chat API.

Aby skonfigurować polecenie w interfejsie Google Chat API, wykonaj te czynności:

1. W konsoli Google Cloud kliknij Menu menu > Interfejsy API i usługi > Włączone interfejsy API i usługi > Google Chat API.

   Otwórz stronę interfejsu Google Chat API

2. Kliknij Konfiguracja.

3. W sekcji Ustawienia połączenia otwórz Aktywatory i podaj szczegóły punktu końcowego. W następnej sekcji musisz użyć tego aktywatora, aby odpowiedzieć na polecenie.

   1. Adres URL punktu końcowego HTTP: możesz tutaj określić jeden wspólny adres URL punktu końcowego HTTP. Możesz też użyć różnych punktów końcowych HTTP dla różnych wyzwalaczy, określając punkt końcowy bezpośrednio w polu Polecenie aplikacji.
   2. Apps Script: wpisz identyfikator wdrożenia Apps Script. Domyślnie wywoływana jest funkcja onAppCommand. Aby użyć innej funkcji Apps Script, w polu Polecenie aplikacji wpisz nazwę funkcji niestandardowej.

4. W sekcji Polecenia kliknij Dodaj polecenie.

5. Podaj te informacje o poleceniu:

   1. Identyfikator polecenia: liczba z zakresu od 1 do 1000, której aplikacja do obsługi czatu używa do rozpoznawania polecenia i zwracania odpowiedzi.
   2. Opis: tekst opisujący sposób używania i formatowania polecenia. Opis może zawierać maksymalnie 50 znaków.
   3. Typ polecenia: wybierz Szybkie polecenie, Polecenie po ukośniku lub Działanie związane z wiadomością.
   4. Podaj nazwę polecenia:
      • Nazwa szybkiego polecenia: wyświetlana nazwa, którą użytkownicy wybierają z menu, aby wywołać polecenie. Może zawierać do 50 znaków, w tym znaki specjalne. Na przykład: Remind me.
      • Nazwa polecenia po ukośniku: tekst, który użytkownicy wpisują, aby wywołać polecenie w wiadomości. Musi zaczynać się od ukośnika, zawierać tylko tekst i może mieć maksymalnie 50 znaków. Na przykład: /remindMe.
      • Nazwa sugerowanego działania: nazwa wyświetlana, którą użytkownicy wybierają z menu, aby wywołać sugerowane działanie. Może zawierać do 50 znaków, w tym znaki specjalne. Na przykład: Remind me.

6. Opcjonalnie: Komunikat powiadomienia o wczytywaniu: komunikat powiadomienia w formie wyskakującego okienka, który ma być wyświetlany użytkownikowi podczas wykonywania sugerowanego działania. Dostępne tylko w przypadku działań związanych z wiadomościami, które nie otwierają okien.

7. Opcjonalnie: jeśli chcesz, aby aplikacja Google Chat odpowiadała na polecenie za pomocą okna, zaznacz pole wyboru Otwórz okno.

8. Kliknij Zapisz.

Polecenie jest teraz skonfigurowane dla aplikacji Google Chat.

Mapowanie poleceń na prompty początkowe

Możesz wyróżnić polecenia jako prompty początkowe, aby użytkownicy widzieli je jako interaktywne elementy po rozpoczęciu pustej wiadomości na czacie z aplikacją w Google Chat.

Aby przypisać polecenie do prompta początkowego:

1. Upewnij się, że polecenie nie wymaga dodatkowych argumentów niestandardowych (jako promptów początkowych obsługiwane są tylko polecenia z opcjami Brak argumentów i Podstawowe argumenty).
2. W konsoli Google Cloud otwórz stronę Konfiguracja interfejsu Chat API.
3. W sekcji Funkcje interaktywne > Sugestie na początek kliknij Dodaj sugestię.
4. Ustaw pozycję (1–3) w kolejności wyświetlania.
5. W sekcji Wybór typu kliknij Wiersz poleceń i wybierz polecenie z menu.
6. Kliknij kolejno Gotowe i Zapisz.

Odpowiadanie na polecenie

Gdy użytkownicy używają polecenia, aplikacja do obsługi czatu otrzymuje obiekt zdarzenia. Ładunek zdarzenia (event.chat.appCommandPayload) zawiera obiekt appCommandPayload ze szczegółami wywołanego polecenia (w tym identyfikatorem i typem polecenia), dzięki czemu możesz zwrócić odpowiednią odpowiedź. Obiekt zdarzenia jest wysyłany do punktu końcowego HTTP lub funkcji Apps Script, które zostały określone podczas konfigurowania wyzwalacza polecenia aplikacji.

Odpowiadanie na polecenie po ukośniku lub szybkie polecenie

Poniższy kod przedstawia przykład aplikacji w Google Chat, która odpowiada na polecenie po ukośniku /about wiadomością tekstową. Aby odpowiadać na polecenia po ukośniku lub szybkie polecenia, aplikacja do Google Chat obsługuje obiekty zdarzeń (event.chat.appCommandPayload) z wyzwalacza Polecenie aplikacji. Gdy ładunek obiektu zdarzenia zawiera pasujący identyfikator polecenia, aplikacja Google Chat zwraca działanie DataActions z obiektem createMessageAction (hostAppDataAction.chatDataAction.createMessageAction):

// The ID of the slash command "/about".
// You must use the same ID in the Google Chat API configuration.
const ABOUT_COMMAND_ID = 1;

/**
 * Handle requests from Google Workspace add on
 *
 * @param {Object} req Request sent by Google Chat
 * @param {Object} res Response to be sent back to Google Chat
 */
http('avatarApp', (req, res) => {
  const chatEvent = req.body.chat;
  let message;
  if (chatEvent.appCommandPayload) {
    message = handleAppCommand(chatEvent);
  } else {
    message = handleMessage(chatEvent);
  }
  res.send({ hostAppDataAction: { chatDataAction: { createMessageAction: {
    message: message
  }}}});
});

/**
 * Responds to an APP_COMMAND event in Google Chat.
 *
 * @param {Object} event the event object from Google Chat
 * @return the response message object.
 */
function handleAppCommand(event) {
  switch (event.appCommandPayload.appCommandMetadata.appCommandId) {
    case ABOUT_COMMAND_ID:
      return {
        text: 'The Avatar app replies to Google Chat messages.'
      };
  }
}

# The ID of the slash command "/about".
# You must use the same ID in the Google Chat API configuration.
ABOUT_COMMAND_ID = 1

@functions_framework.http
def avatar_app(req: flask.Request) -> Mapping[str, Any]:
  """Handle requests from Google Workspace add on

  Args:
    flask.Request req: the request sent by Google Chat

  Returns:
    Mapping[str, Any]: the response to be sent back to Google Chat
  """
  chat_event = req.get_json(silent=True)["chat"]
  if chat_event and "appCommandPayload" in chat_event:
    message = handle_app_command(chat_event)
  else:
    message = handle_message(chat_event)
  return { "hostAppDataAction": { "chatDataAction": { "createMessageAction": {
      "message": message
  }}}}

def handle_app_command(event: Mapping[str, Any]) -> Mapping[str, Any]:
  """Responds to an APP_COMMAND event in Google Chat.

  Args:
    Mapping[str, Any] event: the event object from Google Chat

  Returns:
    Mapping[str, Any]: the response message object.
  """
  if event["appCommandPayload"]["appCommandMetadata"]["appCommandId"] == ABOUT_COMMAND_ID:
    return {
      "text": "The Avatar app replies to Google Chat messages.",
    }
  return {}

// The ID of the slash command "/about".
// You must use the same ID in the Google Chat API configuration.
private static final int ABOUT_COMMAND_ID = 1;

private static final Gson gson = new Gson();

/**
 * Handle requests from Google Workspace add on
 * 
 * @param request the request sent by Google Chat
 * @param response the response to be sent back to Google Chat
 */
@Override
public void service(HttpRequest request, HttpResponse response) throws Exception {
  JsonObject event = gson.fromJson(request.getReader(), JsonObject.class);
  JsonObject chatEvent = event.getAsJsonObject("chat");
  Message message;
  if (chatEvent.has("appCommandPayload")) {
    message = handleAppCommand(chatEvent);
  } else {
    message = handleMessage(chatEvent);
  }
  JsonObject createMessageAction = new JsonObject();
  createMessageAction.add("message", gson.fromJson(gson.toJson(message), JsonObject.class));
  JsonObject chatDataAction = new JsonObject();
  chatDataAction.add("createMessageAction", createMessageAction);
  JsonObject hostAppDataAction = new JsonObject();
  hostAppDataAction.add("chatDataAction", chatDataAction);
  JsonObject dataActions = new JsonObject();
  dataActions.add("hostAppDataAction", hostAppDataAction);
  response.getWriter().write(gson.toJson(dataActions));
}

/**
 * Handles an APP_COMMAND event in Google Chat.
 *
 * @param event the event object from Google Chat
 * @return the response message object.
 */
private Message handleAppCommand(JsonObject event) throws Exception {
  switch (event.getAsJsonObject("appCommandPayload")
    .getAsJsonObject("appCommandMetadata").get("appCommandId").getAsInt()) {
    case ABOUT_COMMAND_ID:
      return new Message()
        .setText("The Avatar app replies to Google Chat messages.");
    default:
      return null;
  }
}

// The ID of the slash command "/about".
// You must use the same ID in the Google Chat API configuration.
const ABOUT_COMMAND_ID = 1;

/**
 * Responds to an APP_COMMAND event in Google Chat.
 *
 * @param {Object} event the event object from Google Chat
 */
function onAppCommand(event) {
  // Executes the app command logic based on ID.
  switch (event.chat.appCommandPayload.appCommandMetadata.appCommandId) {
    case ABOUT_COMMAND_ID:
      return { hostAppDataAction: { chatDataAction: { createMessageAction: { message: {
        text: 'The Avatar app replies to Google Chat messages.'
      }}}}};
  }
}

Aby użyć tego przykładowego kodu, zastąp symbol ABOUT_COMMAND_ID identyfikatorem polecenia, który został podany podczas konfigurowania polecenia w interfejsie Chat API.

Odpowiadanie na sugerowane działanie

Poniższy kod pokazuje przykład aplikacji do Google Chat, która odpowiada na sugerowane działanie Przypomnij mi wiadomością tekstową. Aby odpowiadać na działania związane z wiadomościami, aplikacja Google Chat obsługuje obiekty zdarzeń z reguły Polecenie aplikacji. Gdy ładunek obiektu zdarzenia zawiera identyfikator polecenia działania wiadomości, aplikacja do obsługi czatu zwraca działanie DataActions z obiektem createMessageAction:

/**
 * Responds to an APP_COMMAND interaction event from Google Chat.
 *
 * @param {Object} event The interaction event from Google Chat.
 * @param {Object} res The HTTP response object.
 * @return {Object} The JSON response message with a confirmation.
 */
function onAppCommand(event, res) {
  // Collect the command ID and type from the event metadata.
  const {appCommandId, appCommandType} =
    event.chat.appCommandPayload.appCommandMetadata;

  if (appCommandType === 'MESSAGE_ACTION' &&
      appCommandId === REMIND_ME_COMMAND_ID) {

    // Message actions can access the context of the message they were
    // invoked on, such as the text or sender of that message.
    const messageText = event.chat.appCommandPayload.message.text;

    // Return a response that includes details from the original message.
    return res.json({
      "hostAppDataAction": {
        "chatDataAction": {
          "createMessageAction": {
            "message": {
              "text": `Setting a reminder for message: "${messageText}"`
            }
          }
        }
      }
    });
  }
}

def on_app_command(event):
    """Responds to an APP_COMMAND interaction event from Google Chat.

    Args:
        event (dict): The interaction event from Google Chat.

    Returns:
        dict: The JSON response message with a confirmation.
    """
    # Collect the command ID and type from the event metadata.
    payload = event.get('chat', {}).get('appCommandPayload', {})
    metadata = payload.get('appCommandMetadata', {})
    if metadata.get('appCommandType') == 'MESSAGE_ACTION' and \
       metadata.get('appCommandId') == REMIND_ME_COMMAND_ID:

        # Message actions can access the context of the message they were
        # invoked on, such as the text or sender of that message.
        message_text = payload.get('message', {}).get('text')

        # Return a response that includes details from the original message.
        return {
            "hostAppDataAction": {
                "chatDataAction": {
                    "createMessageAction": {
                        "message": {
                            "text": f'Setting a reminder for message: "{message_text}"'
                        }
                    }
                }
            }
        }

/**
 * Responds to an APP_COMMAND interaction event from Google Chat.
 *
 * @param event The interaction event from Google Chat.
 * @param response The HTTP response object.
 */
void onAppCommand(JsonObject event, HttpResponse response) throws Exception {
  // Collect the command ID and type from the event metadata.
  JsonObject payload = event.getAsJsonObject("chat").getAsJsonObject("appCommandPayload");
  JsonObject metadata = payload.getAsJsonObject("appCommandMetadata");
  String appCommandType = metadata.get("appCommandType").getAsString();

  if (appCommandType.equals("MESSAGE_ACTION")) {
    int commandId = metadata.get("appCommandId").getAsInt();
    if (commandId == REMIND_ME_COMMAND_ID) {
      // Message actions can access the context of the message they were
      // invoked on, such as the text or sender of that message.
      String messageText = payload.getAsJsonObject("message").get("text").getAsString();

      // Return a response that includes details from the original message.
      JsonObject responseMessage = new JsonObject();
      responseMessage.addProperty("text", "Setting a reminder for message: " + messageText);

      JsonObject createMessageAction = new JsonObject();
      createMessageAction.add("message", responseMessage);

      JsonObject chatDataAction = new JsonObject();
      chatDataAction.add("createMessageAction", createMessageAction);

      JsonObject hostAppDataAction = new JsonObject();
      hostAppDataAction.add("chatDataAction", chatDataAction);

      JsonObject finalResponse = new JsonObject();
      finalResponse.add("hostAppDataAction", hostAppDataAction);

      response.getWriter().write(finalResponse.toString());
    }
  }
}

/**
 * Responds to an APP_COMMAND interaction event in Google Chat.
 *
 * @param {Object} event The interaction event from Google Chat.
 * @return {Object} The JSON response message with a confirmation.
 */
function onAppCommand(event) {
  // Collect the command ID and type from the event metadata.
  const {appCommandId, appCommandType} =
    event.chat.appCommandPayload.appCommandMetadata;

  if (appCommandType === 'MESSAGE_ACTION' &&
      appCommandId === REMIND_ME_COMMAND_ID) {

    // Message actions can access the context of the message they were
    // invoked on, such as the text or sender of that message.
    const messageText = event.chat.appCommandPayload.message.text;

    // Return a response that includes details from the original message.
    return CardService.newChatResponseBuilder()
        .setText("Setting a reminder for message: " + messageText)
        .build();
  }
}

Aby użyć tego przykładowego kodu, zastąp symbol REMIND_ME_COMMAND_ID identyfikatorem polecenia, który został określony podczas konfigurowania polecenia w interfejsie Chat API.

Testowanie polecenia

Aby przetestować polecenie i kod, zapoznaj się z artykułem Testowanie funkcji interaktywnych aplikacji Google Chat.

Aby dowiedzieć się, jak przetestować i używać polecenia w interfejsie Chat, zapoznaj się z artykułem Korzystanie z aplikacji w Google Chat w dokumentacji pomocy Google Chat.

Powiązane artykuły

• Zobacz przykłady aplikacji do Google Chat, które używają poleceń.
• Wyślij wiadomość
• Otwieranie interaktywnych okien

/**
 * Handles slash and quick commands.
 *
 * @param {Object} event - The Google Chat event.
 * @param {Object} res - The HTTP response object.
 */
function handleAppCommands(event, res) {
  const {appCommandId, appCommandType} = event.appCommandMetadata;

  switch (appCommandId) {
    case ABOUT_COMMAND_ID:
      return res.send({
        privateMessageViewer: event.user,
        text: 'The Avatar app replies to Google Chat messages.'
      });
    case HELP_COMMAND_ID:
      return res.send({
        privateMessageViewer: event.user,
        text: 'The Avatar app replies to Google Chat messages.'
      });
  }
}

// Checks for the presence of a slash command in the message.
if (event.message.slashCommand) {
  // Executes the slash command logic based on its ID.
  // Slash command IDs are set in the Google Chat API configuration.
  switch (event.message.slashCommand.commandId) {
    case ABOUT_COMMAND_ID:
      return {
        privateMessageViewer: event.user,
        text: 'The Avatar app replies to Google Chat messages.'
      };
  }
}

def handle_app_commands(event: Mapping[str, Any]) -> Mapping[str, Any]:
    """Handles slash and quick commands.

    Args:
        Mapping[str, Any] event: The Google Chat event.

    Returns:
        Mapping[str, Any]: the response
    """
    app_command_id = event["appCommandMetadata"]["appCommandId"]

    if app_command_id == ABOUT_COMMAND_ID:
        return {
            "privateMessageViewer": event["user"],
            "text": "The Avatar app replies to Google Chat messages.",
        }
    elif app_command_id == HELP_COMMAND_ID:
        return {
            "privateMessageViewer": event["user"],
            "text": "The Avatar app replies to Google Chat messages.",
        }
    return {}

/**
 * Handles slash and quick commands.
 *
 * @param event    The Google Chat event.
 * @param response The HTTP response object.
 */
private void handleAppCommands(JsonObject event, HttpResponse response) throws Exception {
  int appCommandId = event.getAsJsonObject("appCommandMetadata").get("appCommandId").getAsInt();

  switch (appCommandId) {
    case ABOUT_COMMAND_ID:
      Message aboutMessage = new Message();
      aboutMessage.setText("The Avatar app replies to Google Chat messages.");
      aboutMessage.setPrivateMessageViewer(new User()
          .setName(event.getAsJsonObject("user").get("name").getAsString()));
      response.getWriter().write(gson.toJson(aboutMessage));
      return;
    case HELP_COMMAND_ID:
      Message helpMessage = new Message();
      helpMessage.setText("The Avatar app replies to Google Chat messages.");
      helpMessage.setPrivateMessageViewer(new User()
          .setName(event.getAsJsonObject("user").get("name").getAsString()));
      response.getWriter().write(gson.toJson(helpMessage));
      return;
  }
}

/**
 * Handles slash and quick commands.
 *
 * @param {Object} event - The Google Chat event.
 * @param {Object} res - The HTTP response object.
 */
function handleAppCommands(event, res) {
  const {appCommandId, appCommandType} = event.appCommandMetadata;

  switch (appCommandId) {
    case ABOUT_COMMAND_ID:
      return res.send({
        privateMessageViewer: event.user,
        text: 'The Avatar app replies to Google Chat messages.'
      });
    case HELP_COMMAND_ID:
      return res.send({
        privateMessageViewer: event.user,
        text: 'The Avatar app replies to Google Chat messages.'
      });
  }
}

/**
 * Handles the APP_COMMAND event type. This function is triggered when a user
 * interacts with a quick command within the Google Chat app.  It responds
 * based on the command ID.
 *
 * @param {Object} event The event object from Google Chat, containing details
 *     about the app command interaction.  It includes information like the
 *     command ID and the user who triggered it.
 */
function onAppCommand(event) {
  // Executes the quick command logic based on its ID.
  // Command IDs are set in the Google Chat API configuration.
  switch (event.appCommandMetadata.appCommandId) {
    case HELP_COMMAND_ID:
      return {
        privateMessageViewer: event.user,
        text: 'The Avatar app replies to Google Chat messages.'
      };
  }
}

def handle_app_commands(event: Mapping[str, Any]) -> Mapping[str, Any]:
    """Handles slash and quick commands.

    Args:
        Mapping[str, Any] event: The Google Chat event.

    Returns:
        Mapping[str, Any]: the response
    """
    app_command_id = event["appCommandMetadata"]["appCommandId"]

    if app_command_id == ABOUT_COMMAND_ID:
        return {
            "privateMessageViewer": event["user"],
            "text": "The Avatar app replies to Google Chat messages.",
        }
    elif app_command_id == HELP_COMMAND_ID:
        return {
            "privateMessageViewer": event["user"],
            "text": "The Avatar app replies to Google Chat messages.",
        }
    return {}

/**
 * Handles slash and quick commands.
 *
 * @param event    The Google Chat event.
 * @param response The HTTP response object.
 */
private void handleAppCommands(JsonObject event, HttpResponse response) throws Exception {
  int appCommandId = event.getAsJsonObject("appCommandMetadata").get("appCommandId").getAsInt();

  switch (appCommandId) {
    case ABOUT_COMMAND_ID:
      Message aboutMessage = new Message();
      aboutMessage.setText("The Avatar app replies to Google Chat messages.");
      aboutMessage.setPrivateMessageViewer(new User()
          .setName(event.getAsJsonObject("user").get("name").getAsString()));
      response.getWriter().write(gson.toJson(aboutMessage));
      return;
    case HELP_COMMAND_ID:
      Message helpMessage = new Message();
      helpMessage.setText("The Avatar app replies to Google Chat messages.");
      helpMessage.setPrivateMessageViewer(new User()
          .setName(event.getAsJsonObject("user").get("name").getAsString()));
      response.getWriter().write(gson.toJson(helpMessage));
      return;
  }
}

/**
 * Responds to an APP_COMMAND interaction event from Google Chat.
 *
 * @param {Object} event The interaction event from Google Chat.
 * @param {Object} res The HTTP response object.
 * @return {Object} The JSON response message with a confirmation.
 */
function handleAppCommand(event, res) {
  // Collect the command ID and type from the event metadata.
  const {appCommandId, appCommandType} = event.appCommandMetadata;

  // Use appCommandType to detect message actions.
  if (appCommandType === 'MESSAGE_ACTION' &&
      appCommandId === REMIND_ME_COMMAND_ID) {

    // Message actions can access the context of the message they were
    // invoked on, such as the text or sender of that message.
    const messageText = event.message.text;

    // Return a response that includes details from the original message.
    return res.send({
      text: `Setting a reminder for this message: "${messageText}"`
    });
  }
}

/**
 * Responds to an APP_COMMAND interaction event in Google Chat.
 *
 * @param {Object} event The interaction event from Google Chat.
 * @return {Object} The JSON response message with a confirmation.
 */
function onAppCommand(event) {
  // Collect the command ID and type from the event metadata.
  const {appCommandId, appCommandType} = event.appCommandMetadata;

  if (appCommandType === 'MESSAGE_ACTION' &&
      appCommandId === REMIND_ME_COMMAND_ID) {

    // Message actions can access the context of the message they were
    // invoked on, such as the text or sender of that message.
    const messageText = event.message.text;

    // Return a response that includes details from the original message.
    return { "text": "Setting a reminder for message: " + messageText };
  }
}

def handle_app_command(event):
    """Responds to an APP_COMMAND interaction event from Google Chat.

    Args:
        event (dict): The interaction event from Google Chat.

    Returns:
        dict: The JSON response message with a confirmation.
    """
    # Collect the command ID and type from the event metadata.
    metadata = event.get('appCommandMetadata', {})
    if metadata.get('appCommandType') == 'MESSAGE_ACTION' and \
       metadata.get('appCommandId') == REMIND_ME_COMMAND_ID:

        # Message actions can access the context of the message they were
        # invoked on, such as the text or sender of that message.
        message_text = event.get('message', {}).get('text')

        # Return a response that includes details from the original message.
        return {
            "text": f'Setting a reminder for message: "{message_text}"'
        }

/**
 * Responds to an APP_COMMAND interaction event from Google Chat.
 *
 * @param event The interaction event from Google Chat.
 * @param response The HTTP response object.
 */
void handleAppCommand(JsonObject event, HttpResponse response) throws Exception {
  // Collect the command ID and type from the event metadata.
  JsonObject metadata = event.getAsJsonObject("appCommandMetadata");
  String appCommandType = metadata.get("appCommandType").getAsString();

  if (appCommandType.equals("MESSAGE_ACTION")) {
    int commandId = metadata.get("appCommandId").getAsInt();
    if (commandId == REMIND_ME_COMMAND_ID) {
      // Message actions can access the context of the message they were
      // invoked on, such as the text or sender of that message.
      String messageText = event.getAsJsonObject("message").get("text").getAsString();

      // Return a response that includes details from the original message.
      JsonObject responseMessage = new JsonObject();
      responseMessage.addProperty("text", "Setting a reminder for message: " + messageText);
      response.getWriter().write(responseMessage.toString());
    }
  }
}