Initial iFrame based Teams Task Module sample

Author: tracyboehrer

libraries/bot-builder/src/main/java/com/microsoft/bot/builder/MessageFactory.java

@@ -201,6 +201,16 @@ public static Activity attachment(Attachment attachment) {
         return attachment(attachment, null, null, null);
     }
 
+    /**
+     * Returns a message activity that contains an attachment.
+     *
+     * @param attachments Attachments to include in the message.
+     * @return A message activity containing the attachment.
+     */
+    public static Activity attachment(List<Attachment> attachments) {
+        return attachment(attachments, null, null, null);
+    }
+
     /**
      * Returns a message activity that contains an attachment.
      *

libraries/bot-integration-core/src/main/java/com/microsoft/bot/integration/Async.java

@@ -0,0 +1,53 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+package com.microsoft.bot.integration;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+
+/**
+ * Asyc and CompletableFuture helpers methods.
+ */
+public final class Async {
+    private Async() {
+
+    }
+
+    /**
+     * Executes a block and throws a completion exception if needed.
+     *
+     * @param supplier The block to execute.
+     * @param <T> The type of the return value.
+     * @return The return value.
+     */
+    public static <T> T tryThrow(ThrowSupplier<T> supplier) {
+        try {
+            return supplier.get();
+        } catch (CompletionException ce) {
+            throw ce;
+        } catch (Throwable t) {
+            throw new CompletionException(t);
+        }
+    }
+
+    /**
+     * Executes a block and returns a CompletableFuture with either the return
+     * value or the exception (completeExceptionally).
+     *
+     * @param supplier The block to execute.
+     * @param <T> The type of the CompletableFuture value.
+     * @return The CompletableFuture
+     */
+    public static <T> CompletableFuture<T> tryCompletion(ThrowSupplier<T> supplier) {
+        CompletableFuture<T> result = new CompletableFuture<>();
+
+        try {
+            result.complete(supplier.get());
+        } catch (Throwable t) {
+            result.completeExceptionally(t);
+        }
+
+        return result;
+    }
+}

libraries/bot-integration-core/src/main/java/com/microsoft/bot/integration/ThrowSupplier.java

@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+package com.microsoft.bot.integration;
+
+/**
+ * A Supplier that throws.
+ * @param <T> The type of the Supplier return value.
+ */
+@FunctionalInterface
+public interface ThrowSupplier<T> {
+    /**
+     * Gets a result.
+     *
+     * @return a result
+     * @throws Throwable Any exception
+     */
+    T get() throws Throwable;
+}

libraries/bot-schema/src/main/java/com/microsoft/bot/schema/Serialization.java

@@ -111,7 +111,7 @@ public static String toString(Object source) throws JsonProcessingException {
      * Parses a JSON document.
      *
      * @param json The JSON to parse.
-     * @return A JsonNode containg the node tree.
+     * @return A JsonNode containing the node tree.
      * @throws IOException Error parsing json.
      */
     public static JsonNode jsonToTree(String json) throws IOException {

samples/54.teams-task-module/README.md

@@ -33,8 +33,10 @@ the Teams service needs to call into the bot.
 
 1) Update the `resources/application.properties` configuration for the bot to use the Microsoft App Id and App Password from the Bot Framework registration. (Note the App Password is referred to as the "client secret" in the azure portal and you can always create a new client secret anytime.)
 
+1) Update `CustomForm.html` to replace your Microsoft App Id *everywhere* you see the place holder string `<<YOUR-MICROSOFT-APP-ID>>`
+
 1) __*This step is specific to Teams.*__
-    - **Edit** the `manifest.json` contained in the  `teamsAppManifest` folder to replace your Microsoft App Id (that was created when you registered your bot earlier) *everywhere* you see the place holder string `<<YOUR-MICROSOFT-APP-ID>>` (depending on the scenario the Microsoft App Id may occur multiple times in the `manifest.json`)
+    - **Edit** the `manifest.json` contained in the `teamsAppManifest` folder to replace your Microsoft App Id (that was created when you registered your bot earlier) *everywhere* you see the place holder string `<<YOUR-MICROSOFT-APP-ID>>` (depending on the scenario the Microsoft App Id may occur multiple times in the `manifest.json`). **Note:** the Task Modules containing pages will require the deployed bot's domain in validDomains of the manifest.
     - **Zip** up the contents of the `teamsAppManifest` folder to create a `manifest.zip`
     - **Upload** the `manifest.zip` to Teams (in the Apps view click "Upload a custom app")
 

