When you were earning about http,

you probably heard about something called cookies.

Now cookies are bits of data that are stored on the client and

are sent on each request to a specific domain.

Now, one of the hardest things about using cookies is avoiding the impulse to say,

me want cookie, a la Cookie Monster.

So now that I've got that out of the way, hopefully I won't do that again.

I'm sorry about that.

You can set a cookie on a response and read it on all future requests.

That sounds exactly like what we wanna do.

Let's go use some cookie power.

Okay, so first thing's first,

let's go extract that query parameter that we pulled here.

Let's put that into its own variable.

So again, what you do is you highlight that, and

you choose Refactor, Extract, Variable.

And what that will do is it will pull out a brand new variable line, and

it's gonna try to name it.

Did a great job.

Username's fine.

And it replaces it.

So now, this variable is able, we're able to use this variable twice.

It's the point of a variable, the local variable.

So on the response object, the ability to set a cookie exists.

So you do a cookie, and then you save the name of the cookie that you want it to be.

So we want it to be called username.

And we want to set it to that new variable that we just did.

Okay, so now every request that gets sent to our domain,

which in our case here is localhost.

It will receive this data.

Do you wanna see it?

Cool, let's do it.

So let's go come here.

And we will reboot the server.

And we'll fly over to our page.

I have my network tools up.

I'm gonna go ahead, and I'm gonna type craigsdennis.

But before I click Sign in, I wanna show you something.

So, this is shortend cuz my screen is smaller here,

but at these little arrows there's a thing here called resources.

Now look at resources.

There is a thing called cookies and then there's a thing that says localhost.

This site has no cookies because we haven't set it yet.

Right?

So I'm gonna set it and when I click send.

It's gonna run through our sign-in.

It's gonna pull the request off, and it's gonna set the cookie.

Boom, and there it is.

It's set.

Okay?. So

now you see that the user name is craigsdennis.

And now, if I come back, and I hit the homepage,

you'll see that the cookies are still there.

And if we look back over here at our network tab.

Let's look at that again.

Hit All.

Look at the local host page here.

You can see that the cookie has, it's there, and it's available.

Let's make the homepage aware of whether or not we've gathered their username.

So we need to make a model.

Right?

So let's make that same model like we did before.

So we'll just do the same thing, and we'll make a new map.

And it's a new map of key values that are both strings.

And it's called model

And we'll make a new HashMap.

It's call String, String.

Okay, and we are going to put into our model, we're gonna put a new value

called username, and we're gonna pull that cookie.

So the way that you do that is just like you might think.

You just say cookie, and then the name of the cookie.

And that will get that value that's there.

Okay, and now our index.hbs needs to know about the model.

And now our template knows about the username value.

So let's use it, right?

Let's go and let's look at our.

Resources.

And we'll look in here.

We'll look under index.

And what we wanna do is we wanna only say hello if we know their name.

So the way to do that in Handlebars is to use what's known as a block helper.

So a black helper, you do a pound.

And the block helper here in this case is something you're familiar with already.

It's called if.

So we're gonna say if username.

It's a little bit different of an if than you're used to.

It's if that exists in the model, that key exists in the model,

then run this code that's inside these two if blocks.

So we're gonna say h1, Welcome, username.

Okay?

And then if we don't know what it is, we wanna have a block called else.

So, in here there is an else.

Okay, and we can grab this code here, and we can move it up.

So now what's happening is it comes in.

It says if there is a username on the model, show this message,

Welcome username.

Otherwise show Welcome Students.

I Better put the exclamation point here, so they both get exclmationed.

All right, so let's go ahead and we'll click run.

We'll do a run, and we'll restart the server.

All right.

Let's look at our index page.

Awesome.

So that's using the first part of the if, and it's using the cookie.

So we can prove that by if we come over here to the Cookies.

If you click the Cookies in Chrome, you can press Delete, and

now the site has no cookies.

And now if I refresh this page, we'll see our form.

And we can put in our name.

That prompt is back.

We don't really need this page anymore, do we?

We don't need this sign in page.

We could just drop them here.

Awesome.

By adding cookies to our bag of tricks,

we now have the core tool set used to make a web application appear to be stateful.

You'll find these patterns of forum submission and

storing values in cookies very relevant.

Now that you know these terms,

it's more a question of how each framework implements them.

Try to remember, this is all just sitting on top of HTTP and providing a nice to use

abstraction but really not doing to much more at it's core.

You should be able to start understanding most web frameworks now.

We should have all the tools we need to start building out the rest of our

application.

Let's go do that, and along the way I'll show you some handy Spark specific tricks

right after these messages.