In the last video we turned our existing step model into an abstract model and

then created a text model that inherited from step.

Thanks to djangos migrations we didn't even lose any of our data

just moved it to another table.

We need a new kind of step though we have text steps but

we want to be able to make sure people are learning what we're teaching so

we should provide some sort of testing mechanism.

Let's make quizzes.

So we want to make another type of step, I want to make a quiz step.

So we're gonna come down here, and we're gonna add a new

class named Quiz, which will be a step.

And let's get the content into the quiz.

And quizzes won't have content like a text step will.

I think the only thing we want to know for quizzes,

we want to know that a quiz has enough questions.

So let's have a total_questions field.

And we'll do that.

And you know what, let's give it a default of we'll say 4.

It has to have at least four questions.

Not terrible all right so now let's go ahead and migrate that oops I have

to spell default correctly all right let's go ahead and make the migrations for that.

Python manage.py make migrations courses.

And that's gonna create the quiz model python manage.py

migrate courses that's going to apply the migration so

cool now we have those and let's stick it into the admin.

So we'll import quiz and let's just register it,

like I said before, this inline is not going to

make less and less sense as we go along.

So, we probably want to strip that out and just use these registered things, or

build what we're gonna build in a little bit, but, let's go back over here and

let's go look at course.

Oops, sorry, I've got to run my server.

There's the server.

All right, refresh.

And now we have Q-U-I-Z-S.

That is not at all how you pluralized the word quizzes.

Jango doesn't know how to pluralize the word quizzes.

Jango just adds an S to the end of everything.

So let's tell it how to do that.

class Meta: verbose_name_plural would be Quizzes.

Save that.

Refresh this.

And now quizzes is spelled correctly.

That's a handy little trick to know.

Depends on how much you use the admin.

But being able to quickly go,

that's not what that's actually called is really useful.

This is also a thing that you can apply internationalization for.

You can apply translations, too.

So if you need to have it in the French version and the German version and

the English version or whatever, you can totally do that too.

All right, so now the other thing we need to do to make our new models all happy and

copacetic Is we need to be able to view those on the front of the site.

So like if we go to courses and 1,

we got Python Basics, none of our stuff is showing up now.

Make sure we have it all in there, cuz we should, right?

Yeah, okay.

So let's go look at our views real quick.

There's our course detail, and that sends our course through.

And we go look at our Templates > Courses

> step_detail, that's what we want,

oh not step_detail sorry, course_detail.

And step_set see there's a problem.

We don't have a step_set anymore.

We need to get all of our stuff.

So let's come here, and let's add in

our view, we're gonna have to do a little Pythony things here.

I'll do my best to walk through all of this, but

I will also put notes in the teacher's notes.

So we're gonna import a function called chain.

And let's just do from.importmodels which

means we'll have to do some updates here models.

Models dot but that's gonna change.

Right?

So we're gonna ignore this view for right now.

But let's just look here at this course detail.

So what we wanna do is we wanna get all the steps, quizzes and

text that relate to a course.

And we want to combine all those so that they're sorted by their order attribute.

So we're gonna call this steps and it's gonna be sorted,

which sorted is a Python function for sorting things.

And what we're going to sort is the chain, or the combination of all these iterables.

And we're gonna do course.text_set.all and

course.quiz_set.all.

So what chain does is it goes through and it takes the first thing,

it takes all the things from text set and it takes all the things from quiz set and

it puts them all into one big iterable together.

And then sorted goes through and

sorts all those by whatever we tell it to sort it by, which is gonna be this.

Key, which is a lambda, or an unnamed function for a step, and we're gonna sort

it by, you know what, let's call it step, and we're gonna say step.order.

So whatever that order is on each thing.

All right and then we're gonna send out course, but let's also send out steps.

We'll call that steps.

All right, I know that's a lot of Python, we will handle all of that really soon.

And let's go a step further here and we're gonna say text_detail.

We'll leave that the same, but we'll call this text, cuz that's what it is.

And then let's do def quiz_detail.

I copied all that right, yeah, there we go.

Quiz_detail, and we're gonna get models.Quiz.

And I'm gonna do some updates on this HTML in between here and

the next video, but we'll talk about the rest of that in just a second.

So we have those two.

Let's go to urls.py, and let's take our step_detail here.

And what we wanna do is we wanna do a t, and

this is gonna go to text detail, name will be text, sure.

Then we'll do a q, and quiz detail, and this will be called quiz.

And the reason we're doing this is because I want to be able to show you,

Oh we have to update that template.

Not this one, but this one.

And we'll say for step in steps.

And this will have to be, We can't.

See we can't fill this out.

So let's fix that.

Let's go over here to our models.py.

And what we need to do, is we need to bring in our reverse function.

So, from Jango.core.URLresolvers.

Import reverse, and then for text and

quiz we both need to specify a new method named get absolute_url.

And what this does is we return a url, or a url string rather.

So, we're gonna return reverse ('courses:text'

cuz that's the name of our url.

And we're gonna specify the kwargs.

So the kwargs are course_pk, which is equal to self.course.

And you can do course.pk, or you could do self.course.id, which requires

one less lookup as far as the database goes, so kind of handy to do that.

And then step_pk, which'll be self.id or self.pk.

We'll do self.id.

And let's just copy this.

Cuz there's no reason to type it again if I don't have to.

Paste it in.

Gonna add another blank line.

And instead of courses:text it'll be courses:quiz.

So there's our two URL's, and in course detail right here instead of spelling out

all of that, step.get_absolute_url.

And if we come over here and refresh our page, there's our steps.

That was a lot of work, I know.

We added the quiz model, we did this chaining and sorted thing.

Which I'll walk through that in the teacher's notes.

And then we also had to add the reverse URL kind of thing.

The get URL thing.

These are all steps that you're going to do a lot when you're dealing with models,

especially abstract or multi-table inheritance models in Jango.

That verbose name plural is really handy for

making things read a little nicer in the admin.

We're not going to spend much time in the admin in this course though.

Okay, let's go make two more models, one for questions and one for answers.