We've learned a lot about the built in tools that Django ships with,

but sometimes you need something even more custom.

Sometimes it's time to DIY your own template tag.

Just like you can create templates that you can include on the fly in

other templates, you can also write template tags

that you can plug in to templates that will render information.

For example, if you always wanted to display the newest items added to a store

or the top-rated game, you can write a custom tag that will dynamically

figure out what the newest or best item is and display that for you.

That's exactly what we're going to do in this video.

We're going to write a custom template tag that will always display the newest

course available at the top of the page, so people who come to our site frequently

can easily find courses they might not have seen before.

So let's get started.

Template tags are a little special in that they have to live in their own directory

called, templatetags.

So, we created a new directory in our courses app, called templatetags.

Don't forget that in order for Python to recognize template

tags as a Python package, we had to add an empty init.py file.

So we created a new file and saved it as __init__.py.

Then we created a second file in which we will write our custom tags and filters.

We called that course_extras.py, since these are the extra tags for

the course's app.

Now we're ready to get started.

Since this is a template tag, we need to import the template module from Django.

That's because the template module contains the function we need to register

our template.

When you register your template tag, what you're doing is making it available to

Django's template language so you can use it.

So let's go ahead and create a variable called register,

that calls the class we'll need later, and save ourselves some typing.

So register equals template.library.

This is basic Python code, but let's review what we just did.

We instantiated an instance of the library class located in the template library and

named that instance register.

Okay, now we're ready to start writing our template tag.

A template tag is just a function that does a specific thing and

you can plug it into your template using regular template syntax.

Like all functions, it needs to be defined.

And then we can add a nice doc string to let us know what this function does.

So it gets the most recent course that was added to the library.

Now, we need to create our query.

We know we want to return the latest course from the course model so

we can use a method called latest to get at that like so.

We have to pass in the field in the model that we want latest to pay attention to.

In this case, we're concerned with the creation date, so

we used the created_at field to get the latest course.

Now, do you see what I see?

We're using the course model, but we haven't imported it yet.

So let's add that to our import statement.

From courses.models import Course.

The last thing we need to do is register our tag.

There are a few different kinds of custom template tags, and

we'll go over those later.

This one is a simple tag, which returns its result as a string.

There are two different ways to register your tag.

There's the long way.

Register.simple_tag and then you feed in

the name of your tag, and that works fine, we just add it right below our function.

But there's a shorter and slightly cleaner way to do this.

We can use a decorator right before our function and

then we don't have to feed in anything.

Now in order for our template tag to show up,

we have to let the template we're dropping it into know that it exists.

Just like you have to use the extends tag to say this template will extend that

other template, and you use the load tag to say I want to load the static files.

You can also use the load tag, to load your template tags into a template, and

make them more accessible to that template.

We want this tag to appear in our layout.html template,

so let's open that up.

We add the load tag to the top of the page.

Load course_extras,

and now we can use our template tag to get the most recent course.

So right here before the block content, we add a p tag and it can say,

don't miss our latest course and then we just drop in our tag.

Now let's start our server.

So we can change directories into our learning site and

then run python manage.py runserver.

And now here at the top we can see don't miss our latest course, Python Testing.

You might be wondering why we created this as a tag instead of just

getting this information in the view and passing it in through the template.

And we could have done that.

But using the template tag for this makes the code more reusable.

Once we've written that tag,

we don't have to perform the work of calling the function,

returning the value, and adding the template variable where we want it.

We just drop the tag in and we're done, easy huh?

You can also create template tags that take context, for example, that take

a string and use it to look something up or that transform it in some way.

We'll get to that in a later video.