def setDefaults(self, instance): """Only call during object initialization. Sets fields to schema defaults """ # TODO think about layout/vs dyn defaults for field in self.values(): if field.getName().lower() == 'id': continue if field.type == "reference": continue # always set defaults on writable fields mutator = field.getMutator(instance) if mutator is None: continue default = field.getDefault(instance) args = (default,) kw = {'field': field.__name__, '_initializing_': True} if shasattr(field, 'default_content_type'): # specify a mimetype if the mutator takes a # mimetype argument # if the schema supplies a default, we honour that, # otherwise we use the site property default_content_type = field.default_content_type if default_content_type is None: default_content_type = getDefaultContentType(instance) kw['mimetype'] = default_content_type mapply(mutator, *args, **kw)
def test_ATDocumentDefaultType(self): # move portal_properties out of the way. it was not here # when we used CMFTestCase and now it fools with the # default mimetype tests _orignal_pp = self.portal['portal_properties'] self.portal._delObject('portal_properties', suppress_events=True) from Products.CMFCore.utils import _tool_interface_registry _marker = object() ptool = _tool_interface_registry.pop('portal_properties', _marker) self.loginAsPortalOwner() # we create a new document: self.portal.invokeFactory('DDocument', id='testdoc', title='TestDocument') obj = self.portal.testdoc # its text field should have the site wide default 'text/plain' textfield = obj.getField('body') self.assertEqual(textfield.getContentType(obj), 'text/html') # and so has the teaser field: teaserfield = obj.getField('teaser') self.assertEqual(teaserfield.getContentType(obj), 'text/html') # then we try to change the sitewide default: setDefaultContentType(self.portal, "text/x-web-markdown") # while this raises no error it won't change the default, as we have # no properties tool nor properties sheet self.assertEqual(getDefaultContentType(self.portal), 'text/x-web-markdown') self.portal['portal_properties'] = _orignal_pp if ptool is not _marker: _tool_interface_registry['portal_properties'] = ptool
def test_ATDocumentDefaultType(self): # move portal_properties out of the way. it was not here # when we used CMFTestCase and now it fools with the # default mimetype tests _orignal_pp = self.portal['portal_properties'] self.portal._delObject('portal_properties', suppress_events=True) from Products.CMFCore.utils import _tool_interface_registry _marker = object() ptool = _tool_interface_registry.pop('portal_properties', _marker) self.loginAsPortalOwner() # we create a new document: self.portal.invokeFactory( 'DDocument', id='testdoc', title='TestDocument') obj = self.portal.testdoc # its text field should have the site wide default 'text/plain' textfield = obj.getField('body') self.assertEqual(textfield.getContentType(obj), 'text/html') # and so has the teaser field: teaserfield = obj.getField('teaser') self.assertEqual(teaserfield.getContentType(obj), 'text/html') # then we try to change the sitewide default: setDefaultContentType(self.portal, "text/x-web-markdown") # while this raises no error it won't change the default, as we have # no properties tool nor properties sheet self.assertEqual(getDefaultContentType( self.portal), 'text/x-web-markdown') self.portal['portal_properties'] = _orignal_pp if ptool is not _marker: _tool_interface_registry['portal_properties'] = ptool
def setDefaults(self, instance): """Only call during object initialization. Sets fields to schema defaults """ # TODO think about layout/vs dyn defaults for field in self.values(): if field.getName().lower() == 'id': continue if field.type == "reference": continue # always set defaults on writable fields mutator = field.getMutator(instance) if mutator is None: continue default = field.getDefault(instance) args = (default, ) kw = {'field': field.__name__, '_initializing_': True} if shasattr(field, 'default_content_type'): # specify a mimetype if the mutator takes a # mimetype argument # if the schema supplies a default, we honour that, # otherwise we use the site property default_content_type = field.default_content_type if default_content_type is None: default_content_type = getDefaultContentType(instance) kw['mimetype'] = default_content_type mapply(mutator, *args, **kw)
def copyField(self, field, translation): accessor = field.getEditAccessor(self.context) if not accessor: accessor = field.getAccessor(self.context) if accessor: data = accessor() else: data = field.get(self.context) mutator = field.getMutator(translation) # if field.__name__ == 'remarks': # import pdb; pdb.set_trace( ) if mutator is not None: # Protect against weird fields, like computed fields kw = {} if shasattr(field, 'default_content_type'): # specify a mimetype if the mutator takes a # mimetype argument # if the schema supplies a default, we honour that, # otherwise we use the site property default_content_type = field.default_content_type if default_content_type is None: default_content_type = getDefaultContentType(field) kw['mimetype'] = default_content_type mutator(data, **kw) else: field.set(translation, data)
def setDefaults(self, instance): """Only call during object initialization, this function sets fields to schema defaults. It's adapted from the original to support IAcquireFieldDefaults adapters. If IAcquireFieldDefaults adapter does not find a suitable field, or that field's value is Falseish, this function will not continue with the normal default machinery. """ for field in self.values(): # ## bika addition: we fire adapters for IAcquireFieldDefaults. # If IAcquireFieldDefaults returns None, this signifies "ignore" return. # First adapter found with non-None result, wins. value = None if shasattr(field, 'acquire'): adapters = {} for adapter in getAdapters((instance,), IAcquireFieldDefaults): sort_val = getattr(adapter[1], 'sort', 1000) if sort_val not in adapters: adapters[sort_val] = [] adapters[sort_val].append(adapter) if adapters: keys = sorted(adapters.keys()) keys.reverse() adapter = adapters[keys[0]] _value = adapter[0][1](field) if _value is not None: value = _value if field.getName().lower() == 'id': continue # If our adapter reflects a value for a reference field, it will # be permitted. if field.type == "reference" and not value: continue default = value if value else field.getDefault(instance) # always set defaults on writable fields mutator = field.getMutator(instance) if mutator is None: continue args = (default,) kw = {'field': field.__name__, '_initializing_': True} if shasattr(field, 'default_content_type'): # specify a mimetype if the mutator takes a mimetype argument if # the schema supplies a default, we honour that, otherwise we use # the site property default_content_type = field.default_content_type if default_content_type is None: default_content_type = getDefaultContentType(instance) kw['mimetype'] = default_content_type mapply(mutator, *args, **kw)
def setDefaults(self, instance): """Only call during object initialization, this function sets fields to schema defaults. It's adapted from the original to support IAcquireFieldDefaults adapters. If IAcquireFieldDefaults adapter does not find a suitable field, or that field's value is Falseish, this function will not continue with the normal default machinery. """ for field in self.values(): # ## bika addition: we fire adapters for IAcquireFieldDefaults. # If IAcquireFieldDefaults returns None, this signifies "ignore" return. # First adapter found with non-None result, wins. value = None if shasattr(field, 'acquire'): adapters = {} for adapter in getAdapters((instance, ), IAcquireFieldDefaults): sort_val = getattr(adapter[1], 'sort', 1000) if sort_val not in adapters: adapters[sort_val] = [] adapters[sort_val].append(adapter) if adapters: keys = sorted(adapters.keys()) keys.reverse() adapter = adapters[keys[0]] _value = adapter[0][1](field) if _value is not None: value = _value if field.getName().lower() == 'id': continue # If our adapter reflects a value for a reference field, it will # be permitted. if field.type == "reference" and not value: continue default = value if value else field.getDefault(instance) # always set defaults on writable fields mutator = field.getMutator(instance) if mutator is None: continue args = (default, ) kw = {'field': field.__name__, '_initializing_': True} if shasattr(field, 'default_content_type'): # specify a mimetype if the mutator takes a mimetype argument if # the schema supplies a default, we honour that, otherwise we use # the site property default_content_type = field.default_content_type if default_content_type is None: default_content_type = getDefaultContentType(instance) kw['mimetype'] = default_content_type mapply(mutator, *args, **kw)
def setDefaults(self, instance): """Only call during object initialization. Sets fields to schema defaults """ # # TODO think about layout/vs dyn defaults for field in self.values(): value = None # if analysis request, set sampling date to default to today if field.getName().lower() == 'samplingdate' \ and instance.portal_type == 'AnalysisRequest': now = DateTime().strftime("%Y-%m-%d %H:%M") value = now # From here, the rest of the body of the original function: # Products.Archetypes.Schema.BasicSchema#setDefaults if field.getName().lower() == 'id': continue # The original version skipped all reference fields. I obviously do # find some use in defining their defaults anyway, so if our adapter # reflects a value for a reference field, I will allow it. if field.type == "reference" and not value: continue default = value if value else field.getDefault(instance) # always set defaults on writable fields mutator = field.getMutator(instance) if mutator is None: continue args = (default,) kw = {'field': field.__name__, '_initializing_': True} if shasattr(field, 'default_content_type'): # specify a mimetype if the mutator takes a # mimetype argument # if the schema supplies a default, we honour that, # otherwise we use the site property default_content_type = field.default_content_type if default_content_type is None: default_content_type = getDefaultContentType(instance) kw['mimetype'] = default_content_type mapply(mutator, *args, **kw)
def test_ATDocumentDefaultType(self): self.loginAsPortalOwner() # we create a new document: self.portal.invokeFactory('DDocument', id='testdoc', title='TestDocument') obj = self.portal.testdoc # its text field should have the site wide default 'text/plain' textfield = obj.getField('body') self.assertEqual(textfield.getContentType(obj), 'text/plain') # and so has the teaser field: teaserfield = obj.getField('teaser') self.assertEqual(teaserfield.getContentType(obj), 'text/plain') # then we try to change the sitewide default: setDefaultContentType(self.portal, "text/x-web-markdown") # while this raises no error it won't change the default, as we have # no properties tool nor properties sheet self.assertEqual(getDefaultContentType(self.portal), 'text/plain')
def test_ATDocumentDefaultType(self): self.loginAsPortalOwner() # we create a new document: self.portal.invokeFactory('DDocument', id='testdoc', title='TestDocument') obj = self.portal.testdoc # its text field should have the site wide default 'text/plain' textfield = obj.getField('body') self.assertEqual(textfield.getContentType(obj), 'text/plain') # and so has the teaser field: teaserfield = obj.getField('teaser') self.assertEqual(teaserfield.getContentType(obj), 'text/plain') # then we try to change the sitewide default: setDefaultContentType(self.portal, "text/x-web-markdown") # while this raises no error it won't change the default, as we have # no properties tool nor properties sheet self.assertEqual(getDefaultContentType(self.portal), 'text/plain')
def get_default_type(self): return getDefaultContentType(self.context)
def edit(self, context, field, request): """Render widget on edit. :returns: Widget's HTML. :rtype: string """ from Products.Archetypes.mimetype_utils import getAllowedContentTypes from Products.Archetypes.mimetype_utils import getDefaultContentType from lxml import etree rendered = '' allowed_mime_types = getAllowedContentTypes(context) if not allowed_mime_types or len(allowed_mime_types) <= 1: # Display textarea with default widget rendered = self._base( **self._base_args(context, field, request)).render() else: # Let pat-textarea-mimetype-selector choose the widget # Initialize the widget without a pattern base_args = self._base_args(context, field, request) pattern_options = base_args['pattern_options'] del base_args['pattern'] del base_args['pattern_options'] textarea_widget = self._base(None, None, **base_args) textarea_widget.klass = '' mt_pattern_name = '{}{}'.format( self._base._klass_prefix, 'textareamimetypeselector' ) # Initialize mimetype selector pattern value_mime_type = field.getContentType(context)\ or getDefaultContentType(context) mt_select = etree.Element('select') mt_select.attrib['id'] = '{}_text_format'.format(field.getName()) mt_select.attrib['name'] = '{}_text_format'.format(field.getName()) mt_select.attrib['class'] = mt_pattern_name mt_select.attrib['{}{}'.format('data-', mt_pattern_name)] =\ json.dumps({ 'textareaName': field.getName(), 'widgets': { 'text/html': { # TODO: currently, we only support # richtext widget config for # 'text/html', no other mimetypes. 'pattern': self.pattern, 'patternOptions': pattern_options } } }) # Create a list of allowed mime types for mt in allowed_mime_types: opt = etree.Element('option') opt.attrib['value'] = mt if value_mime_type == mt: opt.attrib['selected'] = 'selected' opt.text = mt mt_select.append(opt) # Render the combined widget rendered = '{}\n{}'.format( textarea_widget.render(), etree.tostring(mt_select) ) return rendered