samples/54.teams-task-module/pom.xml

@@ -77,7 +77,7 @@
       <dependency>
         <groupId>com.microsoft.bot</groupId>
         <artifactId>bot-integration-spring</artifactId>
-        <version>4.0.0-SNAPSHOT</version>
+        <version>4.6.0-preview4</version>
         <scope>compile</scope>
       </dependency>
       <dependency>

samples/54.teams-task-module/src/main/java/com/microsoft/bot/sample/teamstaskmodule/TeamsTaskModuleBot.java

@@ -3,19 +3,31 @@
 
 package com.microsoft.bot.sample.teamstaskmodule;
 
-import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.microsoft.bot.builder.MessageFactory;
 import com.microsoft.bot.builder.TurnContext;
 import com.microsoft.bot.builder.teams.TeamsActivityHandler;
-import com.microsoft.bot.schema.Activity;
+import com.microsoft.bot.integration.Async;
+import com.microsoft.bot.integration.Configuration;
+import com.microsoft.bot.sample.teamstaskmodule.models.AdaptiveCardTaskFetchValue;
+import com.microsoft.bot.sample.teamstaskmodule.models.CardTaskFetchValue;
+import com.microsoft.bot.sample.teamstaskmodule.models.TaskModuleIds;
+import com.microsoft.bot.sample.teamstaskmodule.models.TaskModuleResponseFactory;
+import com.microsoft.bot.sample.teamstaskmodule.models.TaskModuleUIConstants;
+import com.microsoft.bot.sample.teamstaskmodule.models.UISettings;
 import com.microsoft.bot.schema.Attachment;
+import com.microsoft.bot.schema.CardAction;
 import com.microsoft.bot.schema.HeroCard;
+import com.microsoft.bot.schema.Serialization;
 import com.microsoft.bot.schema.teams.*;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.concurrent.CompletionException;
+import java.util.stream.Collectors;
 import org.apache.commons.io.IOUtils;
-import org.json.JSONObject;
 import org.springframework.stereotype.Component;
 
 import java.io.InputStream;
