Adaptive Card Templating With Azure Bot Framework SDKV4

Adaptive Cards are platform-agnostic snippets of UI, authored in JSON, that apps and services can openly exchange. When delivered to a specific app, the JSON is transformed into native UI that automatically adapts to its surroundings. It helps design and integrate light-weight UI for all major platforms and frameworks.
 
Adaptive Cards Templating is a revolutionary change. It enables the separation of Data & Layouts. 
Let's understand the Adaptive Cards online designer. The designer contains multiple panels that serve different purposes, as shown in the following image:
 
  1. Card Elements
    List of all elements available for use within Adaptive Cards

  2. Rendered Card
    Preview rendering of the card as it would appear in the currently selected host app.

  3. Card Payload Editor
    The browser-friendly JSON editor contains the source of the Adaptive Card that's rendered in the Rendered Card pane.

  4. Card Structure
    The card is represented in this panel as a hierarchical structure. Notice that as you select elements in this panel, the corresponding control is highlighted in the Rendered Card pane.

  5. Element Properties
    The properties, including those that aren't specified in the source of the Adaptive Card, are displayed in this panel for the control currently selected in the Card Structure panel.

  6. Sample Data Editor
    This panel contains the JSON used when using the templating capability of Adaptive Cards.   
Templating enables the separation of data from layout in your Adaptive Card. The template language is the syntax used to author a template

Binding syntax changed from {...} to ${...} i.e. “text": "Hello {name}" becomes "text": "Hello ${name}"
 
Static Card Payload
  1. {  
  2.    "type""TextBlock",  
  3.    "text""Manoj Mittal"  
  4. }  
Template Payload
  1. {  
  2.    "type""TextBlock",  
  3.    "text""${UserName}"  
  4. }  
Let's create bot framework sdkv4 project and associate it with adaptive card templating.
 
Step 1 - Build Bot Framework  SDKV4 C# Project
 
Prerequisties - Azure Bot Framework template installed with Visual Studio 2019.
  • Launch Visual Studio 2019 
  • Select Create new project 
  • Select Azure Bot Framework (.Net Core 2.1 or 3.1) 
  • Create Project.
Step 2 - Create Adaptive Card Template
  • Login to https://adaptivecards.io/designer/
  • Card Element Section desing your card with placehoder, which will be used to bind the data at client side.
  1. {  
  2.   "$schema""http://adaptivecards.io/schemas/adaptive-card.json",  
  3.   "type""AdaptiveCard",  
  4.   "version""1.2",  
  5.   "body": [  
  6.     {  
  7.       "id""cardHeader",  
  8.       "type""Container",  
  9.       "items": [  
  10.         {  
  11.           "id""planetName",  
  12.           "type""TextBlock",  
  13.           "weight""Bolder",  
  14.           "size""Medium",  
  15.           "text""${name}"  
  16.         }  
  17.       ]  
  18.     },  
  19.     {  
  20.       "type""Container",  
  21.       "id""cardBody",  
  22.       "items": [  
  23.         {  
  24.           "id""planetSummary",  
  25.           "type""TextBlock",  
  26.           "wrap"true,  
  27.           "text""${summary}"  
  28.         },  
  29.         {  
  30.           "id""planetDetails",  
  31.           "type""ColumnSet",  
  32.           "columns": [  
  33.             {  
  34.               "type""Column",  
  35.               "width": 100,  
  36.               "items": [  
  37.                 {  
  38.                   "id""planetImage",  
  39.                   "size""Stretch",  
  40.                   "type""Image",  
  41.                   "url""${imageLink}"  
  42.                 }  
  43.               ]  
  44.             },  
  45.             {  
  46.               "type""Column",  
  47.               "width": 250,  
  48.               "items": [  
  49.                 {  
  50.                   "type""FactSet",  
  51.                   "facts": [  
  52.                     {  
  53.                       "id""orderFromSun",  
  54.                       "title""Order from the sun:",  
  55.                       "value""${id}"  
  56.                     },  
  57.                     {  
  58.                       "id""planetNumSatellites",  
  59.                       "title""Known satellites:",  
  60.                       "value""${numSatellites}"  
  61.                     },  
  62.                     {  
  63.                       "id""solarOrbitYears",  
  64.                       "title""Solar orbit (*Earth years*):",  
  65.                       "value""${solarOrbitYears}"  
  66.                     },  
  67.                     {  
  68.                       "id""solarOrbitAvgDistanceKm",  
  69.                       "title""Average distance from the sun (*km*):",  
  70.                       "value""${solarOrbitAvgDistanceKm}"  
  71.                     }  
  72.                   ]  
  73.                 }  
  74.               ]  
  75.             }  
  76.           ]  
  77.         },  
  78.         {  
  79.           "id""imageAttribution",  
  80.           "type""TextBlock",  
  81.           "size""Small",  
  82.           "isSubtle"true,  
  83.           "wrap"true,  
  84.           "text""${imageAlt}",  
  85.           "weight""Lighter"  
  86.         }  
  87.       ]  
  88.     }  
  89.   ],  
  90.   "actions": [  
  91.     {  
  92.       "type""Action.OpenUrl",  
  93.       "title""Learn more on Wikipedia",  
  94.       "url""${wikiLink}"  
  95.     }  
  96.   ]  
  97. }  
