0001-general-extract-placeholder-details-from-templates-i.patch

Frédéric Péters, 13 octobre 2017 10:52

Voir les différences: en ligne côte à côte

Subject: [PATCH] general: extract placeholder details from templates instead
 of settings (#18925)

 combo/data/models.py                               | 32 ++++++++++++++
 combo/manager/views.py                             | 30 ++++++-------
 combo/public/templates/combo/page_template.html    |  8 ++--
 .../templates/combo/page_template_sidebar.html     |  8 ++--
 combo/public/templatetags/combo.py                 | 13 +++++-
 combo/public/views.py                              | 15 +++----
 combo/settings.py                                  | 50 +---------------------
 .../gadjo/templates/combo/page_template.html       |  3 +-
 .../templates/combo/page_template_sidebar.html     |  8 ++--
 tests/test_pages.py                                | 23 ++++++++++
 10 files changed, 107 insertions(+), 83 deletions(-)

         return len(set(page_groups).intersection(user.groups.all())) > 0
     class Placeholder(object):
         def __init__(self, key, name=None, internal=False, acquired=False):
             self.key = key
             self.name = name
             self.internal = internal
             self.acquired = acquired
     class PageManager(models.Manager):
         def get_by_natural_key(self, path):
             parts = [x for x in path.strip('/').split('/') if x] or ['index']
-...
         def get_template_display_name(self):
             return settings.COMBO_PUBLIC_TEMPLATES[self.template_name]['name']
         def get_placeholders(self, template_name=None):
             placeholders = []
             page_template = settings.COMBO_PUBLIC_TEMPLATES.get(template_name or self.template_name)
             if page_template.get('placeholders'):
                 # manual declaration
                 for key, options in page_template['placeholders'].items():
                     placeholders.append(Placeholder(key=key, **options))
                 return placeholders
             template_name = settings.COMBO_PUBLIC_TEMPLATES.get(self.template_name).get('template')
             tmpl = template.loader.select_template([template_name])
             request = RequestFactory().get(self.get_online_url())
             request.user = None
             context = RequestContext(request, {
                 'page': self,
                 'request': request,
                 'synchronous': False,
                 'placeholder_search_mode': True,
                 'placeholders': placeholders,
             })
             tmpl.render(context)
             return placeholders
         def get_next_page(self, user=None):
             pages = Page.get_as_reordered_flat_hierarchy(Page.objects.all())
             this_page = [x for x in pages if x.id == self.id][0]

         def form_valid(self, form):
             response = super(PageAddView, self).form_valid(form)
             if self.object.slug != 'index' or self.object.parent_id:
                 combo_template = settings.COMBO_PUBLIC_TEMPLATES.get(self.object.template_name)
                 for placeholder_key, placeholder in combo_template['placeholders'].items():
                     if placeholder.get('acquired') is True:
                         ParentContentCell(page=self.object, placeholder=placeholder_key, order=0).save()
                 for placeholder in self.object.get_placeholders():
                     if placeholder.acquired is True:
                         ParentContentCell(page=self.object,
                                 placeholder=placeholder.key, order=0).save()
             return response
-...
             new_template_name = self.object.template_name
             response = super(PageSelectTemplateView, self).form_valid(form)
             if old_template_name != new_template_name:
                 old_template = settings.COMBO_PUBLIC_TEMPLATES.get(old_template_name)
                 new_template = settings.COMBO_PUBLIC_TEMPLATES.get(new_template_name)
                 old_placeholder_keys = [x.key for x in self.get_object().get_placeholders()]
                 page_cells = CellBase.get_cells(page_id=self.object.id)
                 for placeholder_key, placeholder in new_template['placeholders'].items():
                     if not placeholder.get('acquired') is True:
                 for placeholder in self.object.get_placeholders(new_template_name):
                     if not placeholder.acquired:
                         continue
                     if placeholder_key in old_template:
                     if placeholder.key in old_placeholder_keys:
                         continue
                     if [x for x in page_cells if x.placeholder == placeholder_key]:
                     if [x for x in page_cells if x.placeholder == placeholder.key]:
                         # skip placeholders that already have cells
                         continue
                     ParentContentCell(page=self.object, placeholder=placeholder_key, order=0).save()
                     ParentContentCell(page=self.object, placeholder=placeholder.key, order=0).save()
             return response
     page_select_template = PageSelectTemplateView.as_view()
-...
             placeholders = []
             combo_template = settings.COMBO_PUBLIC_TEMPLATES.get(template)
             for placeholder_key, placeholder in combo_template['placeholders'].items():
             for placeholder in self.object.get_placeholders():
                 placeholder_dict = {
                     'key': placeholder_key,
                     'name': placeholder['name'],
                     'key': placeholder.key,
                     'name': placeholder.name,
+                }
                 placeholder_dict['cells'] = [x for x in cells if (
                     x.placeholder == placeholder_key)]
                 placeholder_dict['cells'] = [x for x in cells if x.placeholder == placeholder.key]
                 placeholders.append(placeholder_dict)
             context['placeholders'] = placeholders

     {% load combo gadjo %}<!DOCTYPE html>
     {% load combo gadjo i18n %}<!DOCTYPE html>
     <html>
      <head>
       <meta charset="utf-8"/>
-...
       {% endblock %}
       {% block combo-content %}
       {% placeholder "content" %}
       {% trans "Content" as name %}
       {% placeholder "content" name=name %}
       {% endblock %}
      </div>
      <div id="footer">
       {% block footer %}
         {% placeholder "footer" %}
         {% trans "Footer" as name %}
         {% placeholder "footer" name=name acquired=True %}
         {% skeleton_extra_placeholder footer %}
         <span style="display: none">{% now "Y-m-d H:i:s" %}</span>
         {% end_skeleton_extra_placeholder %}

     {% extends "combo/page_template.html" %}
     {% load combo %}
     {% load combo i18n %}
     {% block combo-content %}
     <div id="main-content">
     {% placeholder "content" %}
     {% trans "Content" as name %}
     {% placeholder "content" name=name %}
     </div>
     <div id="sidebar">
     {% placeholder "sidebar" %}
     {% trans "Sidebar" as name %}
     {% placeholder "sidebar" name=name %}
     </div>
     {% endblock %}

     from django.template.base import TOKEN_BLOCK, TOKEN_VAR
     from django.utils import dateparse
     from combo.data.models import Placeholder
     from combo.public.menu import get_menu_context
     from combo.utils import NothingInCacheException
     from combo.apps.dashboard.models import DashboardCell, Tile
-...
             placeholder_name, placeholder_name, content)
     @register.inclusion_tag('combo/placeholder.html', takes_context=True)
     def placeholder(context, placeholder_name):
     def placeholder(context, placeholder_name, **options):
         if context.get('placeholder_search_mode'):
             context['placeholders'].append(Placeholder(key=placeholder_name, **options))
             return context
         context['cells'] = [x for x in context.get('page_cells', []) if
                 x.placeholder == placeholder_name and
                 (context.get('render_skeleton') or x.is_relevant(context))]