@@ -34,23 +46,29 @@
  */
 @Component
 public class TeamsTaskModuleBot extends TeamsActivityHandler {
+    private final String baseUrl;
+    private final List<UISettings> actions = Arrays.asList(
+        TaskModuleUIConstants.ADAPTIVECARD,
+        TaskModuleUIConstants.CUSTOMFORM,
+        TaskModuleUIConstants.YOUTUBE
+    );
 
-    @Override
-    protected CompletableFuture<Void> onTeamsMembersAdded(
-        List<TeamsChannelAccount> membersAdded,
-        TeamInfo teamInfo,
-        TurnContext turnContext
-    ) {
-        return turnContext.sendActivity(MessageFactory.attachment(getTaskModuleHeroCard()))
-            .thenApply(resourceResponse -> null);
+    public TeamsTaskModuleBot(Configuration configuration) {
+        baseUrl = configuration.getProperty("BaseUrl");
     }
 
     @Override
     protected CompletableFuture<Void> onMessageActivity(
         TurnContext turnContext
     ) {
-        Attachment attachment = getTaskModuleHeroCard();
-        return turnContext.sendActivity(MessageFactory.attachment(attachment))
+        // This displays two cards: A HeroCard and an AdaptiveCard.  Both have the same
+        // options.  When any of the options are selected, `onTeamsTaskModuleFetch`
+        // is called.
+        return turnContext.sendActivity(MessageFactory.attachment(Arrays.asList(
+                getTaskModuleHeroCardOptions(),
+                getTaskModuleAdaptiveCardOptions()
+            ))
+        )
             .thenApply(resourceResponse -> null);
     }
 
@@ -59,92 +77,127 @@ protected CompletableFuture<TaskModuleResponse> onTeamsTaskModuleFetch(
         TurnContext turnContext,
         TaskModuleRequest taskModuleRequest
     ) {
-        Activity reply;
-        try {
-            reply = MessageFactory.text(
-                "onTeamsTaskModuleFetch TaskModuleRequest: " +
-                    new ObjectMapper().writeValueAsString(taskModuleRequest));
-        } catch (JsonProcessingException e) {
-            CompletableFuture<TaskModuleResponse> result = new CompletableFuture<>();
-            result.completeExceptionally(new CompletionException(e));
-            return result;
-        }
+        // Called when the user selects an options from the displayed HeroCard or
+        // AdaptiveCard.  The result is the action to perform.
+        return Async.tryCompletion(() -> {
+            CardTaskFetchValue<String> value = Serialization
+                .safeGetAs(taskModuleRequest.getData(), CardTaskFetchValue.class);
+
+            TaskModuleTaskInfo taskInfo = new TaskModuleTaskInfo();
+            switch (value.getData()) {
+                // Display the YouTube.html page
+                case TaskModuleIds.YOUTUBE: {
+                    String url = baseUrl + "/" + TaskModuleIds.YOUTUBE;
+                    taskInfo.setUrl(url);
+                    taskInfo.setFallbackUrl(url);
+                    setTaskInfo(taskInfo, TaskModuleUIConstants.YOUTUBE);
+                    break;
+                }
+
+                // Display the CustomForm.html page, and post the form data back via
+                // onTeamsTaskModuleSubmit.
+                case TaskModuleIds.CUSTOMFORM: {
+                    String url = baseUrl + "/" + TaskModuleIds.CUSTOMFORM;
+                    taskInfo.setUrl(url);
+                    taskInfo.setFallbackUrl(url);
+                    setTaskInfo(taskInfo, TaskModuleUIConstants.CUSTOMFORM);
+                    break;
+                }
 
-        return turnContext.sendActivity(reply)
-            .thenApply(resourceResponse -> {
-                Attachment adaptiveCard = getTaskModuleAdaptiveCard();
-
-                return new TaskModuleResponse() {{
-                    setTask(new TaskModuleContinueResponse() {{
-                        setType("continue");
-                        setValue(new TaskModuleTaskInfo() {{
-                            setCard(adaptiveCard);
-                            setHeight(200);
-                            setWidth(400);
-                            setTitle("Adaptive Card: Inputs");
-                        }});
-                    }});
-                }};
-            });
+                // Display an AdaptiveCard to prompt user for text, and post it back via
+                // onTeamsTaskModuleSubmit.
+                case TaskModuleIds.ADAPTIVECARD:
+                    taskInfo.setCard(createAdaptiveCardAttachment());
+                    setTaskInfo(taskInfo, TaskModuleUIConstants.ADAPTIVECARD);
+                    break;
+
+                default:
+                    break;
+            }
+
+            return taskInfo;
+        })
+            .thenApply(TaskModuleResponseFactory::toTaskModuleResponse);
     }
 
     @Override
     protected CompletableFuture<TaskModuleResponse> onTeamsTaskModuleSubmit(
         TurnContext turnContext,
         TaskModuleRequest taskModuleRequest
     ) {
-        Activity reply;
-        try {
-            reply = MessageFactory.text(
-                "onTeamsTaskModuleSubmit TaskModuleRequest: " +
-                    new ObjectMapper().writeValueAsString(taskModuleRequest));
-        } catch (JsonProcessingException e) {
-            CompletableFuture<TaskModuleResponse> result = new CompletableFuture<>();
-            result.completeExceptionally(new CompletionException(e));
-            return result;
-        }
-
-        turnContext.sendActivity(reply)
-            .thenApply(resourceResponse -> null);
+        // Called when data is being returned from the selected option (see `onTeamsTaskModuleFetch').
+        return Async.tryCompletion(() ->
+            // Echo the users input back.  In a production bot, this is where you'd add behavior in
+            // response to the input.
+            MessageFactory.text(
+                "onTeamsTaskModuleSubmit TaskModuleRequest: "
+                    + new ObjectMapper().writeValueAsString(taskModuleRequest)
+            )
+        )
+            .thenCompose(turnContext::sendActivity)
+            .thenApply(resourceResponse -> TaskModuleResponseFactory.createResponse("Thanks!"));
+    }
 
-        return CompletableFuture.completedFuture(new TaskModuleResponse() {{
-            setTask(new TaskModuleMessageResponse() {{
-                setType("message");
-                setValue("Thanks!");
-            }});
-        }});
+    private void setTaskInfo(TaskModuleTaskInfo taskInfo, UISettings uiSettings) {
+        taskInfo.setHeight(uiSettings.getHeight());
+        taskInfo.setWidth(uiSettings.getWidth());
+        taskInfo.setTitle(uiSettings.getTitle());
     }
 
-    private Attachment getTaskModuleHeroCard() {
+    private Attachment getTaskModuleHeroCardOptions() {
+        List<CardAction> buttons = actions.stream().map(cardType ->
+            new TaskModuleAction(cardType.getButtonTitle(),
+                new CardTaskFetchValue<String>() {{
+                    setData(cardType.getId());
+                }})
+        ).collect(Collectors.toCollection(ArrayList::new));
+
         HeroCard card = new HeroCard() {{
             setTitle("Task Module Invocation from Hero Card");
-            setSubtitle(
-                "This is a hero card with a Task Module Action button.  Click the button to show an Adaptive Card within a Task Module.");
-            setButtons(Arrays.asList(
-                new TaskModuleAction(
-                    "Adaptive Card",
-                    new JSONObject().put(
-                        "data",
-                        "adaptivecard"
-                    ).toString()
-                )
-            ));
+            setButtons(buttons);
         }};
         return card.toAttachment();
     }
 
-    private Attachment getTaskModuleAdaptiveCard() {
-        try {
-            InputStream inputStream = getClass().getClassLoader()
-                .getResourceAsStream("adaptivecard.json");
-            String result = IOUtils.toString(inputStream, StandardCharsets.UTF_8);
+    private Attachment getTaskModuleAdaptiveCardOptions() {
+        try (InputStream inputStream = getClass().getClassLoader()
+            .getResourceAsStream("adaptiveTemplate.json")
+        ) {
+            String cardTemplate = IOUtils.toString(inputStream, StandardCharsets.UTF_8);
+
+            List<Map<String,Object>> cardActions = actions.stream().map(cardType -> {
+                Map<String, Object> a = new HashMap<>();
+                a.put("type", "Action.Submit");
+                a.put("title", cardType.getButtonTitle());
+                a.put("data", new AdaptiveCardTaskFetchValue<String>() {{
+                    setData(cardType.getId());
+                }});
+                return a;
+            }).collect(Collectors.toCollection(ArrayList::new));
+
+            String adaptiveCardJson = String.format(cardTemplate, Serialization.toString(cardActions));
 
-            return new Attachment() {{
-                setContentType("application/vnd.microsoft.card.adaptive");
-                setContent(new ObjectMapper().readValue(result, ObjectNode.class));
-            }};
+            return adaptiveCardAttachmentFromJson(adaptiveCardJson);
         } catch (Throwable t) {
             throw new CompletionException(t);
         }
     }
+
+    private Attachment createAdaptiveCardAttachment() {
+        try (InputStream inputStream = getClass().getClassLoader()
+            .getResourceAsStream("adaptivecard.json")
+        ) {
+            String result = IOUtils.toString(inputStream, StandardCharsets.UTF_8);
+            return adaptiveCardAttachmentFromJson(result);
+        } catch (Throwable t) {
+            throw new CompletionException(t);
+        }
+    }
+
+    private Attachment adaptiveCardAttachmentFromJson(String json) throws IOException {
+        return new Attachment() {{
+            setContentType("application/vnd.microsoft.card.adaptive");
+            setContent(new ObjectMapper().readValue(json, ObjectNode.class));
+        }};
+    }
 }