Initiieren von Aktionen mithilfe von Nachrichtenerweiterungen

Aktionsbasierte Nachrichtenerweiterungen ermöglichen es Ihren Benutzern, Aktionen in externen Diensten auszulösen, während sie sich in Teams befinden.

Hinzufügen einer Nachrichtenerweiterung zu Ihrer App

Eine Nachrichtenerweiterung ist ein in der Cloud gehosteter Dienst, der auf Benutzeranforderungen hört und strukturierte Daten, z. B. eine Karte, bereitstellt. Sie integrieren Ihren Dienst über Bot Framework-Objekte Activity in Microsoft Teams. Unsere .NET- und Node.js-Erweiterungen für das Bot Builder-SDK können Ihnen helfen, Ihrer App Nachrichtenerweiterungsfunktionen hinzuzufügen.

Im Bot-Framework registrieren

Sie müssen zuerst einen Bot beim Microsoft Bot Framework registrieren. Die Microsoft-App-ID und die Rückrufendpunkte für Ihren Bot, wie dort definiert, werden in Ihrer Nachrichtenerweiterung verwendet, um Benutzeranforderungen zu empfangen und darauf zu reagieren. Denken Sie daran, den Microsoft Teams-Kanal für Ihren Bot zu aktivieren.

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

Aktualisieren Ihres App-Manifests

Wie bei Bots und Registerkarten aktualisieren Sie das Manifest Ihrer App, um die Nachrichtenerweiterungseigenschaften einzuschließen. Über diese Eigenschaften bestimmen Sie, wie Ihre Nachrichtenerweiterung im Microsoft Teams-Client angezeigt wird und sich verhält. Nachrichtenerweiterungen werden ab Manifest v1.0 unterstützt.

Deklarieren Ihrer Nachrichtenerweiterung

Um eine Nachrichtenerweiterung hinzuzufügen, fügen Sie eine neue JSON-Struktur der obersten Ebene mit der composeExtensions Eigenschaft in Ihr Manifest ein. Sie können nur eine einzelne Nachrichtenerweiterung für Ihre App erstellen.

Die Erweiterungsdefinition ist ein Objekt mit folgender Struktur:

Definieren von Befehlen

Ihre Nachrichtenerweiterung sollte einen Befehl deklarieren, der angezeigt wird, wenn der Benutzer Ihre App über die Schaltfläche "Weitere Optionen " (⋯) im Verfassungsfeld auswählt.

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

Nachrichtenerweiterungen für Aktionstypen

Um Aktionen aus einer Nachrichtenerweiterung zu initiieren, legen Sie den type Parameter auf actionfest. Eine einzelne Nachrichtenerweiterung kann bis zu 10 verschiedene Befehle enthalten und mehrere such- und aktionsbasierte Befehle enthalten.

Vollständiges App-Manifestbeispiel

Der folgende Code ist ein Beispiel für ein Manifest mit einem Such- und einem create-Befehl:

{
  "$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",
  "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

Sie können Aktionen aus dem Bereich zum Verfassen von Nachrichten und auch aus einer Nachricht heraus initiieren, indem Sie Ihre Nachrichtenerweiterung verwenden, mit der Sie den Nachrichteninhalt zur Verarbeitung an Ihren Bot senden können. Sie können optional auf diese Nachricht mit der unter Antworten zum Senden beschriebenen Methode antworten. Die Antwort wird als Antwort auf die Nachricht eingefügt, die Benutzer vor dem Absenden bearbeiten können.

Benutzer können auf die Nachrichtenerweiterung über die Option "Aktion ergreifen " des Überlaufmenüs ... zugreifen, wie in der folgenden Abbildung dargestellt:

Damit Ihre Nachrichtenerweiterung aus einer Nachricht heraus funktioniert, fügen Sie den context Parameter wie im folgenden Beispiel zum Objekt Ihrer commands Nachrichtenerweiterung in Ihrem App-Manifest hinzu. Gültige Zeichenfolgen für das context Array sind "message", "commandBox", und "compose". Der Standardwert ist ["compose", "commandBox"]. Vollständige Details zum context Parameter finden Sie im Abschnitt zum Definieren von Befehlen:

"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
    }]
    ...

Der folgende Code ist ein Beispiel für das value Objekt mit den Nachrichtendetails, die als Teil der composeExtensions Anforderung 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 durch Hochladen

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

Um Ihre Nachrichtenerweiterung zu öffnen, wechseln Sie zu einem Ihrer Chats oder Kanäle. Wählen Sie im Feld "Verfassen" die Schaltfläche "Weitere Optionen " (⋯) und dann Ihre Nachrichtenerweiterung aus.

Sammeln von Benutzereingaben

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

Liste statischer Parameter

