ProxyField.py 24.1 KB
Newer Older
1
# -*- coding: utf-8 -*-
Jean-Paul Smets's avatar
Jean-Paul Smets committed
2 3
##############################################################################
#
4
# Copyright (c) 2006 Nexedi SARL and Contributors. All Rights Reserved.
Jean-Paul Smets's avatar
Jean-Paul Smets committed
5
#                    Jean-Paul Smets <jp@nexedi.com>
6
#                    Romain Courteaud <romain@nexedi.com>
Jean-Paul Smets's avatar
Jean-Paul Smets committed
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
#
# WARNING: This program as such is intended to be used by professional
# programmers who take the whole responsability of assessing all potential
# consequences resulting from its eventual inadequacies and bugs
# End users who are looking for a ready-to-use solution with commercial
# garantees and support are strongly adviced to contract a Free Software
# Service Company
#
# This program is Free Software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
#
##############################################################################

31 32
import six
from _thread import get_ident
33 34 35 36 37 38 39

from AccessControl import allow_class, ClassSecurityInfo
from Acquisition import aq_base
from MethodObject import Method
from zLOG import LOG, WARNING


Jean-Paul Smets's avatar
Jean-Paul Smets committed
40 41 42 43
from Products.Formulator import Widget, Validator
from Products.Formulator.Field import ZMIField
from Products.Formulator.DummyField import fields
from Products.Formulator.Errors import ValidationError
44
from Products.Formulator.TALESField import TALESMethod
45
from Products.ERP5Type.TransactionalVariable import getTransactionalVariable
46
from Products.ERP5Type.ObjectMessage import ObjectMessage
47
from Products.ERP5Type.Globals import DTMLFile
Jean-Paul Smets's avatar
Jean-Paul Smets committed
48

Romain Courteaud's avatar
Romain Courteaud committed
49

50 51 52
class BrokenProxyField(Exception):
  pass
allow_class(BrokenProxyField)
53

54 55 56
class WidgetDelegatedMethod(Method):
  """Method delegated to the proxied field's widget.
  """
57
  __code__ = func_code = None
58

59 60 61 62 63 64 65 66 67
  def __init__(self, method_id, default=''):
    self._method_id = method_id
    self._default = default

  def __call__(self, instance, *args, **kw):
    field = instance
    proxied_field = field.getRecursiveTemplateField()
    if proxied_field:
      proxied_method = getattr(proxied_field.widget, self._method_id)
68 69 70
      try:
        return proxied_method(field, *args, **kw)
      finally:
71
        self.__code__ = self.func_code = getattr(proxied_method, '__code__', None)
72 73 74
    return self._default


Jean-Paul Smets's avatar
Jean-Paul Smets committed
75 76
class ProxyWidget(Widget.Widget):
  """
77 78 79 80
  A widget that renders itself as a field from another form
  after changing its title and id. It is recommended to define
  a master form on which complex fields with a lot of TALES
  are defined in order to minimize code duplication.
Jean-Paul Smets's avatar
Jean-Paul Smets committed
81 82
  """

83
  property_names = [
84 85
    'form_id',
    'field_id',
Jean-Paul Smets's avatar
Jean-Paul Smets committed
86 87 88 89 90
  ]

  form_id = fields.StringField(
                                'form_id',
                                title='Form ID',
91 92
                                description= \
                                  "ID of the master form.",
Jean-Paul Smets's avatar
Jean-Paul Smets committed
93
                                default="",
94
                                display_width=40,
Jean-Paul Smets's avatar
Jean-Paul Smets committed
95 96 97 98 99
                                required=1)

  field_id = fields.StringField(
                                'field_id',
                                title='Field ID',
100 101
                                description= \
                                  "ID of the field in the master form.",
Jean-Paul Smets's avatar
Jean-Paul Smets committed
102
                                default="",
103
                                display_width=40,
Jean-Paul Smets's avatar
Jean-Paul Smets committed
104 105
                                required=1)

106 107 108 109 110 111
  # Field API Methods, delegated to the template field widget
  render = WidgetDelegatedMethod('render', default='')
  render_htmlgrid = WidgetDelegatedMethod('render_htmlgrid', default='')
  render_view = WidgetDelegatedMethod('render_view', default='')
  render_pdf = WidgetDelegatedMethod('render_pdf', default='')
  render_css = WidgetDelegatedMethod('render_css', default='')
