Besprechungen in Google Chat planen

Programmierkenntnisse: Mittel
Dauer: 25 Minuten
Projekttyp: Google Chat-App

Ziele

• Verstehen, was die Lösung tut.
• Verstehen, wie die Apps Script-Dienste in der Lösung funktionieren.
• Die Umgebung einrichten
• Das Script einrichten
• Das Script ausführen.

Informationen zu dieser Lösung

Sie können eine Besprechung in Google Kalender direkt über eine Direktnachricht oder einen Bereich in Google Chat planen. Sie können bestimmte Details für die Besprechung festlegen, z. B. Betreff, Startzeit oder Dauer, oder die Standardeinstellungen für die sofortige Besprechungsplanung verwenden.

Funktionsweise

Das Chat-App-Script verwendet Slash-Befehle und Dialogfelder, um Besprechungsdetails von Nutzern abzurufen und einen Kalendertermin zu planen. Das Script enthält Standardeinstellungen für Besprechungen, die an Ihre Bedürfnisse angepasst werden können.

Apps Script-Dienste

Diese Lösung verwendet die folgenden Dienste:

• Kalenderdienst: Erstellt den Kalendertermin anhand der angegebenen Besprechungsinformationen.
• Basisdienst: Verwendet die Klasse Session, um die Zeitzone des Scripts abzurufen. Kalender verwendet diese Zeitzone beim Planen des Termins.
• Dienst „Utilities“: Formatiert das Datum für den Kalendertermin und codiert die Ereignis-ID, um die Ereignis-URL abzurufen.

Vorbereitung

• Ein Google Workspace-Konto für Unternehmen oder Enterprise mit Zugriff auf Google Chat.
• Google Cloud-Projekt erstellen.

Umgebung einrichten

Cloud-Projekt in der Google Cloud Console öffnen

Öffnen Sie das Cloud-Projekt, das Sie für dieses Beispiel verwenden möchten, falls es noch nicht geöffnet ist:

1. Rufen Sie in der Google Cloud Console die Seite Projekt auswählen auf.

   Cloud-Projekt auswählen

2. Wählen Sie das Google Cloud-Projekt aus, das Sie verwenden möchten. Oder klicken Sie auf Projekt erstellen und folgen Sie der Anleitung auf dem Bildschirm. Wenn Sie ein Google Cloud-Projekt erstellen, müssen Sie möglicherweise die Abrechnung für das Projekt aktivieren.

API aktivieren

Bevor Sie Google APIs verwenden können, müssen Sie sie in einem Google Cloud-Projekt aktivieren. Sie können eine oder mehrere APIs in einem einzelnen Google Cloud-Projekt aktivieren.

• Aktivieren Sie in Ihrem Cloud-Projekt die Google Chat API.

  API aktivieren

OAuth-Zustimmungsbildschirm konfigurieren

Für alle Chat-Apps ist eine Konfiguration des Zustimmungsbildschirms erforderlich. Wenn Sie den OAuth-Zustimmungsbildschirm Ihrer App konfigurieren, legen Sie fest, was Google den Nutzern anzeigt, und registrieren Ihre App, damit Sie sie später veröffentlichen können.

1. Rufen Sie in der Google API Console das Menü auf > Google Auth Platform > Branding.

   Zum Branding

2. Wenn Sie die Google Auth Platform bereits konfiguriert haben, können Sie die folgenden Einstellungen für den OAuth-Zustimmungsbildschirm unter Branding, Zielgruppe und Datenzugriff konfigurieren. Wenn Sie die Meldung Google Auth Platform noch nicht konfiguriert sehen, klicken Sie auf Jetzt starten:
1. Geben Sie unter Anwendungsinformationen im Feld Anwendungsname einen Namen für die App ein.
2. Wählen Sie unter E‑Mail-Adresse für Nutzersupport eine E‑Mail-Adresse für den Support aus, über die Nutzer Sie kontaktieren können, wenn sie Fragen zu ihrer Einwilligung haben.
3. Klicken Sie auf Weiter.
4. Wählen Sie unter Zielgruppe die Option Intern aus.
5. Klicken Sie auf Weiter.
6. Geben Sie unter Kontaktdaten eine E‑Mail-Adresse ein, über die Sie über Änderungen an Ihrem Projekt benachrichtigt werden können.
7. Klicken Sie auf Weiter.
8. Lesen Sie unter Abschließen die Nutzerdatenrichtlinie für Google API-Dienste. Wenn Sie damit einverstanden sind, wählen Sie Ich akzeptiere die Richtlinie zu Nutzerdaten für Google API-Dienste aus.
9. Klicken Sie auf Weiter.
10. Klicken Sie auf Erstellen.
3. Sie können das Hinzufügen von Bereichen vorerst überspringen. Wenn Sie später eine App für die Verwendung außerhalb Ihrer Google Workspace-Organisation erstellen, müssen Sie den Nutzertyp in Extern ändern. Fügen Sie dann die Autorisierungsbereiche hinzu, die Ihre App benötigt. Weitere Informationen finden Sie in der vollständigen Anleitung zum Konfigurieren des OAuth-Zustimmungsbildschirms.

