Okay, so now let's develop our flash messages.

So again, not having all the tools at your disposal

doesn't mean that we can't build our own.

So one thing we haven't talked about yet, and

we're gonna lean on this pretty heavy, are these things called sessions.

So web sessions are a key value data store that are available in most frameworks.

They're specific to the client or the website and

it's kinda like a pocket that you can stuff things into.

Spark offers one and you can access it right off the request.

So the way that Spark uniquely identifies a session,

it does it by sending out a uniquely identified cookie.

We'll take a look at that here in a bit.

But the server then uses that cookie to maintain a data store for

each client who asks for one of these sessions or packets.

Let's start by using it and I'll show you how it works.

Let's build a simple way to set a single flash message.

So first let's attack the messaging around voting.

So add voter, we made it so that it returns a boolean, but

we're not doing anything here with it yet, so let's catch it.

So let's say boolean added, and let's let them know that their vote counted, right?

Otherwise it's kinda confusing.

You vote and get redirected and might see it there in the list, but

let's make sure that they see it.

So we'll say if added, and we'll call a message that we have

not written yet, so we'll say set flash message.

Thanks for your vote.

Now what's nice about writing the message name before it exist is,

IntelliJ is gonna build this for us.

So we'll say, create method set flash message.

And now it knew that we are in the static context, right?

And it knew that it didn't return anything cuz we didn't ask it to return anything.

And it popped in the request and the string for us.

I'm gonna clean this up a little bit here.

It's not quite right.

So we're gonna say the string is the message.

The request has a method named session on it.

So if we say req.session and you see there, there's two options.

We have one here that says create or something with no parameters.

So, by default, it will create one.

And this is okay in this case cuz we're saying set the flash method,

but we don't want it to always create it.

So, when we go to check this in a bit we wanna remember that we don't wanna

create a session if we don't need it, right?

Because that's just expensive and wasteful.

But we're gonna set a message, and

if we don't have one of these web sessions to do, we need to have it right, so.

So we're gonna say req that session and

the way you set key values is with a thing called attribute.

So we're gonna say attribute and attribute we want is we wanna set a flash message.

So this is the key the name and

there we're gonna pass in what came across which is message there.

We're probably gonna use this string here a lot to get them out as well.

So this is a place where we should store it once and then use it many times.

So let's go ahead, and I'm gonna do, I'm just gonna say flash message key.

And this is a good place for a constant.

And remember those are all capitals.

So we'll say FLASH_MESSAGE_KEY.

And of course that's not defined yet, but

let's go ahead and have IntelliJ help us out.

So we'll create a constant field FLASH_MESSAGE_KEY.

Exactly what we want.

So there it is,

it blew out java.lang.String completely for some reason.

We don't need that.

FLASH_MESSAGE_KEY.

And we're gonna set to be flash message.

We could then change that to whatever we want in the future,

should that have some sort of namespace closure.

But this is all up here and

remember it's static because we're accessing inside of a static method.

Awesome.

So, what good is our setter if we don't have a getter, right?

So let's go ahead and let's add our getter.

Now this one is gonna be a little bit trickier.

So it's also gonna be private.

It's static, cuz we're gonna access from inside.

I'm gonna say getFlashMessage.

It's gonna require a request object,

because that's how we're gonna get to the session.

Okay so like I was saying before one thing I wanna make sure is that we

don't create these sessions if we're not gonna use them.

You don't wanna check and accidentally create one.

Totally wasteful.

So what you can do is pass a false through there.

So if you say req.session and

you pass a false which this should just create if it doesn't exist.

So we're gonna say false.

If that doesn't exist, then there's no flash message to get,

so we should just return null, right?

So we're gonna shortcut this function.

There's no need to keep going.

And I'm sorry. It's not void.

We wanna return a string.

Okay.

So, if the session already exists, maybe somebody else created it.

So we wanna make sure that our key exists, okay?

So we're gonna say if req.session, and now we know that it already exists.

Because if it did, the session wouldn't [INAUDIBLE].

So if req.session.attributes, this is a way you can get all of them,

contains FLASH_MESSAGE_KEY.

Okay, so what we're gonna say here is actually if it doesn't

let's get out too, we return null.

And then finally, if it does exist, we can pop it out.

Now here's the thing, we need the cast.

Remember we needed a type cast because what goes in there are, it's,

the key is a string but the value is an object.

So we're going to get the session, we know that it exists.

We're going to pull out the attribute.

FLASH_MESSAGE_KEY.

Cool.

So now we can get and set our messages, let's make a way to display them.

Now this really could be on any page, so

first let's set up our base.hbs with a flash message area.

So let's go into base and

right in here inside the page, let's make it the first thing inside the page.

So, one thing that we haven't done yet is we have not pushed a model in.

So this could be on any page so let's go ahead and

let's say any model that has a thing called flash message.

We will just write out p and

I'm going to give it an HTML id, so we can really specifically target this.

So we'll say flash-message and

