Session Attributes

Let’s take a look at how we access session attributes from a Lambda function. 

Session attributes are stored in the response that your skill receives from Alexa as a JSON. We can create and edit attribute fields by accessing their key. Inside of the Lambda function, you can access session attribute values using `this.attributes`.

 ```js
this.attributes['yourAttribute'] = 'value';
```
In the example above, we create a field in `attributes` and save the string `'value'` to it. `this` references the `alexa` object that's instantiated in the `export.handlers` function.

Since the LaunchRequest is usually the first intent that the skill executes, we often set the initial attribute state inside of it. 

```js
// Inside of LaunchRequest
this.attributes['numberCorrect'] = 0; 
```
In the example above, we set the initial value of our `'numberCorrect'` attribute to `0`, because the user has not attempted any answers yet.

For this skill, we want to use session attributes to keep track of the language we’re practicing, how many questions we’ve answered, and which ones we’ve gotten correct. To help with this interaction, we've included a `flashcardsDictionary` object that contains information about our flashcards, including the questions and their answers in different programming languages. 

In this exercise, think about what initial states would make sense for each session attribute. 



In this lesson, we're going to build a Codecademy Flashcards skill and look at how you can program Alexa to remember details about your conversation within a session &mdash; the time between when you open the skill and close the skill. 

Imagine you were working through a deck of vocabulary flashcards. As you progress through the deck, you keep track of which flashcards you have completed and which you have not. Also, you may keep track of the number of flashcards you have answered correctly.

In this lesson, you will add a notion of short-term memory. As a user progresses through the flashcards in your skill, you can keep track of the user's progress through the deck by keeping track of the current index and number of correct cards. 

Additionally, you will add an option for users to choose the programming language for the questions in their flashcard deck.

To remember all of these things, we need to use *session attributes*. Session attributes allow Alexa to remember and update user-provided details throughout a session. 

You can think of session attributes as being similar to variables that store information about the program, except values stored in session attributes persist throughout a session. In a later lesson, we'll talk about how you can persist attributes between sessions by writing them to a DynamoDB database (aka long-term memory).


Introduction

In the last exercise, we used interpolation to create a speech output. Though, accessing session attributes and slot values can get messy. In this exercise we'll see how variables can help us clean up our code.

Look at how our speech output changes when we add a variable to our intent: 

  ```javascript
'CurrentGenreIntent': function() {

var genre = this.event.request.intent.slots.genres.value;
 
this.attributes['genre'] = genre;

this.response.listen('Ok, so you like ' + 
genre + ' movies. Let me ask you a few ' + 
'more questions and then I’ll give you ' +
'my recommendation.");

this.emit(':responseReady');

}
  ```
By saving our session attributes to the `genre` variable, we have refactored the string in our speech output to be more readable.


Session Attributes and Variables

Before we build the Lambda function logic for our flashcards skill, we want to build the interaction model. 

To do so, we’ll navigate to <a href="https://developer.amazon.com/" target="_blank" rel="noopener noreferrer">developer.amazon.com</a> and use the Alexa Skill Builder. If you are unfamiliar with this process or need a refresher, check out these videos: <a href="https://content.codecademy.com/courses/alexa/learn-alexa-introduction/skill-information-2p-v2.mp4" target="_blank" rel="noopener noreferrer">how to create a skill</a> and <a href="https://content.codecademy.com/courses/alexa/learn-alexa-introduction/hello-intent-v2.mp4" target="_blank" rel="noopener noreferrer">how to build an interaction model</a>. 

---

#### Create an interaction model
1. Add a custom slot named `languages` with the following slot values: ruby, python, javascript.
2. Add a custom slot named `answer` with the following slot values:  length, len, print, puts, console.log, capitalized, lowercase.
3. Create a custom intent named `SetMyLanguageIntent`
4. Add the following utterances to `SetMyLanguageIntent`: `Test my {languages} knowledge` and `Practice {languages}`
5. Create a custom intent named `AnswerIntent`
6. Add the following utterances to `AnswerIntent`: `I think it's {answer}` and `Is it {answer}`



Building the Interaction Model