112
  render_dict = WidgetDelegatedMethod('render_dict', default=None)
113
  render_odf = WidgetDelegatedMethod('render_odf', default='')
114 115
  render_odt = WidgetDelegatedMethod('render_odt', default=None)
  render_odt_view = WidgetDelegatedMethod('render_odt_view', default=None)
116 117
  render_odt_variable = WidgetDelegatedMethod('render_odt_variable',
                                              default=None)
118
  render_odg = WidgetDelegatedMethod('render_odg', default=None)
119 120
  get_javascript_list = WidgetDelegatedMethod(
                            'get_javascript_list', default=[])
Jean-Paul Smets's avatar
Jean-Paul Smets committed
121

122

Jean-Paul Smets's avatar
Jean-Paul Smets committed
123 124 125 126
class ProxyValidator(Validator.Validator):
  """
    Validation of entered value through proxy field
  """
127
  property_names = []
Jean-Paul Smets's avatar
Jean-Paul Smets committed
128 129

  def validate(self, field, key, REQUEST):
130
    proxy_field = field.getRecursiveTemplateField()
Jean-Paul Smets's avatar
Jean-Paul Smets committed
131
    try:
132
      result = proxy_field.validator.validate(field, key, REQUEST)
133
    except ValidationError as error:
Jean-Paul Smets's avatar
Jean-Paul Smets committed
134 135 136 137 138 139 140 141 142
      error.field_id = field.id
      raise error
    return result

ProxyWidgetInstance = ProxyWidget()
ProxyValidatorInstance = ProxyValidator()

class ProxyField(ZMIField):
  meta_type = "ProxyField"
143
  security = ClassSecurityInfo()
Jean-Paul Smets's avatar
Jean-Paul Smets committed
144 145 146

  widget = ProxyWidgetInstance
  validator = ProxyValidatorInstance
147
  delegated_list = tuple()
148
  delegated_message_list = tuple()
149

150 151 152 153 154 155 156 157 158 159
  # methods screen
  security.declareProtected('View management screens',
                            'manage_main')
  manage_main = DTMLFile('dtml/proxyFieldEdit', globals())

  # tales screen
  security.declareProtected('View management screens',
                            'manage_talesForm')
  manage_talesForm = DTMLFile('dtml/proxyFieldTales', globals())

160 161 162 163
  # messages screen
  security.declareProtected('View management screens', 'manage_messagesForm')
  manage_messagesForm = DTMLFile('dtml/proxyFieldMessages', globals())

164 165 166 167 168 169 170 171 172 173
  # proxy field list header
  security.declareProtected('View management screens', 'proxyFieldListHeader')
  proxyFieldListHeader = DTMLFile('dtml/proxyFieldListHeader', globals())

  security.declareProtected('Change Formulator Forms', 'manage_edit')
  def manage_edit(self, REQUEST):
    """
    Surcharged values from proxied field.
    """
    # Edit template field attributes
174
    template_field = self.getTemplateField()
175
    if template_field is not None:
176
      template_field = self.getRecursiveTemplateField()
177 178 179 180 181 182 183

      # Check the surcharged checkboxes
      surcharge_list = []
      for group in template_field.form.get_groups():
        for field in template_field.form.get_fields_in_group(group):
          field_id = field.id
          checkbox_key = "surcharge_%s" % field_id
184
          if checkbox_key not in REQUEST:
185 186 187 188 189
            surcharge_list.append(field_id)

      try:
        # validate the form and get results
        result = template_field.form.validate(REQUEST)
190
      except ValidationError as err:
191 192 193 194 195 196 197 198 199
        if REQUEST:
          message = "Error: %s - %s" % (err.field.get_value('title'),
                                        err.error_text)
          return self.manage_main(self, REQUEST,
                                  manage_tabs_message=message)
        else:
          raise

      self._surcharged_edit(result, surcharge_list)
200

201 202 203 204 205 206 207
    # Edit standards attributes
    # XXX It is not possible to call ZMIField.manage_edit because
    # it returns at the end...
    # we need to had a parameter to the method
    try:
      # validate the form and get results
      result = self.form.validate(REQUEST)
208
    except ValidationError as err:
209 210 211 212 213 214 215 216 217
      if REQUEST:
        message = "Error: %s - %s" % (err.field.get_value('title'),
                                      err.error_text)
        return self.manage_main(self,REQUEST,
                                manage_tabs_message=message)
      else:
        raise

    self._edit(result)