we will write out here the value of flashMessage should it exist.

Now one thing that's really nice about Handlebars is see that if there.

This if even if it doesn't exist, if this doesn't exist,

it somehow is going to say it's okay it doesn't exist in the model,

I don't care that you're talking about a variable that doesn't exist.

In Java that would kinda throw up.

It would say that this doesn't work, this can't compile,

I don't know what you're talking about.

But here in Handlebars it's kinda wrapped in a notion of something that's kinda

falsey, right?

Okay, so Sully is always thinking ahead, our designer friend.

He sent me some CSS already.

He said, if you ever wanna show them some flash messages, why don't you use this?

Which is great because I would not know how to style this or

even think about styling it, so let's pop into our main CSS and

I'm just gonna add this here at the bottom.

We'll add this flash message.

Cool. Thank you, Sully, once again.

He's so good.

So let's go show this on our list of ideas.

When we're showing the ideas here, we're now going to add to our model.

We'll say model.put and let's put in a flashMessage,

right, that was the model variable that we're looking for.

And we'll say getFlashMessage and we'll pass on the request.

Cool, and that therefore, if it exists it will push it across.

If not, it will be null and it will not show our flashMessage.

So let's go ahead and let's open this up and

reboot the server and I'm gonna come over and

let's refresh the page here let's get back to the ideas list

let's put in Spark Testing and suggest that.

Okay, now let's go ahead and look first at these resources.

And we'll look at our cookies.

And you'll see that I only have this username of myself here.

But when I vote, you should create the session and set that message

that we successfully voted into it, which will therefore, first create a session.

Okay, so let's click vote.

Boom. Here's our flash message, and

look, here is our cookie, and

this is the way that we're being uniquely identified from Spark.

So the name of it is this, and this is the value, some long value over there,

but that's how it's knowing what session we're talking about.

So, we have a session.

So, let's see, if I refresh this page, hmm.

That message stays there because the flash message is there.

One thing most flash messaging systems do is make sure that

after the user has seen the message once, they don't see it again.

So, let's make ours a little bit smarter.

We wanna leave the gitting in place in case they don't want this specific

functionality but, in this case, I think it makes sense.

So, let's go over, back to our main method.

And let's add, let's add a new method called

captureFlashMessage, it will be much like this.

So I'm gonna copy it and instead of get let's say captureFlashMessage.

And let's pull that out, let's pull the message up,

string message equals get flash message and pass on the request.

Okay, so if the message isn't empty, if we've got something, right?

Then we have a session, so we should remove that key completely.

So the way that you do that is remove attribute, and

we're gonna remove the FLASH_MESSAGE_KEY.

So therefore, this is going to see if it exists,

if it does, we are going to get rid of it.

You're going to pop that off of the session.

Cool.

So now we come back to where we were using getFlashMessage.

Which is in our listing of our ideas up here, somewhere, here it is,

so, we're saying getFlashMessage, we're going to say captureFlashMessage.

So this time it will show it once, and then it will disappear.

So let's add an else to where that voter call was, right?

So else, so it wasn't added, so we're gonna say setFlashMessage,

and we'll say request, you already voted.

Now see how easy it was now that we have all the functionality in place to add

a brand new message, it's pretty easy now.

So while we're here, let's go ahead and let's check our to do's.

So we have this one about sending a message about a redirect somehow.

So before they try to get to the ideas page, if they are not logged in,

we redirect them.

So let's go ahead and let's get rid of that to do and let's add a flash message.

We'll say whoops, please sign

in first and it will redirect.

Here's the other thing.

For the splash page, we need to make sure that we also

capture the flash messages and add them to the model.

This is starting to feel a little duplicated isn't it.

Check the teacher's notes if you're interested in how we might be able to

wrap this up.

So it's a captureFlashMessage(req).

So for now it's in only two of these calls but

if we do this we're gonna have to do this everywhere.

So you wanna make some way to make that generic,

but again check the teacher's notes.

So let's go ahead and let's pop over and we'll wipe both of our cookies away.

Let's get rid of the username too.

We will try to refresh the ideas page, okay?

So what's gonna happen is it should tell us that we need to log in.

So we're redirected, face palm, I forgot to restart the server.

Do not forget to restart the server.

So frustrating, right?

Okay.

What did I do wrong?

So it says, I forgot to pass in the request.

Okay, so let's run that again.

We're not logged in, we're going to go to /ideas.

Now this is going to create a flash message for

us cause or create a session for us because it's going to set a flash message.

There. So it says whoops, please sign in first.

Now that redirect makes more sense, doesn't it?

And there is out session idea that got created.

So now let's log in and if we go to view all course ideas.

And we'll say Spark Testing.

I'll vote for it once and it'll say, thanks for your vote.

And if I come and I refresh this page, see how the message has gone away.

But if I try to vote again, it'll say, you already voted.

Awesome.

That was an excellent micro-implementation of flash messages using web sessions.

Wow. You built that

messaging system in a flash!