What to do in those strange situations where you need to use an instance's method, which needs at least one argument, in the template? You can't always generate the values from the views.py and send them in variables, imagine a for loop where you need to get it.
The easy way to do it is using Django filters.
Three solutions. Pick the one that fits your needs.
There are three solution presented in this article:
1. calling one method only which requires one argument;
2. calling one method only which requires more string/int arguments;
3. calling any method which requires one or more arguments.
The no argument case is a simple {{ instance.method }} call, so there is no point discussing it.
To illustrate our examples, we'll use the following model and call the template_call() method:
from django.db import models
class SomeObject(models.Model):
some_field = models.TextField()
def template_call(self, *args):
""" this is the method that will be called """
return ", ".join(args)
Calling one method only which requires one argument
The simplest case. We only need to call one method which requires only one argument. A normal filter is enough since we can hardcode the method's name in it and send the attribute as a parameter:
#template_filters.py
from django import template
register = template.Library()
@register.filter
def test_simple_template_call(instance, args):
"""
allows only one argument for one exact method
"""
return instance.test_template_call(args)
# template usage
{{ instance|test_simple_template_call:"value1" }}
# output
value1
Calling one method only which requires more string/int arguments
This approach is similar to the one before, the difference is that the arguments will be passed as key=value pairs separated by '&'. To resolve them, we will use the same class Django uses to parse query strings out of URL's, since it is the same structure.
#template_filters.py
from django.http import QueryDict
@register.filter
def test_advanced_template_call(instance, args):
"""
allows more arguments like a query dict:
var_name=value&var_name2=value
"""
qd = QueryDict(args)
return instance.test_template_call(*qd.values())
# template usage
{{ instance|test_advanced_template_call:"var_1=value1&var_2=value2" }}
# output (note the values order)
value2, value1
Calling any method which requires one or more arguments
This is the complex one. You can send any number of arguments and specify which method to call. For this to happen we need not one, but two filters: one to set the arguments in the instance's attributes and one to name the method. The order the filters are called is essential: first the arguments and then the method.
#template_filters.py
@register.filter
def template_args(instance, arg):
"""
stores the arguments in a separate instance attribute
"""
if not hasattr(instance, "_TemplateArgs"):
setattr(instance, "_TemplateArgs", [])
instance._TemplateArgs.append(arg)
return instance
@register.filter
def template_method(instance, method):
"""
retrieves the arguments if any and calls the method
"""
method = getattr(instance, method)
if hasattr(instance, "_TemplateArgs"):
to_return = method(*instance._TemplateArgs)
delattr(instance, '_TemplateArgs')
return to_return
return method()
# template usage
{{ instance|template_args:"value1"|template_args:"value2"|template_args:"value3"|template_method:"test_template_call" }}
# output
value1, value2, value3
With all this filters, you can choose the one that best fits your needs without over doing it.
Category:
Django
Tagged as:
django
template tag
1 Comment