218

219 220 221 222 223
    if REQUEST:
      message="Content changed."
      return self.manage_main(self, REQUEST,
                              manage_tabs_message=message)

224 225 226 227 228 229 230 231 232 233 234 235 236 237 238
  def manage_edit_surcharged_xmlrpc(self, mapping):
    """Edit surcharged properties
    This method is similar to manage_edit_xmlrpc, and it marks the properties
    as not delegated.
    """
    self._surcharged_edit(mapping, mapping.keys())

  def manage_tales_surcharged_xmlrpc(self, mapping):
    """Edit surcharged TALES
    This method is similar to manage_tales_xmlrpc, and it marks the TALES
    properties as not delegated.
    """
    self._surcharged_tales(mapping, mapping.keys())


239
  def _surcharged_edit(self, result, surcharge_list):
240
    # first check for any changes
241 242 243 244 245 246
    values = self.values
    # if we are in unicode mode, convert result to unicode
    # acquire get_unicode_mode and get_stored_encoding from form..
    if self.get_unicode_mode():
      new_result = {}
      for key, value in result.items():
247
        if isinstance(value, six.binary_type):
248
          # in unicode mode, Formulator UI always uses UTF-8
249
          value = six.text_type(message, 'utf-8')
250 251 252 253 254 255 256 257
        new_result[key] = value
      result = new_result

    changed = []
    for key, value in result.items():
      # XXX Remove old values
      values.pop(key, None)
      # store keys for which we want to notify change
258
      if key not in values or values[key] != value:
259 260 261 262 263 264
        changed.append(key)

    proxied_field = self.getTemplateField()
    for key, value in result.items():
      if key not in surcharge_list:
        result.pop(key)
265 266
        if key in self.tales:
          self.tales.pop(key)
267 268 269 270

    # now do actual update of values
    values.update(result)
    self.values = values
271
    self.delegated_list = sorted(surcharge_list)
272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292

    # finally notify field of all changed values if necessary
    for key in changed:
      method_name = "on_value_%s_changed" % key
      if hasattr(self, method_name):
        getattr(self, method_name)(values[key])

  security.declareProtected('Change Formulator Forms', 'manage_tales')
  def manage_tales(self, REQUEST):
    """
    Surcharged talesfrom proxied field.
    """
    template_field = self.getRecursiveTemplateField()
    if template_field is not None:

      # Check the surcharged checkboxes
      surcharge_list = []
      for group in template_field.tales_form.get_groups():
        for field in template_field.tales_form.get_fields_in_group(group):
          field_id = field.id
          checkbox_key = "surcharge_%s" % field_id
293
          if checkbox_key not in REQUEST:
294 295 296 297 298 299
            surcharge_list.append(field_id)


      try:
        # validate the form and get results
        result = template_field.tales_form.validate(REQUEST)
300
      except ValidationError as err:
301 302 303 304 305 306 307 308 309 310 311 312 313
        if REQUEST:
          message = "Error: %s - %s" % (err.field.get_value('title'),
                                        err.error_text)
          return self.manage_talesForm(self, REQUEST,
                                       manage_tabs_message=message)
        else:
          raise

      self._surcharged_tales(result, surcharge_list)

    try:
      # validate the form and get results
      result = self.tales_form.validate(REQUEST)
314
    except ValidationError as err:
315 316 317 318 319 320 321 322 323 324
      if REQUEST:
        message = "Error: %s - %s" % (err.field.get_value('title'),
                                      err.error_text)
        return self.manage_talesForm(self,REQUEST,
                                     manage_tabs_message=message)
      else:
        raise

    self._edit_tales(result)

325

326 327 328 329 330 331
    if REQUEST:
      message="Content changed."
      return self.manage_talesForm(self, REQUEST,
                                            manage_tabs_message=message)

  def _surcharged_tales(self, result, surcharge_list):
332
    # first check for any changes
333 334 335 336 337 338 339 340 341 342 343
    tales = self.tales

    changed = []
    for key, value in result.items():
      # XXX Remove old values
      tales.pop(key, None)

    proxied_field = self.getTemplateField()
    for key, value in result.items():
      if key not in surcharge_list:
        result.pop(key)
344 345
        if key in self.values:
          self.values.pop(key)