Script einrichten

Apps Script-Projekt erstellen

1. Klicken Sie auf die folgende Schaltfläche, um das Apps Script-Projekt Besprechungen über Google Chat planen zu öffnen.
   Projekt öffnen
2. Klicken Sie auf Übersicht .
3. Klicken Sie auf der Übersichtsseite auf „Kopie erstellen“ .

Wenn Sie bestimmte Google APIs verwenden oder Ihre App veröffentlichen möchten, müssen Sie Ihr Cloud-Projekt mit Ihrem Apps Script-Projekt verknüpfen. Für diese Anleitung ist das nicht erforderlich. Weitere Informationen finden Sie in der Anleitung zu Google Cloud-Projekten.

Testbereitstellung erstellen

1. Klicken Sie in Ihrem kopierten Apps Script-Projekt auf Bereitstellen > Bereitstellungen testen.
2. Kopieren Sie die Bereitstellungs-ID für das Head-Deployment für einen späteren Schritt und klicken Sie auf Fertig.

Chat API konfigurieren

1. Rufen Sie in der Google API Console die Seite Chat API auf.
   Zur Chat API
2. Klicken Sie auf Konfiguration.
3. Deaktivieren Sie Diese Chat-App als Google Workspace-Add‑on erstellen. Sie werden in einem Dialogfeld aufgefordert, die Aktion zu bestätigen. Klicken Sie im Dialogfeld auf Deaktivieren.
4. Konfigurieren Sie die Chat API mit den folgenden Informationen:
   • Name: Meeting Scheduler
   • Avatar-URL: Fügen Sie eine URL hinzu, die auf ein Bild mit einer Mindestgröße von 256 × 256 Pixel verweist.
   • Beschreibung: Quickly create meetings.
   • Funktionalität: Aktivieren Sie beide Kästchen, damit Nutzer der App direkt Nachrichten senden und sie zu Bereichen hinzufügen können.
   • Verbindungseinstellungen: Klicken Sie auf Apps Script und geben Sie die Bereitstellungs-ID für das Head-Deployment ein.
   • Slash-Befehle: Fügen Sie Slash-Befehle für /help und /schedule_Meeting hinzu. Gehen Sie dazu so vor:
     1. Klicken Sie auf Slash-Befehl hinzufügen und konfigurieren Sie ihn mit den folgenden Informationen:
        • Name: /help
        • Befehls-ID: 1
        • Beschreibung: Learn what this app does.
     2. Klicken Sie noch einmal auf Slash-Befehl hinzufügen und konfigurieren Sie ihn mit den folgenden Informationen:
        • Name: /schedule_Meeting
        • Befehls-ID: 2
        • Beschreibung: Schedule a meeting.
        • Aktivieren Sie das Kästchen Öffnet ein Dialogfeld.
   • Berechtigungen: Wählen Sie Bestimmte Personen und Gruppen in Ihrer Domain aus und geben Sie Ihre E‑Mail-Adresse ein.
5. Klicken Sie auf Speichern und aktualisieren Sie die Seite.
6. Setzen Sie auf der Konfigurationsseite unter App-Status den Status auf Live – für Nutzer verfügbar.
7. Klicken Sie auf Speichern.

Das Script ausführen.

1. Öffnen Sie Google Chat.
2. Klicken Sie auf „Chat starten“ .
3. Suchen Sie nach dem Namen der App: Meeting Scheduler.
4. Senden Sie eine erste Nachricht, z. B. hello, um die Autorisierung anzufordern.

