Initiieren von Aktionen mit Messaging-Erweiterungen

Wichtig

Die Artikel in diesem Abschnitt basieren auf dem v3 Bot Framework SDK. Wenn Sie nach aktueller Dokumentation (Version 4.6 oder höher) des SDK suchen, lesen Sie den Abschnitt "Aufgabenorientierte Interaktionen mit Messaging-Erweiterungen".

Aktionsbasierte Messaging-Erweiterungen ermöglichen Es Ihren Benutzern, Aktionen in externen Diensten während Teams auszulösen.

Beispiel für eine Messaging-Erweiterungskarte

In den folgenden Abschnitten wird dies beschrieben:

Hinzufügen einer Messaging-Erweiterung zu Ihrer App

Eine Messaging-Erweiterung ist ein in der Cloud gehosteter Dienst, der Benutzeranforderungen überwacht und mit strukturierten Daten wie z. B. einer Karteantwortet. Sie integrieren Ihren Dienst mit Microsoft Teams über Bot Activity Framework-Objekte. Unsere .NET- und Node.js-Erweiterungen für das Bot Builder SDK können Ihnen helfen, Ihrer App Messaging-Erweiterungsfunktionen hinzuzufügen.

Diagramm des Nachrichtenflusses für Messaging-Erweiterungen

Registrieren im Bot Framework

Wenn sie dies noch nicht getan haben, müssen Sie zuerst einen Bot beim Microsoft Bot Framework registrieren. Die Dort definierten Microsoft-App-ID- und Rückrufendpunkte für Ihren Bot werden in Ihrer Messaging-Erweiterung verwendet, um Benutzeranforderungen zu empfangen und darauf zu reagieren. Denken Sie daran, den Microsoft Teams-Kanal für Ihren Bot zu aktivieren.

Notieren Sie Ihre Bot-App-ID und Ihr App-Kennwort. Sie müssen die App-ID in Ihrem App-Manifest angeben.

Aktualisieren des App-Manifests

Wie bei Bots und Registerkarten aktualisieren Sie das Manifest Ihrer App, um die Eigenschaften der Messaging-Erweiterung einzuschließen. Diese Eigenschaften steuern, wie Ihre Messaging-Erweiterung im Microsoft Teams Client angezeigt wird und wie sie sich verhält. Messaging-Erweiterungen werden ab Version 1.0 des Manifests unterstützt.

Deklarieren Der Messaging-Erweiterung

Um eine Messaging-Erweiterung hinzuzufügen, fügen Sie eine neue JSON-Struktur auf oberster Ebene in Ihr Manifest mit der composeExtensions Eigenschaft ein. Derzeit sind Sie auf die Erstellung einer einzelnen Messaging-Erweiterung für Ihre App beschränkt.

Hinweis

Das Manifest bezieht sich auf Messaging-Erweiterungen als composeExtensions . Dies dient zur Aufrechterhaltung der Abwärtskompatibilität.

Die Erweiterungsdefinition ist ein Objekt mit der folgenden Struktur:

Eigenschaftenname Zweck Pflichtfeld?
botId Die eindeutige Microsoft-App-ID für den Bot, wie bei Bot Framework registriert. Dies sollte in der Regel mit der ID für Ihre gesamte Teams-App übereinstimmen. Ja
scopes Array, das deklariert, ob diese Erweiterung zu bereichen (oder zu beiden) hinzugefügt werden personal team kann. Ja
canUpdateConfiguration Aktiviert Einstellungen Menüelement. Nein
commands Array von Befehlen, die von dieser Messaging-Erweiterung unterstützt werden. Sie sind auf 10 Befehle beschränkt. Ja

Definieren von Befehlen

Ihre Messaging-Erweiterung sollte einen Befehl deklarieren, der angezeigt wird, wenn der Benutzer Ihre App über die Schaltfläche "Weitere Optionen" () im Feld "Verfassen" auswählt.

Screenshot der Liste der Messaging-Erweiterungen in Teams

Im App-Manifest ist das Befehlselement ein Objekt mit der folgenden Struktur:

Eigenschaftenname Zweck Pflichtfeld? Mindestversion des Manifests
id Eindeutige ID, die Sie diesem Befehl zuweisen. Die Benutzeranforderung enthält diese ID. Ja 1.0
title Befehlsname. Dieser Wert wird in der Benutzeroberfläche angezeigt. Ja 1.0
description Hilfetext, der angibt, was dieser Befehl bewirkt. Dieser Wert wird in der Benutzeroberfläche angezeigt. Ja 1.0
type Legen Sie den Befehlstyp fest. Mögliche Werte sind query und action. Wenn dieser Wert nicht vorhanden ist, wird der Standardwert auf query . Nein 1.4
initialRun Optionaler Parameter, der mit Befehlen verwendet query wird. Wenn der Wert auf "true" festgelegt ist, wird angegeben, dass dieser Befehl ausgeführt werden soll, sobald der Benutzer diesen Befehl auf der Benutzeroberfläche auswählt. Nein 1.0
fetchTask Optionaler Parameter, der mit Befehlen verwendet action wird. Auf "true" festgelegt, um die adaptive Karte oder Web-URL abzurufen, die im Aufgabenmodulangezeigt werden soll. Dies wird verwendet, wenn die Eingaben für den action Befehl dynamisch sind, im Gegensatz zu einem statischen Satz von Parametern. Beachten Sie, dass die Statische Parameterliste für den Befehl ignoriert wird, wenn sie auf "true" festgelegt ist. Nein 1.4
parameters Statische Liste der Parameter für den Befehl. Ja 1.0
parameter.name Der Name des Parameters. Dies wird in der Benutzeranforderung an Ihren Dienst gesendet. Ja 1.0
parameter.description Beschreibt die Zwecke dieses Parameters oder ein Beispiel für den Wert, der angegeben werden soll. Dieser Wert wird in der Benutzeroberfläche angezeigt. Ja 1.0
parameter.title Kurzer benutzerfreundlicher Parametertitel oder -beschriftung. Ja 1.0
parameter.inputType Legen Sie den Typ der erforderlichen Eingabe fest. Mögliche Werte sind text , , , , , textarea number date time toggle . Der Standardwert ist auf text . Nein 1.4
context Optionales Array von Werten, das den Kontext definiert, in dem die Nachrichtenaktion verfügbar ist. Mögliche Werte sind message , compose oder commandBox . Der Standardwert lautet ["compose", "commandBox"]. Nein 1,5

Nachrichtenerweiterungen des Aktionstyps

Um Aktionen von einer Messaging-Erweiterung aus zu initiieren, legen Sie den type Parameter auf action . Unten sehen Sie ein Beispiel für ein Manifest mit einer Suche und einem Befehl zum Erstellen. Eine einzelne Messaging-Erweiterung kann bis zu 10 verschiedene Befehle enthalten. Dies kann sowohl mehrere Suchbefehle als auch mehrere aktionsbasierte Befehle umfassen.

Beispiel für ein vollständiges App-Manifest

{
  "$schema": "https://developer.microsoft.com/json-schemas/teams/v1.8/MicrosoftTeams.schema.json",
  "manifestVersion": "1.5",
  "version": "1.0",
  "id": "57a3c29f-1fc5-4d97-a142-35bb662b7b23",
  "packageName": "com.microsoft.teams.samples.Todo",
  "developer": {
    "name": "John Developer",
    "websiteUrl": "http://todobotservice.azurewebsites.net/",
    "privacyUrl": "http://todobotservice.azurewebsites.net/privacy",
    "termsOfUseUrl": "http://todobotservice.azurewebsites.net/termsofuse"
  },
  "name": {
    "short": "To Do",
    "full": "To Do"
  },
  "description": {
    "short": "Find or create a new task in To Do",
    "full": "Find or create a new task in To Do"
  },
  "icons": {
    "outline": "todo-outline.jpg",
    "color": "todo-color.jpg"
  },
  "accentColor": "#ff6a00",
  "composeExtensions": [
    {
      "botId": "57a3c29f-1fc5-4d97-a142-35bb662b7b23",
      "canUpdateConfiguration": true,
      "commands": [
        {
          "id": "searchCmd",
          "description": "Search you Todo's",
          "title": "Search",
          "initialRun": true,
          "context": ["commandBox", "compose"],
          "parameters": [
            {
              "name": "searchKeyword",
              "description": "Enter your search keywords",
              "title": "Keywords"
            }
          ]
        },
        {
          "id": "addTodo",
          "description": "Create a To Do item",
          "title": "Create To Do",
          "type": "action",
          "context": ["commandBox", "message", "compose"],
          "parameters": [
            {
              "name": "Name",
              "description": "To Do Title",
              "title": "Title",
              "inputType": "text"
            },
            {
              "name": "Description",
              "description": "Description of the task",
              "title": "Description",
              "inputType": "textarea"
            },
            {
              "name": "Date",
              "description": "Due date for the task",
              "title": "Date",
              "inputType": "date"
            }
          ]
        },
        {
          "id": "reassignTodo",
          "description": "Reassign a todo item",
          "title": "Reassign a todo item",
          "type": "action",
          "fetchTask": false,
          "parameters": [
            {
              "name": "Name",
              "title": "Title"
              "inputType": "text"
            }
          ]
        }
      ]
    }
  ],
  "permissions": [
    "identity",
    "messageTeamMembers"
  ],
  "validDomains": [
    "todobotservice.azurewebsites.net",
    "*.todobotservice.azurewebsites.net"
  ]
}