One good use of session attributes is to capture and store user input through slots so you can use that information at a later time. This information is sent to your Lambda function as part of the JSON response. 

To get a slot value, you first need to figure out how your slot is sent in the JSON request. The following is an example JSON request for a movie recommendation skill:

```js
"request": {
    "type": "IntentRequest",
    "requestId": "EdwRequestId.d30fb1fe-8f09-4a80-ab90-b736c2959146",
    "intent": {
      "name": "SetGenreIntent",
      "slots": {
        "genres": {
          "name": "genres",
          "value": "horror"
        }
      }
    }
```
The structure of the JSON object tells us how to access user input. We can use the following format to set a `genre` session attribute to the value saved to a user slot input:

```js
this.attributes['genre'] =  this.event.request.intent.slots.genres.value;
```

In this lesson we want Alexa to interpret the utterance, “Test my Ruby knowledge”, recognize “Ruby” as a slot value, and store it in the `language` session attribute for Alexa to use in later speech intents.

Assigning Slot Values to Session Attributes

Often, you want to combine session attribute values with another string to generate a custom speech output. 

Let's consider our movie genre skill. If we wanted Alexa to respond with the current genre of a movie, which has been stored in a session attribute, we could use the following to generate the speech output. 

```javascript
'SetGenreIntent': function() {

 this.attributes['genre'] = 
 this.event.request.intent.slots.genres.value; 

 this.response.speak('Ok, so you like ' + 
 this.attributes['genre'] + ' movies.' +
 'Let me ask you a few more questions and ' + 
 'then I’ll give you my recommendation.').listen();
    
  this.emit(':responseReady');
}
```
We can see the interpolation in the `this.response.speak` speech output, where we insert the `genre` session attribute inside of the response. 

String Interpolation with Session Attributes

Now that we’ve added all of the functionality of session attributes, let’s create our Lambda function.

We’ve detailed the steps below, but if you need a refresher, check out this video on <a href="https://content.codecademy.com/courses/alexa/learn-alexa-lambda-aws/create-alexa-function.mp4" target="_blank" rel="noopener noreferrer">creating a Lambda function</a> and this video on <a href="https://content.codecademy.com/courses/alexa/learn-alexa-lambda-aws/update-lambda.mp4" target="_blank" rel="noopener noreferrer">adding your ARN to your Alexa skill</a>.


Create the Lambda Function

Congratulations! You now know how to persist data throughout an Alexa session. Let’s review what you learned:

- We define session attributes using `key: value` pair syntax.
- You can modify session attributes by assigning new values to them (e.g. `this.attributes["numberCorrect"]++`)
- You can access a slot, such as `answer`, from the JSON response, like:
```js
this.event.request.intent.slots.answer.value
```
- You can combine session attribute values with other strings to generate a custom speech output, like:
```js
this.response.listen('Hello, ' +
       this.attributes['name'] + 
       '. What is your favorite language?');
```
- It's a good idea to refactor your code by saving session attributes to variables.
```js
var name = this.attributes['name'];
```

It’s important to note that session attributes persist throughout the session, but if we were to open the skill again, those same attributes would be reset. 

In a later lesson, we’ll show you how to preserve your values across sessions using an AWS DynamoDB database, where you will learn how to give Alexa "long-term memory".


Review

Like variables, session attributes hold values that we can change after we've created them.

For example, if any of our session attributes are numbers, we can set their initial values and use number operations (e.g. increment) to overwrite them later. 

```js
'LaunchRequest': function() { 
  this.attributes['currentIndex'] = 0;
};
```
The `attributes` field holds an object with a field named `currentIndex` set to the value `0`.

In this lesson, you will keep track of the number of flashcards in the same way &mdash; each time a user answers one of the questions, we will increment the value saved to the `currentIndex` attribute as follows:

```js
  this.attributes['currentIndex']++;
```


Modifying Session Attributes

Now that we’ve completed our skill, let’s test it out. We’ve included our version of the service simulator to let you see how the requests and responses should appear. 

Try out the following utterances in order:
1. *Open Codecademy Flashcards*
2. *Test my Ruby knowledge*
3. *Is it length*
