0001-general-use-lazy-variables-to-generate-inspect-page-.patch

Frédéric Péters, 25 février 2020 13:38

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

Subject: [PATCH] general: use lazy variables to generate inspect page (#39849)

 tests/test_backoffice_pages.py | 25 ++++++++++++
 wcs/backoffice/management.py   | 40 ++++++++++---------
 wcs/data_sources.py            |  3 ++
 wcs/qommon/substitution.py     | 21 ++++++++++
 wcs/variables.py               | 70 +++++++++++++++++++++++++++++-----
 wcs/wf/create_formdata.py      |  5 +++
 6 files changed, 135 insertions(+), 29 deletions(-)

     from wcs.qommon.form import PicklableUpload
     from wcs.qommon.ident.password_accounts import PasswordAccount
     from wcs.qommon.http_request import HTTPRequest
     from wcs.qommon.substitution import CompatibilityNamesDict
     from wcs.roles import Role
     from wcs.workflows import (Workflow, CommentableWorkflowStatusItem,
             ChoiceWorkflowStatusItem, EditableWorkflowStatusItem,
-...
         assert pq('.field-type-file .value').text() == 'bar'
     def test_linked_forms_variables(create_formdata):
         # create source formdata
         formdata = create_formdata['source_formdef'].data_class()()
         upload = PicklableUpload('/foo/bar', content_type='text/plain')
         upload.receive([b'hello world'])
         formdata.data = {
             '0': 'coucou',
             '1': upload,
+        }
         formdata.just_created()
         formdata.store()
         formdata.perform_workflow()
         formdata.store()
         formdata.jump_status('2')
         formdata.perform_workflow()
         formdata.store()
         get_publisher().substitutions.reset()
         get_publisher().substitutions.feed(formdata)
         substvars = get_publisher().substitutions.get_context_variables(mode='lazy')
         assert str(substvars['form_links_resubmitted_form_var_foo_string']) == 'coucou'
         assert 'form_links_resubmitted_form_var_foo_string' in substvars.get_flat_keys()
     def test_backoffice_create_formdata_map_fields_by_varname(create_formdata):
         create_formdata['create_formdata'].map_fields_by_varname = True
         create_formdata['create_formdata'].mappings  = []

     import json
     import re
     import time
     import types
     import vobject
     try:
-...
     from ..qommon.evalutils import make_datetime
     from ..qommon.misc import C_, ellipsize
     from ..qommon.afterjobs import AfterJob
     from ..qommon.substitution import CompatibilityNamesDict
     from ..qommon import emails
     from ..qommon import sms
     from ..qommon import errors
-...
     from wcs.formdata import FormData
     from wcs.formdef import FormDef
     from wcs.roles import logged_users_role, Role
     from wcs.variables import LazyFieldVar
     from wcs.workflows import get_role_translation, template_on_formdata
     from .submission import FormFillPage
-...
             r += htmltext('<div id="inspect-variables" class="section">')
             r += htmltext('<h2>%s</h2>') % _('Variables')
             r += htmltext('<ul class="form-inspector biglist">')
             substvars = self.filled.get_static_substitution_variables()
             substvars.update(self.filled.formdef.get_static_substitution_variables())
             substvars = CompatibilityNamesDict()
             substvars.update(self.filled.get_substitution_variables())
             static_substvars = {}
             def safe(v):
                 if isinstance(v, str):
-...
                         v = repr(v)
                 return v
             backward_compatibility_varnames = re.compile('^(attachments|form_field_.*|'
                                                      'form_f[0-9]+|form_fbo[0-9]+|form_user_f[0-9]+|'
                                                      'form_f[a-f0-9]{8}_.*|'
                                                      'form_fbo[a-f0-9]{8}_.*|'
                                                      'form_user_f[a-f0-9]{8}_.*|'
                                                      'form_user_field_.*|form_user_f_.*)$')
             blacklisted_varnames = ['form_objects']
             for k, v in sorted(substvars.items()):
                 if k in blacklisted_varnames:
             for k in sorted(substvars.get_flat_keys()):
                 k = safe(k)
                 v = substvars[k]
                 if isinstance(v, LazyFieldVar):
                     r += htmltext('<li><code title="%s">%s</code>') % (k, k)
                     r += htmltext('  <div class="value"><span>%s</span>') % v
                 elif isinstance(v, (types.FunctionType, types.MethodType)):
                     continue
                 if backward_compatibility_varnames.search(k):
                 elif hasattr(v, 'inspect_keys') or isinstance(v, dict):
                     # skip expanded
                     continue
                 k = safe(k)
                 r += htmltext('<li><code title="%s">%s</code>') % (k, k)
                 r += htmltext('  <div class="value"><span>%s</span>') % ellipsize(safe(v), 10000)
                 if not isinstance(v, six.string_types):
                     r += htmltext(' <span class="type">(%r)</span>') % type(v)
                 else:
                     r += htmltext('<li><code title="%s">%s</code>') % (k, k)
                     r += htmltext('  <div class="value"><span>%s</span>') % ellipsize(safe(v), 10000)
                     if not isinstance(v, six.string_types):
                         r += htmltext(' <span class="type">(%r)</span>') % type(v)
                 r += htmltext('</div></li>')
             r += htmltext('</div>')

wcs/data_sources.py
451	451	class DataSourcesSubstitutionProxy(object):
452	452	def __getattr__(self, attr):
453	453	return get_structured_items(NamedDataSource.get_by_slug(attr).data_source)
	454
	455	def inspect_keys(self):
	456	return []

             except KeyError:
                 return default
         def get_flat_keys(self):
             flat_keys = {}
             def flatten(base, depth=10):
                 item = self[base]
                 if hasattr(item, 'inspect_keys'):
                     sub_keys = item.inspect_keys()
                 elif isinstance(item, dict):
                     sub_keys = item.keys()
                 else:
                     return
                 for sub_key in sub_keys:
                     new_base = '%s_%s' % (base, sub_key)
                     flat_keys[new_base] = None
                     flatten(new_base, depth=depth - 1)
             for key in self.keys():
                 flatten(key)
             return flat_keys.keys()
         def __getitem__(self, key):
             try:
                 val = super(CompatibilityNamesDict, self).__getitem__(key)

         def __init__(self, formdef):
             self._formdef = formdef
         def inspect_keys(self):
             return self.options.keys()
         _options = None
         @property
         def options(self):
-...
             super(LazyFormData, self).__init__(formdata.formdef)
             self._formdata = formdata
         def inspect_keys(self):
             blacklist = ('field', 'inspect_keys', 'page_no', 'role', 'formdef', 'objects')
             for key in dir(self):
                 if key[0] == '_' or key in blacklist:
                     continue
                 yield key
         @property
         def objects(self):
             return LazyFormDefObjectsManager(self._formdef, formdata=self._formdata)
-...
             self._data = data or {}
             self._formdata = formdata
         def inspect_keys(self):
             return self.varnames.keys()
         _varnames = None
         @property
         def varnames(self):
-...
                 return LazyFieldVarMap(self._data, field, self._formdata)
             if field.key == 'password':
                 return LazyFieldVarPassword(self._data, field, self._formdata)
             if field.store_structured_value:
                 return LazyFieldVarStructured(self._data, field, self._formdata)
             return LazyFieldVar(self._data, field, self._formdata)
-...
                 return getattr(self, key)
             except AttributeError:
                 pass
             structured_value = self._field.get_structured_value(self._data)
             if not structured_value:
                 raise KeyError(key)
             if isinstance(structured_value, dict):
                 return structured_value[key]
             if isinstance(structured_value, list):
                 for i, struct_value in enumerate(structured_value):
                     if str(key) == str(i):
                         return struct_value
             raise KeyError(key)
         def __iter__(self):
-...
             raise AssertionError('lazy cannot be pickled')
     class LazyFieldVarStructured(LazyFieldVar):
         def inspect_keys(self):
             structured_value = self._field.get_structured_value(self._data)
             if not structured_value:
                 return []
             keys = ['raw']
             def walk(base, value):
                 if isinstance(value, dict):
                     for k, v in value.items():
                         walk(k if not base else base + '_' + k, v)
                 else:
                     keys.append(base)
             walk('', structured_value)
             return keys
         def __getitem__(self, key):
             try:
                 return super(LazyFieldVarStructured, self).__getitem__(key)
             except KeyError:
                 pass
             structured_value = self._field.get_structured_value(self._data)
             if not structured_value:
                 raise KeyError(key)
             if isinstance(structured_value, dict):
                 return structured_value[key]
             if isinstance(structured_value, list):
                 for i, struct_value in enumerate(structured_value):
                     if str(key) == str(i):
                         return struct_value
             raise KeyError(key)
     class DateOperatorsMixin(object):
         def __eq__(self, other):
             if hasattr(other, 'timetuple'):
-...
     class LazyFieldVarDate(DateOperatorsMixin, LazyFieldVar):
         def inspect_keys(self):
             return ['year', 'month', 'day']
         def get_raw(self):
             return self._data.get(self._field.id)
-...
         day = tm_mday
     class LazyFieldVarMap(LazyFieldVar):
     class LazyFieldVarMap(LazyFieldVarStructured):
         def split(self, *args, **kwargs):
             # Compatibility with usage of map variable as a string. It is
             # recommended to use lat/lon properties instead.
             return self._data.get(self._field.id).split(*args, **kwargs)
         def inspect_keys(self):
             return ['lat', 'lon']
     class LazyFieldVarPassword(LazyFieldVar):
         def __getitem__(self, key):
-...
         def __init__(self, user):
             self._user = user
         def inspect_keys(self):
             return ['display_name', 'email', 'var']
         @property
         def display_name(self):
             return self._user.display_name

                     return part.formdata.get_substitution_variables()
             raise AttributeError(varname)
         def inspect_keys(self):
             for part in self._formdata.iter_evolution_parts():
                 if isinstance(part, LinkedFormdataEvolutionPart) and part.varname:
                     yield part.varname
     class CreateFormdataWorkflowStatusItem(WorkflowStatusItem):
         description = N_('New Form Creation')
+    -

Projet

Général

Profil

Produits Entr'ouvert » w.c.s.

0001-general-use-lazy-variables-to-generate-inspect-page-.patch