5. Wenn die App antwortet, klicken Sie auf Konfigurieren und autorisieren Sie die App. Wenn auf dem OAuth-Zustimmungsbildschirm die Warnung Diese App wurde nicht verifiziert angezeigt wird, wählen Sie Erweitert > Zu {Project Name} (unsicher) aus.

6. Senden Sie /schedule_Meeting an die App.

7. Fügen Sie im Dialogfeld mindestens eine E‑Mail-Adresse für einen Eingeladenen hinzu. Sie können die anderen Felder aktualisieren oder die Standardeinträge verwenden.

8. Klicken Sie auf Senden.

9. Klicken Sie auf Kalendertermin öffnen, um die Besprechung aufzurufen.

Code ansehen

Wenn Sie den Apps Script-Code für diese Lösung ansehen möchten, klicken Sie unten auf Quellcode ansehen:

Quellcode ansehen

Code.gs

apps-script/schedule-meetings/Code.js

Auf GitHub ansehen

// To learn how to use this script, refer to the documentation:
// https://developers.google.com/workspace/chat/tutorial-schedule-meetings

/*
Copyright 2022 Google LLC

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    https://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

// Application constants
const APPNAME = "Chat Meeting Scheduler";
const SLASHCOMMAND = {
  HELP: 1, // /help
  DIALOG: 2, // /schedule_Meeting
};

/**
 * Responds to an ADDED_TO_SPACE event in Google Chat.
 * Called when the Chat app is added to a space. The Chat app can either be directly added to the space
 * or added by a @mention. If the Chat app is added by a @mention, the event object includes a message property.
 * Returns a Message object, which is usually a welcome message informing users about the Chat app.
 *
 * @param {Object} event The event object from Google Chat
 */
function onAddToSpace(event) {
  let message = "";

  // Personalizes the message depending on how the Chat app is called.
  if (event.space.singleUserBotDm) {
    message = `Hi ${event.user.displayName}!`;
  } else {
    const spaceName = event.space.displayName
      ? event.space.displayName
      : "this chat";
    message = `Hi! Thank you for adding me to ${spaceName}`;
  }

  // Lets users know what they can do and how they can get help.
  message = `${message}/nI can quickly schedule a meeting for you with just a few clicks.Try me out by typing */schedule_Meeting*. /nTo learn what else I can do, type */help*.`;

  return { text: message };
}

/**
 * Responds to a MESSAGE event triggered in Chat.
 * Called when the Chat app is already in the space and the user invokes it via @mention or / command.
 * Returns a message object containing the Chat app's response. For this Chat app, the response is either the
 * help text or the dialog to schedule a meeting.
 *
 * @param {object} event The event object from Google Chat
 * @return {object} JSON-formatted response as text or Card message
 */
function onMessage(event) {
  // Handles regular onMessage logic.
  // Evaluates if and handles for all slash commands.
  if (event.message.slashCommand) {
    switch (event.message.slashCommand.commandId) {
      case SLASHCOMMAND.DIALOG: // Displays meeting dialog for /schedule_Meeting.
        // TODO update this with your own logic to set meeting recipients, subjects, etc (e.g. a group email).
        return getInputFormAsDialog_({
          invitee: "",
          startTime: getTopOfHourDateString_(),
          duration: 30,
          subject: "Status Stand-up",
          body: "Scheduling a quick status stand-up meeting.",
        });

      case SLASHCOMMAND.HELP: // Responds with help text for /help.
        return getHelpTextResponse_();

      /* TODO Add other use cases here. E.g:
      case SLASHCOMMAND.NEW_FEATURE:  // Your Feature Here
        getDialogForAddContact(message);
      */
    }
  }
  // Returns text if users didn't invoke a slash command.
  return { text: "No action taken - use Slash Commands." };
}

/**
 * Responds to a CARD_CLICKED event triggered in Chat.
 * @param {object} event the event object from Chat
 * @return {object} JSON-formatted response
 * @see https://developers.google.com/workspace/chat/receive-respond-interactions
 */
