Heads up! To view this whole video, sign in with your Courses account or enroll in your free 7-day trial. Sign In Enroll
Preview
Start a free Courses trial
to watch this video
Now that we can save posts in the database, let's create a form and view for capturing them from the user.
We assigned the database and the current user, from Flask Login, to the g object, Flask's global attribute that gets passed around to all of our views automatically, so now we can use it to get the current user.
Alert!
In this video and the others in this course, you'll see me using {{ current_user.is_authenticated() }}. At the time of filming, this was the correct way to use the is_authenticated() method on the UserMixin from flask-login. BUT, as is often the case in open source, things have changed. You'll now want to always use it as a property instead. So, use {{ current_user.is_authenticated }} instead. No parentheses!
Related Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign upRelated Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign up
As you can probably guess, there won't be
a lot to our stream form.
0:00
But we need to create a view and we should
probably make the form available all
0:03
the time so we can let the user post a new
message no matter where they are.
0:07
Okay, so if we're going to make a form for
0:12
them to post things from, then we to go
back to forms.py.
0:14
So our forms are getting easier and
easier.
0:19
Our log in form was two fields.
0:21
And this form is only going to be one.
0:24
So let's make a PostForm which is a Form.
0:26
And it's just going to have content.
0:30
And that's going to be a TextAreaField.
0:31
And we're gonna put in a message, I'm
gonna say what's up.
0:35
You can, of course, put in whatever you
want.
0:38
And, our only validator on this is going
to be DataRequired, and that's it.
0:41
So let me come up here and import the
TextAreaField.
0:50
[NOISE] And, we want to save.
0:53
And there's our new Form.
1:00
So that's great.
1:02
So now we need to go use that form.
1:03
So let's go back over here to app.py, and
let's make a new route.
1:06
[BLANK_AUDIO]
1:11
And let's say a new_post.
1:16
[BLANK_AUDIO]
1:18
And what we could do.
1:21
Let's think about this for just a moment.
1:23
What we could do is we could make it to
where we have one route
1:24
that always gets posted to, that will
create the new post, and
1:27
then send you back to, like, your stream
page, or whatever.
1:31
That would make it to where if we wanted
to show the form on every single page,
1:34
then that's a really easy way.
1:38
We can post to that and it just gets
redirected.
1:39
I think showing the form on every single
page might get a little visually messy and
1:42
we have to create and pass this post form
every single time.
1:47
That doesn't seem like the most fun thing
to do, so
1:52
let's instead just use this route.
1:56
And we'll have a view where they can just
go to post.
1:58
And then, if you wanted to in your own
version of this, you could load that view
2:01
through Ajax, and hit a button, you pull
up a model that shows that view or
2:05
whatever, they type in their post and then
it does whatever it does.
2:10
All right, so, let's call this post.
2:13
And you know what?
2:17
I just realized we need to make this log
in required,
2:17
cuz we don't want non-logged in users to
be posting.
2:20
So, form equals forms.PostForm,
2:25
and if form.validate_on_submit.
2:29
So you notice when we're working with
forms,
2:34
we're basically doing the same thing every
time.
2:36
We build the form, and we're gonna send it
to our template.
2:38
But, if the form comes in, and it's been
submitted, then we're gonna validate it,
2:40
and see if it works, and then, do
whatever.
2:44
So, models.Post.create.
2:48
And user is going to be g.user.
2:51
And then, this is a fun thing.
2:54
It actually took me a little while to find
this.
2:55
So g.user is just this kinda lazy object.
2:58
We have to actually go and get the object.
3:01
So we have to run this method of
_get_current_object().
3:03
It's a little weird, so I made sure
[LAUGH] and
3:08
found out how to do this for us.
3:11
So that's a little strange,
3:13
but that's what we do, g.user, that's our
global user.
3:13
We need to add that in.
3:18
Let's add that in in just a moment.
3:19
And then we have to go and get that
current object each time.
3:20
And then content equals form.content.data.
3:23
And let's call strip on that,
3:27
just in case they put in a bunch of white
space or whatever.
3:29
So we're gonna flash Message posted:
Thanks!
3:32
And that's going to be a success.
3:38
And we're gonna return a redirect url_for
index.
3:42
And then out here we're gonna return a
render_template('post.html', form=form).
3:51
Okay, so I said we were gonna do this
g.user.
4:00
So let's come up here to our
before_request.
4:03
And that's where we want to add that in.
4:08
So what we want to do is actually I need
to add two things.
4:11
So we're going to say g.user =
current_user.
4:15
And then we're going to come up here to
our login imports and
4:20
we're going to import current_user.
4:25
So this is just a little method or
4:28
object that we can use that will find the
current_user.
4:31
So pretty handy.
4:35
Let's just go ahead and look at our post
form again.
4:36
So that's that, nothing really
exceptional.
4:39
So anyway, we're rendering out this
post.html, we should go build that.
4:43
So, we'll say new file, post.html.
4:47
And let's say that this is going to extend
layout.html and
4:51
we're gonna bring in that macro from
4:59
'macros.html' import render_field.
5:04
And in block content, we want to
5:09
do form method = POST action = this page,
5:14
form.hidden_tag for
5:21
field in form render_field(field).
5:25
[SOUND] And then button
5:31
type = submit id = submit Post.
5:37
And then that ends our form and we end our
block.
5:45
'Kay, so, if we were to go over here to
TwoCans, and
5:50
we were to go to new post, then there's
our form.
5:55
So, let's add in a way that we can get to
here from where ever.
5:58
So, we can get to the home page a couple
of ways, we can log out, but
6:00
we don't have any way to get to this post
page.
6:05
So let's go add that.
6:08
Let's go over here to our layout.html.
6:09
And here where we have this All link,
let's add in a new thing,
6:15
if current_user.is_authenticated, cuz we
only wanna show this if they're logged in.
6:22
There's no reason to show them a link they
can't use, right?
6:31
The URL for post, that's the name of our
view.
6:35
And class = new.
6:39
And let's say Create New Post.
6:42
All right, now let's refresh this.
6:46
Sweet, we've got this Create New Post
thing.
6:53
And it's highlighted here because of some
JavaScript that's running.
6:55
Since this course is about Flask, we're
not gonna talk about the JavaScript,
6:58
but feel free to check it out inside the
Static folder.
7:01
That G object is becoming more useful than
I'd expect.
7:05
Now that we can post messages, let's show
them on the index page and
7:08
show just your messages on your personal
Stream View.
7:11
You need to sign up for Treehouse in order to download course files.
Sign upYou need to sign up for Treehouse in order to set up Workspace
Sign up