-...
             context['skeleton'] = ''
         return context
     @register.simple_tag(takes_context=True)
     def placeholder_option(context, **options):
         placeholder = context['placeholders'][-1]
         for option in options:
             setattr(placeholder, option, options.get(option))
         return context
     @register.simple_tag(takes_context=True)
     def render_cell(context, cell):
         if context.get('render_skeleton') and cell.is_user_dependant(context):

             # add default ParentContentCells to the page
             cells = []
             combo_template = settings.COMBO_PUBLIC_TEMPLATES[selected_page.template_name]
             for placeholder_key, placeholder in combo_template['placeholders'].items():
                 if placeholder.get('acquired') is True:
                     cells.append(ParentContentCell(page=selected_page, placeholder=placeholder_key, order=0))
             for placeholder in selected_page.get_placeholders():
                 if placeholder.acquired:
                     cells.append(ParentContentCell(page=selected_page, placeholder=placeholder.key, order=0))
         else:
             cells = CellBase.get_cells(page_id=selected_page.id)
-...
             self.page.template_name = self.template_name
             self.page.save()
             combo_template = settings.COMBO_PUBLIC_TEMPLATES[self.page.template_name]
             for i, placeholder in enumerate(combo_template['placeholders'].keys()):
                 cell = TextCell(page=self.page, placeholder=placeholder, order=0)
                 if placeholder == 'footer':
             for i, placeholder in enumerate(self.page.get_placeholders()):
                 cell = TextCell(page=self.page, placeholder=placeholder.key, order=0)
                 if placeholder.key == 'footer':
                     cell.text = '<p>%s</p>' % lorem_ipsum.sentence()
                 else:
                     cell.text = '<h2>%s</h2>%s' % (
-...
                 if i == 0:
                     # add a template selector in first placeholder
                     cell = TextCell(page=self.page, placeholder=placeholder, order=1)
                     cell = TextCell(page=self.page, placeholder=placeholder.key, order=1)
                     options_html = []
                     for template_key, template_dict in settings.COMBO_PUBLIC_TEMPLATES.items():
                         attr = 'value="%s"' % template_key

         'standard': {
             'name': _('One column'),
             'template': 'combo/page_template.html',
             'placeholders': {
                 'content': {
                     'name': _('Content'),
                 },
                 'footer': {
                     'name': _('Footer'),
                     'acquired': True,
                 },
+            }
         },
         'standard-sidebar': {
             'name': _('One column + sidebar'),
             'template': 'combo/page_template_sidebar.html',
             'placeholders': {
                 'content': {
                     'name': _('Content'),
                 },
                 'sidebar': {
                     'name': _('Sidebar'),
                 },
                 'footer': {
                     'name': _('Footer'),
                     'acquired': True,
                 },
+            }
         },
         'two-columns': {
             'name': _('Two columns'),
             'template': 'combo/page_template_2cols.html',
             'placeholders': {
                 'content': {
                     'name': _('Left Column'),
                 },
                 'right': {
                     'name': _('Right Column'),
                 },
                 'footer': {
                     'name': _('Footer'),
                     'acquired': True,
                 },
+            }
         },
         'two-columns-sidebar': {
             'name': _('Two columns + sidebar'),
             'template': 'combo/page_template_2cols_sidebar.html',
             'placeholders': {
                 'content': {
                     'name': _('Left Column'),
                 },
                 'right': {
                     'name': _('Right Column'),
                 },
                 'sidebar': {
                     'name': _('Sidebar'),
                 },
                 'footer': {
                     'name': _('Footer'),
                     'acquired': True,
                 },
+            }
             # get those labels into gettext catalog
             '_': (_('Left Column'), _('Right Column')),
         },
+    }

     {% block content %}
     <div id="portal-agent-content">
     {% block combo-content %}
     {% placeholder "content" %}
     {% trans "Content" as name %}
     {% placeholder "content" name=name %}
     {% endblock %}
     </div>
     {% endblock %}

     {% extends "combo/page_template.html" %}
     {% load combo %}
     {% load combo i18n %}
     {% block bodyargs %}{{ block.super }} class="with-sidebar"{% endblock %}
     {% block combo-content %}
     <div id="page-content">
     {% placeholder "content" %}
     {% trans "Content" as name %}
     {% placeholder "content" name=name %}
     </div>
     {% endblock %}
     {% block after-main-content %}
     <div id="sidebar">
     {% placeholder "sidebar" %}
     {% trans "Sidebar" as name %}
     {% placeholder "sidebar" name=name %}
     </div>
     {% endblock %}

     from django.conf import settings
     from django.contrib.auth.models import User, Group
     from django.test import override_settings
     from django.utils.timezone import now
     from combo.data.models import Page, CellBase, TextCell, LinkCell
     from combo.data.management.commands.import_site import Command as ImportSiteCommand