Bei dieser Methode müssen Sie lediglich eine statische Liste von Parametern im Manifest definieren, wie im Befehl "Create To Do" gezeigt. Um diese Methode zu verwenden, stellen Sie sicher fetchTask , dass Sie auf festgelegt sind false und dass Sie Ihre Parameter im Manifest 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 Senden klicken, wird a composeExtensions/submitAction an den Bot gesendet. Weitere Informationen zu den erwarteten Antworten finden Sie unter Antworten zum Senden.

Dynamische Eingabe mittels einer adaptiven Karte

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

Bei dieser Methode empfängt Ihr Dienst ein composeExtensions/fetchTask Ereignis und antwortet mit einer Antwort auf Basis einer adaptiven Karte basierend auf dem Aufgabenmodul. Im Folgenden finden Sie 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 über eine Webansicht

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

Genau wie beim adaptiven Kartenfluss sendet Ihr Dienst ein fetchTask Ereignis und antwortet mit einer URL-basierten Aufgabenmodulantwort. Im Folgenden finden Sie eine Beispielantwort mit einer adaptiven Karte:

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

Anfordern der Installation Ihres Unterhaltungsbots

Wenn Ihre App einen Unterhaltungsbot enthält, stellen Sie sicher, dass er in der Unterhaltung installiert ist, bevor Sie Ihr Aufgabenmodul laden, um mehr Kontext für Ihr Aufgabenmodul zu erhalten. Möglicherweise müssen Sie die Liste abrufen, um ein Steuerelement für die Personenauswahl oder die Liste der Kanäle in einem Team aufzufüllen.

Um diesen Fluss zu vereinfachen, überprüfen Sie, wenn Ihre Nachrichtenerweiterung den composeExtensions/fetchTask Aufruf zum ersten Mal empfängt, ob Ihr Bot im aktuellen Kontext installiert ist. Du kannst dies erhalten, indem du den Aufruf "Liste abrufen" versuchst. Wenn Ihr Bot beispielsweise nicht installiert ist, geben Sie eine adaptive Karte mit einer Aktion zurück, die den Benutzer auffordert, Ihren Bot zu installieren. Der Benutzer muss über die Berechtigung verfügen, Apps an diesem Speicherort zu installieren. Wenn sie keine Installation durchführen können, werden Sie in der 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 der Bot eine weitere Aufrufnachricht mit name = composeExtensions/submitAction und value.data.msteams.justInTimeInstall = true.

Hier ist ein Beispiel für den Invoke:

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

Reagieren Sie auf den Aufruf mit derselben Aufgabenantwort, mit der Sie geantwortet haben, wenn der Bot installiert wurde.

Antworten, um zu übermitteln

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

These are the different expected responses to a submitAction.

Antwort des Aufgabenmoduls

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

Compose extensions auth/config response

Erweiterungen Compose auth/config wird verwendet, wenn Ihre Erweiterung entweder authentifiziert oder konfiguriert werden muss, um fortzufahren. Weitere Informationen finden Sie im Abschnitt "Authentifizierung " im Abschnitt "Suche".

Ergebnisantwort Compose Erweiterungen

Compose Ergebnisantwort "Erweiterungen" wird verwendet, um als Ergebnis des Befehls eine Karte in das Feld "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": "https://placekitten.com/200/200"
            },
            {
              "title": "Details",
              "facts": [
                {
                  "name": "Assigned to:",
                  "value": "[Larry Brown](mailto:larryb@example.com)"
                },
                {
                  "name": "State:",
                  "value": "Active"
                }
              ]
            }
          ]
        }
      }
    ]
  }
}

Reagieren Sie mit einer adaptiven Kartennachricht, die von einem Bot gesendet wurde

Reagieren Sie auf die Übermittlungsaktion, indem Sie eine Nachricht mit einer adaptiven Karte in den Kanal mit einem Bot einfügen. Ihr Benutzer kann eine Vorschau der Nachricht anzeigen, bevor er sie absendet, und sie 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 Card-Antwort erstellen. Das folgende Szenario zeigt, wie Sie diesen Flow verwenden können, um eine Abfrage zu konfigurieren, ohne die Konfigurationsschritte in die Kanalnachricht einzuschließen.

1. Der Benutzer wählt die Nachrichtenerweiterung aus, um das Aufgabenmodul auszulösen.
2. Der Benutzer verwendet das Aufgabenmodul, um die Umfrage zu konfigurieren.
3. Nachdem Sie das Konfigurationsaufgabenmodul übermittelt haben, 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 der Bot durch Klicken Send hinzugefügt.
5. Wenn Sie mit der adaptiven Karte interagieren, wird die Nachricht vor dem Senden geändert.
6. Sobald der Benutzer auswählt, postet Sendder Bot die Nachricht im Kanal.

Um diesen Flow zu aktivieren, sollte Ihr Aufgabenmodul wie im folgenden Beispiel reagieren, in dem die Vorschaunachricht für den Benutzer angezeigt wird:

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

