Okay, we have a form, but we're not using it.

Since we're using Flask-WTF, we have a couple of really nice convenience methods.

Let's write our register view and

explore what all we have available when we use forms.

Okay, after all that work in forms, we want to be able to render this one,

we want to send it to a template.

So let's go over here to our app.py and

we're going to import a couple of more things.

It's gonna get kinda long so I'm gonna put parentheses around this too cuz, you know,

we're gonna be importing a lot of stuff.

So we needed to bring in our render_template cuz we know we're gonna

render a template.

Let's bring in flash cuz we're probably gonna wanna send out some flash messages.

Let's bring in redirect because after the form is submitted correctly, with,

you know, the appropriate values, we probably want to redirect back or

send them to somewhere else.

And then if we're gonna do redirects,

we're gonna need url_for so that we can bring in some stuff.

And we didn't go to a new line yet, but I bet we will later.

Okay, so we've imported our models.

Let's go ahead and import our forms, too.

Again, we're gonna have more than one form, so

we'll just import the whole module.

Let's go add this route.

And it's going to be app.route and let's say register and our methods for

this are going to be get and post, because we want them to be able to load the view,

and that way they'll be able to see the template and they'll see the form.

And then we also want them to be able to post back to the view so

it processes the form.

So, let's say def register, I'm not going to take anything.

And then we're gonna create a form.

And this is going to be forms.registerForm.

And we don't have to send them any information to registerForm.

Flask and Flask-WTF are smart enough that they know like, oh,

some information came in through the post, let's go ahead and send that.

Speaking of that being smart, we're gonna add another line here,

if form.validate on submit.

So what this method does, it belongs to the form, and it detects that they have

valid, or, not validated, sorry, they've submitted the form, it's been posted.

And we run the validation, remember all the validators that we added?

And it comes back as either, everything is good, or things are missing.

So that's all we're gonna deal with here.

So if it comes back and it's valid, then we're gonna flash up a message, and

let's say yay, you registered!

And the something I'm actually gonna add here that we didn't do the last time that

we did flash messages, is I'm gonna add in the message category.

Though the category for this is going to be success.

These will be more important, and more obvious, a little later on,

when we, finish building out all of our HTML and we start showing flash messages.

Okay, so things are good.

We've flashed up this message, and

then we're going to create model.user.create_user.

We're gonna create a user.

Now, how do we get the data out of our form?

So we're gonna say, name, username is equal to form.username.data.

And we're gonna say email is equal to form.email.data.

And password is equal to form.password.data.

Okay? So

we're just pulling out these individual fields.

And then we're going to return a redirect URL for index so

we should probably create an index view here in a minute.

And then regardless of what goes on,

if we don't do the redirect, then we're going to render the template and

we'll render register.html and we'll pass it our form.

All right. So let's talk about templates,

because we need to make a template.

Actually let's go ahead and make, just real quick, at.route, forward slash,

just at home page, index will return hey.

All right.

We'll do a lot more on the index page later, just for

right now though we'll just have it send back some text.

So templates.

We need to make a new folder that's named template.

And then inside there we need to make a new file that is register.html.

So let's think about this.

I don't have a layout.html yet.

I don't wanna bother with making one just yet, so let's just start writing our form.

Method equals post.

And action equals here, which that just redirects back to here.

And I'll give it a class of form, think that's needed in our CSS.

So form has been passed in and we need to render this form in some way.

So, the first thing we need to do, is render this form.hidden tag.

So what this does is it creates a div that has a style attribute so it's hidden.

It, it won't show up in your browser.

And inside of there, is where it puts whatever hidden tags are in your form.

So for instance, we're going to have a CSRF, or C surf tag, that's inserted into

this, to make things nice and safe, so our forms have to be submitted from our site.

That'll get rendered in here.

If we need other forms to be hidden, or fields to be hidden, then,

they would go in here, as well.

We don't have any, but if your, later work does.

Okay. So now, let's say for field in form.

These are our fields.

Div class equals field.

And inside that, if field.errors, so

if there's any errors on the field,

then for error in field.errors,

div class equals notification error.

And then we wanna print out the error.

We gotta end our for, we gotta end our if.

And let's, let's take these two and have those end.

And then we have to do field, and then we want to render

a placeholder inside the field, and we want that to be the field's label,

and then the text that belong to that field's label.

And so, for example, we have our, let me finish this, I'll come back over here.

If we look at forms.py, our username field,

we have this label here of username, so here in register.html

this placeholder is going to be username because that's the text of our label.