0001-templates-use-a-template-to-render-formdata-history-.patch

Frédéric Péters, 11 août 2017 17:26

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

Subject: [PATCH 1/3] templates: use a template to render formdata history
 (#17601)

 MANIFEST.in                             |   1 +
 wcs/formdata.py                         |  40 +++++++++++-
 wcs/forms/common.py                     | 107 ++------------------------------
 wcs/forms/root.py                       |   1 +
 wcs/qommon/template.py                  |   6 ++
 wcs/templates/wcs/formdata_history.html |  43 +++++++++++++
 wcs/workflows.py                        |   6 +-
 7 files changed, 100 insertions(+), 104 deletions(-)
 create mode 100644 wcs/templates/wcs/formdata_history.html

MANIFEST.in
8	8	recursive-include data/themes/alto/ .html .css .png .gif .jpg .js .ezt .xml
9	9	recursive-include data/vendor/ *.dat
10	10	recursive-include wcs/qommon/static/ .css .png .gif .jpg .js .eot .svg .ttf *.woff
	11	recursive-include wcs/templates *.html

             return self._formdata
         def get_author_name(self):
             user_id = self.who
             if self.who == '_submitter':
                 user_id = self.formdata.user_id
             try:
                 return get_publisher().user_class.get(user_id).display_name
             except KeyError:
                 return None
         def get_author_qualification(self):
             if self.who == '_submitter' and not self.formdata.is_submitter(get_request().user):
                 return _('Original Submitter')
             else:
                 return get_publisher().user_class.get(self.who).display_name
             return None
         def add_part(self, part):
             if not self.parts:
-...
                 del odict['_formdata']
             return odict
         @property
         def datetime(self):
             return datetime.datetime(*self.time[:6])
         def is_hidden(self):
             if self.status:
                 wf_status = self.formdata.get_status(self.status)
                 if wf_status and not wf_status.is_visible(self.formdata, get_request().user):
                     return True
             return False
         def get_status(self):
             return self.formdata.get_status(status=self.status)
         def get_status_label(self):
             return self.formdata.get_status_label(status=self.status)
         def is_status_change(self):
             if not self.status:
                 return False
             idx = self.formdata.evolution.index(self)
             if idx == 0:
                 return True
             while idx:
                 if self.formdata.evolution[idx-1].status and self.status != self.formdata.evolution[idx-1].status:
                     return True
                 idx -= 1
             return False
     class FormData(StorableObject):
         _names = 'XX'

     from wcs.fields import WidgetField, FileField
     from wcs.workflows import EditableWorkflowStatusItem
     from django.template import RequestContext
     from qommon import _
     from qommon import template
     from qommon import get_logger
-...
         _q_extra_exports = []
         form_page_class = None
         history_templates = ['wcs/formdata_history.html']
         def html_top(self, title = None):
             template.html_top(title = title, default_org = _('Forms'))
-...
                 return
             if not self.formdef.is_user_allowed_read_status_and_history(get_request().user, self.filled):
                 return
             r = TemplateIO(html=True)
             r += htmltext('<div class="bo-block" id="evolution-log">')
             r += htmltext('<h2 class="foldable">%s</h2>') % _('Log')
             r += htmltext('<ul id="evolutions">')
             hidden = False
             previous_status = None
             for evo in self.filled.evolution:
                 status_css_class = ''
                 if evo.status:
                     wf_status = self.filled.get_status(evo.status)
                     if wf_status:
                         status_css_class = wf_status.extra_css_class
                     if wf_status and not wf_status.is_visible(self.filled, get_request().user):
                         hidden = True
                     else:
                         hidden = False
                 if hidden:
                     continue
                 evo_author = None
                 evo_author_more = None
                 klass = 'msg-system'
                 if evo.who:
                     if evo.who == '_submitter':
                         klass = 'msg-in'
                         evo_author = _('Original Submitter')
                         if get_request().user and self.filled.is_submitter(get_request().user):
                             evo_author = get_request().user.display_name
                         elif self.filled.user_id:
                             try:
                                 evo_author = get_publisher().user_class.get(self.filled.user_id).display_name
                                 evo_author_more = _('(Original Submitter)')
                             except KeyError:
                                 pass
                     else:
                         klass = 'msg-out'
                         try:
                             evo_author = evo.get_author_name()
                         except KeyError:
                             pass
                 status_block = TemplateIO(html=True)
                 if evo.status:
                     status_block += htmltext('<div class="evolution-metadata">')
                     status_block += htmltext('<span class="status">%s</span> '
                             ) % self.filled.get_status_label(evo.status)
                     status_block += htmltext('<span class="time">%s</span> '
                             ) % misc.localstrftime(evo.time)
                     status_block += htmltext('</div>') # <-- .evolution-metadata -->
                 parts = TemplateIO(html=True)
                 if evo_author:
                     parts += htmltext('<span class="user">%s') % evo_author
                     if evo_author_more:
                         parts += htmltext(' <span>%s</span>') % evo_author_more
                     parts += htmltext('</span>')
                 if not evo.status:
                     parts += htmltext('<span class="time">%s</span> ') % misc.localstrftime(evo.time)
                 if evo.comment:
                     if evo.comment.startswith(str('#pre')):
                         parts += htmltext('<div class="comment"><pre>%s</pre></div>') % evo.comment[4:]
                     else:
                         parts += htmltext('<div class="comment">')
                         parts += htmltext('<p>')
                         parts += htmltext('\n').join(
                                 [(x or htmltext('</p><p>')) for x in evo.comment.splitlines()])
                         parts += htmltext('</p>')
                         parts += htmltext('</div>')
                 for t in evo.display_parts():
                     parts += t
                 parts_value = parts.getvalue()
                 if not (parts_value or evo.status != previous_status):
                     continue
                 if evo.status:
                     previous_status = evo.status
                 try:
                     status_colour = self.filled.get_status(previous_status).colour
                 except AttributeError:
                     status_colour = 'ffffff'
                 fg_colour = misc.get_foreground_colour(status_colour)
                 r += htmltext('<li class="%s %s">' % (klass, status_css_class))
                 r += htmltext('<span class="item" style="background: #%s; color: %s;"></span>' %
                         (status_colour, fg_colour))
                 r += htmltext('<div>')
                 r += status_block.getvalue()
                 if parts_value:
                     r += htmltext('<div class="msg">')
                     r += htmltext(parts_value)
                     r += htmltext('</div>')
                 r += htmltext('</div>')
                 r += htmltext('</li>')
             r += htmltext('</ul>')
             r += htmltext('</div>') # .bo-block #evolution-log
             return r.getvalue()
             context = RequestContext(get_request(), {'formdata': self.filled})
             return template.render(self.history_templates, context)
         def check_receiver(self):
             session = get_session()

wcs/forms/root.py
1577	1577	class PublicFormStatusPage(FormStatusPage):
1578	1578	_q_exports_orig = ['', 'download', 'status']
1579	1579	form_page_class = FormPage
	1580	history_templates = ['wcs/front/formdata_history.html', 'wcs/formdata_history.html']
1580	1581
1581	1582	def __init__(self, args, *kwargs):
1582	1583	FormStatusPage.__init__(self, args, *kwargs)

     import glob
     import xml.etree.ElementTree as ET
     from django.template.loader import render_to_string
     from quixote import get_session, get_request, get_response, get_publisher
     from quixote.directory import Directory
     from quixote.util import StaticDirectory, StaticFile
-...
         template.generate(fd, vars)
         return fd.getvalue()
     def render(template_name, context):
         return htmltext(render_to_string(template_name, context).encode('utf-8'))

     {% load i18n %}
     <div class="bo-block" id="evolution-log">
      <h2 class="foldable">{% trans "Log" %}</h2>
      <ul id="evolutions">
       {% for evolution in formdata.evolution %}
         {% if not evolution.is_hidden %}
         {% with status=evolution.get_status display_parts=evolution.display_parts %}
         {% if evolution.who or evolution.is_status_change or display_parts %}
         <li class="{% if evolution.who == '_submitter' %}msg-in{% elif evolution.who %}msg-out{% else %}msg-system{% endif %} {{ status.extra_css_class }}">
           <span class="item" style="background: #{{ status.colour }}; color: {{ status.get_contrast_color}}"></span>
           <div>
            {% if evolution.status %}
              <div class="evolution-metadata">
                <span class="status">{{evolution.get_status_label}}</span>
                <span class="time">{{evolution.datetime}}</span>
              </div>
            {% endif %}
            <div class="msg">
              {% if evolution.who %}
              <span class="user">{{evolution.get_author_name}}
                      <span>{% if evolution.get_author_qualification %}({{evolution.get_author_qualification}}){% endif %}</span>
              </span>
              {% endif %}
              {% if not evolution.status %}
                <span class="time">{{evolution.datetime}}</span>
              {% endif %}
              {% if evolution.comment %}
              <div class="comment">
                {{evolution.comment|linebreaks}}
              </div>
              {% endif %}
              {% for part in display_parts %}
                {{part|safe}}
              {% endfor %}
            </div>
           </div>
         </li>
         {% endif %}
         {% endwith %}
         {% endif %}
       {% endfor %}
      </ul>
     </div>

     from quixote import get_request, redirect
     from qommon import _
     from qommon.misc import C_, get_as_datetime, file_digest
     from qommon.misc import C_, get_as_datetime, file_digest, get_foreground_colour
     from qommon.storage import StorableObject, atomic_write
     from qommon.form import *
     from qommon.humantime import seconds2humanduration
-...
                     waitpoint = item.waitpoint or waitpoint
             return bool(endpoint or waitpoint)
         def get_contrast_color(self):
             colour = self.colour or 'ffffff'
             return misc.get_foreground_colour(colour)
         def __getstate__(self):
             odict = self.__dict__.copy()
             if odict.has_key('parent'):
+    -

Projet

Général

Profil

Produits Entr'ouvert » w.c.s.

0001-templates-use-a-template-to-render-formdata-history-.patch