-...
         TextCell.objects.filter(pk=cell.id).update(last_update_timestamp=future_time)
         assert page.get_last_update_time() == future_time
     def test_get_placeholders():
         page = Page(title=u'foo', slug='foo', template_name='standard-sidebar', order=0)
         placeholders = page.get_placeholders()
         assert [x.key for x in placeholders] == ['content', 'sidebar', 'footer']
         assert placeholders[0].acquired is False
         assert placeholders[-1].acquired is True
         with override_settings(COMBO_PUBLIC_TEMPLATES={
                 'standard-sidebar': {
                     'name': 'Test',
                     'template': 'combo/page_template_sidebar.html',
                     'placeholders': {
                         'content': {'name': 'Content'},
                         'content2': {'name': 'Second Content'},
                         'sidebar': {'name': 'Sidebar'},
                         'footer': {'name': 'Footer', 'acquired': False},
                         }}}):
             placeholders = page.get_placeholders()
             assert set([x.key for x in placeholders]) == set(['content', 'content2', 'sidebar', 'footer'])
             footer_placeholder = [x for x in placeholders if x.key == 'footer'][0]
             assert footer_placeholder.acquired is False
+    -

Projet

Général

Profil

Produits Entr'ouvert » Combo

0001-general-extract-placeholder-details-from-templates-i.patch