CODEWITHSUNDEEP
djangodjango-templates
Xun Yang
Xun Yang

Reputation: 4419

django: using blocks in included templates

I have some html structures that are reused in quite a few different places. It's different from a overall template so I can't extend it, it can also be used to contain complicated content so I don't think defining it as a template tag does a good job. Below is some pseudo code describing my desired outcome, when using template_level2.html you can easily put stuff into the reusable_pattern_template by calling the block inside it. If I do use this code, what you write in 'actual content' of template_level_2.html wouldn't show up. How should I deal with this?

base.html

<html>
<head></head>
<body>
{% block content %}{% endblock %}
</body>
</html>

template_level1.html

{% extends 'base.html' %}
{% block content %}
  Something here...
  {% include 'reusable_pattern_template.html' %}
  Something else here...
{% endblock %}

reusable_pattern_template.html

<div>
  <div>
    <div>
      {% block local_content %}{% endblock %}
    </div>
   </div>
</div>

template_level2.html

{% extends 'template_level1.html' %}
{% block local_content %}
  Actual content here...
{% endblock %}

update: Sorry, the extends in template_level2.html has some misspelling, I've just corrected it.

It may not be very clear, but the code above is more of a pseudo code describing my desired outcome. In short,

Upvotes: 58

Views: 51394

Answers (7)

AIM
AIM

Reputation: 1

I understand what you want to do, however, Django does not process blocks in included files... I have a "dirty" solution for you:

Let's suppose you have: initial_state

This won't be possible since constants.html won't be processed into a new about.html, which will be processed into base.html...

The "dirty" solution: possible_solution

With this, you can re-use the same block as many times as you want, however you will create a new file for each of them...

Upvotes: 0

ScriptKiddieOnAComputer
ScriptKiddieOnAComputer

Reputation: 984

Not the exact thing but you can do this (I've used it for including navigation bars):

Use with and only

snippet.html:

<div>
  {{ listItem1 }}{{ listItem2 }}...{{ listItemN }}
</div>

index.html:

{% include 'snippet.html' with listItem1='<li>HOME</li>' listItem2 ='<li>ABOUT</li>' only %}

Since, we have used only after listItem2, all further variables will be ignored.

Upvotes: 0

Josh
Josh

Reputation: 2518

In short, you can create variables in whichever template you're planning to include e.g.

{{ localcontent }}

and then assign those variables wherever you include the template e.g.

{% include "name_snippet.html" with localcontent="Actual content" %}

Upvotes: 3

hwjp
hwjp

Reputation: 16091

I came across this problem and ended up with the following compromise, hoping someone else might find it useful. It relies on using with blocks in the child templates.

base.html wants to reuse a common nav.html include, but define some blocks where variables inside nav.html might be overriden by child templates.

<!-- base.html: -->
<html>
  [...]
  <nav class="desktop">
    {% block desktop_nav %}
      {% include "includes/nav.html" %}
    {% endblock %}
  </nav>
  [...]
  <nav class="mobile">
    {% block mobile_nav %}
      {% include "includes/nav.html" %}
    {% endblock %}
  </nav>
  [...]

The include template depends on a variable called selected, which base.html does not define, by default:

<!--includes/nav.html:-->
<a href="/about/" class="{% if selected == 'about' %}selected{% endif %}">About</a>
<a href="/people/" class="{% if selected == 'people' %}selected{% endif %}">People</a>
<a href="/contact/" class="{% if selected == 'contact' %}selected{% endif %}">Contact</a>

But child pages can override that value as follows:

<!--about.html:-->
{% extends "base.html" %}
{% block desktop_nav %}{% with selected='about' %}{{ block.super }}{% endwith %}{% endblock %}
{% block mobile_nav %}{% with selected='about' %}{{ block.super }}{% endwith %}{% endblock %}

so, not perfect, I still have to have two separate blocks and use those with blocks twice, but it does allow me to override variables in include blocks from the parent template.

Upvotes: 13

Gordon Wrigley
Gordon Wrigley

Reputation: 11785

You could split reusable_pattern_template into begin and end templates. Then in level1 you can go include begin, block, include end.

Alternatively you could pass a template name into reusable_pattern_template as a context variable and then include it in reusable_pattern_template. This will require changing the relationship between level1 and level2 in your example but is generally more powerful.

Upvotes: 0

Umur Kontacı
Umur Kontacı

Reputation: 35478

It seems that the final template is trying to extend itself (if it was in quotes).

You really don't need that much of complexity. It's actually pretty much simpler.

The base template should hold the skeleton of your template, then you can extend it to make customizations. For reusable code blocks that you don't want to include in your every view, include them where appropriate but don't use any block, extends or include statement within the included file. Django will not parse those but the context variable passed from the view can still be used.

Upvotes: 5

Chris Pratt
Chris Pratt

Reputation: 239470

Django does not process blocks in included files.

The include tag should be considered as an implementation of "render this subtemplate and include the HTML", not as "parse this subtemplate and include its contents as if it were part of the parent". This means that there is no shared state between included templates -- each include is a completely independent rendering process. (Django template tag documentation)

Upvotes: 73

Related Questions