We are almost done with customizing Django templates.

In real world scenarios you'll probably have users pasting long text

descriptions into your admin site using Markdown or another plain text format.

Markdown is what's used on GitHub for example, for read me files.

It allows you to easily type text that will render as html on a webpage, but

in Django you have to do some preparation to get that to happen as expected.

So let's write.

You guessed it, a custom filter for that.

First, we're going to install a Python library called markdown2.

In your console, change directories into learning site and

the run this command, pip install markdown2.

Okay.

Once that finishes running, open up course_extras.py and

add import markdown2 to the top.

Now, just to make sure everything's installed, let's start our server and

load our page.

If we don't get an import error, we know that everything installed correctly.

So we'll do python manage.py runserver,

and then identify our port.

Great.

It looks like we are good to go.

So let's create our function.

We'll put the console down here.

And then down here at the bottom, we'll call our function mark down to html.

And it's going to take an argument,

it'll take a markdown text as an argument.

It will return html, so we'll call what it returns html_body.

It's the stuff in the middle that we need to worry about.

So let's add a dock string, so

that everyone knows what this function is supposed to do.

So, converts markdown text to html.

That's pretty straightforward.

If we look at the documentation for markdown too.

We see that it's pretty simple.

We should be able to just call the mark down method on our passed in text,

and it will do all the processing for us.

I love simple libraries like this that are really powerful, and

do something amazing and useful, but don't require a lot of work on my part.

So let's add that to our function.

So we can say that html body is going to be equal to markdown2.markdown,

and then we pass in our markdown text.

So what this will do, is it will convert our markdown text into html and

store that result in our variable html body, which we then return.

Finally, we need to register our filter, and this is going to be exactly the same

as whenever we registered our time estimate filter.

The only thing we need to change is the name of the filter.

Markdown to html.

There we go.

Can you think of a place in our site where someone might

enter markdown text instead of regular html or plain text?

I can, the course description.

Sometimes those are longer and require some formatting.

So let's create a super user to log into the admin and

replace the current course description with some marked down text.

So down in your consul, stop your server with Ctrl+C.

And then run python manage.py createsuperuser.

I'm going to make my name Lacey, my user name.

And then I'll set my email address to Lacey@teamtreehouse.com.

My password, that's private.

Okay.

Let's restart our server, and

then head into the admin to edit a course description with some markdown text.

So up here in our url we just do /admin and

then we log in using those credentials that we just created.

Here in courses, I'm gonna change Python testing.

So right now it just says, learn to test your Python applications with unittest and

doctests.

I'm gonna replace this with some mark down text that I've created.

And we'll go over what those should do.

Okay. So I've added this header and

this double pound sign means that this line testing is amazing,

should appear inside the header tags.

Then, these next two lines learn to test your Python applications with unitest and

doctest and things you will learn should each show up inside their own P tags.

Then when you put a little dash next to a series of things that are in a list,

in html, this should render as an unordered list.

So now that we've done this, let's scroll down and save.

And let's head back into our course.

When we go to Python Testing,

it looks like those special mark down characters just rendered normally.

They didn't convert.

Oh, but that's because we forgot something important.

We forgot to add this filter that we created to our description, so

let's add that.

We ca go to the course_detail page and then we can just add our new

markdown_to_html filter.

Let's reload.

Oh, invalid filter.

Because up here with this load humanize, we also needed to load our course extras.

Now we can put load course extras on it's own line or

we can just stack it, next to humanize.

So let's do that to save ourselves some time.

Okay, this isn't quite what we expected.

We're seeing the actual html tags instead of the rendered html.

Now this is actually a nice thing that Django is doing for us.

It's Django's way of protecting us from code that might get plugged into our data

and might be malicious.

We just need to tell Django this code is safe,

meaning that it can render this html as html, with no problem.

For that, we can use the safe filter, so

we can chain safe next to markdown to html.

Now, when we reload the page, we get our nice, friendly rendered html.

There's a better way to mark text as safe though.

We should mark our output from the filter as safe, so

that anything that goes through this filter is marked safe and

we don't have to keep using the safe filter over and over again.

So let's import something called mark safe into course extras.

We can lower this console.

Go back up to the top and

from django.utils.safestring we import mark_safe,

and then we'll just pass our output into mark_safe as we return it.

Finally, we can go ahead and delete the safe filter from our variable.

Now when we refresh the page, we have the exact same result,

which is what we wanted.

In the real world, we do a few things differently.

We would probably have the user select the format that they were using to submit

their data, markdown, plain text, or something else, and

we'd use the appropriate conversion filter accordingly.

We would also add that filter to all the text content,

for example, to the step content, as well as to the course content.

But for our purposes, we've proven the concept, and that's enough.