Using a ModelForm, at least to display a blank form,

is exactly the same work as using a regular form.

You instantiate it and send it to the template.

You even render it to HTML in the same way.

Where they definitely deviate, though, is in the processing of them.

You still use the normal isValid method, but after that,

you can save instances to the database.

This sounds like something we should take to workspaces.

All right, so I want to make a couple of views for

dealing with creating quizzes and editing quizzes.

And I know that I want these to be something that only logged

in users can do, so we need to import a little thingy here.

And so what we wanna do is.

We probably wanna give back some messages at some point.

I'm gonna import this just in case.

Maybe we use it, maybe we don't, but for right now I'm gonna import it.

And then django.contrib.auth.decorators

import login_required, which this decorator

lets us mark a view as requiring a logged in user.

If you've done the flask courses, we've done something like this.

Basically it just makes it so, you log into the admin, and

then you can go see our quiz creation, quiz editing thing.

You can't do it unless you are doing that.

And then from django.http import HttpResponseRedirect.

You know we're gonna need that, because we gotta be able to send people back and

forth to places.

And then, we're gonna need forms, so from.import forms.

All right, let's get started with our views, and I'm gonna bump

this up a little bit just so that I know this is above the closed captioning.

All right, cool.

So first let's make a view for creating a quiz.

So first of all we'll mark it as login_required and

then let's call this quiz_create, pretty explanatory title there.

It's gonna take the request and we wanna get the course_pk.

We wanna know what course this quiz belongs to.

And so of course first we wanna get the course that it belongs to.

So we'll do a get_object_or_440, you should remember this from Django basics,

models.Course and the pk of that should be the course_pk.

And then just like with our suggestion view,

we wanna make a form that's just blank, so forms.QuizForm.

So there's just nothing in there, so cool, simple enough, right?

So if request.method is equal to POST,

so somebody has posted our form, then we wanna do a new version of the form.

And we wanna say request.POST.

I gotta spell it and capitalize it correctly.

And now if that new form is valid, then we're gonna do,

this is a little bit different.

We're gonna make a new variable, called quiz, and we're gonna say form.save.

So normally, if we were to just close this right there, it just saves a new

instance of the quiz in the database, but we're missing something.

We don't have the quiz associated with the course.

So, we need to do that.

So what we're gonna do is we're gonna do form.save and we're say commit=False.

I kinda wish this was named a little differently but

I don't know what I would name it.

But commit normally is true, commit=False means

don't actually put this in the database, just make the model instance for me.

So make the model, hold to it in memory, don't actually do anything with it.

Let me modify some stuff and then we'll save it directly in a moment.

So now we have quiz which is just a quiz instance.

So let's do quiz.course is equal to the course that we

got up at the top there and then let's do quiz.save.

And you know what for, let's just do messages.add_message,

request, message.SUCCESS.

And we'll just say, Quiz added!

I'm a big fan of exclamation marks if you hadn't noticed.

And then we'll return HttpResponseRedirect and

we just wanna go back to the quiz, get_absolute_url.

We don't need reverse at this point.

All right, and so, out here,

if it's not a post, you can do else, if you want, but you don't have to.

Out here, we're just gonna do return render (request,

'courses/quiz_form.html', and

{'form': form}).

All right, so let's go make our template and our URL,

just to make sure we got everything done correctly.

Let's go do URLs first.

So if we come over here to our URLs, and

we wanna put in an edit quiz one, or create quiz one, sorry.

So, URL and let's see,

r and then ?P, there we go,

course_pk would be \d+ just like we had before,

and then we'll say create_quiz and

this will go to views.quiz_create, and we'll give it a name of create_quiz.

Easy enough.

All right, and then for templates inside courses here,

we said we were gonna call it quiz_form.

Ideally, we'll get to use the same template for

both creating a quiz and editing a quiz.

So let's see what that should look like.

So this should be extends course/layout.html.

And then we should have block content,

div class="row".

And then inside of there, we wanna do this.

And let's just say, Make a new quiz, and

then form method="POST" and action= nothing.

And then inside there let's do our

csrf_token and then our form.as_p,

and then our input type="submit"

class="button" value="Save".

All right, cool.

And then we need to end our block.

And I think there's actually something, if we come look at text_detail, yeah,

we've got a couple of extra things here, let's bring those in.

This is stuff that's just inside the templates,

I'll let you look through all this if you want.

Let's send that quiz back out.

[SOUND] Or, sorry, not the quiz, the course.

All right, there we go.

So then here, we can say

New Quiz cuz for now it is.

And we can say course.title and block.super.

And that right there, that will let us have a link back to the course.

And it looked like this was supposed to be columns.

And, if I remember correctly, we need to do block.super right here.

All of this is just design details,

you don't have to worry about doing all of this stuff.

So let's add here, on this course detail, let's add a link for adding a new quiz.

So if we come over here and we look at our course detail,

down here at the bottom, let's do if user.is_authenticated

which just checks to make sure that someone is logged in.

And then we'll end our if.

Let's do an hr and then a href= url 'courses:create_quiz',

course_pk would equal step.,

actually I think we have, yeah,

we have course, course.pk, course.id.

And then let's say class="button".

And let's just say New Quiz.

All right, so if we refresh this, cool,

there's our new quiz button, let's click new quiz yep.

Courses.

Cool, bam, make a new quiz, and there's our thing.

Awesome, we should be able to send this through and make a new quiz, so

let's make a new quiz, and we'll just say Review: Strings.

Let's talk about strings.

And it's gonna have five questions, and the order is gonna be three.

Hit Save, and we get to see the Review: Strings.

We get Quiz added.

And if we look at Python Basics, now we have Review: Strings right here, and

we can click on Review: Strings.