def get_ttw_fields(obj): """Returns names of the fields that were added to obj through the web""" fti = getUtility(IDexterityFTI, name=obj.portal_type) full_schema = fti.lookupSchema() all_fields = schema.getFieldsInOrder(full_schema) schema_policy = getUtility(ISchemaPolicy, name=fti.schema_policy) original_schema = schema_policy.bases(None, None)[0] original_fields = schema.getFieldsInOrder(original_schema) new_fields = [ field[0] for field in all_fields if field[0] not in dict(original_fields).keys() ] for behavior_id in fti.behaviors: behavior = getUtility(IBehavior, behavior_id).interface if behavior in IGNORED_BEHAVIORS or not IFormFieldProvider.providedBy( behavior): continue try: default_fieldset_fields = non_fieldset_fields(behavior) behavior_name = behavior_id.split('.')[-1] # @TODO: get generic method to get widget id new_fields.extend([ '%s.%s' % (behavior_name, field_name) for field_name in default_fieldset_fields ]) except: pass return new_fields
def copy_fields_dexterity(self, source, target): # Copy the content from the canonical fields try: fields = schema.getFieldsInOrder( source.getTypeInfo().lookupSchema()) # noqa except AttributeError as e: log.info("Error: %s" % "/".join(source.getPhysicalPath())) log.exception(e) return for key, value in fields: if key.lower() in SKIPPED_FIELDS_DX: # skip language log.info("Skipped %s" % key) continue self.change_content(source, target, key, value) # Copy the contents from behaviors behavior_assignable = IBehaviorAssignable(source) if behavior_assignable: behaviors = behavior_assignable.enumerateBehaviors() for behavior in behaviors: for key, value in getFieldsInOrder(behavior.interface): if key.lower() in SKIPPED_FIELDS_DX: # skip language log.info("Skipped %s" % key) continue self.change_content_for_behavior(source, target, key, behavior.interface)
def researh_fields_dexterity(item): # Get fields from schema fields = { "created": { "type": "datetime" }, "modified": { "type": "datetime" }, "immediately_addable_types": { "type": "lines" }, "locally_allowed_types": { "type": "lines" }, "constrain_types_mode": { "type": "integer" }, } for field_name, field_instance in getFieldsInOrder( item.getTypeInfo().lookupSchema()): fields[field_name] = parse_field_dexterity(field_name, field_instance) # Get fields from behaviors behavior_assignable = IBehaviorAssignable(item) if behavior_assignable: behaviors = behavior_assignable.enumerateBehaviors() for behavior in behaviors: for field_name, field_instance in getFieldsInOrder( behavior.interface): fields[field_name] = parse_field_dexterity( field_name, field_instance) return fields
def get_ttw_fields(obj): """Returns names of the fields that were added to obj through the web""" fti = getUtility(IDexterityFTI, name=obj.portal_type) full_schema = fti.lookupSchema() all_fields = schema.getFieldsInOrder(full_schema) schema_policy = getUtility(ISchemaPolicy, name=fti.schema_policy) original_schema = schema_policy.bases(None, None)[0] original_fields = schema.getFieldsInOrder(original_schema) new_fields = [field[0] for field in all_fields if field[0] not in dict(original_fields).keys()] for behavior_id in fti.behaviors: behavior = getUtility(IBehavior, behavior_id).interface if behavior == IContactDetails or not IFormFieldProvider.providedBy(behavior): continue try: default_fieldset_fields = non_fieldset_fields(behavior) behavior_name = behavior_id.split('.')[-1] # @TODO: get generic method to get widget id new_fields.extend(['%s.%s' % (behavior_name, field_name) for field_name in default_fieldset_fields]) except: pass return new_fields
def _fields(self): """ """ context = self.context behavior_fields = [] # Stap 1 metadata behavior_assignable = IBehaviorAssignable(context) if behavior_assignable: behaviors = behavior_assignable.enumerateBehaviors() for behavior in behaviors: behavior_fields += getFieldsInOrder(behavior.interface) # Stap 2 eigen velden fti = context.getTypeInfo() schema = fti.lookupSchema() content_fields = getFieldsInOrder(schema) fields = behavior_fields fields += content_fields # for field_info in fields: # try: # field_name = field_info[0] # field = field_info[1] # print field_info # print getattr(context, field_name) # except Exception, e: # pass return fields
def get_schema_fields(model_or_obj, marker=None): for schema in get_schemas(model_or_obj): for name, field in getFieldsInOrder(schema): yield name, field, schema if model_implements_marker(model_or_obj, marker): for name, field in getFieldsInOrder(marker): yield name, field, marker
def __call__(self, context, query=None): results = [] field_ids = [] exclude = ['im_handle', 'use_parent_address'] exclude_behaviors = ['plone.app.content.interfaces.INameFromTitle'] behaviors = set() portal_types = api.portal.get_tool('portal_types') contact_portal_types = ['person', 'organization', 'position', 'held_position'] # noqa for contact_portal_type in contact_portal_types: schema = getUtility( IDexterityFTI, name=contact_portal_type).lookupSchema() fieldsets = mergedTaggedValueList(schema, FIELDSETS_KEY) for name, field in getFieldsInOrder(schema): if name not in exclude and name not in field_ids: visible_name = u'{0}: {1}'.format( contact_portal_type, field.title) field_ids.append(name) results.append((name, visible_name)) portal_type = getattr(portal_types, contact_portal_type) behaviors.update(set(portal_type.behaviors)) try: # remove duplicates photo results.remove(('photo', u'held_position: Photo')) except ValueError: pass for behavior in behaviors: if behavior not in exclude_behaviors: try: # not able to get fields from IDirectoryContactDetails # with nameToInterface(context, behavior) if behavior == 'cpskin.core.behaviors.directorycontact.IDirectoryContactDetails': # noqa from cpskin.core.behaviors.directorycontact import ( IDirectoryContactDetails) interface = IDirectoryContactDetails else: interface = nameToInterface(context, behavior) fieldsets = mergedTaggedValueList(interface, FIELDSETS_KEY) for name, field in getFieldsInOrder(interface): if name not in exclude and name not in field_ids: if not fieldsets: visible_name = field.title else: fieldset = [ fieldset for fieldset in fieldsets if name in fieldset.fields # noqa ][0] field_ids.append(name) visible_name = u'{0}: {1}'.format( fieldset.label, field.title) results.append((name, visible_name)) except: pass items = [ SimpleTerm(i, i, j) for i, j in results if j ] return SimpleVocabulary(items)
def __call__(self, context, query=None): results = [] field_ids = [] exclude = ['im_handle', 'use_parent_address'] exclude_behaviors = ['plone.app.content.interfaces.INameFromTitle'] behaviors = set() portal_types = api.portal.get_tool('portal_types') contact_portal_types = [ 'person', 'organization', 'position', 'held_position' ] # noqa for contact_portal_type in contact_portal_types: schema = getUtility(IDexterityFTI, name=contact_portal_type).lookupSchema() fieldsets = mergedTaggedValueList(schema, FIELDSETS_KEY) for name, field in getFieldsInOrder(schema): if name not in exclude and name not in field_ids: visible_name = u'{0}: {1}'.format(contact_portal_type, field.title) field_ids.append(name) results.append((name, visible_name)) portal_type = getattr(portal_types, contact_portal_type) behaviors.update(set(portal_type.behaviors)) try: # remove duplicates photo results.remove(('photo', u'held_position: Photo')) except ValueError: pass for behavior in behaviors: if behavior not in exclude_behaviors: try: # not able to get fields from IDirectoryContactDetails # with nameToInterface(context, behavior) if behavior == 'cpskin.core.behaviors.directorycontact.IDirectoryContactDetails': # noqa from cpskin.core.behaviors.directorycontact import ( IDirectoryContactDetails) interface = IDirectoryContactDetails else: interface = nameToInterface(context, behavior) fieldsets = mergedTaggedValueList(interface, FIELDSETS_KEY) for name, field in getFieldsInOrder(interface): if name not in exclude and name not in field_ids: if not fieldsets: visible_name = field.title else: fieldset = [ fieldset for fieldset in fieldsets if name in fieldset.fields # noqa ][0] field_ids.append(name) visible_name = u'{0}: {1}'.format( fieldset.label, field.title) results.append((name, visible_name)) except: pass items = [SimpleTerm(i, i, j) for i, j in results if j] return SimpleVocabulary(items)
def get_dx_schema(context): schema = dict(getFieldsInOrder(context.getTypeInfo().lookupSchema())) behavior_assignable = IBehaviorAssignable(context) if behavior_assignable: for behavior in behavior_assignable.enumerateBehaviors(): for k, v in getFieldsInOrder(behavior.interface): schema[k] = v return schema
def get_field_data(self): from plone.dexterity.interfaces import IDexterityFTI from plone.behavior.interfaces import IBehaviorAssignable data = {} schema = getUtility(IDexterityFTI, name=self.obj.portal_type).lookupSchema() for name, field in getFieldsInOrder(schema): data[name] = getattr(self.obj, name, None) behavior_assignable = IBehaviorAssignable(self.obj) for behavior in behavior_assignable.enumerateBehaviors(): binst = behavior.interface(self.obj) bdata = {} for name, field in getFieldsInOrder(behavior.interface): bdata[name] = getattr(binst, name, None) data[behavior.interface.__identifier__] = bdata if ILayoutAware.providedBy(self.obj): from plone.tiles.data import ANNOTATIONS_KEY_PREFIX from plone.app.blocks.utils import getLayout from repoze.xmliter.utils import getHTMLSerializer from plone.app.blocks import tiles from plone.app.blocks import gridsystem from lxml.html import tostring tdata = {} annotations = IAnnotations(self.obj, {}) for key in annotations.keys(): if key.startswith(ANNOTATIONS_KEY_PREFIX): adata = annotations[key] tdata[key] = adata data['tile_data'] = tdata req = site.REQUEST layout = getLayout(self.obj) dom = getHTMLSerializer(layout) try: tiles.renderTiles(req, dom.tree, site=site, baseURL=self.obj.absolute_url() + '/layout_view') except TypeError: tiles.renderTiles(req, dom.tree, baseURL=self.obj.absolute_url() + '/layout_view') gridsystem.merge(req, dom.tree) data['rendered_layout'] = tostring(dom.tree) return data
def _all_fields(self): type_info = self.context.getTypeInfo() if type_info is None: return schema = type_info.lookupSchema() for field in getFieldsInOrder(schema): yield field behavior_assignable = IBehaviorAssignable(self.context) if behavior_assignable: for behavior in behavior_assignable.enumerateBehaviors(): for field in getFieldsInOrder(behavior.interface): yield field
def get_ttw_fields(obj): """Returns names of the fields that were added to obj through the web""" fti = getUtility(IDexterityFTI, name=obj.portal_type) full_schema = fti.lookupSchema() all_fields = schema.getFieldsInOrder(full_schema) schema_policy = getUtility(ISchemaPolicy, name=fti.schema_policy) original_schema = schema_policy.bases(None, None)[0] original_fields = schema.getFieldsInOrder(original_schema) new_fields = frozenset(dict(all_fields).keys()) - \ frozenset(dict(original_fields).keys()) return new_fields
def get_ordered_fields(fti): """ return fields in fieldset order """ # NOTE: code extracted from collective.excelexport. Original comments # preserved # this code is much complicated because we have to get sure # we get the fields in the order of the fieldsets # the order of the fields in the fieldsets can differ # of the getFieldsInOrder(schema) order... # that's because fields from different schemas # can take place in the same fieldset schema = fti.lookupSchema() fieldset_fields = {} ordered_fieldsets = ['default'] for fieldset in schema.queryTaggedValue(FIELDSETS_KEY, []): ordered_fieldsets.append(fieldset.__name__) fieldset_fields[fieldset.__name__] = fieldset.fields if fieldset_fields.get('default', []): fieldset_fields['default'] += non_fieldset_fields(schema) else: fieldset_fields['default'] = non_fieldset_fields(schema) # Get the behavior fields fields = getFieldsInOrder(schema) for behavior_id in fti.behaviors: schema = getUtility(IBehavior, behavior_id).interface if not IFormFieldProvider.providedBy(schema): continue fields.extend(getFieldsInOrder(schema)) for fieldset in schema.queryTaggedValue(FIELDSETS_KEY, []): fieldset_fields.setdefault( fieldset.__name__, []).extend(fieldset.fields) ordered_fieldsets.append(fieldset.__name__) fieldset_fields['default'].extend(non_fieldset_fields(schema)) ordered_fields = [] for fieldset in ordered_fieldsets: ordered_fields.extend(fieldset_fields[fieldset]) fields.sort(key=lambda field: ordered_fields.index(field[0])) return fields
def _image_field_info(self): type_info = self.context.getTypeInfo() schema = type_info.lookupSchema() fields = getFieldsInOrder(schema) behavior_assignable = IBehaviorAssignable(self.context) if behavior_assignable: behaviors = behavior_assignable.enumerateBehaviors() for behavior in behaviors: fields += getFieldsInOrder(behavior.interface) for fieldname, field in fields: img_field = getattr(self.context, fieldname, None) if img_field and IImage.providedBy(img_field): yield (fieldname, img_field)
def add_subscriber_in_period(self, context, period, subscriber, form, data): request = self.request subscriber.first_name = data.get("first_name") subscriber.last_name = data.get("last_name") subscriber.email = data.get("email") subscriber.number_of_people = int(data.get("number_of_people")) subscriber.reindexObject() period.reindexObject() mailer = get_actions(context).get("mailer") if not mailer: return extra_form = DummyFormView(context, request) extra_form.schema = form.schema extra_form.prefix = "form" extra_form._update() subscriber_fields = [x[0] for x in getFieldsInOrder(ISubscriber)] subscriber_fields.append("period") widgets = filter_widgets(extra_form.widgets, subscriber_fields) data = filter_fields(data, extra_form.schema, subscriber_fields) bodyfield = mailer.body_pt extra = { "data": data, "fields": OrderedDict([(i, j.title) for i, j in getFieldsInOrder(extra_form.schema)], ), "widgets": widgets, "mailer": mailer, "body_pre": "", "body_post": "", "body_footer": "", } template = ZopePageTemplate(mailer.__name__) template.write(bodyfield) template = template.__of__(context) subscriber.all_informations = RichTextValue( template.pt_render(extra_context=extra), ) subscriber.reindexObject()
def fields(self): class o(object): def __init__(self, n, d, v): self.name = n self.title = d.title self.value = v @property def richtext(self): return isinstance(self.value, RichTextValue) @property def has_value(self): if self.richtext: return not not self.value.output return not not self.value for (n, d) in getFieldsInOrder(ISyllabus): v = getattr(self.context, n, '') if n not in [ 'semester', ]: _o = o(n, d, v) if _o.has_value: yield _o
def get_configured_fields(self): context = self.context tileType = queryUtility(ITileType, name=self.__name__) conf = self.get_tile_configuration() fields = getFieldsInOrder(tileType.schema) uuid = self.data.get('uuid', '') results = [] for name, field in fields: image_field = INamedImageField.providedBy(field) data = self.data[name] if not ((image_field and (data or uuid)) or (not image_field and data)): # If there's no data for this field, ignore it # special condition, if the field is an image field and # there is no uuid, then ignore it too continue if isinstance(data, RichTextValue): transformer = ITransformer(context, None) if transformer is not None: content = transformer(data, 'text/x-html-safe') else: content = data field = {'id': name, 'content': content, 'title': field.title} if not self._include_updated_field(field, conf.get(name)): continue results.append(field) return results
def dump(self, schema): log.info(" Dumping schema %r" % schema.__identifier__) fields = [] field_dumper = FieldDumper(schema) for name, field in getFieldsInOrder(schema): dottedname = '.'.join((schema.__identifier__, field.getName())) if dottedname in IGNORED_FIELDS: log.info(" Skipping field %s" % dottedname) continue field_dump = field_dumper.dump(field) fields.append(field_dump) schema_dump = OrderedDict(( ('name', schema.__identifier__), ('fields', fields), )) # Fieldsets fieldsets = self._get_fieldsets_for_schema(schema) if fieldsets: schema_dump['fieldsets'] = fieldsets return schema_dump
def __init__(self, model, **kwargs): BaseFieldSet.__init__(self, model, **kwargs) self.iface = model self.rebind(model) self._fields = OrderedDict() self._render_fields = OrderedDict() self._bound_pk = None for name, field in schema.getFieldsInOrder(self.iface): klass = field.__class__ try: t = self._fields_mapping[klass] except KeyError: raise NotImplementedError('%s is not mapped to a type' % klass) else: self.append(Field(name=name, type=t)) self._fields[name].label_text = field.title or name if field.description: self._fields[name].set(instructions=field.description) if field.required: self._fields[name].validators.append(validators.required) if klass is schema.Password: self._fields[name].set(renderer=fields.PasswordFieldRenderer) if klass is schema.Text: self._fields[name].set(renderer=fields.TextAreaFieldRenderer) if klass is schema.List: value_type = self.iface[name].value_type if isinstance(value_type, schema.Choice): self._fields[name].set(options=value_type, multiple=True) else: self._fields[name].set(multiple=True) elif klass is schema.Choice: self._fields[name].set(renderer=fields.SelectFieldRenderer, options=self.iface[name])
def render(self, **kwargs): """ Render exhibit view """ options = { 'lens': self.lens, 'id': self.__name__.replace('.', '-'), 'extra': "" } # Add extra stuff extra = [] for name, field in schema.getFieldsInOrder(IExhibitTimelineEdit): if name == u"lens": continue elif name == u"start" and self.start: extra.append('ex:start="%s"' % self.start) continue elif name == u"end" and self.end: extra.append('ex:end="%s"' % self.end) continue elif not name.startswith('ex_'): continue # Extra value = self.data.get(name, field.default) if value is None: continue ex_name = name.replace('ex_', 'ex:') extra.append('%s="%s"' % (ex_name, value)) options['extra'] = " ".join(extra) return self.ex_template % options
def get_schema_validation_errors(action_data, schema): """Validate a dict against a schema. Return a list of basic schema validation errors (required fields, constraints, but doesn't check invariants yet). Loosely based on zope.schema.getSchemaValidationErrors, but: - Processes fields in schema order - Handles dict subscription access instead of object attribute access - Respects required / optional fields - Raises RequiredMissing instead of SchemaNotFullyImplemented """ errors = [] for name, field in getFieldsInOrder(schema): try: value = action_data[name] except KeyError: # property for the given name is not implemented if not field.required: continue errors.append((name, RequiredMissing(name))) else: try: field.bind(action_data).validate(value) except ValidationError as e: errors.append((name, e)) # Also reject fields that are not part of the schema errors.extend(get_unknown_fields(action_data, schema)) return errors
def setData(self, data, metadata): """Inserts the field data on self.context """ for schemata in iterSchemata(self.context): repr = schemata(self.context) subdata = data.get(schemata.getName(), {}) for name, field in schema.getFieldsInOrder(schemata): if name not in subdata: continue value = subdata[name] value = self.unpack(name, field, value) if value == _marker: continue if name == 'description' and value == '' and isinstance( value, str): # Prevent ValueError: Description must be unicode. # Dexterity has a wrong default description which is str instead # of unicode. value = u'' setattr(repr, name, value) if HAS_RELATIONS: updateRelations(self.context, None)
def get_field_by_name(fieldname, context): schemata = iterSchemata(context) for schema in schemata: fields = getFieldsInOrder(schema) for fn, field in fields: if fn == fieldname: return field
def migrate_schema_fields(self): for schemata in iterSchemataForType('DashboardPODTemplate'): for fieldName, field in getFieldsInOrder(schemata): # bypass interface methods if not IMethod.providedBy(field): # special handling for file field setattr(self.new, fieldName, getattr(self.old, fieldName, None))
def _exportNode(self): """Export the object as a DOM node. """ node = self._getObjectNode('object') settings = queryAdapter(self.context, ISettings) for name, _field in schema.getFieldsInOrder(ISettings): child = self._doc.createElement('property') child.setAttribute('name', name) value = getattr(settings, name) if isinstance(value, (tuple, list)): for item in value: if not value: continue element = self._doc.createElement('element') element.setAttribute('value', item) child.appendChild(element) else: if isinstance(value, (bool, int)): value = repr(value) value = self._doc.createTextNode(value) child.appendChild(value) node.appendChild(child) for child in self.context.objectValues(): exporter = queryMultiAdapter((child, self.environ), IBody) node.appendChild(exporter.node) return node
def enumerate_iface_fields(iface, exclude=[], include=[]): for name, field in getFieldsInOrder(iface): if name in exclude: continue if include and name not in include: continue yield name, field
def migrate(self, old, new): marker.mark(new, ILogoMarker) for name, field in schema.getFieldsInOrder(ILogoContent): migrate_simplefield(old, ILogoContent(new), name, name) _logger.info("Migrating Logo Content for %s" % new.absolute_url())
def get_mail_body(self, fields, request, context): """Returns the mail-body with footer. """ schema = get_fields(context) all_fields = [f for f in fields # TODO # if not (f.isLabel() or f.isFileField()) and not (getattr(self, # 'showAll', True) and f.getServerSide())] if not (INamedFile.providedBy(fields[f])) and not (getattr(self, 'showAll', True) and IFieldExtender(schema[f]).serverSide) ] # which fields should we show? if getattr(self, 'showAll', True): live_fields = all_fields else: live_fields = [ f for f in all_fields if f in getattr(self, 'showFields', ())] if not getattr(self, 'includeEmpties', True): all_fields = live_fields live_fields = [f for f in all_fields if fields[f]] for f in all_fields: value = fields[f] if value: live_fields.append(f) #bare_fields = [schema[f] for f in live_fields] bare_fields = dict([(f, fields[f]) for f in live_fields]) bodyfield = self.body_pt # pass both the bare_fields (fgFields only) and full fields. # bare_fields for compatability with older templates, # full fields to enable access to htmlValue replacer = DollarVarReplacer(fields).sub extra = { 'data': bare_fields, 'fields': dict([(i, j.title) for i, j in getFieldsInOrder(schema)]), 'mailer': self, 'body_pre': self.body_pre and replacer(self.body_pre), 'body_post': self.body_post and replacer(self.body_post), 'body_footer': self.body_footer and replacer(self.body_footer), } template = ZopePageTemplate(self.__name__) template.write(bodyfield) template = template.__of__(context) body = template.pt_render(extra_context=extra) # if isinstance(body, unicode): #body = body.encode("utf-8") #keyid = getattr(self, 'gpg_keyid', None) #encryption = gpg and keyid # if encryption: #bodygpg = gpg.encrypt(body, keyid) # if bodygpg.strip(): #body = bodygpg return body
def to_widget_value(self, value): """Just dispatch it.""" if value is self.field.missing_value: return NO_VALUE retval = ObjectWidgetValue() retval.original_value = value registry = self.widget.request.registry for name, field in getFieldsInOrder(self.field.schema): dman = registry.getMultiAdapter((value, field), IDataManager) subv = dman.query() if subv is NO_VALUE: # look up default value subv = field.default # XXX: too many discriminators # adapter = zope.component.queryMultiAdapter( # (context, self.request, self.view, field, widget), # interfaces.IValue, name='default') # if adapter: # value = adapter.get() widget = registry.getMultiAdapter((field, self.widget.request), IFieldWidget) if IFormAware.providedBy(self.widget): # form property required by objectwidget widget.form = self.widget.form alsoProvides(widget, IFormAware) converter = registry.getMultiAdapter((field, widget), IDataConverter) retval[name] = converter.to_widget_value(subv) return retval
def render(self, **kwargs): """ Render exhibit view """ options = { 'lens': self.lens, 'id': self.__name__.replace('.', '-'), 'extra': "" } # Add extra stuff extra = [] for name, field in schema.getFieldsInOrder(IExhibitTileEdit): if name == u"lens": continue elif not name.startswith('ex_'): continue # Extra value = self.data.get(name, field.default) if value is None: continue ex_name = name.replace('ex_', 'ex:') extra.append('%s="%s"' % (ex_name, value)) options['extra'] = " ".join(extra) return self.ex_template % options
def _set_default_configuration(self): defaults = {} tile_type = getUtility(ITileType, name=self.tile.__name__) fields = getFieldNamesInOrder(tile_type.schema) for name, field in getFieldsInOrder(tile_type.schema): order = unicode(fields.index(name)) # default configuration attributes for all fields defaults[name] = {'order': order, 'visibility': u'on'} if name == 'css_class': # css_class, set default defaults[name] = field.default if ITextLine.providedBy(field): # field is TextLine, we should add 'htmltag' defaults[name]['htmltag'] = u'h2' elif INamedBlobImageField.providedBy(field): # field is an image, we should add 'position' and 'imgsize' defaults[name]['position'] = u'left' defaults[name]['imgsize'] = u'mini 200:200' elif IInt.providedBy(field): defaults[name][name] = field.default elif IDatetime.providedBy(field): # field is Datetime, we should add 'format' defaults[name]['format'] = 'datetime' return defaults
def render(self, **kwargs): """ Render exhibit view """ options = {"lens": self.lens, "id": self.__name__.replace(".", "-"), "extra": ""} # Add extra stuff extra = [] for name, field in schema.getFieldsInOrder(IExhibitMapEdit): if name == u"lens": continue elif name == u"latlng" and self.latlng: extra.append('ex:latlng=".%s"' % self.latlng) continue elif name == u"lat" and self.lat: extra.append('ex:lat=".%s"' % self.lat) continue elif name == u"lng" and self.lng: extra.append('ex:lng=".%s"' % self.lng) continue elif not name.startswith("ex_"): continue # Extra value = self.data.get(name, field.default) if value is None: continue ex_name = name.replace("ex_", "ex:") extra.append('%s="%s"' % (ex_name, value)) options["extra"] = " ".join(extra) return self.ex_template % options
def get_taxonomies(self): """Return all field added by taxonomies""" portal_type = self.context.portal_type schema = getUtility(IDexterityFTI, name=portal_type).lookupSchema() fields = getFieldsInOrder(schema) taxonomies = [] for name, field in fields: # categories check is a hack for Namur, do not remove it. if (name.startswith('taxonomy_') or 'categories' in name) \ and field: if getattr(field, 'value_type', None): vocabulary_name = field.value_type.vocabularyName else: vocabulary_name = field.vocabularyName factory = getUtility(IVocabularyFactory, vocabulary_name) vocabulary = factory(api.portal.get()) tokens = getattr(self.context, name, '') if not tokens: continue if isinstance(tokens, basestring): tokens = [tokens] categories = [] for token in tokens: if token in vocabulary.inv_data.keys(): cat = vocabulary.inv_data.get(token) categories.append(cat[1:]) categories.sort() tax = {} tax['name'] = field.title tax['id'] = name tax['value'] = ', '.join(categories) taxonomies.append(tax) return sort_taxonomies(taxonomies)
def field(self, value): """ The field information is passed to the widget after it is initialised. Use this call to initialise the column definitions. """ self._field = value schema = self._field.value_type.schema fieldmodes = {} if MODES_KEY: try: modes_tags = schema.getTaggedValue(MODES_KEY) except KeyError: pass else: for __, fieldname, mode in modes_tags: fieldmodes[fieldname] = mode self.columns = [] for name, field in getFieldsInOrder(schema): col = { 'name': name, 'label': field.title, 'description': field.description, 'required': field.required, 'mode': fieldmodes.get(name, None), } self.columns.append(col)
def modifiedDexterity(obj, event): """ a dexterity based object was modified """ pu = getToolByName(obj, 'portal_url', None) if pu is None: # `getObjectFromLinks` is not possible without access # to `portal_url` return rc = getToolByName(obj, 'reference_catalog', None) if rc is None: # `updateReferences` is not possible without access # to `reference_catalog` return fti = getUtility(IDexterityFTI, name=obj.portal_type) schema = fti.lookupSchema() additional_schema = getAdditionalSchemata(context=obj, portal_type=obj.portal_type) schemas = [i for i in additional_schema] + [schema] refs = set() for schema in schemas: for name, field in getFieldsInOrder(schema): if isinstance(field, RichText): # Only check for "RichText" ? value = getattr(schema(obj), name) if not value: continue links = extractLinks(value.raw) refs |= getObjectsFromLinks(obj, links) updateReferences(IReferenceable(obj), referencedRelationship, refs)
def getFields(self): fields = [] for schema_name, schema in self._getSchemas(): for field_name, field in getFieldsInOrder(schema): if IChoice.providedBy(field): fields.append(StringField( schema_name + '.' + field.__name__, required=field.required, schemata='categorization', widget=atapi.SelectionWidget( label = field.title, description = field.description, ), vocabulary = atapi.DisplayList([(t.value, t.title or t.token) for t in field.vocabulary]), )) elif ISet.providedBy(field) and IChoice.providedBy(field.value_type): # XXX should be set fields.append(LinesField( schema_name + '.' + field.__name__, required=field.required, schemata='categorization', widget=atapi.MultiSelectionWidget( label = field.title, description = field.description, ), vocabulary = atapi.DisplayList([(t.value, t.title or t.token) for t in field.value_type.vocabulary]), )) return fields
def render(self): el = ElementTree.Element(ElementTree.QName(self.namespace, self.name)) if self._value is None: return el interface = self.context.schema for name, field in getFieldsInOrder(interface): field = field.bind(self._value) field_value = field.get(self._value) # Careful this could result in elements not been displayed that # should be. This is tested in test_widgets but it mightened be # what some people think. if field_value == field.missing_value and \ not self.render_missing_values and not field.required: continue widget = zope.component.getMultiAdapter((field, self.request), interfaces.IDAVWidget) widget.namespace = self.namespace widget.setRenderedValue(field.get(self._value)) el.append(widget.render()) return el
def field(self, value): """ The field information is passed to the widget after it is initialised. Use this call to initialise the column definitions. """ self._field = value schema = self._field.value_type.schema fieldmodes = {} if MODES_KEY: try: modes_tags = schema.getTaggedValue(MODES_KEY) except KeyError: pass else: for __, fieldname, mode in modes_tags: fieldmodes[fieldname] = mode self.columns = [] for name, field in getFieldsInOrder(schema): col = { 'name': name, 'label': field.title, 'required': field.required, 'mode': fieldmodes.get(name, None), } self.columns.append(col)
def get_configured_fields(self): # Override this method, since we are not storing anything # in the fields, we just use them for configuration tileType = queryUtility(ITileType, name=self.__name__) conf = self.get_tile_configuration() fields = getFieldsInOrder(tileType.schema) results = OrderedDict() for name, obj in fields: field = {'title': obj.title} if name in conf: field_conf = conf[name] if ('visibility' in field_conf and field_conf['visibility'] == u'off'): # If the field was configured to be invisible, then just # ignore it continue if 'htmltag' in field_conf: # If this field has the capability to change its html tag # render, save it here field['htmltag'] = field_conf['htmltag'] if 'imgsize' in field_conf: field['scale'] = field_conf['imgsize'] if 'size' in field_conf: field['size'] = field_conf['size'] results[name] = field return results
def __init__(self, fti=None): if not fti: return sql_connection = queryUtility(ISQLBaseConnectionUtility, name=fti.sql_connection, default=None) if sql_connection: self.connection_name = sql_connection.name else: sql_connection = queryUtility(ISQLBaseConnectionUtility, name=fti.sql_table, default=None) if sql_connection: self.connection_name = sql_connection.name else: processor = SQLBaseConnectionUtility(fti) connection_name = processor.name LOG.info('Base connection utility registered as '+connection_name) gsm = getGlobalSiteManager() gsm.registerUtility(processor, ISQLBaseConnectionUtility, name=connection_name) self.connection_name = connection_name self.sql_table = fti.sql_table self.factory = fti.factory self.sql_id_column = getattr(fti, 'sql_id_column', None) and getattr(fti, 'sql_id_column', None) or 'id' fieldnames = {} for field_name, field in schema.getFieldsInOrder( fti.lookupSchema() ): if getattr(field, 'sql_column', None): sql_column = getattr(field, 'sql_column', None) fieldnames[field_name] = sql_column for line in getattr(fti, 'sql_fields_columns', []): fieldnames[line.split(':')[0]] = line.split(':')[1] self.fieldnames = fieldnames
def modifiedDexterity(obj, event): """ a dexterity based object was modified """ pu = getToolByName(obj, 'portal_url', None) if pu is None: # `getObjectFromLinks` is not possible without access # to `portal_url` return rc = getToolByName(obj, 'reference_catalog', None) if rc is None: # `updateReferences` is not possible without access # to `reference_catalog` return fti = getUtility(IDexterityFTI, name=obj.portal_type) fields = [] schema = fti.lookupSchema() additional_schema = getAdditionalSchemata(context=obj, portal_type=obj.portal_type) schemas = [i for i in additional_schema] + [schema] refs = set() for schema in schemas: for name,field in getFieldsInOrder(schema): if isinstance(field, RichText): # Only check for "RichText" ? value = getattr(schema(obj), name) if not value: continue links = extractLinks(value.raw) refs |= getObjectsFromLinks(obj, links) updateReferences(IReferenceable(obj), referencedRelationship, refs)
def serialize(self, results): """Serialize fields of a list of Dexterity-based content type objects. :param results: [required] list of objects to be serialized :type results: list of catalog brains :returns: list of serialized objects :rtype: list of dictionaries """ s = [] for i in results: obj = i.getObject() # find out object schema to list its fields schema = getUtility(IDexterityFTI, name=obj.portal_type).lookupSchema() # initialize a dictionary with the object uri # XXX: should we use the UUID? fields = dict(uri=obj.absolute_url()) # continue with the rest of the fields for name, field in getFieldsInOrder(schema): # 'name' could be a @property and not a real field if not hasattr(obj, name): continue value = getattr(obj, name) fields[name] = type_cast(value, obj=obj) s.append(fields) return s
def render(self, **kwargs): """ Render exhibit view """ options = { 'lens': self.lens, 'id': self.__name__.replace('.', '-'), 'extra': "" } # Add extra stuff extra = [] for name, field in schema.getFieldsInOrder(IExhibitTabularEdit): if name == u"lens": continue elif name == u"columns": extra.append('ex:columns="%s"' % ", ".join(self.columns)) extra.append('ex:columnLabels="%s"' % ", ".join(self.labels)) extra.append('ex:columnFormats="%s"' % ", ".join(self.formats)) continue elif not name.startswith('ex_'): continue # Extra value = self.data.get(name, field.default) if value is None: continue ex_name = name.replace('ex_', 'ex:') extra.append('%s="%s"' % (ex_name, value)) options['extra'] = " ".join(extra) return self.ex_template % options
def handleSubmit(self, action): unsorted_data, errors = self.extractData() if errors: self.status = self.formErrorsMessage return unsorted_data = self.updateServerSideData(unsorted_data) errors = self.processActions(unsorted_data) if errors: return self.setErrorsMessage(errors) data = OrderedDict( [x for x in getFieldsInOrder(self.schema) if x[0] in unsorted_data] ) data.update(unsorted_data) thanksPageOverride = self.context.thanksPageOverride if thanksPageOverride: thanksPageOverrideAction = self.context.thanksPageOverrideAction thanksPage = get_expression(self.context, thanksPageOverride) if thanksPageOverrideAction == 'redirect_to': self.request.response.redirect(thanksPage) elif thanksPageOverrideAction == 'traverse_to': thanksPage = self.context.restrictedTraverse( thanksPage.encode('utf-8')) thanksPage = mapply( thanksPage, self.request.args, self.request ).encode('utf-8') self.request.response.write(thanksPage) else: # we come back to the form itself. # the thanks page is handled in the __call__ method pass
def handleSubmit(self, action): unsorted_data, errors = self.extractData() if errors: self.status = self.formErrorsMessage return unsorted_data = self.updateServerSideData(unsorted_data) errors = self.processActions(unsorted_data) if errors: return self.setErrorsMessage(errors) data = OrderedDict( [x for x in getFieldsInOrder(self.schema) if x[0] in unsorted_data] ) data.update(unsorted_data) thanksPageOverride = self.context.thanksPageOverride if not thanksPageOverride: # we come back to the form itself. # the thanks page is handled in the __call__ method return thanksPageOverrideAction = self.context.thanksPageOverrideAction thanksPage = get_expression(self.context, thanksPageOverride) if six.PY2 and isinstance(thanksPage, six.text_type): thanksPage = thanksPage.encode("utf-8") if thanksPageOverrideAction == "redirect_to": self.request.response.redirect(thanksPage) return if thanksPageOverrideAction == "traverse_to": thanksPage = self.context.restrictedTraverse(thanksPage) thanksPage = mapply(thanksPage, self.request.args, self.request) self.request.response.write(safe_encode(thanksPage))
def create_subtask(task, data): subtask = createContent('opengever.task.task', id=data['title'], **data) notify(ObjectCreatedEvent(subtask)) subtask = addContentToContainer(task, subtask, checkConstraints=True) for schemata in iterSchemata(subtask): super_repr = schemata(task) repr = schemata(subtask) for name, field in schema.getFieldsInOrder(schemata): if name in data: value = data[name] else: value = getattr(super_repr, name, None) setattr(repr, name, value) activity = TaskAddedActivity(subtask, task.REQUEST, task) activity.record() notify(ObjectModifiedEvent(subtask)) return subtask
def get_configured_fields(self): # Override this method, since we are not storing anything # in the fields, we just use them for configuration tileType = queryUtility(ITileType, name=self.__name__) conf = self.get_tile_configuration() fields = getFieldsInOrder(tileType.schema) results = [] for name, obj in fields: field = {'id': name, 'title': obj.title} if name in conf: field_conf = conf[name] if ('visibility' in field_conf and field_conf['visibility'] == u'off'): # If the field was configured to be invisible, then just # ignore it continue if 'htmltag' in field_conf: # If this field has the capability to change its html tag # render, save it here field['htmltag'] = field_conf['htmltag'] if 'imgsize' in field_conf: field['scale'] = field_conf['imgsize'] if 'size' in field_conf: field['size'] = field_conf['size'] results.append(field) return results
def get_configured_fields(self): # Override this method, since we are not storing anything # in the fields, we just use them for configuration tileType = queryUtility(ITileType, name=self.__name__) conf = self.get_tile_configuration() fields = getFieldsInOrder(tileType.schema) results = [] for name, obj in fields: field = {"id": name, "title": obj.title} if name in conf: field_conf = conf[name] if "visibility" in field_conf and field_conf["visibility"] == u"off": # If the field was configured to be invisible, then just # ignore it continue if "htmltag" in field_conf: # If this field has the capability to change its html tag # render, save it here field["htmltag"] = field_conf["htmltag"] if "imgsize" in field_conf: field["scale"] = field_conf["imgsize"] if "size" in field_conf: field["size"] = field_conf["size"] results.append(field) return results
def set_defaults(obj): for schemata in iterSchemata(obj): for name, field in getFieldsInOrder(schemata): try: value = field.get(field.interface(obj)) if value: # field is present with a truthy value, nothing to do continue except AttributeError: # Field not present, set default pass default = queryMultiAdapter( (obj, obj.REQUEST, None, field, None), IValue, name='default') if default is not None: default = default.get() if default is None: default = getattr(field, 'default', None) if default is None: try: default = field.missing_value except AttributeError: pass field.set(field.interface(obj), default) return obj
def map_with_vocab(self, behavior, fieldname, value): """Look in the schema for a vocab and return the mapped value """ if type(value) == int: return str(value) portal = self.layer['portal'] fields = getFieldsInOrder(behavior) for name, field in fields: if name == fieldname: # We have different types of fields, so we have to check, # that we become the vocabulary value_type = field if IList.providedBy(field) or ITuple.providedBy(field): value_type = field.value_type if IChoice.providedBy(value_type): if value_type.vocabulary: vocab = value_type.vocabulary(portal) else: vocab = getVocabularyRegistry().get( portal, value_type.vocabularyName) value = vocab.getTerm(value).title return value