Initiieren von Aktionen aus Nachrichten

Zusätzlich zum Initiieren von Aktionen aus dem Bereich zum Verfassen von Nachrichten können Sie auch Ihre Messaging-Erweiterung verwenden, um eine Aktion aus einer Nachricht auszulösen. Auf diese Weise können Sie den Nachrichteninhalt zur Verarbeitung an Ihren Bot senden und optional mit einer Antwort mithilfe der Methode antworten, die unter Antworten auf die Übermittlungbeschrieben wird. Die Antwort wird als Antwort auf die Nachricht eingefügt, die Ihre Benutzer vor dem Senden bearbeiten können. Ihre Benutzer können über das Überlaufmenü auf die Messaging-Erweiterung zugreifen ... und dann wie in der folgenden Abbildung Take action auswählen:

Beispiel für das Initiieren einer Aktion aus einer Nachricht

Damit Ihre Messaging-Erweiterung von einer Nachricht aus funktioniert, fügen Sie den context Parameter dem Objekt Ihrer Messaging-Erweiterung im commands App-Manifest hinzu, wie im folgenden Beispiel gezeigt. Gültige Zeichenfolgen für das context Array sind , und "message" "commandBox" "compose" . Der Standardwert ist ["compose", "commandBox"]. Ausführliche Informationen zum Parameter finden Sie im Abschnitt zum Definieren von Befehlen: context