Ihre Nachrichtenerweiterung muss auf zwei neue Arten von Interaktionen reagieren: value.botMessagePreviewAction = "send" und value.botMessagePreviewAction = "edit". Der folgende Code ist ein Beispiel für das Objekt, das value 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, müssen Sie mit einer task Antwort antworten, deren Werte mit den vom Benutzer übermittelten Informationen aufgefüllt sind. 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);
        }
    });

public class MessagesController : ApiController
{

    [BotAuthentication]
    public async Task<HttpResponseMessage> Post([FromBody]Activity activity)
    {
        MicrosoftAppCredentials.TrustServiceUrl(activity.ServiceUrl, DateTime.MaxValue);
        ConnectorClient connectorClient = new ConnectorClient(
            new Uri(activity.ServiceUrl),
            ConfigurationManager.AppSettings[MicrosoftAppCredentials.MicrosoftAppIdKey],
            ConfigurationManager.AppSettings[MicrosoftAppCredentials.MicrosoftAppPasswordKey]);

        if (activity.Type == ActivityTypes.Invoke)
        {
            // Initial task module presented to the user.
            if (activity.Name == "composeExtension/fetchTask")
            {
                string task = GetTaskModule();

                return Request.CreateResponse(HttpStatusCode.OK, JObject.Parse(task));
            }
            else if (activity.Name == "composeExtension/submitAction")
            {
                dynamic activityValue = JObject.FromObject(activity.Value);
                string botMessagePreviewAction = activityValue["botMessagePreviewAction"];

                // This is the initial card response sent after the task module is submitted.
                if (botMessagePreviewAction is null)
                {
                    string text = activityValue.data.cardMessage;

                    AdaptiveCard card = new AdaptiveCard(new AdaptiveSchemaVersion("1.0"));
                    card.Body.Add(new AdaptiveTextBlock()
                    {
                        Text = "This card will be inserted into the conversation by the bot.",
                        Size = AdaptiveTextSize.Large,
                        Wrap = true
                    });
                    card.Body.Add(new AdaptiveTextBlock()
                    {
                        Text = "The text below is what you provided."
                    });
                    card.Body.Add(new AdaptiveTextBlock()
                    {
                        Text = text,
                    });

                    string cardJson = card.ToJson();

                    string cardMessage = $@"{{
                        'composeExtension': {{
                        'type': 'botMessagePreview',
                        'activityPreview': {{
                            'type': 'message',
                            'attachments': [{{
                                'contentType': 'application/vnd.microsoft.card.adaptive',
                                'content': {cardJson}
                            }}]
                        }}
                        }}
                    }}";

                    JObject res = JObject.Parse(cardMessage);
                    return Request.CreateResponse(HttpStatusCode.OK, res);

                }
                else
                {
                    // This is the "send the card to the channel" event.
                    if (botMessagePreviewAction.Equals("send"))
                    {
                        string cardJson = JsonConvert.SerializeObject(activityValue.botActivityPreview[0].attachments[0].content);

                        AdaptiveCardParseResult cardResult = AdaptiveCard.FromJson(cardJson);
                        AdaptiveCard card = cardResult.Card;
                        Attachment cardAttachment = new Attachment
                        {
                            ContentType = AdaptiveCard.ContentType,
                            Content = card
                        };


                        Activity response = activity.CreateReply();
                        response.Attachments.Add(cardAttachment);

                        var result = await connectorClient.Conversations.SendToConversationAsync(response);
                    }
                    // This is fired if the user edits the card before sending it.
                    else if (botMessagePreviewAction.Equals("edit"))
                    {
                        string task = GetTaskModule();

                        return Request.CreateResponse(HttpStatusCode.OK, JObject.Parse(task));
                    }
                    else
                    {
                        return Request.CreateResponse(HttpStatusCode.NotImplemented);
                    }
                }
            }
        }

        return Request.CreateResponse(HttpStatusCode.NotImplemented);

    }

    private static string GetTaskModule()
    {
        AdaptiveCard card = new AdaptiveCard(new AdaptiveSchemaVersion("1.0"));
        card.Body.Add(new AdaptiveTextBlock()
        {
            Text = "Please enter the following information:",
            Size = AdaptiveTextSize.Large
        });
        card.Body.Add(new AdaptiveTextBlock()
        {
            Text = "Card Message:"
        });
        card.Body.Add(new AdaptiveTextInput()
        {
            Id = "cardMessage",
            Spacing = AdaptiveSpacing.None,
            Placeholder = "Card message goes here."
        });
        card.Actions.Add(new AdaptiveSubmitAction()
        {
            Title = "Submit"
        });

        string cardJson = card.ToJson();

        // Create the task module response.
        string task = $@"{{
                            'task': {{
                                'type': 'continue',
                                'value': {{
                                    'card': {{
                                        'contentType': 'application/vnd.microsoft.card.adaptive',
                                        'content': {cardJson}
                                        }}
                                    }}
                                }}
                            }}";
        return task;
    }

}

Siehe auch

Bot Framework Beispiele