If you've taken customizing Django templates, you might remember writing

a custom filter that estimated how long it would take someone to complete a course,

based on how many words were in the course description.

It's not the most scientific method of estimating time to completion, but

that's fine.

Now we're going to use the same function we wrote in that course

to add a custom attribute to our model that will then display in the admin.

Remember that custom template tags are just regular Python functions, so

we can import that function into another module and use it.

So, let's get started.

Open up course_extras.py.

So you see this function here time_estimate?

This is the function we're going to be using.

Now if you scroll to the top, you'll see that we're all ready importing

the course.models into course_extras, which is great.

We don't wanna change that.

But it makes things a little tricky when we import this function

into our models.py file.

Since we're going to be importing time_estimate from coarse_extras.py into

models.py., but since course_extras.py is all ready importing one of the models,

we would get an error if we added the import statement to the top of models.py.

Basically, we'd be trying to do a recursive import and

Python would be, what?

So instead, let's go into the course model and add our method,

which we will call time_to_complete and

then we'll add the import statement directly inside this method.

This will get us around any sort of recursive import errors that we

might encounter.

So we define time_to_complete and then we add the import statement.

So, from courses.templatetags.course_extras

import time_estimate.

We'll also want to return the result of calling the time_estimate function,

so we can go ahead and add that as well.

Awesome.

Now, remember that time estimate is based on the number of words.

So, we need to pass in the number of words or

the word count of the course description into the time_estimate function call.

Whenever we did this in customizing Django templates,

we got the word count using one of Django's built-in filters.

But in models.py, we don't have access to that.

Instead, we can get out the word count using a combination

of the built in Python functions len and split.

So, we'll just get the length of self.description but

that's just going to give us the character count or the byte count.

So instead, we add split and then that will get us the word count.

So save that, and now all we need to do is add the time to

complete attribute to the list display in our CourseAdmin class.

So, we go into admin.py and right here in the CourseAdmin,

inside the list display variable, we just add time_to_complete.

All right, save that and then start your server,

if it's not all ready started, and refresh your courses list.

And now you see that we have these numbers underneath time to complete, and

remember, these numbers stand in for minutes.

Now, one quick caveat.

When I refreshed mine the first time,

all I got was 0 minutes across the board because our descriptions are so short.

So, I went into a couple of courses, and I replaced the course description with

some sort of fun dessert-themed lorem ipsum text just to bulk up the word

count in the description and illustrate how the time to complete would work.

So feel free to Google, like fun lorem ipsum and

experiment with this for yourself.

But as you can see, a number all by itself like this this random 14 or this 25,

is not super helpful.

It's useful to have the unit of measurement, like the minutes.

And so we can add this to the method on our model to return the minutes.

So, we can return this whole thing as a string.

So, if we go back into models.py and we add some things to this return statement.

So we open up a string and then we add these brackets and

then min and close the string and then we add format and

we enclose the whole rest of this line inside the format call.

And we refresh our page.

Then we have the minutes added so we can see that Ruby Basics takes 14

minutes versus Python testing, which apparently takes no time at all.

That looks a lot better.

Great work.

As you can see, adding custom attributes to your list view

is as easy as writing a little method to bring back the information you need and

then adding it to your admin class.

Now, we've got this handy piece of information at our fingertips.

We could even use this to add an extra filter to this page.

Why don't you try that on your own?