PARAF-512: Converted sub-templates usage view and viewlet to z3c.table and added the merge variable name column

Author: chris-adam

CHANGES.rst

@@ -6,6 +6,8 @@ Changelog
 
 - Removed the duplicated "no value" option of the `style_template` field. (MOD-1080)
   [chris-adam]
+- Converted sub-templates usage view and viewlet to z3c.table and added the merge variable name column. (PARAF-512)
+  [chris-adam]
 
 
 3.49 (2026-07-31)

src/collective/documentgenerator/browser/configure.zcml

@@ -198,6 +198,42 @@
         factory=".table.DownloadColumn"
         />
 
+    <adapter
+        name="SubTemplateColumn"
+        for="zope.interface.Interface
+             zope.interface.Interface
+             .table.SubTemplatesUsageTable"
+        provides="z3c.table.interfaces.IColumn"
+        factory=".table.SubTemplateColumn"
+        />
+
+    <adapter
+        name="SubTemplateUsagePathColumn"
+        for="zope.interface.Interface
+             zope.interface.Interface
+             .table.SubTemplatesUsageTable"
+        provides="z3c.table.interfaces.IColumn"
+        factory=".table.SubTemplateUsagePathColumn"
+        />
+
+    <adapter
+        name="SubTemplateUsageTemplatesColumn"
+        for="zope.interface.Interface
+             zope.interface.Interface
+             .table.SubTemplatesUsageTable"
+        provides="z3c.table.interfaces.IColumn"
+        factory=".table.SubTemplateUsageTemplatesColumn"
+        />
+
+    <adapter
+        name="SubTemplateUsageModelVariableColumn"
+        for="zope.interface.Interface
+             zope.interface.Interface
+             .table.SubTemplatesUsageTable"
+        provides="z3c.table.interfaces.IColumn"
+        factory=".table.SubTemplateUsageModelVariableColumn"
+        />
+
     <!-- batchactions -->
     <browser:viewlet
         zcml:condition="installed collective.eeafaceted.batchactions"

src/collective/documentgenerator/browser/sub_templates_usage.pt

@@ -12,48 +12,11 @@
   <h1 class="documentFirstHeading" i18n:translate="sub_templates_usage_title">Sub-templates usages</h1>
 
   <div id="content-core">
-    <table class="listing" tal:define="entries view/sub_templates_usage">
-      <thead>
-        <tr>
-          <th i18n:translate="sub_template_usage_sub_template">Sub-template</th>
-          <th i18n:translate="sub_template_usage_path">Path</th>
-          <th i18n:translate="sub_template_usage_templates">Using templates</th>
-        </tr>
-      </thead>
-      <tbody>
-        <tal:entry repeat="entry entries">
-          <tr tal:condition="not:entry/groups">
-            <td>
-              <tal:path condition="entry/rel_path">
-                <span tal:content="entry/rel_path">Folder / Sub folder</span> /
-              </tal:path>
-              <a tal:attributes="href entry/sub_template/getURL"
-                 tal:content="entry/sub_template/Title">Sub-template</a>
-            </td>
-            <td colspan="2"><em i18n:translate="sub_template_usage_not_used">not used</em></td>
-          </tr>
-          <tr tal:repeat="group entry/groups">
-            <td tal:condition="repeat/group/start"
-                tal:attributes="rowspan python:len(entry['groups'])">
-              <tal:path condition="entry/rel_path">
-                <span tal:content="entry/rel_path">Folder / Sub folder</span> /
-              </tal:path>
-              <a tal:attributes="href entry/sub_template/getURL"
-                 tal:content="entry/sub_template/Title">Sub-template</a>
-            </td>
-            <td tal:content="group/title_path">Folder / Sub folder</td>
-            <td>
-              <ul>
-                <li tal:repeat="template group/templates">
-                  <a tal:attributes="href template/absolute_url"
-                     tal:content="template/Title">Template title</a>
-                </li>
-              </ul>
-            </td>
-          </tr>
-        </tal:entry>
-      </tbody>
-    </table>
+    <tal:block define="results view/table/values" tal:condition="results">
+      <div id="dg-batch"><tal:batch replace="structure view/table/renderBatch" /></div>
+      <tal:listing replace="structure view/table/render" />
+      <div id="dg-batch"><tal:batch replace="structure view/table/renderBatch" /></div>
+    </tal:block>
   </div>
 
 </metal:main>

src/collective/documentgenerator/browser/table.py