346 347 348 349

    # now do actual update of values
    tales.update(result)
    self.tales = tales
350
    self.delegated_list = sorted(surcharge_list)
351
    # Put a default value on not delegated parameter
352 353
    for key in six.iterkeys(result):
      if key not in self.values:
354
        self.values[key] = self.get_recursive_orig_value(key, include=0)
355

356 357 358 359 360 361 362 363 364
  security.declareProtected('Change Formulator Fields', 'manage_messages')
  def manage_messages(self, REQUEST):
    """Change message texts.
    """
    surcharge_list = []
    messages = self.message_values
    unicode_mode = self.get_unicode_mode()
    for message_key in self.get_error_names():
      checkbox_key = "surcharge_%s" % message_key
365
      if checkbox_key not in REQUEST:
366 367 368
        surcharge_list.append(message_key)
        message = REQUEST[message_key]
        if unicode_mode:
369
          message = six.text_type(message, 'utf-8')
370 371 372 373 374
        messages[message_key] = message
      else:
        if message_key in messages:
          messages.pop(message_key)
    self.message_values = messages
375
    self.delegated_message_list = sorted(surcharge_list)
376 377 378 379 380
    if REQUEST:
      message="Content changed."
      return self.manage_messagesForm(self,REQUEST,
                                      manage_tabs_message=message)

381 382
  security.declareProtected('View management screens', 'get_error_message')
  def get_error_message(self, name):
383
    if not self.is_message_delegated(name):
384 385 386 387 388 389 390
      try:
        return self.message_values[name]
      except KeyError:
        if name in self.validator.message_names:
          return getattr(self.validator, name)
        else:
          return "Unknown error: %s" % name
391 392 393
    else:
      return self.getTemplateField().get_error_message(name)

394 395 396 397
  security.declareProtected('View management screens', 'get_error_names')
  def get_error_names(self):
    """Get error messages.
    """
398 399
    return self.getTemplateField().get_error_names()

400
  security.declareProtected('Access contents information', 'getTemplateField')
401
  def getTemplateField(self, cache=True):
402 403
    """
    Return template field of the proxy field.
404
    """
405
    if cache:
406 407 408 409
      tales = self.tales
      if self._p_oid is None or tales['field_id'] or tales['form_id']:
        cache = False
      else:
410 411 412 413
        try:
          return self._getTemplateFieldCache()
        except KeyError:
          pass
414

415
    portal = self.getPortalObject()
Nicolas Delaby's avatar
Nicolas Delaby committed
416
    portal_skins = portal.portal_skins
417 418
    form = self.aq_parent
    object = form.aq_parent
Romain Courteaud's avatar
Romain Courteaud committed
419 420 421 422 423 424 425 426

    form_id = self.get_value('form_id')
    proxy_field = None
    form_id_with_skin_folder_name_flag = False
    if '/' in form_id:
      # If a / is in the form_id, it means that skin_folder is explicitly
      # defined. If so, prevent acquisition to get the form.
      form_id_with_skin_folder_name_flag = True
427 428 429
      proxy_form = aq_base(portal_skins).unrestrictedTraverse(form_id, None)
      if proxy_form is not None:
        proxy_form = portal_skins.unrestrictedTraverse(form_id)
Romain Courteaud's avatar
Romain Courteaud committed
430 431 432 433 434
    else:
      proxy_form = getattr(object, form_id, None)

    if (proxy_form is not None):
      field_id = self.get_value('field_id')
435 436
      proxy_field = proxy_form._getOb(field_id, None)
      if proxy_field is None:
Romain Courteaud's avatar
Romain Courteaud committed
437 438 439 440 441
        if form_id_with_skin_folder_name_flag is False:
          # Try to get the field from another field library with a lower
          # priority.
          # This should return no field if the skin folder name is defined in
          # form_id.
442 443
          skin_selection_name = object.getCurrentSkinName()
          if skin_selection_name is not None:
Romain Courteaud's avatar
Romain Courteaud committed
444 445 446 447
            selection_dict = portal_skins._getSelections()
            candidate_folder_id_list = selection_dict[skin_selection_name].split(',')

            for candidate_folder_id in candidate_folder_id_list:
448
              candidate_folder = portal_skins._getOb(candidate_folder_id, None)
Romain Courteaud's avatar
Romain Courteaud committed
449
              if candidate_folder is not None:
450
                proxy_form = candidate_folder._getOb(form_id, None)
Romain Courteaud's avatar
Romain Courteaud committed
451
                if proxy_form is not None:
452 453 454 455 456 457 458 459 460 461
                  # proxy_form was retrieved outside of skin magic, fake the
                  # acquisition context skin magic would have produced so it
                  # works the same (ex: for acquired permissions).
                  # The drawback is that the form the field is actually comming
                  # from will be harder to identify, but that's just how skins
                  # work.
                  proxy_field = aq_base(proxy_form).__of__(portal)._getOb(
                    field_id,
                    None,
                  )
Romain Courteaud's avatar
Romain Courteaud committed
462 463 464
                  if proxy_field is not None:
                    break

465
    if proxy_field is None:
466
      LOG('ProxyField', WARNING,
467 468
          'Could not get a field from a proxy field %s in %s' % \
              (self.id, object.id))
469
    if cache:
470
      self._setTemplateFieldCache(proxy_field)
471 472
    return proxy_field

473
  security.declareProtected('Access contents information', 'getRecursiveTemplateField')
474
  def getRecursiveTemplateField(self, delegated_id=None):
475
    """
476
    Return template field of the proxy field.
477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492
    If delegated_id is None, the result is not a ProxyField,
    else it is the field that defines the value (possibly an
    intermediate proxy field).
    """
    seen = [aq_base(self)]
    while delegated_id is None or self.is_delegated(delegated_id):
      field = self.getTemplateField()
      if not isinstance(field, ProxyField):
        if field is None:
          error = "Can't find the template field of %r"
          break
        return field
      self = field
      field = aq_base(field)
      if field in seen:
        error = "Infinite loop when searching template field of %r"
493
        break
494 495 496 497
      seen.append(field)
    else:
      return self
    raise BrokenProxyField(error % self)
498

499 500 501 502
  def _get_sub_form(self, field=None):
    if field is None:
      field = self
    return self.getTemplateField()._get_sub_form(field=field)
503

504
  security.declareProtected('Access contents information',
505 506 507 508 509 510
                            'is_delegated')
  def is_delegated(self, id):
    """
    Return true if we get the value from the proxied field.
    No, if we surcharged the value on the proxy field.
    """
511
    return id not in self.delegated_list
512

513
  security.declareProtected('Access contents information',
514 515 516 517 518 519 520 521
                            'is_message_delegated')
  def is_message_delegated(self, id):
    """
    Return true if we get the message from the proxied field.
    No, if we surcharged the message on the proxy field.
    """
    return id not in self.delegated_message_list

522
  security.declareProtected('Access contents information',
523 524 525 526 527 528 529
                            'get_recursive_orig_value')
  def get_recursive_orig_value(self, id, include=1):
    """
    Get value for id recursively.
    """
    if include and \
      ((id in self.widget.property_names) or \
530
       ((not self.is_delegated(id)) and \
531
       (id in self.values))):
532 533 534 535 536 537 538 539 540
      return self.get_orig_value(id)
    else:
      proxied_field = self.getTemplateField()
      if proxied_field.__class__ == ProxyField:
        return proxied_field.get_recursive_orig_value(id)
      else:
        return proxied_field.get_orig_value(id)

  security.declareProtected('View management screens', 'get_recursive_tales')
541
  def get_recursive_tales(self, id):
542 543 544
    """
    Get tales expression method for id.
    """
545 546 547 548 549
    if id not in self.widget.property_names:
      self = self.getRecursiveTemplateField(id)
    tales = self.get_tales(id)
    if tales:
      return TALESMethod(tales._text)
550

551 552 553 554 555 556 557 558
  # XXX Not implemented
  security.declareProtected('View management screens', 'get_recursive_override')
  def get_recursive_override(self, id):
    """
    Get override method for id (not wrapped).
    """
    return self.overrides.get(id, "")

559
  security.declareProtected('Edit target', 'manage_edit_target')
560 561 562 563 564 565 566 567 568 569 570 571 572 573
  def manage_edit_target(self, RESPONSE):
    """
    Edit target field of this proxy
    """
    proxy_field = self.getTemplateField()
    if proxy_field:
      RESPONSE.redirect(proxy_field.absolute_url() + "/manage_main")
    else:
      # FIXME: should show some error message
      # ("form_id and field_id don't define a valid template")
      pass

  security.declareProtected('Edit target', 'manage_tales_target')
  def manage_tales_target(self, RESPONSE):
