We have courses, but each curse should have steps to it.

Maybe it will be videos, or maybe it'll be text based steps, or

images, whatever method you want to teach with.

Since I don't know what your step of choice will be and

we're not gonna deal with video or image uploads.

We'll just call them steps.

Anyway, let's get to it.

So since steps are a logical part of our courses, we'll keep them in the same app.

So let's close some of this stuff up again.

It gets a little unwieldy at times.

So inside courses, inside models.py, we're gonna add our new model.

And we'll say class Step(models.Model).

So what goes into a step?

Well I think a title deserves to be there.

And this will again be a char field of,

255 characters or less.

I think we would have a description just like our course would be.

So so far a step and a course are the same thing just the created app.

I think we would have an order field,

so that we could specify what order different fields come in.

And we'll set the default on this as zero, and then let's do a course,

and this will be a foreign key, and this will link back to course.

And since we know we're going to print these out eventually,

let's do return self.typo.

Okay, so there's a lot here, the first two items should be pretty familiar from our

course model, they're exactly the same.

The last two items though are new, and I briefly went over them but

let's talk about them a bit more.

Order lets us control the order of steps.

Maybe we forget to create a step and we have to create it later.

This way, we can add a new one, and we can set where it should be in the order.

Setting it to zero makes it so

we can set other numbers to control the ordering of steps later.

There are other solutions to this.

you could have them auto-increment.

You could set them at a negative, like, there's different ways to do this.

Zero is a pretty safe default.

That we ordered automatically by their ID, and

then we'll handle the other ordering later.

And then, the course attribute is a foreign key.

And a foreign key is a record or a column that points to a record in another table.

Can be on the same table, but for now it's in another table.

So, what we're doing is we're saying, hey here's this step.

And maybe this is a step ID of three and it belongs to the course with

an ID of one, so it belongs to that course over there and points to that course.

This way, a single course can have multiple steps, but

each step only has one course.

This is what is known as a one to many relationship, or

we're looking at it from the step side, a many to one.

Many steps belong to one course.

And then of course we have our Dundar STR method,

which will print out the title of the step.

You might want to print out the order but

I'll let you put that in there if you want.

So now that we've made our our model.

Got ahead of myself.

Now that we've made our model, we, of course, have to create a new migration.

You'll do this dance a lot.

You'll make a model, then you'll make a migration,

and then you'll apply the migration.

It might seem monotonous and

time consuming, but it's good to know exactly what's going on behind the scenes.

So, let's do this.

Python manage.py, make migrations for courses.

Hey, we had to make one, cool.

Python manage.py,

migrate courses.

Done. Applies all my migrations.

Okay.

So we've made our model.

We can play with it in the shell if we want to.

But, I think it's easier just to stick it in the admin and

then go mess with it in the admin.

And I bet you agree with me.

So let's run the server again.

And then shrink our terminal down.

And let's go look at admin.py.

And let's import Step and let's copy and paste this line and change Course to Step.

So we've imported it, we've registered it, things are cool right?

Let's go back to our admin and check it out.

/admin, there's our steps, there's our courses.

Okay, so let's go add a step.

So, we'll add a step, give it a title, and we'll say What's the deal with strings?

Strings are more than just a bunch of letters.

Find out why!

Okay, and the courses belongs to, this is course of Pythons basics step.

So let's go ahead and save that.

Cool, now this isn't terrible but

we if we had a lot of courses this might get really difficult.

That drop down, that can take a while to read through and find stuff.

Probably a better way, and you know I wouldn't ask that unless it was true.

Django lets us create smaller forms that represent another model

inside the admin form for a model.

So we can edit and create steps for our courses while we're editing and

creating a particular course.

We need to create two new classes for this to work though.

So let's hop back over to our editor.

I get to do all of them right here inside admin.

So now first we need to make the class for

our smaller form and that's known as an inline.

So we're gonna say class StepInline(admin.StackedInline).

Now there are two types of inlines.

There are stacked inlines and tabular inlines.

We're gonna use the stack version, but feel free to switch over to tabular and

try that out.

And we said our model is equal to step, now that's it.

On it's own, this doesn't do anything, but this creates the inline.

So now We have to make our next thing, which is our course admin.

This is the admin for handling our courses.

This let's us specify custom special things.

So this is (admin.ModelAdmin) and we're gonna set inlines = [StepInline,].

All right, now this is the one thing that's a little bit weird.

When we made this StepInline, we set model = Step.

We didn't set a model on course admin, we do there here.

So we register course, and then we register it with course admin, okay, and

if we want we can delete this, but let's leave it alone for right now.

So let's come over here and look at this again, let's go back to courses.

Courses, and let's look at Python basics because we know it has a step.

Python basics, and look, here's our step.

What's the deal with strings?

Strings are more than just blah blah blah, there's the order.

Here's where we can add a second one, and a third one, and a fourth one, and

if we need to add more we can click add another step.

So that's pretty awesome, we can edit, delete, and

we can add new steps right here in the admin.

There's a lot more that we can do with inlines but this is enough for now.

I've linked to more documentation on them in the teachers notes though, so

feel free to explore them some more on your own