@@ -275,3 +275,101 @@ def getLinkContent(self, item):
             safe_unicode(translate(PMF('Download'), context=self.request)),
             u'%s/++resource++collective.documentgenerator/download_icon.svg' % self.table.portal_url)
         return down_img
+
+
+class SubTemplatesUsageTable(Table):
+    """Table that displays sub-templates and the templates using them."""
+
+    cssClassEven = u'even'
+    cssClassOdd = u'odd'
+    cssClasses = {'table': 'listing nosort sub-templates-usage'}
+
+    batchSize = 200
+    startBatchingAt = 200
+    sortOn = None
+    results = []
+
+    @CachedProperty
+    def values(self):
+        return self.results
+
+
+class SubTemplateUsageTable(SubTemplatesUsageTable):
+    """Usage table variant for the viewlet, where the sub-template is the context."""
+
+    hidden_columns = ('SubTemplateColumn', 'SubTemplateUsageModelVariableColumn')
+
+    def setUpColumns(self):
+        columns = super(SubTemplateUsageTable, self).setUpColumns()
+        return [col for col in columns if col.__name__ not in self.hidden_columns]
+
+
+class SubTemplateColumn(Column):
+    """Column that displays the sub-template."""
+
+    header = _(u'sub_template_usage_sub_template', default=u'Sub-template')
+    weight = 10
+    cssClasses = {'td': 'sub-template-column'}
+
+    def renderCell(self, item):
+        if not item['first']:
+            return u''
+        brain = item['sub_template']
+        link = u'<a href="{0}">{1}</a>'.format(brain.getURL(), escape(safe_unicode(brain.Title)))
+        if item['rel_path']:
+            return u'<span>{0}</span> / {1}'.format(escape(item['rel_path']), link)
+        return link
+
+
+class SubTemplateUsagePathColumn(Column):
+    """Column that displays the path of the templates using the sub-template."""
+
+    header = _(u'sub_template_usage_path', default=u'Path')
+    weight = 20
+    cssClasses = {'td': 'usage-path-column'}
+
+    def renderCell(self, item):
+        if item['group'] is None:
+            return u'-'
+        return escape(safe_unicode(item['group']['title_path']))
+
+
+class SubTemplateUsageTemplatesColumn(Column):
+    """Column that displays the templates using the sub-template."""
+
+    header = _(u'sub_template_usage_templates', default=u'Using templates')
+    weight = 30
+    cssClasses = {'td': 'using-templates-column'}
+
+    def render_template(self, template):
+        """Return the cell content for one template using the sub-template."""
+        return u'<a href="{0}">{1}</a>'.format(template.absolute_url(), escape(safe_unicode(template.Title())))
+
+    def renderCell(self, item):
+        if item['group'] is None:
+            return u'<em>{0}</em>'.format(translate(
+                _(u'sub_template_usage_not_used', default=u'not used'), context=self.request))
+        return u'<ul>{0}</ul>'.format(u''.join(
+            u'<li>{0}</li>'.format(self.render_template(tmpl)) for tmpl in item['group']['templates']))
+
+
+class SubTemplateUsageModelVariableColumn(Column):
+    """Column that displays the variable name used for the sub-template."""
+
+    header = _(u'sub_template_usage_variable', default=u'Model variable')
+    weight = 40
+    cssClasses = {'td': 'pod-context-name-column'}
+
+    def _get_pod_context_name(self, pod_template, sub_template_uid):
+        """Return the 'pod_context_name' under which sub_template_uid is merged in pod_template."""
+        for line in getattr(pod_template, 'merge_templates', None) or []:
+            if line.get('template') == sub_template_uid:
+                return line.get('pod_context_name') or u''
+        return u''
+
+    def renderCell(self, item):
+        if item['group'] is None:
+            return u''
+        return u'<ul>{0}</ul>'.format(u''.join(
+            u'<li>{0}</li>'.format(escape(self._get_pod_context_name(tmpl, item['sub_template_uid'])))
+            for tmpl in item['group']['templates']))

src/collective/documentgenerator/browser/views.py

@@ -2,10 +2,12 @@
 from Acquisition import aq_inner
 from Acquisition import aq_parent
 from collections import OrderedDict
+from collective.documentgenerator.browser.table import SubTemplatesUsageTable
 from collective.documentgenerator.browser.table import TemplatesTable
 from collective.documentgenerator.content.pod_template import IPODTemplate
 from collective.documentgenerator.content.pod_template import MailingLoopTemplate
 from collective.documentgenerator.content.pod_template import SubTemplate