574
    """
575 576 577 578
    Edit target field of this proxy
    """
    proxy_field = self.getTemplateField()
    if proxy_field:
579
      RESPONSE.redirect(proxy_field.absolute_url() + "/manage_talesForm")
580
    else:
581
      # FIXME: should show some error message
582 583
      # ("form_id and field_id don't define a valid template")
      pass
584

585 586 587 588 589 590 591 592
  security.declareProtected('View', 'title')
  def title(self):
    """The title of this field."""
    try:
      return super(ProxyField, self).title()
    except BrokenProxyField:
      return 'broken'

593 594 595 596 597 598
  security.declareProtected('Access contents information', 'has_value')
  def has_value(self, id):
    """
    Return true if the field defines such a value.
    """
    result = None
599 600
    if (id in self.widget.property_names) or \
       (not self.is_delegated(id)):
601 602 603 604 605 606
      result = ZMIField.has_value(self, id)
    else:
      proxy_field = self.getTemplateField()
      if proxy_field is not None:
        result = proxy_field.has_value(id)
    return result
607 608 609 610 611 612 613 614 615 616

  security.declareProtected('Access contents information', '_get_user_input_value')
  def _get_user_input_value(self, key, REQUEST):
    """
    Try to get a value of the field from the REQUEST
    """
    proxy_field = self.getTemplateField()
    if proxy_field is not None:
      result = proxy_field._get_user_input_value(key, REQUEST)
    else:
617 618
      result = ZMIField._get_user_input_value(self, key, REQUEST)
    return result
619

620 621 622 623 624 625 626
  security.declareProtected('Access contents information', 'get_orig_value')
  def get_orig_value(self, id):
    """Get value for id; don't do any override calculation.
    """
    if id not in self.widget.property_names and self.is_delegated(id):
      return self.getTemplateField().get_orig_value(id)
    return ZMIField.get_orig_value(self, id)
627 628 629

  security.declareProtected('Access contents information', 'get_value')
  def get_value(self, id, **kw):
630
    if id in self.widget.property_names:
631 632
      return ZMIField.get_value(self, id, **kw)
    try:
633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652
      field = self.getRecursiveTemplateField(id)
      if isinstance(field, ProxyField):
        cls = field.getRecursiveTemplateField().__class__
        try:
          _ProxyField = cls.__ProxyField
        except AttributeError:
          class _ProxyField(cls):
            def __init__(self):
              pass
          cls.__ProxyField = _ProxyField
        tmp_field = _ProxyField()
        for attr in 'values', 'tales', 'overrides':
          setattr(tmp_field, attr, getattr(field, attr).copy())
        field = tmp_field
    except BrokenProxyField:
      # do not break Form.get_field
      if id != 'enabled':
        raise
    else:
      return field.get_value(id, field=self, **kw)
653 654

  def _getCacheId(self):
655 656
    assert self._p_oid
    return 'ProxyField', self._p_oid
657 658

  def _setTemplateFieldCache(self, field):
659
    getTransactionalVariable()[self._getCacheId()] = field
660 661

  def _getTemplateFieldCache(self):
662 663
    parent = self.aq_parent
    if parent is not None:
664
      cache = getTransactionalVariable()[self._getCacheId()]
665 666 667
      if cache is not None:
        return cache.__of__(parent)
    raise KeyError
668

669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692
  security.declareProtected('Change Formulator Fields', 'checkConsistency')
  def checkConsistency(self, fixit=False):
    """Check the proxy field internal data structures are consistent
    """
    object_relative_url = '/'.join(self.getPhysicalPath())[len(self.getPortalObject().getPath()):]
    difference = set(self.tales).difference(self.values)
    if difference:
      if fixit:
        for key in difference:
          if key in self.delegated_list:
            self.values[key] = self.get_recursive_orig_value(key, include=0)
          else:
            self.tales.pop(key)
        # XXX since we are modifying the field, let's take this opportunity
        # to sort delegated_list if it was not sorted.
        self.delegated_list = sorted(self.delegated_list)
        self._p_changed = True

      return [
        ObjectMessage(
             object_relative_url=object_relative_url,
             message="Internal proxy field data structures are inconsistent. "
                     "Differences: {}".format(difference))]
    return []