function onCardClick(event) {
  if (event.action.actionMethodName === "handleFormSubmit") {
    const recipients = getFieldValue_(event.common.formInputs, "email");
    const subject = getFieldValue_(event.common.formInputs, "subject");
    const body = getFieldValue_(event.common.formInputs, "body");

    // Assumes dialog card inputs for date and times are in the correct format. mm/dd/yyy HH:MM
    const dateTimeInput = getFieldValue_(event.common.formInputs, "date");
    const startTime = getStartTimeAsDateObject_(dateTimeInput);
    const duration = Number(
      getFieldValue_(event.common.formInputs, "duration"),
    );

    // Handles instances of missing or invalid input parameters.
    const errors = [];

    if (!recipients) {
      errors.push("Missing or invalid recipient email address.");
    }
    if (!subject) {
      errors.push("Missing subject line.");
    }
    if (!body) {
      errors.push("Missing event description.");
    }
    if (!startTime) {
      errors.push("Missing or invalid start time.");
    }
    if (!duration || Number.isNaN(duration)) {
      errors.push("Missing or invalid duration");
    }
    if (errors.length) {
      // Redisplays the form if missing or invalid inputs exist.
      return getInputFormAsDialog_({
        errors,
        invitee: recipients,
        startTime: dateTimeInput,
        duration,
        subject,
        body,
      });
    }

    //  Calculates the end time via duration.
    const endTime = new Date(startTime.valueOf());
    endTime.setMinutes(endTime.getMinutes() + duration);

    // Creates calendar event with notification.
    const calendar = CalendarApp.getDefaultCalendar();
    const scheduledEvent = calendar.createEvent(subject, startTime, endTime, {
      guests: recipients,
      sendInvites: true,
      description: `${body}\nThis meeting scheduled by a Google Chat App!`,
    });

    // Gets a link to the Calendar event.
    const url = getCalendarEventURL_(scheduledEvent, calendar);

    return getConfirmationDialog_(url);
  }
  if (event.action.actionMethodName === "closeDialog") {
    // Returns this dialog as success.
    return {
      actionResponse: {
        type: "DIALOG",
        dialog_action: {
          actionStatus: "OK",
        },
      },
    };
  }
}

/**
 * Responds with help text about this Chat app.
 * @return {string} The help text as seen below
 */
function getHelpTextResponse_() {
  const help = `*${APPNAME}* lets you quickly create meetings from Google Chat. Here\'s a list of all its commands:
  \`/schedule_Meeting\`  Opens a dialog with editable, preset parameters to create a meeting event
  \`/help\`  Displays this help message

  Learn more about creating Google Chat apps at https://developers.google.com/chat.`;

  return { text: help };
}

Dialog.gs

apps-script/schedule-meetings/Dialog.js

Auf GitHub ansehen

/**
 * Copyright 2022 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * Form input dialog as JSON.
 * @return {object} JSON-formatted cards for the dialog.
 */
function getInputFormAsDialog_(options) {
  const form = getForm_(options);
  return {
    actionResponse: {
      type: "DIALOG",
      dialogAction: {
        dialog: {
          body: form,
        },
      },
    },
  };
}

/**
 * Form JSON to collect inputs regarding the meeting.
 * @return {object} JSON-formatted cards.
 */
function getForm_(options) {
  const sections = [];

  // If errors present, display additional section with validation messages.
  if (options.errors?.length) {
    let errors = options.errors.reduce((str, err) => `${str}• ${err}<br>`, "");
    errors = `<b>Errors:</b><br><font color="#ba0000">${errors}</font>`;
    const errorSection = {
      widgets: [
        {
          textParagraph: {
            text: errors,
          },
        },
      ],
    };
    sections.push(errorSection);
  }
  const formSection = {
    header: "Schedule meeting and send email to invited participants",
    widgets: [
      {
        textInput: {
          label: "Event Title",
          type: "SINGLE_LINE",
          name: "subject",
          value: options.subject,
        },
      },
      {
        textInput: {
          label: "Invitee Email Address",
          type: "SINGLE_LINE",
          name: "email",
          value: options.invitee,
          hintText: "Add team group email",
        },
      },
      {
        textInput: {
          label: "Description",
          type: "MULTIPLE_LINE",
          name: "body",
          value: options.body,
        },
      },
      {
        textInput: {
          label: "Meeting start date & time",
          type: "SINGLE_LINE",
          name: "date",
          value: options.startTime,
          hintText: "mm/dd/yyyy H:MM",
        },
      },
      {
        selectionInput: {
          type: "DROPDOWN",
          label: "Meeting Duration",
          name: "duration",
          items: [
            {
              text: "15 minutes",
              value: "15",
              selected: options.duration === 15,
            },
            {
              text: "30 minutes",
              value: "30",
              selected: options.duration === 30,
            },
            {
              text: "45 minutes",
              value: "45",
              selected: options.duration === 45,
            },
            {
              text: "1 Hour",
              value: "60",
              selected: options.duration === 60,
            },
            {
              text: "1.5 Hours",
              value: "90",
              selected: options.duration === 90,
            },
            {
              text: "2 Hours",
              value: "120",
              selected: options.duration === 120,
            },
          ],
        },
      },
    ],
    collapsible: false,
  };
  sections.push(formSection);
  const card = {
    sections: sections,
    name: "Google Chat Scheduled Meeting",
    fixedFooter: {
      primaryButton: {
        text: "Submit",
        onClick: {
          action: {
            function: "handleFormSubmit",
          },
        },
        altText: "Submit",
      },
    },
  };
  return card;
}