+from collective.documentgenerator.viewlets.sub_template_usage import _sub_template_usage_groups_to_rows
 from collective.documentgenerator.content.style_template import IStyleTemplate
 from collective.documentgenerator.utils import common_prefix_length
 from collective.documentgenerator.utils import get_path_segments
@@ -106,6 +108,8 @@ class SubTemplatesUsage(BrowserView):
     """Overview listing, for each sub-template, the POD templates that use
        it in their 'merge_templates' field, grouped by the path they live in."""
 
+    __table__ = SubTemplatesUsageTable
+
     def sub_templates_usage(self):
         """Return a list of {'sub_template': brain, 'rel_path': unicode, 'groups': [...]}
            entries, one per sub-template (including unused ones), ordered by the
@@ -120,8 +124,8 @@ def sub_templates_usage(self):
             segments = get_path_segments(aq_parent(aq_inner(sub_template)))
             all_segments.append(segments)
             templates = get_pod_templates_using(sub_template)
-            result.append({"sub_template": brain, "segments": segments,
-                           "groups": group_templates_by_path(templates)})
+            result.append({"sub_template": brain, "sub_template_uid": brain.UID,
+                           "segments": segments, "groups": group_templates_by_path(templates)})
         common = common_prefix_length([[seg[0] for seg in segs] for segs in all_segments])
         for entry in result:
             tail = entry.pop("segments")[common:]
@@ -130,6 +134,16 @@ def sub_templates_usage(self):
                                    safe_unicode(e["sub_template"].Title).lower()))
         return result
 
+    def update(self):
+        self.table = self.__table__(self.context, self.request)
+        self.table.__name__ = u"sub-templates-usage"
+        self.table.results = _sub_template_usage_groups_to_rows(self.sub_templates_usage())
+        self.table.update()
+
+    def __call__(self):
+        self.update()
+        return self.index()
+
 
 class DisplayChildrenPodTemplateProvider(ContentProviderBase):
     template = ViewPageTemplateFile("children_pod_template.pt")

src/collective/documentgenerator/tests/test_sub_templates_usage_view.py

@@ -1,5 +1,9 @@
 # -*- coding: utf-8 -*-
 
+from collective.documentgenerator.browser.table import SubTemplateUsageModelVariableColumn
+from collective.documentgenerator.browser.table import SubTemplateColumn
+from collective.documentgenerator.browser.table import SubTemplateUsagePathColumn
+from collective.documentgenerator.browser.table import SubTemplateUsageTemplatesColumn
 from collective.documentgenerator.testing import PODTemplateIntegrationTest
 from plone import api
 from Products.CMFPlone.utils import _createObjectByType
@@ -16,10 +20,27 @@ def setUp(self):
         super(TestSubTemplatesUsageView, self).setUp()
         self.view = self.portal.restrictedTraverse("@@sub-templates-usage")
 
+    def _rows(self):
+        """Add a second usage group for the demo sub-template and an unused sub-template.
+
+        Returns the 3 table rows: the demo sub-template first group, its second
+        group (a continuation row) and the unused sub-template.
+        """
+        pod = self.portal.podtemplates
+        folder = _createObjectByType("Folder", pod, "folder_z", title=u"Zeta")
+        api.content.create(type="SubTemplate", id="st_z", title=u"In Zeta", container=folder)
+        api.content.create(type="ConfigurablePODTemplate", id="in_zeta", title=u"In Zeta template",
+                           container=folder,
+                           merge_templates=[{"template": pod.sub_template.UID(),
+                                             "pod_context_name": u"zeta_var", "do_rendering": False}])
+        self.view.update()
+        return self.view.table.results
+
     def test_sub_templates_usage(self):
         entries = self.view.sub_templates_usage()
         # one entry per sub-template (here the single demo 'sub_template')
         self.assertEqual([e["sub_template"].getId for e in entries], ["sub_template"])
+        self.assertEqual(entries[0]["sub_template_uid"], self.portal.podtemplates.sub_template.UID())
         # the only sub-template defines the whole common path -> empty rel_path
         self.assertEqual(entries[0]["rel_path"], u"")
         # both using templates share the same folder -> one group, sorted by title
@@ -49,3 +70,73 @@ def test_rel_path_strips_common_part(self):
         # the common 'podtemplates' segment never appears in the displayed path
         pod_title = pod.Title()
         self.assertFalse(any(pod_title in rel_path for rel_path in rel_paths))
+
+    def test_update(self):
+        rows = self._rows()
+        self.assertEqual([col.__name__ for col in self.view.table.columns],
+                         ["SubTemplateColumn", "SubTemplateUsagePathColumn", "SubTemplateUsageTemplatesColumn",
+                          "SubTemplateUsageModelVariableColumn"])
+        # one row per (sub-template, path group), 'first' marking a group start
+        self.assertEqual([(r["sub_template"].getId, r["first"], r["group"] is None) for r in rows],
+                         [("sub_template", True, False), ("sub_template", False, False),
+                          ("st_z", True, True)])
+        # the whole page renders the table
+        self.assertIn(u'class="listing nosort sub-templates-usage"', self.view())
+
+    def test_SubTemplateColumn(self):
+        rows = self._rows()
+        column = SubTemplateColumn(self.view.context, self.view.request, self.view.table)
+        self.assertEqual(column.renderHeadCell(), u"Sous-modèle")
+        self.assertEqual(column.renderCell(rows[0]),
+                         u'<a href="http://nohost/plone/podtemplates/sub_template">Header</a>')
+        # a continuation row leaves the cell empty, as the removed rowspan did
+        self.assertEqual(column.renderCell(rows[1]), u"")
+        # a sub-template out of the common path is prefixed by its relative path
+        self.assertEqual(column.renderCell(rows[2]),
+                         u'<span>Zeta</span> / '
+                         u'<a href="http://nohost/plone/podtemplates/folder_z/st_z">In Zeta</a>')
+
+    def test_SubTemplateUsagePathColumn(self):
+        rows = self._rows()
+        column = SubTemplateUsagePathColumn(self.view.context, self.view.request, self.view.table)
+        self.assertEqual(column.renderHeadCell(),
+                         u"Chemin des modèles utilisant ce sous-modèle")
+        self.assertEqual(column.renderCell(rows[0]), u"POD Templates")
+        self.assertEqual(column.renderCell(rows[1]), u"POD Templates / Zeta")
+        # an unused sub-template has no path to show
+        self.assertEqual(column.renderCell(rows[2]), u"-")
+
+    def test_SubTemplateUsageTemplatesColumn(self):
+        rows = self._rows()
+        column = SubTemplateUsageTemplatesColumn(self.view.context, self.view.request, self.view.table)
+        self.assertEqual(column.renderHeadCell(), u"Modèles concernés")
+        self.assertEqual(column.renderCell(rows[0]),
+                         u'<ul><li><a href="http://nohost/plone/podtemplates/test_template_bis">'
+                         u'Collection template</a></li>'
+                         u'<li><a href="http://nohost/plone/podtemplates/test_template_multiple">'
+                         u'Multiple format template</a></li></ul>')
+        self.assertEqual(column.renderCell(rows[1]),
+                         u'<ul><li><a href="http://nohost/plone/podtemplates/folder_z/in_zeta">'
+                         u'In Zeta template</a></li></ul>')
+        self.assertEqual(column.renderCell(rows[2]), u"<em>Pas utilisé</em>")
+        # render_template is the seam imio.dms.mail overrides to flag the signer rules
+        self.assertEqual(column.render_template(self.portal.podtemplates.test_template),
+                         u'<a href="http://nohost/plone/podtemplates/test_template">General template</a>')
+
+    def test_SubTemplateUsageModelVariableColumn(self):
+        rows = self._rows()
+        column = SubTemplateUsageModelVariableColumn(self.view.context, self.view.request, self.view.table)
+        self.assertEqual(column.renderHeadCell(), u"Model variable")
+        # one variable name per using template, in the same order as the templates column
+        self.assertEqual(column.renderCell(rows[0]), u"<ul><li>header</li><li>header</li></ul>")
+        self.assertEqual(column.renderCell(rows[1]), u"<ul><li>zeta_var</li></ul>")
+        self.assertEqual(column.renderCell(rows[2]), u"")
+
+        # _get_pod_context_name finds nothing for a template not merging the sub-template,
+        # for a template without the field at all and for an unknown uid
+        pod = self.portal.podtemplates
+        sub_uid = pod.sub_template.UID()
+        self.assertEqual(column._get_pod_context_name(pod.test_template_multiple, sub_uid), "header")
+        self.assertEqual(column._get_pod_context_name(pod.test_template, sub_uid), u"")
+        self.assertEqual(column._get_pod_context_name(pod.test_style_template, sub_uid), u"")
+        self.assertEqual(column._get_pod_context_name(pod.test_template_multiple, "unknown-uid"), u"")