Card will look like this,
 
 
Create Folder into Visual Code Project name - Resource.
 
Add Json Template with the name of card.json.
 
 
Step 3 -  Add Card and Data Binding
Browse Project and Add Nuget Package:-
  • AdaptiveCards.Templating
Browse echobot.cs file
 
Load the card.json into  
  1. private readonly string _cards = Path.Combine(".""Resources""Card.json");  
On Message Activity Function, Load Json into template variable
  1. var adaptiveCardJson = (File.ReadAllText(_cards));  
  2.            AdaptiveCardTemplate template = new AdaptiveCardTemplate(adaptiveCardJson);  
Step 4 - Add Data  and bind with template variable
 
Add reference of AdaptiveCards.Templating.  
 
Note
I used static data or hard coded data here for article purposes. Data Json can be rendered via API also. 
  1. var adaptiveCardJson = (File.ReadAllText(_cards));  
  2.            AdaptiveCardTemplate template = new AdaptiveCardTemplate(adaptiveCardJson);  
  3.            var myData = new  
  4.            {  
  5.                id = "1",  
  6.                name = "Saturn",  
  7.                summary = "Saturn is the sixth planet from the Sun and the second-largest in the Solar System, after Jupiter. It is a gas giant with an average radius about nine times that of Earth. It has only one-eighth the average density of Earth; however, with its larger volume, Saturn is over 95 times more massive. Saturn is named after the Roman god of wealth and agriculture; its astronomical symbol (♄) represents the god's sickle.",  
  8.                solarOrbitYears = "29.46",  
  9.                solarOrbitAvgDistanceKm = "1433525000",  
  10.                numSatellites = "82",  
  11.                wikiLink = "https://en.wikipedia.org/wiki/Saturn",  
  12.                imageLink = "https://upload.wikimedia.org/wikipedia/commons/c/c7/Saturn_during_Equinox.jpg",  
  13.                imageAlt = "NASA / JPL / Space Science Institute [Public domain]"  
  14.            };  
  15.            string cardJson = template.Expand(myData);  
  16.            var cardAttachment = CreateAdaptiveCardAttachment(cardJson);  
Now turn to render the adaptive card.
  1. private static Attachment CreateAdaptiveCardAttachment(string _card)  
  2.        {  
  3.            var adaptiveCardAttachment = new Attachment()  
  4.            {  
  5.                ContentType = "application/vnd.microsoft.card.adaptive",  
  6.                Content = JsonConvert.DeserializeObject(_card),  
  7.            };  
  8.            return adaptiveCardAttachment;  
  9.        }  
Step 5 - Run Code locally (F5) using Bot Framework Emulator
 
Data and Layout separated while rendering card. Layouts exists at client side and binding of data also happens at client side. As data will come from the API, it  will have server side execution.
 
Earlier we used to bind the Data and Layout at server side and traverse the entire structure. 
 
 
Code Base can be downloaded from here.
 
I hope you have enjoyed and learned something new in this article. Thanks for reading and stay tuned for the next article.