/**
 * Confirmation dialog after a calendar event is created successfully.
 * @param {string} url The Google Calendar Event url for link button
 * @return {object} JSON-formatted cards for the dialog
 */
function getConfirmationDialog_(url) {
  return {
    actionResponse: {
      type: "DIALOG",
      dialogAction: {
        dialog: {
          body: {
            sections: [
              {
                widgets: [
                  {
                    textParagraph: {
                      text: "Meeting created successfully!",
                    },
                    horizontalAlignment: "CENTER",
                  },
                  {
                    buttonList: {
                      buttons: [
                        {
                          text: "Open Calendar Event",
                          onClick: {
                            openLink: {
                              url: url,
                            },
                          },
                        },
                      ],
                    },
                    horizontalAlignment: "CENTER",
                  },
                ],
              },
            ],
            fixedFooter: {
              primaryButton: {
                text: "OK",
                onClick: {
                  action: {
                    function: "closeDialog",
                  },
                },
              },
            },
          },
        },
      },
    },
  };
}

Utilities.gs

apps-script/schedule-meetings/Utilities.js

Auf GitHub ansehen

/**
 * Copyright 2022 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * Helper function that gets the field value from the given form input.
 * @return {string}
 */
function getFieldValue_(formInputs, fieldName) {
  return formInputs[fieldName][""].stringInputs.value[0];
}

// Regular expression to validate the date/time input.
const DATE_TIME_PATTERN = /\d{1,2}\/\d{1,2}\/\d{4}\s+\d{1,2}:\d\d/;

/**
 * Casts date and time from string to Date object.
 * @return {date}
 */
function getStartTimeAsDateObject_(dateTimeStr) {
  if (!dateTimeStr || !dateTimeStr.match(DATE_TIME_PATTERN)) {
    return null;
  }

  const parts = dateTimeStr.split(" ");
  const [month, day, year] = parts[0].split("/").map(Number);
  const [hour, minute] = parts[1].split(":").map(Number);

  Session.getScriptTimeZone();

  return new Date(year, month - 1, day, hour, minute);
}

/**
 * Gets the current date and time for the upcoming top of the hour (e.g. 01/25/2022 18:00).
 * @return {string} date/time in mm/dd/yyy HH:MM format needed for use by Calendar
 */
function getTopOfHourDateString_() {
  const date = new Date();
  date.setHours(date.getHours() + 1);
  date.setMinutes(0, 0, 0);
  // Adding the date as string might lead to an incorrect response due to time zone adjustments.
  return Utilities.formatDate(
    date,
    Session.getScriptTimeZone(),
    "MM/dd/yyyy H:mm",
  );
}

/**
 * Creates the URL for the Google Calendar event.
 *
 * @param {object} event The Google Calendar Event instance
 * @param {object} cal The associated Google Calendar
 * @return {string} URL in the form of 'https://www.google.com/calendar/event?eid={event-id}'
 */
function getCalendarEventURL_(event, cal) {
  const baseCalUrl = "https://www.google.com/calendar";
  // Joins Calendar Event Id with Calendar Id, then base64 encode to derive the event URL.
  let encodedId = Utilities.base64Encode(
    `${event.getId().split("@")[0]} ${cal.getId()}`,
  ).replace(/\=/g, "");
  encodedId = `/event?eid=${encodedId}`;
  return baseCalUrl + encodedId;
}

Nächste Schritte

• Übersicht für Chat-Entwickler
• Google Chat-App mit Apps Script erstellen