"composeExtensions": [
  {
    "botId": "57a3c29f-1fc5-4d97-a142-35bb662b7b23",
    "canUpdateConfiguration": true,
    "commands": [
      {
        "id": "reassignTodo",
        "description": "Reassign a todo item",
        "title": "Create To Do",
        "type": "Action",
        "context": ["message"],
        "fetchTask": true
    }]
    ...

Unten sehen Sie ein Beispiel für das value Objekt, das die Nachrichtendetails enthält, die als Teil der composeExtension Anforderung gesendet werden, die an Ihren Bot gesendet werden.

{
  "name": "composeExtension/submitAction",
  "type": "invoke",
...
  "value": {
    "commandId": "setReminder",
    "commandContext": "message",
    "messagePayload": {
      "id": "1111111111",
      "replyToId": null,
      "createdDateTime": "2019-02-25T21:29:36.065Z",
      "lastModifiedDateTime": null,
      "deleted": false,
      "subject": "Message subject",
      "summary": null,
      "importance": "normal",
      "locale": "en-us",
      "body": {
        "contentType": "html",
        "content": "this is the message"
    },
      "from": {
        "device": null,
        "conversation": null,
        "user": {
          "userIdentityType": "aadUser",
          "id": "wxyz12ab8-ab12-cd34-ef56-098abc123876",
          "displayName": "Jamie Smythe"
        },
        "application": null
      },
      "reactions": [
        {
          "reactionType": "like",
          "createdDateTime": "2019-02-25T22:40:40.806Z",
          "user": {
            "device": null,
            "conversation": null,
            "user": {
              "userIdentityType": "aadUser",
              "id": "qrst12346-ab12-cd34-ef56-098abc123876",
              "displayName": "Jim Brown"
            },
            "application": null
          }
        }
      ],
      "mentions": [
        {
          "id": 0,
          "mentionText": "Sarah",
          "mentioned": {
            "device": null,
            "conversation": null,
            "user": {
              "userIdentityType": "aadUser",
              "id": "ab12345678-ab12-cd34-ef56-098abc123876",
              "displayName": "Sarah"
            },
            "application": null
          }
        }
      ]
    }
  ...

Testen per Upload

Sie können Ihre Messaging-Erweiterung testen, indem Sie Ihre App hochladen. Weitere Informationen finden Sie unter Hochladen Ihrer App in einem Team.

Um Ihre Messaging-Erweiterung zu öffnen, navigieren Sie zu einem Ihrer Chats oder Kanäle. Wählen Sie im Feld "Verfassen" die Schaltfläche "Weitere Optionen" (⋯) aus, und wählen Sie Ihre Messaging-Erweiterung aus.

Sammeln von Eingaben von Benutzern

Es gibt drei Möglichkeiten, Informationen von einem Endbenutzer in Teams zu sammeln.

Liste statischer Parameter

Bei dieser Methode müssen Sie lediglich eine statische Liste von Parametern im Manifest definieren, wie oben im Befehl "Erstellen To Do" dargestellt. Um diese Methode zu verwenden, stellen Sie sicher, dass sie fetchTask festgelegt ist und Dass Sie Die Parameter im Manifest false definieren.

Wenn ein Benutzer einen Befehl mit statischen Parametern auswählt, generiert Teams ein Formular in einem Aufgabenmodul mit den definierten Parametern im Manifest. Wenn Sie auf "Absenden" klicken, wird eine composeExtension/submitAction an den Bot gesendet. Weitere Informationen zu dem erwarteten Satz von Antworten finden Sie unter Antworten zur Übermittlung.

Dynamische Eingabe mithilfe einer adaptiven Karte

Bei dieser Methode kann Ihr Dienst eine benutzerdefinierte adaptive Karte definieren, um die Benutzereingaben zu erfassen. Legen Sie für diesen Ansatz den fetchTask Parameter true im Manifest fest. Wenn Sie festlegen, fetchTask true werden statische Parameter, die für den Befehl definiert sind, ignoriert.

Bei dieser Methode empfängt Ihr Dienst ein composeExtension/fetchTask Ereignis und antwortet mit einer Antwort des adaptiven kartenbasierten Aufgabenmoduls. Es folgt eine Beispielantwort mit einer adaptiven Karte:

{
    "task": {
        "type": "continue",
        "value": {
            "card": {
                "contentType": "application/vnd.microsoft.card.adaptive",
                "content": {
                    "body": [
                        {
                            "type": "TextBlock",
                            "text": "Please enter the following information:"
                        },
                        {
                            "type": "TextBlock",
                            "text": "Name"
                        },
                        {
                            "type": "Input.Text",
                            "spacing": "None",
                            "title": "New Input.Toggle",
                            "placeholder": "Placeholder text"
                        },
                        {
                            "type": "TextBlock",
                            "text": "Date of birth"
                        },
                        {
                            "type": "Input.Date",
                            "spacing": "None",
                            "title": "New Input.Toggle"
                        }
                    ],
                    "type": "AdaptiveCard",
                    "$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
                    "version": "1.0"
                }
            }
        }
    }
}

Der Bot kann auch mit einer Authentifizierungs-/Konfigurationsantwort antworten, wenn der Benutzer die Erweiterung authentifizieren oder konfigurieren muss, bevor er die Benutzereingabe erhält.

Dynamische Eingabe mithilfe einer Webansicht

Bei dieser Methode kann Ihr Dienst ein basiertes Widget anzeigen, <iframe> um eine benutzerdefinierte Benutzeroberfläche anzuzeigen und Benutzereingaben zu sammeln. Legen Sie für diesen Ansatz den fetchTask Parameter true im Manifest fest.

Genau wie im adaptiven Kartenfluss sendet Ihr Dienst ein fetchTask Ereignis und antwortet mit einer URL-basierten Aufgabenmodulantwort. Es folgt eine Beispielantwort mit einer adaptiven Karte:

{
    "task": {
        "value": {
            "url": "http://mywebapp.com/input"
        },
        "type": "continue"
    }
}

Anfordern der Installation Ihres Unterhaltungs-Bots

Wenn Ihre App einen Unterhaltungsbot enthält, stellen Sie sicher, dass er in der Unterhaltung installiert ist, bevor Sie das Aufgabenmodul laden. Dies kann in Situationen hilfreich sein, in denen Sie zusätzlichen Kontext für Ihr Aufgabenmodul abrufen müssen. Beispielsweise müssen Sie möglicherweise die Liste abrufen, um ein Personenauswahl-Steuerelement oder die Liste der Kanäle in einem Team aufzufüllen.

Um diesen Fluss zu vereinfachen, wenn Ihre Messaging-Erweiterung zum ersten Mal die composeExtension/fetchTask Aufrufüberprüfung empfängt, um festzustellen, ob Ihr Bot im aktuellen Kontext installiert ist. Sie können dies erreichen, indem Sie versuchen, einen Listenanruf zu erhalten. Wenn Ihr Bot beispielsweise nicht installiert ist, geben Sie eine adaptive Karte mit einer Aktion zurück, die den Benutzer zur Installation des Bots anfordert. Der Benutzer muss über die Berechtigung zum Installieren von Apps an diesem Speicherort verfügen. Wenn sie nicht installiert werden können, wird die Nachricht aufgefordert, sich an den Administrator zu wenden.

Hier ist ein Beispiel für die Antwort:

{
  "type": "AdaptiveCard",
  "body": [
    {
      "type": "TextBlock",
      "text": "Looks like you haven't used Disco in this team/chat"
    }
  ],
  "actions": [
    {
      "type": "Action.Submit",
      "title": "Continue",
      "data": {
        "msteams": {
          "justInTimeInstall": true
        }
      }
    }
  ],
  "version": "1.0"
}

Sobald der Benutzer die Installation abgeschlossen hat, erhält Ihr Bot eine weitere Aufrufnachricht mit name = composeExtension/submitAction , und value.data.msteams.justInTimeInstall = true .

Hier ist ein Beispiel für den Aufruf:

{
  "value": {
    "commandId": "giveKudos",
    "commandContext": "compose",
    "context": {
      "theme": "default"
    },
    "data": {
      "msteams": {
        "justInTimeInstall": true
      }
    }
  },
  "conversation": {
    "id": "19:7705841b240044b297123ad7f9c99217@thread.skype"
  },
  "name": "composeExtension/submitAction",
  "imdisplayname": "Bob Smith"
}

Antworten Sie auf den Aufruf mit der gleichen Aufgabenantwort, mit der Sie geantwortet hätten, wenn der Bot bereits installiert wäre.

Antworten auf Übermittlung

Sobald ein Benutzer die Eingabe abgeschlossen hat, empfängt der Bot ein composeExtension/submitAction Ereignis mit der Befehls-ID und den festgelegten Parameterwerten.

Dies sind die unterschiedlichen erwarteten Antworten auf ein submitAction .

Antwort des Aufgabenmoduls

Dies wird verwendet, wenn Ihre Erweiterung Dialogfelder miteinander verketten muss, um weitere Informationen zu erhalten. Die Antwort ist genau die gleiche wie fetchTask zuvor erwähnt.

Verfassen-Erweiterungs-Authentifizierungs-/Konfigurationsantwort

Dies wird verwendet, wenn ihre Erweiterung entweder authentifiziert oder konfiguriert werden muss, um fortzufahren. Weitere Informationen finden Sie im Abschnitt "Authentifizierung" im Suchabschnitt.

Ergebnisantwort der Erstellerweiterung

Dies wird verwendet, um eine Karte als Ergebnis des Befehls in das Feld zum Verfassen einzufügen. Es ist die gleiche Antwort, die im Suchbefehl verwendet wird, aber sie ist auf eine Karte oder ein Ergebnis im Array beschränkt.

{
  "composeExtension": {
    "type": "result",
    "attachmentLayout": "list",
    "preview": {
          "contentType": "application/vnd.microsoft.card.thumbnail",
          "content": {
            "title": "85069: Create a cool app",
            "images": [
              {
                "url": "https://placekitten.com/200/200"
              }
            ]
          }
        },
    "attachments": [
      {  
        "contentType": "application/vnd.microsoft.teams.card.o365connector",
        "content": {
          "sections": [
            {
              "activityTitle": "[85069]: Create a cool app",
              "activityImage&quot;: &quot;https://placekitten.com/200/200"
            },
            {
              "title": "Details",
              "facts": [
                {
                  "name": "Assigned to:",
                  "value&quot;: &quot;[Larry Brown](mailto:larryb@example.com)"
                },
                {
                  "name": "State:",
                  "value": "Active"
                }
              ]
            }
          ]
        }
      }
    ]
  }
}

Antworten mit einer von einem Bot gesendeten adaptiven Kartennachricht

Reagieren Sie auf die Sendeaktion, indem Sie eine Nachricht mit einer adaptiven Karte mit einem Bot in den Kanal einfügen. Ihr Benutzer kann eine Vorschau der Nachricht anzeigen, bevor er sie übermittelt, und möglicherweise auch bearbeiten/mit ihr interagieren. Dies kann in Szenarien nützlich sein, in denen Sie Informationen von Ihren Benutzern sammeln müssen, bevor Sie eine adaptive Kartenantwort erstellen. Das folgende Szenario zeigt, wie Sie diesen Fluss verwenden können, um eine Abfrage zu konfigurieren, ohne die Konfigurationsschritte in die Kanalnachricht einzuschließen.

  1. Der Benutzer wählt die Messaging-Erweiterung aus, um das Aufgabenmodul auszulösen.
  2. Der Benutzer verwendet das Aufgabenmodul, um die Abfrage zu konfigurieren.
  3. Nach dem Übermitteln des Konfigurationsaufgabenmoduls verwendet die App die im Aufgabenmodul bereitgestellten Informationen, um eine adaptive Karte zu erstellen, und sendet sie als botMessagePreview Antwort an den Client.
  4. Der Benutzer kann dann eine Vorschau der adaptiven Kartennachricht anzeigen, bevor der Bot sie in den Kanal einfügt. Wenn der Bot noch kein Mitglied des Kanals ist, wird durch Klicken auf Send den Bot der Bot hinzugefügt.
  5. Durch die Interaktion mit der adaptiven Karte wird die Nachricht vor dem Senden geändert.
  6. Sobald der Benutzer den Bot auswählt, Send wird die Nachricht an den Kanal gesendet.

Um diesen Fluss zu aktivieren, sollte Ihr Aufgabenmodul wie im folgenden Beispiel antworten, in dem dem Benutzer die Vorschaunachricht angezeigt wird.

Hinweis

Die activityPreview muss eine Aktivität mit genau message 1 adaptiver Kartenanlage enthalten.

{
  "composeExtension": {
    "type": "botMessagePreview",
    "activityPreview": {
      "type": "message",
      "attachments":  [
        {
          "contentType": "application/vnd.microsoft.card.adaptive",
          "content": << Card Payload >>
        }
      ]
    }
  }
}

Ihre Nachrichtenerweiterung muss jetzt auf zwei neue Arten von Interaktionen reagieren, value.botMessagePreviewAction = "send" und value.botMessagePreviewAction = "edit" . Unten sehen Sie ein Beispiel für das value Objekt, das Sie verarbeiten müssen:

{
  "name": "composeExtension/submitAction",
  "type": "invoke",
  "conversation": { "id": "19:c366b75791784100b6e8b515fd55b063@thread.skype" },
  "imdisplayname": "Pranav Smith",
  ...
  "value": {
    "botMessagePreviewAction": "send" | "edit",
    "botActivityPreview": [
      {
        "type": "message/card",
        "attachments": [
          {
            "content":
              {
                "type": "AdaptiveCard",
                "body": [{<<card payload>>}]
              },
            "contentType" : "application/vnd.microsoft.card.adaptive"
          }
        ],
        "context": { "theme": "default" }
      }
    ],
  }
}

Wenn Sie auf die edit Anforderung antworten, sollten Sie mit einer Antwort mit den Werten antworten, task die mit den Informationen gefüllt sind, die der Benutzer bereits übermittelt hat. Wenn Sie auf die send Anforderung antworten, sollten Sie eine Nachricht an den Kanal senden, der die fertige adaptive Karte enthält.

teamChatConnector.onComposeExtensionSubmitAction((
    event: builder.IEvent,
    request: teamBuilder.IComposeExtensionActionCommandRequest,
    callback: (err: Error, result: any, statusCode: number) => void) => {
        let invokeValue = (<any> event).value;

        if (invokeValue.botMessagePreviewAction ) {
            let attachment = invokeValue.botActivityPreview[0].attachments[0];

            if (invokeValue.botMessagePreviewAction === 'send') {
                let msg = new builder.Message()
                    .address(event.address)
                    .addAttachment(attachment);
                teamChatConnector.send([msg.toMessage()],
                    (error) => {
                        if(error){
                            //TODO: Handle error and callback
                        }
                        else {
                            callback(null, null, 200);
                        }
                    }
                );
            }

            else if (invokeValue.botMessagePreviewAction === 'edit') {
              // Create the card and populate with user-inputted information
              let card = { ... }

              let taskResponse = {
                task: {
                  type: "continue",
                  value: {
                    title: "Card Preview",
                    card: {
                      contentType: 'application/vnd.microsoft.card.adaptive',
                      content: card
                    }
                  }
                }
              }
              callback(null, taskResponse, 200);
            }

        else {
            let attachment = {
                  //create adaptive card
                };
            let activity = new builder.Message().addAttachment(attachment).toMessage();
            let response = teamBuilder.ComposeExtensionResponse.messagePreview()
                .preview(activity)
                .toResponse();
            callback(null, response, 200);
        }
    });