Import the Starter Skill

1. Log into Oracle Digital Assistant.
2. Click in the top left corner to open the side menu.
3. Expand Development and then click Skills.
4. Hide the menu by clicking again.
5. Locate the CRCPizzaBot starter skill.
6. If you can't locate the skill, click Import Skill (located at the upper right).

   

7. Browse to, and then select, CRCStarterSkill(1.0).zip. Then click Open.

Explore and Test the Skill

Take a look at the intents and entities.

1. In the dashboard, click the CRCStarterSkill tile to open skill in the Skill Builder. The intent editor should be selected when this development environment is launched. If it isn't, click Intents in the left navbar.
2. Click Entities in the left navbar. Notice the CheeseType, NoToppings, PizzaCrust, PizzaSize, PizzaToppings, and PizzaType entities that contribute the information required for a pizza order. Within the scope of this tutorial, you are just going to work with the PizzaType and PizzaSize entities.
3. Click Intents in the left navbar. Take a look at the two intents created for this skill: Welcome and OrderPizza. Notice that OrderPizza is associated with both the PizzaType and PizzaSize entities.
4. Click Train (located on the right side of the top menu).
5. Accept the default selections in the Train dialog and then click Submit.
6. With the model now built, test it by clicking Try It Out! (located at the upper right).
7. Enter I want to order a large pepperoni pizza in the Message field and then click Enter. Note that the returned confidence level for the OrderPizza intent (it's 100%). This time, however, only one of the two entities could be extracted from the user message, meaning that the skill must explicitly ask for the pizza size.
8. Close the tester.
9. Click Flows in the left navbar. Note the existing dialog flow states to handle the user intents and unresolved intents.

What you just did: You've imported the basic skill into your instance, trained it, and tested its intent resolution.

Create the askSize State

1. In the dialog flow, click + Components and then choose User Interface.
2. Choose Common response - text.
3. Choose orderPizza in the Insert After menu.
4. Switch on the Remove Comments toggle and then click Apply.
5. Change the name of the added dialog flow state from textResponse to askSize.
6. Update the following properties:

   Property	Value
   variable	"pizzaSize"
   nlpResultvariable	"iResult"
   text	"What size pizza?"

7. Delete everything between text and transitions.
8. For the transitions property, replace
   

         actions: 
           someAction:
           

   with
   

       transitions:
         next: "confirmOrder" 

   (You'll add the confirmOrder state in the next section.)
9. Delete any unneeded properties so that the askSize state looks like this:
   

   askSize:
       component: "System.CommonResponse"
       properties:
         processUserMessage: true
         keepTurn: false
         variable: "pizzaSize"
         nlpResultVariable: "iResult"
         metadata: 
           responseItems:         
           - type: "text"  
             text: "What size pizza?"  
       transitions:
         next: "confirmOrder" 

   Click here to find this snippet.

Create the confirmOrder State

1. In the dialog flow, click + Components (located at the top left) and then choose User Interface.
2. Click Output.
3.  Choose askSize in the Insert After menu, switch on Remove Comments, then click Apply.
4. Rename the newly added output state confirmOrder.
5. Add the following Apache FreeMarker expression to the text property:
   

   "Your ${pizzaSize.value?lower_case} ${pizzaType.value?capitalize} pizza is on its way"

6. Add the following transitions property:
   

      transitions:
         return: "done"

   When you're done, the confirmOrder state should look like this:

     confirmOrder:
       component: "System.Output"
       properties:
         text: "Your order of a ${pizzaSize.value?lower_case} ${pizzaType.value?capitalize} pizza is on its way"
         keepTurn: false
         translate:
       transitions:
         return: "done"

7. Click Validate. If there are syntax errors that you can't resolve, replace the existing dialog flow definition with this one.

Add a List of Values for the orderPizza State

1. In the dialog flow, click + Components.
2. Choose Common response - text, choose orderPizza in the Insert After menu.
3. Choose Remove Comments and then click Apply.
4. Delete the orderPizza state that you previously created so that the textResponse state is directly under the # TUTORIAL START comment:

   ...
   
   # TUTORIAL START
   
     textResponse:
       component: "System.CommonResponse"
       properties:
         # set processUserMessage to true if the dialog flow should return to this state after receiving user message
         processUserMessage: true
         # set keepTurn (true/false) to true if the dialog flow should transition to the next state without waiting for user input. Only applicable when processUserMessage is false
   
   ... 
                       

5. Rename the textResponse state name to orderPizza.
6. Set the variable property to "pizzaType".
7. Set the nlpResultVariable property to "iResult".
8. The responseItems element contains two text responses: the first is the Simple text sample response and the second (which is the one you're going to define), is the Text with actions sample. Remove the Simple text sample response by deleting the following block of code.

           - type: "text"  
             text: "Simple text sample"  
             footerText:
             iteratorVariable: 
             separateBubbles: false
             visible: 
               expression:            
               channels:
                 include:
                 exclude:  
               onInvalidUserInput:  

9. Edit the remaining text response by adding the following properties:

   Property	Value
   text	"Which pizza do you want?"
   -label	"${enumValue?capitalize}"
   iteratorVariable	"pizzaType.type.enumValues"

10. For the payload property, replace this:
    

                  action: "someAction"  
                  variables: 
                    user.someVariable: "someValue" 

    with this
    

                  variables: 
                    pizzaType: "${enumValue}"

11. Edit the transition to navigate to the askSize state:

        transitions: 
          next: "askSize"

12. Delete the unneeded properties so that the orderPizza looks like this:
    

      orderPizza:
        component: "System.CommonResponse"
        properties:
          processUserMessage: true
          keepTurn: false
          variable: "pizzaType" 
          nlpResultVariable: "iResult"       
          maxPrompts: 
    
          metadata: 
            responseItems:      
            - type: "text"  
              text: "What kind of pizze do you want?" 
              actions: 
              - label: "${enumValue?capitalize}"
                type: "postback"
                keyword: 
                payload: 
                  variables: 
                    pizzaType: "${enumValue}"
                iteratorVariable: "pizzaType.type.enumValues"   
        transitions: 
          next: "askSize" 

13. Click Validate. If you're encountering syntax or spacing errors, paste in this snippet.

What you just did: You defined the following properties to create the content for these messages:

• iteratorVariable--List items can be created (stamped) from an iterator. The PizzaType entity is of type value list, which means that it has a list of values defined that can be accessed through the pizzaType dialog flow variable.
• label--When the list data is read from a value list entity, then the currently stamped item is accessed through the ${enumValue} expression. An Apache FreeMarker expression ?capitalize is used to create a user-friendly message format form the all-uppercase pizza type names in the entity.
• variables--List item actions (postback actions) can update one or many variables when a user taps on an item in the list. In the pizza skill, there is only one dialog flow variable pizzaType that needs to be updated. The string pizzaType: "${enumValue}" assigns the current iterator value to the variable. So if, for example, a user taps on the Pepperoni list item, the PEPPERONI value is saved to the dialog flow variable.

Test the Cards

1. Click to open the Skill Tester. If needed, click Reset to clear the prior conversation.
2. Enter I want to order a pizza.
3. Scroll to the second pizza in the carousel (Pepperoni).
4. Click Order.
5. Select a pizza size.
6. Click Reset.
7. Enter I want to order a pepperoni pizza.

   In this conversation, you bypass the cards because of the variable and nlpResultVariable properties that you set for the System.CommonResponse component.

8. Click Reset and then close the Skill Tester.

   

Add Keyword Support to the Cards

When working with card layouts, it is not the card you select to perform a selection, but the button(s) displayed on a card. In this tutorial, each card displays a single button for ordering the displayed pizza. Following the next steps, you will implement keyword support for buttons in the cards.

1. In the actions property of the orderPizza state, replace the value for the labelproperty with the following string:
   

   "Order
   (${enumValue[0]?upper_case}${enumValue[1]?upper_case})${enumValue?keep_after(enumValue[1])}"

2. Add the following value to the keyword property:
   

   "${enumValue[0]?upper_case}${enumValue[1]?upper_case}"

   When you're done, the orderPizza state should look like this:
   

     orderPizza:
       component: "System.CommonResponse"
       properties:
         processUserMessage: true
         variable: "pizzaType"
         nlpResultVariable: "iResult"
         metadata: 
           responseItems:         
           - type: "cards" 
             cardLayout: "horizontal"
             cards:
             - title: "${enumValue}"
               description: "${pizzaCardInfo.value[enumValue].description}"
               imageUrl: "${pizzaCardInfo.value[enumValue].image}"
               iteratorVariable: "pizzaType.type.enumValues"
               rangeStart:
               rangeSize:
               actions:
               - label: "Order (${enumValue[0]?upper_case}${enumValue[1]?upper_case})${enumValue?keep_after(enumValue[1])}"
                 type: "postback"
                 keyword: "${enumValue[0]?upper_case}${enumValue[1]?upper_case}" 
                 payload: 
                   action: "selectPizza"  
                   variables: 
                     pizzaType: "${enumValue}" 
       transitions:
         next: "askSize"
         actions:
           selectPizza: "askSize"

Test the Keyword Support

1. Click to open the Skill Tester.
2. Enter I want to order a pizza.

   Note the CH in the Order (CH)EESE Basic card button label.

3. Enter CH.
4. When prompted, select Large. The skill then outputs a confirmation message for a large cheese pizza.
5. Click Reset.
6. Enter I want to order a pizza.
7. When the Cheese Basic pizza card display, enter pe.
8. When the skill prompts you for a size, enter l. The skill then outputs a confirmation message for a large pepperoni pizza.

   

   There are two observations with this latest exercise. Firstly, the keyword uses two letters to make a pizza selection. This is because two pizzas, Pepperoni and Premium, both start with a "P" as the first character. So a single letter keyword does not work. Secondly, the keyword selection does work even if a card is not displayed. Note, however, that if you use page ranging to reduce the number of cards that are rendered at any one time (some messengers like Facebook require this), then only the cards that can be accessed with a keyword shortcut are the ones that are within the current page range.