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 handle_field_added(ph_schema, event): field = event.field index_name = ph_schema.__name__ + "." + field.__name__ catalog = getToolByName(getSite(), "portal_catalog") if index_name not in catalog.Indexes: if ISet.providedBy(field) and IChoice.providedBy(field.value_type): catalog.addIndex(index_name, "KeywordIndex") if IChoice.providedBy(field): catalog.addIndex(index_name, "FieldIndex")
def handle_field_added(ph_schema, event): field = event.field index_name = ph_schema.__name__ + '.' + field.__name__ catalog = getToolByName(getSite(), 'portal_catalog') if index_name not in catalog.Indexes: if ISet.providedBy(field) and IChoice.providedBy(field.value_type): catalog.addIndex(index_name, 'KeywordIndex') if IChoice.providedBy(field): catalog.addIndex(index_name, 'FieldIndex')
def _base_args(self): """Method which will calculate _base class arguments. Returns (as python dictionary): - `pattern`: pattern name - `pattern_options`: pattern options - `name`: field name - `value`: field value :returns: Arguments which will be passed to _base :rtype: dict """ args = super(AjaxSelectWidget, self)._base_args() args['name'] = self.name args['value'] = self.value args.setdefault('pattern_options', {}) context = self.context field = None if IChoice.providedBy(self.field): args['pattern_options']['maximumSelectionSize'] = 1 field = self.field elif ICollection.providedBy(self.field): field = self.field.value_type if IChoice.providedBy(field): args['pattern_options']['allowNewItems'] = 'false' args['pattern_options'] = dict_merge(self._ajaxselect_options(), args['pattern_options']) if field and getattr(field, 'vocabulary', None): form_url = self.request.getURL() source_url = '{0:s}/++widget++{1:s}/@@getSource'.format( form_url, self.name, ) args['pattern_options']['vocabularyUrl'] = source_url # ISequence represents an orderable collection if ISequence.providedBy(self.field) or self.orderable: args['pattern_options']['orderable'] = True if self.vocabulary == 'plone.app.vocabularies.Keywords': membership = getToolByName(context, 'portal_membership') user = membership.getAuthenticatedMember() registry = getUtility(IRegistry) roles_allowed_to_add_keywords = registry.get( 'plone.roles_allowed_to_add_keywords', set()) roles = set(user.getRolesInContext(context)) allowNewItems = bool( roles.intersection(roles_allowed_to_add_keywords), ) args['pattern_options']['allowNewItems'] = str( allowNewItems, ).lower() return args
def update(self): super(AddForm, self).update() # set humanized default value for choice fields with no defaults for widget in self.widgets: field = widget.context if IChoice.providedBy(field): if IGenenerateVocabularyDefault.providedBy(widget): field.default = widget.getDefaultVocabularyValue() if IChoice.providedBy(field) and field.default is None: widget._messageNoValue = _("bungeni_widget_no_value", "choose ${title} ...", mapping={"title": field.title})
def update(self): super(AddForm, self).update() # set humanized default value for choice fields with no defaults for widget in self.widgets: field = widget.context if IChoice.providedBy(field): if IGenenerateVocabularyDefault.providedBy(widget): field.default = widget.getDefaultVocabularyValue() if IChoice.providedBy(field) and field.default is None: widget._messageNoValue = _( "bungeni_widget_no_value", "choose ${title} ...", mapping={"title": field.title} )
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
def js(self): value_type = self.field.value_type vocab = None if IChoice.providedBy(self.field.value_type): if value_type.vocabulary: vocab = value_type.vocabulary if value_type.vocabularyName: vocab = getVocabularyRegistry().get( self.context, self.field.value_type.vocabularyName) values = [(term.token, term.value) for term in vocab] old_values = self._get_old_values(vocab) else: values = enumerate(self.context.portal_catalog.uniqueValuesFor('Subject')) old_values = enumerate(self.context.Subject()) tags = "" old_tags = "" index = 0 for index, value in values: tags += "{id: '%s', name: '%s'}" % (value.replace("'", "\\'"), value.replace("'", "\\'")) if values.index((index, value)) < len(values) - 1: tags += ", " old_index = 0 # XXX: this is not used #prepopulate for index, value in old_values: old_tags += u"{id: '%s', name: '%s'}" % (value.replace("'", "\\'"), value.replace("'", "\\'")) if old_values.index((index, value)) < len(old_values) - 1: old_tags += ", " result = self.js_template % dict(id=self.id, klass=self.klass, newtags=unicode(tags, errors='ignore'), oldtags=old_tags) return result
def __call__(self): # Binding is necessary for named vocabularies if IField.providedBy(self.field): self.field = self.field.bind(self.context) value = self.get_value() value_type = self.field.value_type if ( value is not None and IChoice.providedBy(value_type) and IVocabularyTokenized.providedBy(value_type.vocabulary) ): values = [] for v in value: try: term = value_type.vocabulary.getTerm(v) values.append({"token": term.token, "title": term.title}) except LookupError: log.warning( "Term lookup error: %r %s (%s:%s)" % ( v, self.field.title, self.context.portal_type, self.context.absolute_url(1), ) ) value = values return json_compatible(value)
def __init__(self, field, vocabulary, request): # XXX flacoste 2006-07-23 Workaround Zope3 bug #545: # CustomWidgetFactory passes wrong arguments to a MultiCheckBoxWidget if IChoice.providedBy(vocabulary): vocabulary = vocabulary.vocabulary MultiCheckBoxWidget.__init__(self, field, vocabulary, request) self._disabled_items = []
def _validate(self, value): # XXX HACK: Can't call the super, since it'll check to # XXX see if we provide DictRow. # We're only a dict, so we can't. # super(DictRow, self)._validate(value) # Validate the dict against the schema # Pass 1 - ensure fields are present if value is NO_VALUE: return # Treat readonly fields for field_name in getFields(self.schema).keys(): field = self.schema[field_name] if field.readonly: value[field_name] = field.default errors = [] for field_name in getFields(self.schema).keys(): if field_name not in value: errors.append(AttributeNotFoundError(field_name, self.schema)) if errors: raise WrongContainedType(errors, self.__name__) # Pass 2 - Ensure fields are valid for field_name, field_type in getFields(self.schema).items(): if IChoice.providedBy(field_type): # Choice must be bound before validation otherwise # IContextSourceBinder is not iterable in validation bound = field_type.bind(value) bound.validate(value[field_name]) else: field_type.validate(value[field_name])
def import_node_for_field(self, field, child): value = None # If we have a collection, we need to look at the value_type. # We look for <element>value</element> child nodes and get the # value from there if ICollection.providedBy(field): value_type = field.value_type value = [] for element in child.childNodes: if element.nodeName != 'element': continue value.append(self.import_node_for_field(value_type, element)) elif IObject.providedBy(field): value = {} for element in child.childNodes: if element.nodeName != 'property': continue property_key = self.extract_text(element.attributes['name']) property_value = self.import_node_for_field(field.schema[property_key], element) value[property_key] = property_value elif IChoice.providedBy(field): # Choice fields can be optional, so treat an empty contents as None value = self.extract_text(child) if not value: value = None else: value = self.from_unicode(field, value) else: # Otherwise, just get the value of the <property /> node value = self.extract_text(child) if not (field.getName() == 'root' and value in ['', '/']): value = self.from_unicode(field, value) value = self.field_typecast(field, value) return value
def verify_registry_key(self): registry = queryUtility(IRegistry) if registry is None: logger.warning('Plone registry is not available, doing nothing.') return False record = registry.records.get(self.name) if record is None: logger.warning( 'The registry key for the utility registry `%s` is not ' 'registered.', self.name) return False if not (IList.providedBy(record.field) and IChoice.providedBy(record.field.value_type) and record.field.value_type.vocabularyName == self.available_vocab ): logger.warning( 'The registry key for the utility registry `%s` is registered ' 'incorrectly.', self.name) return False return True
def _base_args(self): """Method which will calculate _base class arguments. Returns (as python dictionary): - `pattern`: pattern name - `pattern_options`: pattern options - `name`: field name - `value`: field value :returns: Arguments which will be passed to _base :rtype: dict """ args = super(RelatedItemsWidget, self)._base_args() args['name'] = self.name args['value'] = self.value args.setdefault('pattern_options', {}) if IChoice.providedBy(self.field): args['pattern_options']['maximumSelectionSize'] = 1 field_name = self.field and self.field.__name__ or None args['pattern_options'] = dict_merge( get_relateditems_options(self.context, args['value'], self.separator, self.vocabulary, self.vocabulary_view, field_name), args['pattern_options']) return args
def additional(self): info = super(ListJsonSchemaProvider, self).additional() if IChoice.providedBy(self.field.value_type): info["uniqueItems"] = True else: info["uniqueItems"] = False return info
def additional(self): info = super(ListJsonSchemaProvider, self).additional() if IChoice.providedBy(self.field.value_type): info['uniqueItems'] = True else: info['uniqueItems'] = False return info
def __init__(self, value_type=None, unique=False, **kw): self.search_view = kw.pop('search_view', None) self.placeholder = kw.pop('placeholder', '') if IChoice.providedBy(value_type): self.add_terms = False super(Select2MultiField, self).__init__(value_type, unique, **kw)
def update(self): super(AddForm, self).update() # set default values for required choice fields for widget in self.widgets: field = widget.context if (IChoice.providedBy(field) and field.required and field.default is None): for term in field.vocabulary: field.default = term.value
def update(self): super(AddForm, self).update() # set default values for required choice fields for widget in self.widgets: field = widget.context if IChoice.providedBy(field) and field.required and field.default is None: for term in field.vocabulary: field.default = term.value
def _get_value_type_source(self, field): """Get the source of a Choice field that is used as the `value_type` for a multi-valued ICollection field, like ITuple. """ value_type = getattr(field, 'value_type', None) value_type_source = getattr(value_type, 'source', None) if not value_type or not IChoice.providedBy( value_type) or not value_type_source: return None return value_type_source
def _base_args(self): """Method which will calculate _base class arguments. Returns (as python dictionary): - `pattern`: pattern name - `pattern_options`: pattern options - `name`: field name - `value`: field value :returns: Arguments which will be passed to _base :rtype: dict """ args = super(RelatedItemsWidget, self)._base_args() args['name'] = self.name args['value'] = self.value args.setdefault('pattern_options', {}) field = None if IChoice.providedBy(self.field): args['pattern_options']['maximumSelectionSize'] = 1 field = self.field elif ICollection.providedBy(self.field): field = self.field.value_type vocabulary_name = self.vocabulary field_name = self.field and self.field.__name__ or None context = self.context view_context = get_widget_form(self) # For EditForms and non-Forms (in tests), the vocabulary is looked # up on the context, otherwise on the view if (IEditForm.providedBy(view_context) or not IForm.providedBy(view_context)): view_context = context args['pattern_options'] = dict_merge( get_relateditems_options( view_context, args['value'], self.separator, vocabulary_name, self.vocabulary_view, field_name, ), args['pattern_options']) if (not self.vocabulary_override and field and getattr(field, 'vocabulary', None)): # widget vocab takes precedence over field form_url = self.request.getURL() source_url = '{0:s}/++widget++{1:s}/@@getSource'.format( form_url, self.name) args['pattern_options']['vocabularyUrl'] = source_url return args
def _base_args(self): """Method which will calculate _base class arguments. Returns (as python dictionary): - `pattern`: pattern name - `pattern_options`: pattern options - `name`: field name - `value`: field value :returns: Arguments which will be passed to _base :rtype: dict """ args = super(AjaxSelectWidget, self)._base_args() args["name"] = self.name args["value"] = self.value args.setdefault("pattern_options", {}) field_name = self.field and self.field.__name__ or None context = self.context # We need special handling for AddForms if IAddForm.providedBy(getattr(self, "form")): context = self.form vocabulary_name = self.vocabulary field = None if IChoice.providedBy(self.field): args["pattern_options"]["maximumSelectionSize"] = 1 field = self.field elif ICollection.providedBy(self.field): field = self.field.value_type if not vocabulary_name and field is not None: vocabulary_name = field.vocabularyName args["pattern_options"] = dict_merge( get_ajaxselect_options( context, args["value"], self.separator, vocabulary_name, self.vocabulary_view, field_name ), args["pattern_options"], ) if field and getattr(field, "vocabulary", None): form_url = self.request.getURL() source_url = "%s/++widget++%s/@@getSource" % (form_url, self.name) args["pattern_options"]["vocabularyUrl"] = source_url # ISequence represents an orderable collection if ISequence.providedBy(self.field) or self.orderable: args["pattern_options"]["orderable"] = True return args
def get_widgets(self): widgets = form.setUpWidgets(self.form_fields, '', self.context, self.request,ignore_request=True ) for widget in widgets: if IChoice.providedBy(widget.context): if widget.context.default is None: widget._messageNoValue = _(u"event_form_field_default", default=u"choose ${event_field_title}", mapping={'event_field_title': widget.context.title} ) yield widget
def _base_args(self): """Method which will calculate _base class arguments. Returns (as python dictionary): - `pattern`: pattern name - `pattern_options`: pattern options - `name`: field name - `value`: field value :returns: Arguments which will be passed to _base :rtype: dict """ args = super(AjaxSelectWidget, self)._base_args() args['name'] = self.name args['value'] = self.value args.setdefault('pattern_options', {}) field_name = self.field and self.field.__name__ or None context = self.context # We need special handling for AddForms if IAddForm.providedBy(getattr(self, 'form')): context = self.form vocabulary_name = self.vocabulary field = None if IChoice.providedBy(self.field): args['pattern_options']['maximumSelectionSize'] = 1 field = self.field elif ICollection.providedBy(self.field): field = self.field.value_type if not vocabulary_name and field is not None: vocabulary_name = field.vocabularyName args['pattern_options'] = dict_merge( get_ajaxselect_options(context, args['value'], self.separator, vocabulary_name, self.vocabulary_view, field_name), args['pattern_options']) if field and getattr(field, 'vocabulary', None): form_url = self.request.getURL() source_url = "%s/++widget++%s/@@getSource" % (form_url, self.name) args['pattern_options']['vocabularyUrl'] = source_url # ISequence represents an orderable collection if ISequence.providedBy(self.field) or self.orderable: args['pattern_options']['orderable'] = True return args
def common_widget_updates(context): """ Given a context, update field widgets for it. Context May be any z3c.form instance or a field group contained within. """ # form field filter definition: vtype = lambda formfield: getattr(formfield.field, 'value_type', None) use_vocab = lambda v: hasattr(v, '__len__') and hasattr(v, '__iter__') is_choice = lambda formfield: IChoice.providedBy(formfield.field) v_choice = lambda formfield: IChoice.providedBy(vtype(formfield)) is_collection = lambda formfield: ICollection.providedBy(formfield.field) is_multi = lambda formfield: is_collection(formfield) and v_choice( formfield) # noqa is_date = lambda formfield: IDate.providedBy(formfield.field) is_bool = lambda formfield: IBool.providedBy(formfield.field) # filtered lists of form fields by type formfields = context.fields.values() choicefields = filter(is_choice, formfields) multifields = filter(is_multi, formfields) datefields = filter(is_date, formfields) boolfields = filter(is_bool, formfields) for formfield in choicefields: vocab = formfield.field.vocabulary if use_vocab(vocab) and len(vocab) <= 6: formfield.widgetFactory = RadioFieldWidget for formfield in multifields: vocab = formfield.field.value_type.vocabulary if use_vocab(vocab) and len(vocab) <= 16: formfield.widgetFactory = CheckBoxFieldWidget for formfield in datefields: formfield.widgetFactory = TypeADateFieldWidget for formfield in boolfields: formfield.widgetFactory = RadioFieldWidget
def common_widget_updates(context): """ Given a context, update field widgets for it. Context May be any z3c.form instance or a field group contained within. """ # form field filter definition: vtype = lambda formfield: getattr(formfield.field, 'value_type', None) use_vocab = lambda v: hasattr(v, '__len__') and hasattr(v, '__iter__') is_choice = lambda formfield: IChoice.providedBy(formfield.field) v_choice = lambda formfield: IChoice.providedBy(vtype(formfield)) is_collection = lambda formfield: ICollection.providedBy(formfield.field) is_multi = lambda formfield: is_collection(formfield) and v_choice(formfield) # noqa is_date = lambda formfield: IDate.providedBy(formfield.field) is_bool = lambda formfield: IBool.providedBy(formfield.field) # filtered lists of form fields by type formfields = context.fields.values() choicefields = filter(is_choice, formfields) multifields = filter(is_multi, formfields) datefields = filter(is_date, formfields) boolfields = filter(is_bool, formfields) for formfield in choicefields: vocab = formfield.field.vocabulary if use_vocab(vocab) and len(vocab) <= 3: formfield.widgetFactory = RadioFieldWidget for formfield in multifields: vocab = formfield.field.value_type.vocabulary if use_vocab(vocab) and len(vocab) <= 16: formfield.widgetFactory = CheckBoxFieldWidget for formfield in datefields: formfield.widgetFactory = TypeADateFieldWidget for formfield in boolfields: formfield.widgetFactory = RadioFieldWidget
def __call__(self, context, request): # Sequence widget factory if ICollection.providedBy(context): args = (context, context.value_type, request) + self.args # Vocabulary widget factory elif IChoice.providedBy(context): args = (context, context.vocabulary, request) + self.args # Regular widget factory else: args = (context, request) + self.args return self._create(args)
def __call__(self): # Binding is necessary for named vocabularies if IField.providedBy(self.field): self.field = self.field.bind(self.context) value = self.get_value() value_type = self.field.value_type if (value is not None and IChoice.providedBy(value_type) and IVocabularyTokenized.providedBy(value_type.vocabulary)): values = [] for v in value: term = value_type.vocabulary.getTerm(v) values.append({u"token": term.token, u"title": term.title}) value = self.field._type(values) return json_compatible(value)
def update(self): super(TaskModifiedTemplate, self).update() task = self.context ev = self.context0 request = self.request data = {} attributes = dict([(attr.interface, list(attr.attributes)) for attr in ev.descriptions]) for iface, fields in attributes.items(): ob = iface(task) for fieldId in fields: field = iface[fieldId].bind(ob) value = field.get(ob) if IChoice.providedBy(field): try: value = field.vocabulary.getTerm(value).title except LookupError: pass if ICollection.providedBy(field) and IChoice.providedBy(field.value_type): voc = field.value_type.vocabulary value = u", ".join([voc.getTerm(v).title for v in value]) if IDate.providedBy(field): value = getFormatter(request, "date", "full").format(value) if IDatetime.providedBy(field): value = getFormatter(request, "dateTime", "medium").format(value) data[field.title] = value data = data.items() data.sort() self.data = data
def _base_args(self): """Method which will calculate _base class arguments. Returns (as python dictionary): - `pattern`: pattern name - `pattern_options`: pattern options - `name`: field name - `value`: field value :returns: Arguments which will be passed to _base :rtype: dict """ args = super(RelatedItemsWidget, self)._base_args() args['name'] = self.name args['value'] = self.value args.setdefault('pattern_options', {}) field = None if IChoice.providedBy(self.field): args['pattern_options']['maximumSelectionSize'] = 1 field = self.field elif ICollection.providedBy(self.field): field = self.field.value_type vocabulary_name = self.vocabulary if not vocabulary_name: if field is not None and field.vocabularyName: vocabulary_name = field.vocabularyName else: vocabulary_name = 'plone.app.vocabularies.Catalog' field_name = self.field and self.field.__name__ or None args['pattern_options'] = dict_merge( get_relateditems_options(self.context, args['value'], self.separator, vocabulary_name, self.vocabulary_view, field_name), args['pattern_options']) if not self.vocabulary: # widget vocab takes precedence over field if field and getattr(field, 'vocabulary', None): form_url = self.request.getURL() source_url = "%s/++widget++%s/@@getSource" % ( form_url, self.name) args['pattern_options']['vocabularyUrl'] = source_url return args
def theme_options(self): data = {} for name in self.schema.names(): field = self.schema[name] if not IField.providedBy(field): continue value = getattr(self.settings, name, None) if value == None: continue name = name.replace(self.theme + '_', '', 1) if IBool.providedBy(field): data[name] = jsbool(value) elif IChoice.providedBy(field) or ITextLine.providedBy(field): data[name] = '"' + value + '"' elif IInt.providedBy(field) or IFloat.providedBy(field): data[name] = str(value) return data
def get_vocabularies(request, attribute_map): """ Returns a dictionary containing all (translated) vocabularies used by the given attribute map. """ vocabularies = {} translate = tools.translator(request) for header, field in attribute_map.items(): if IChoice.providedBy(field): vocabulary = zope.component.getUtility(IVocabularyFactory, field.vocabularyName) vocabulary = vocabulary(None) vocabularies[header] = dict([ (translate(term.title).lower(), term.value) for term in vocabulary._terms ]) return vocabularies
def __call__(self): # Binding is necessary for named vocabularies if IField.providedBy(self.field): self.field = self.field.bind(self.context) value = self.get_value() value_type = self.field.value_type if value is not None and IChoice.providedBy(value_type): # XXX with elephanvocabulary, "real" vocab is stored on vocabulary.vocab vocab = getattr(value_type.vocabulary, "vocab", value_type.vocabulary) if IVocabularyTokenized.providedBy(vocab): values = [] for v in value: try: term = value_type.vocabulary.getTerm(v) values.append({u"token": term.token, u"title": term.title}) except LookupError: logger.warning("Term lookup error: %r" % v) value = values return json_compatible(value)
def _base_args(self): """Method which will calculate _base class arguments. Returns (as python dictionary): - `pattern`: pattern name - `pattern_options`: pattern options - `name`: field name - `value`: field value :returns: Arguments which will be passed to _base :rtype: dict """ args = super(RelatedItemsWidget, self)._base_args() args["name"] = self.name args["value"] = self.value args.setdefault("pattern_options", {}) vocabulary_name = self.vocabulary field = None if IChoice.providedBy(self.field): args["pattern_options"]["maximumSelectionSize"] = 1 field = self.field elif ICollection.providedBy(self.field): field = self.field.value_type if field is not None and field.vocabularyName: vocabulary_name = field.vocabularyName field_name = self.field and self.field.__name__ or None args["pattern_options"] = dict_merge( get_relateditems_options( self.context, args["value"], self.separator, vocabulary_name, self.vocabulary_view, field_name ), args["pattern_options"], ) if field and getattr(field, "vocabulary", None): form_url = self.request.getURL() source_url = "%s/++widget++%s/@@getSource" % (form_url, self.name) args["pattern_options"]["vocabularyUrl"] = source_url return args
def get_value(self, default=None): terms = [] values = getattr( self.field.interface(self.context), self.field.__name__, default, ) if not values: return if not IChoice.providedBy(self.field.value_type): return for value in values: term = _get_vocab_term( self.context, self.field.value_type.vocabularyName, value, ) terms.append(term) return terms
def _validate_fields(schema, value, errors=None): if errors is None: errors = [] # Interface can be used as schema property for Object fields that plan to # hold values of any type. # Because Interface does not include any Attribute, it is obviously not # worth looping on its methods and filter them all out. if schema is Interface: return errors # if `value` is part of a cyclic graph, we need to break the cycle to avoid # infinite recursion. Collect validated objects in a thread local dict by # it's python represenation. A previous version was setting a volatile # attribute which didn't work with security proxy if id(value) in VALIDATED_VALUES.__dict__: return errors VALIDATED_VALUES.__dict__[id(value)] = True # (If we have gotten here, we know that `value` provides an interface # other than zope.interface.Interface; # iow, we can rely on the fact that it is an instance # that supports attribute assignment.) try: for name in schema.names(all=True): if not IMethod.providedBy(schema[name]): try: attribute = schema[name] if IChoice.providedBy(attribute): # Choice must be bound before validation otherwise # IContextSourceBinder is not iterable in validation bound = attribute.bind(value) bound.validate(getattr(value, name)) elif IField.providedBy(attribute): # validate attributes that are fields attribute.validate(getattr(value, name)) except ValidationError as error: errors.append(error) except AttributeError as error: # property for the given name is not implemented errors.append(SchemaNotFullyImplemented(error)) finally: del VALIDATED_VALUES.__dict__[id(value)] return errors
def get_fieldtype_by_schema(self, field): type_field = "" if IRelationList.providedBy(field): type_field = "relation" elif "ListField" in str(field): type_field = "datagridfield" self.datagrids[field.__name__] = False elif IChoice.providedBy(field): type_field = "choice" elif ITextLine.providedBy(field): type_field = "text" elif IList.providedBy(field): type_field = "list" elif IText.providedBy(field): type_field = "text" elif IRichText.providedBy(field): type_field = "text" else: type_field = "unknown" return type_field
def get_default_value_by_schema(self, field): type_field = " " if IRelationList.providedBy(field): type_field = [] elif "ListField" in str(field): type_field = [] self.datagrids[field.__name__] = False elif IChoice.providedBy(field): type_field = " " elif ITextLine.providedBy(field): type_field = " " elif IList.providedBy(field): type_field = [] elif IText.providedBy(field): type_field = " " elif IRichText.providedBy(field): type_field = " " else: type_field = " " return type_field
def get_value(self, default=None): values = getattr( self.field.interface(self.context), self.field.__name__, default, ) if not values: return values elif not IChoice.providedBy(self.field.value_type): return values return [ dict( title=get_term_title( self.context, self.request, self.field.value_type, value, ), value=value, ) for value in values ]
def js(self): value_type = self.field.value_type vocab = None if IChoice.providedBy(self.field.value_type): if value_type.vocabulary: vocab = value_type.vocabulary if value_type.vocabularyName: vocab = getVocabularyRegistry().get( self.context, self.field.value_type.vocabularyName) values = [(term.token, term.value) for term in vocab] old_values = self._get_old_values(vocab) else: values = enumerate( self.context.portal_catalog.uniqueValuesFor('Subject')) old_values = enumerate(self.context.Subject()) tags = "" old_tags = "" index = 0 for index, value in values: tags += "{id: '%s', name: '%s'}" % (value.replace( "'", "\\'"), value.replace("'", "\\'")) if values.index((index, value)) < len(values) - 1: tags += ", " old_index = 0 # XXX: this is not used #prepopulate for index, value in old_values: old_tags += u"{id: '%s', name: '%s'}" % (value.replace( "'", "\\'"), value.replace("'", "\\'")) if old_values.index((index, value)) < len(old_values) - 1: old_tags += ", " result = self.js_template % dict(id=self.id, klass=self.klass, newtags=unicode(tags, errors='ignore'), oldtags=old_tags) return result
def _base_args(self): """Method which will calculate _base class arguments. Returns (as python dictionary): - `pattern`: pattern name - `pattern_options`: pattern options - `name`: field name - `value`: field value :returns: Arguments which will be passed to _base :rtype: dict """ args = super(RelatedItemsWidget, self)._base_args() args['name'] = self.name args['value'] = self.value args.setdefault('pattern_options', {}) field = None if IChoice.providedBy(self.field): args['pattern_options']['maximumSelectionSize'] = 1 field = self.field elif ICollection.providedBy(self.field): field = self.field.value_type vocabulary_name = self.vocabulary field_name = self.field and self.field.__name__ or None context = self.context view_context = get_widget_form(self) # For EditForms and non-Forms (in tests), the vocabulary is looked # up on the context, otherwise on the view if ( IEditForm.providedBy(view_context) or not IForm.providedBy(view_context) ): view_context = context args['pattern_options'] = dict_merge( get_relateditems_options( view_context, args['value'], self.separator, vocabulary_name, self.vocabulary_view, field_name, ), args['pattern_options'] ) if ( not self.vocabulary_override and field and getattr(field, 'vocabulary', None) ): # widget vocab takes precedence over field form_url = self.request.getURL() source_url = '{0:s}/++widget++{1:s}/@@getSource'.format( form_url, self.name ) args['pattern_options']['vocabularyUrl'] = source_url return args
def handleSubmit(self, action): """submit was pressed""" if 'xlsdata' in self.widgets: fields = self.allFields codepage = self.widgets['codepage'].value[0] fileWidget = self.widgets['xlsdata'] fileUpload = fileWidget.extract() filename = datetime.now().strftime('in_%Y%m%d%H%M%S.xls') f_handle, f_name = tempfile.mkstemp(filename) outf = open(f_name, 'wb') outf.write(fileUpload.read()) outf.close() parseRet = xl.parse_xls(f_name, codepage) os.remove(f_name) # allAttributes = {} for interface in implementedBy(self.factory): for i_attrName in interface: i_attr = interface[i_attrName] if IField.providedBy(i_attr): allAttributes[i_attrName] = i_attr # for sheet_name, values in parseRet: matrix = [[]] for row_idx, col_idx in sorted(values.keys()): v = values[(row_idx, col_idx)] if isinstance(v, unicode): v = u"%s" % v # v.encode(codepage, 'backslashreplace') else: v = ` v ` v = u'%s' % v.strip() last_row, last_col = len(matrix), len(matrix[-1]) while last_row <= row_idx: matrix.extend([[]]) last_row = len(matrix) while last_col < col_idx: matrix[-1].extend(['']) last_col = len(matrix[-1]) matrix[-1].extend([v]) attrNameList = matrix[0] attrValMatrix = matrix[1:] for attrValVector in attrValMatrix: attrDict = {} for attrIndex, attrVal in enumerate(attrValVector): attrDict[attrNameList[attrIndex]] = attrVal # --------------------------------------- if attrDict.has_key('IntID'): attrDict.pop('IntID') if attrDict.has_key('objectID'): attrObjectID = attrDict.pop('objectID') oldObj = self.context[attrObjectID] for attrName, newValString in attrDict.items(): #print u"ddd4-> %s" % (attrName) attrField = allAttributes[attrName] #print u"type(%s): %s" % (attrField, type(attrField)) # if attrName == "rooms": if IChoice.providedBy(attrField): v_widget = getMultiAdapter(\ (attrField,self.request), interfaces.IFieldWidget) v_widget.context = oldObj v_dataconverter = queryMultiAdapter(\ (attrField, v_widget), interfaces.IDataConverter) if len(newValString) > 0: newVal = v_dataconverter.toFieldValue( [newValString]) else: newVal = v_dataconverter.toFieldValue([]) else: if attrName == "isTemplate": v_widget = checkbox.SingleCheckBoxFieldWidget(\ attrField,self.request) else: v_widget = getMultiAdapter(\ (attrField,self.request), interfaces.IFieldWidget) v_widget.context = oldObj v_dataconverter = queryMultiAdapter(\ (attrField, v_widget), interfaces.IDataConverter) if ICollection.providedBy(attrField): if len(newValString) > 0: newVal = v_dataconverter.toFieldValue( newValString.split(';')) else: newVal = v_dataconverter.toFieldValue( []) else: newVal = v_dataconverter.toFieldValue( newValString) if getattr(oldObj, attrName) != newVal: setattr(oldObj, attrName, newVal) dcore = IWriteZopeDublinCore(oldObj) dcore.modified = datetime.utcnow() if attrName == "ikName": IBrwsOverview(oldObj).setTitle(newVal) else: oldObj = None # new Object # newObj = createObject(self.factoryId) # newObj.__post_init__() dataVect = {} for attrName, newValString in attrDict.items(): attrField = allAttributes[attrName] if IChoice.providedBy(attrField): v_widget = getMultiAdapter(\ (attrField,self.request), interfaces.IFieldWidget) v_dataconverter = queryMultiAdapter(\ (attrField, v_widget), interfaces.IDataConverter) if len(newValString) > 0: newVal = v_dataconverter.toFieldValue( [newValString]) else: newVal = v_dataconverter.toFieldValue([]) else: if attrName == "isTemplate": v_widget = checkbox.SingleCheckBoxFieldWidget(\ attrField,self.request) else: v_widget = getMultiAdapter(\ (attrField,self.request), interfaces.IFieldWidget) v_dataconverter = queryMultiAdapter(\ (attrField, v_widget), interfaces.IDataConverter) if ICollection.providedBy(attrField): if len(newValString) > 0: newVal = v_dataconverter.toFieldValue( newValString.split(';')) else: newVal = v_dataconverter.toFieldValue( []) else: newVal = v_dataconverter.toFieldValue( newValString) dataVect[str(attrName)] = newVal #setattr(newObj, attrName, newVal) #self.context.__setitem__(newObj.objectID, newObj) #print "dataVect: ", dataVect newObj = self.factory(**dataVect) newObj.__post_init__() if oldObj is not None: dcore = IWriteZopeDublinCore(oldObj) dcore.modified = datetime.utcnow() IBrwsOverview(newObj).setTitle(dataVect['ikName']) self.context[newObj.objectID] = newObj if hasattr(newObj, "store_refs"): newObj.store_refs(**dataVect) notify(ObjectCreatedEvent(newObj)) url = absoluteURL(self.context, self.request) self.request.response.redirect(url)
def __init__(self, field, vocabulary, request): # XXX flacoste 2006-07-23 Workaround Zope3 bug #545: # CustomWidgetFactory passes wrong arguments to a MultiCheckBoxWidget if IChoice.providedBy(vocabulary): vocabulary = vocabulary.vocabulary MultiCheckBoxWidget.__init__(self, field, vocabulary, request)
def elementToValue(field, element, default=_marker): """Read the contents of an element that is assumed to represent a value allowable by the given field. If converter is given, it should be an IToUnicode instance. If not, the field will be adapted to this interface to obtain a converter. """ value = default if IDict.providedBy(field): key_converter = IFromUnicode(field.key_type) value = OrderedDict() for child in element.iterchildren(tag=etree.Element): if noNS(child.tag.lower()) != 'element': continue parseinfo.stack.append(child) key_text = child.attrib.get('key') if key_text is None: k = None else: k = key_converter.fromUnicode(six.text_type(key_text)) value[k] = elementToValue(field.value_type, child) parseinfo.stack.pop() value = fieldTypecast(field, value) elif ICollection.providedBy(field): value = [] for child in element.iterchildren(tag=etree.Element): if noNS(child.tag.lower()) != 'element': continue parseinfo.stack.append(child) v = elementToValue(field.value_type, child) value.append(v) parseinfo.stack.pop() value = fieldTypecast(field, value) elif IChoice.providedBy(field): vocabulary = None try: vcf = getUtility(IVocabularyFactory, field.vocabularyName) vocabulary = vcf(None) except: pass if vocabulary and hasattr(vocabulary, 'by_value'): try: field._type = type(list(vocabulary.by_value.keys())[0]) except: pass value = fieldTypecast(field, element.text) # Unicode else: text = element.text if text is None: value = field.missing_value else: converter = IFromUnicode(field) if isinstance(text, six.binary_type): text = text.decode() else: text = six.text_type(text) value = converter.fromUnicode(text) # handle i18n if isinstance(value, six.string_types) and \ parseinfo.i18n_domain is not None: translate_attr = ns('translate', I18N_NAMESPACE) domain_attr = ns('domain', I18N_NAMESPACE) msgid = element.attrib.get(translate_attr) domain = element.attrib.get(domain_attr, parseinfo.i18n_domain) if msgid: value = Message(msgid, domain=domain, default=value) elif translate_attr in element.attrib: value = Message(value, domain=domain) return value
def exportXlsData(self): """get XLS file for all folder objects""" filename = datetime.now().strftime('ict_%Y%m%d%H%M%S.xls') f_handle, f_name = tempfile.mkstemp(filename) wbook = Workbook() wb_hosts = wbook.add_sheet('ddd') style0 = XFStyle() font0 = Font() font0.height = 6 * 20 style0.num_format_str = '@' style0.font = font0 style1 = XFStyle() font1 = Font() font1.height = 6 * 20 style1.num_format_str = '@' style1.font = font1 heading_pattern = xl.Pattern() heading_pattern.pattern = xl.Pattern.SOLID_PATTERN heading_pattern.pattern_back_colour = 0x5 heading_pattern.pattern_fore_colour = 0x5 fields = self.fields attrList = [fname for fname, fval in fields.items()] itemList = self.context.items() pos_y = 0 pos_x = 0 for attr in attrList: wb_data = Formula(u'"%s"' % attr) style0.pattern = heading_pattern wb_hosts.write(pos_y, pos_x, wb_data, style0) pos_x += 1 # IntID wb_data = Formula(u'"IntID"') wb_hosts.write(pos_y, pos_x, wb_data, style0) pos_x += 1 # objectID wb_data = Formula(u'"objectID"') wb_hosts.write(pos_y, pos_x, wb_data, style0) wb_hosts.col(pos_x).width *= 3 pos_x += 1 pos_y = 1 # allAttributes = {} for interface in implementedBy(self.factory): for i_attrName in interface: i_attr = interface[i_attrName] if IField.providedBy(i_attr): allAttributes[i_attrName] = i_attr # for item_n, item_v in itemList: pos_x = 0 for attr in attrList: # from zope.interface import implementedBy # ff=self.factory # tt=[i for i in implementedBy(ff)] # it=tt[-1] #attrField = self.attrInterface[attr] attrField = allAttributes[attr] # tmpFieldProperty = getattr(self.factory, attr) # if hasattr(tmpFieldProperty, '_FieldProperty__field'): # attrField = getattr(self.factory, attr)._FieldProperty__field attrDm = datamanager.AttributeField(item_v, attrField) v_style = XFStyle() v_font = Font() v_font.height = 6 * 20 v_style.font = v_font value = None if IChoice.providedBy(attrField): v_style.num_format_str = '@' dateValue = attrDm.get() v_widget = getMultiAdapter(\ (attrField,self.request), interfaces.IFieldWidget) v_widget.context = item_v # dm = zope.component.getMultiAdapter( # (self.content, field.field), interfaces.IDataManager) # zope.component.getMultiAdapter( # (self.context, # self.request, # self.form, # getattr(widget, 'field', None), # widget), # interfaces.IValidator).validate(fvalue) # dm = zope.component.getMultiAdapter( # (self.__context__, field), interfaces.IDataManager) v_dataconverter = queryMultiAdapter(\ (attrDm.field, v_widget), interfaces.IDataConverter) #print u"ddd55: %s: %s" % (attr, dateValue) if dateValue is not None: value = v_dataconverter.toWidgetValue(dateValue)[0] #print "value3-> %s: %s " % (attr, value) # elif ICollection.providedBy(attrField): # v_style.num_format_str = '@' # value = getattr(item_v, attr) # print "ddd66: %s: %s" % (attr, value) # elif IBool.providedBy(attrField): # v_style.num_format_str = '@' # value = getattr(item_v, attr) # print "value2-> %s: %s " % (attr, value) else: v_style.num_format_str = '@' dateValue = attrDm.get() v_widget = getMultiAdapter(\ (attrField,self.request), interfaces.IFieldWidget) v_widget.context = item_v v_dataconverter = queryMultiAdapter(\ (attrDm.field, v_widget), interfaces.IDataConverter) #d2 = queryMultiAdapter((attrDm.field, v_widget),interfaces.IDataConverter) if dateValue is not None: value = v_dataconverter.toWidgetValue(dateValue) if type(value) is list: value = u";".join(value) #print u"value1-> %s: %s " % (attr, value) if value is not None: #print u"wb_hosts.write(%s, %s, %s, %s)" % (pos_y, pos_x, value, v_style) wb_hosts.write(pos_y, pos_x, value, v_style) pos_x += 1 # IntID uidutil = queryUtility(IIntIds) wb_data = Formula(u'"%s"' % uidutil.getId(item_v)) wb_hosts.write(pos_y, pos_x, wb_data, style0) pos_x += 1 # objectID wb_data = Formula(u'"%s"' % item_v.objectID) wb_hosts.write(pos_y, pos_x, wb_data, style0) pos_x += 1 pos_y += 1 wbook.save(f_name) self.request.response.setHeader('Content-Type', 'application/vnd.ms-excel') self.request.response.setHeader(\ 'Content-Disposition', 'attachment; filename=\"%s\"' % filename) setNoCacheHeaders(self.request.response) datafile = open(f_name, "r") dataMem = datafile.read() datafile.close() os.remove(f_name) return dataMem
def _xlsSheet2folder_(self, request, values, folder): # dbg # print "_xlsSheet2folder_(folder=%s)" % folder fields = fieldsForFactory(folder.contentFactory, ['objectID']) allAttributes = {} for interface in implementedBy(folder.contentFactory): for i_attrName in interface: i_attr = interface[i_attrName] if IField.providedBy(i_attr): allAttributes[i_attrName] = i_attr matrix = [[]] for row_idx, col_idx in sorted(values.keys()): v = values[(row_idx, col_idx)] if isinstance(v, unicode): v = u"%s" % v # v.encode(codepage, 'backslashreplace') else: v = `v` v = u'%s' % v.strip() last_row, last_col = len(matrix), len(matrix[-1]) while last_row <= row_idx: matrix.extend([[]]) last_row = len(matrix) while last_col < col_idx: matrix[-1].extend(['']) last_col = len(matrix[-1]) matrix[-1].extend([v]) attrNameList = matrix[0] attrValMatrix = matrix[1:] for attrValVector in attrValMatrix: attrDict = {} for attrIndex, attrVal in enumerate(attrValVector): attrDict[attrNameList[attrIndex]] = attrVal # --------------------------------------- # if attrDict.has_key('IntID'): # attrDict.pop('IntID') if attrDict.has_key('objectID') and \ attrDict['objectID'] in folder: attrObjectID = attrDict.pop('objectID') oldObj = folder[attrObjectID] # dbg # print "update old object: ", oldObj.ikName for attrName, newValString in attrDict.items(): attrField = allAttributes[attrName] if IChoice.providedBy(attrField): v_widget = getMultiAdapter(\ (attrField,request), interfaces.IFieldWidget) v_widget.context = oldObj v_dataconverter = queryMultiAdapter(\ (attrField, v_widget), interfaces.IDataConverter) if len(newValString) > 0: try: newVal = v_dataconverter.toFieldValue([newValString]) except LookupError: newVal = v_dataconverter.toFieldValue([]) else: newVal = v_dataconverter.toFieldValue([]) else: if attrName == "isTemplate": v_widget = checkbox.SingleCheckBoxFieldWidget(\ attrField,request) else: v_widget = getMultiAdapter(\ (attrField,request), interfaces.IFieldWidget) v_widget.context = oldObj v_dataconverter = queryMultiAdapter(\ (attrField, v_widget), interfaces.IDataConverter) if ICollection.providedBy(attrField): if len(newValString) > 0: newVal = v_dataconverter.toFieldValue(newValString.split(';')) else: newVal = v_dataconverter.toFieldValue([]) else: try: newVal = v_dataconverter.toFieldValue(newValString) except LookupError: newVal = getattr(oldObj, attrName) if getattr(oldObj, attrName) != newVal: # dbg # print "change Value old:'%s' new:'%s'" % \ # dbg # (getattr(oldObj, attrName), newVal) setattr(oldObj, attrName, newVal) dcore = IWriteZopeDublinCore(oldObj) dcore.modified = datetime.utcnow() if attrName == "ikName": IBrwsOverview(oldObj).setTitle(newVal) else: oldObj = None # new Object # newObj = createObject(self.factoryId) # newObj.__post_init__() # dbg # print "new object: ", attrDict['ikName'] dataVect = {} for attrName, newValString in attrDict.items(): attrField = allAttributes[attrName] if IChoice.providedBy(attrField): v_widget = getMultiAdapter(\ (attrField,request), interfaces.IFieldWidget) v_dataconverter = queryMultiAdapter(\ (attrField, v_widget), interfaces.IDataConverter) if len(newValString) > 0: try: newVal = v_dataconverter.toFieldValue([newValString]) except LookupError: newVal = v_dataconverter.toFieldValue([]) else: newVal = v_dataconverter.toFieldValue([]) else: if attrName == "isTemplate": v_widget = checkbox.SingleCheckBoxFieldWidget(\ attrField,request) else: v_widget = getMultiAdapter(\ (attrField,request), interfaces.IFieldWidget) v_dataconverter = queryMultiAdapter(\ (attrField, v_widget), interfaces.IDataConverter) if ICollection.providedBy(attrField): if len(newValString) > 0: try: newVal = v_dataconverter.toFieldValue(newValString.split(';')) except LookupError: newVal = v_dataconverter.toFieldValue([]) else: newVal = v_dataconverter.toFieldValue([]) else: try: newVal = v_dataconverter.toFieldValue(newValString) except LookupError: newVal = None dataVect[str(attrName)] = newVal #setattr(newObj, attrName, newVal) #self.context.__setitem__(newObj.objectID, newObj) #print "dataVect: ", dataVect newObj = folder.contentFactory(**dataVect) # new Object, but already have an object id if attrDict.has_key('objectID'): newObj.setObjectId(attrDict['objectID']) newObj.__post_init__() if oldObj is not None: dcore = IWriteZopeDublinCore(oldObj) dcore.modified = datetime.utcnow() IBrwsOverview(newObj).setTitle(dataVect['ikName']) folder[newObj.objectID] = newObj if hasattr(newObj, "store_refs"): newObj.store_refs(**dataVect) notify(ObjectCreatedEvent(newObj))
def get_attribute_values(request, record, attribute_map): values = {} vocabularies = get_vocabularies(request, attribute_map) for header, field in attribute_map.items(): downloaded = download_field_from_url(field, record[header]) if downloaded is not False: values[field.__name__] = downloaded continue if IDate.providedBy(field): if not record[header]: values[field.__name__] = None else: values[field.__name__] = parse_date(record[header]) continue if IDatetime.providedBy(field): if not record[header]: values[field.__name__] = None else: values[field.__name__] = parse_datetime(record[header]) continue if IURI.providedBy(field): if not record[header].strip(): values[field.__name__] = None continue if IList.providedBy(field): if ITextLine.providedBy(field.value_type): values[field.__name__] = convert_to_list(record[header]) continue if ISet.providedBy(field): if IChoice.providedBy(field.value_type): values[field.__name__] = set(convert_to_list(record[header])) continue if IChoice.providedBy(field): if not record[header].strip(): values[field.__name__] = None else: vocabulary = vocabularies[header] if record[header].lower() not in vocabulary: raise ContentImportError( _( u'The ${name} column contains the ' u'unknown value ${value}', mapping=dict(name=header, value=record[header]) ) ) values[field.__name__] = vocabulary[record[header].lower()] continue assert IFromUnicode.providedBy(field), """ {} does not support fromUnicode """.format(field) try: values[field.__name__] = field.fromUnicode(record[header]) if isinstance(values[field.__name__], basestring): values[field.__name__] = values[field.__name__].strip() if isinstance(field, Text): values[field.__name__] = values[field.__name__].replace( '<br />', '\n' ) except ValidationError, e: raise ContentImportError(e.doc(), colname=header) except ValueError, e: raise ContentImportError(e.message, colname=header)
def _base_args(self): """Method which will calculate _base class arguments. Returns (as python dictionary): - `pattern`: pattern name - `pattern_options`: pattern options - `name`: field name - `value`: field value :returns: Arguments which will be passed to _base :rtype: dict """ args = super(RelatedItemsWidget, self)._base_args() args['name'] = self.name args['value'] = self.value args.setdefault('pattern_options', {}) field = None if IChoice.providedBy(self.field): args['pattern_options']['maximumSelectionSize'] = 1 field = self.field elif ICollection.providedBy(self.field): field = self.field.value_type vocabulary_name = self.vocabulary field_name = self.field and self.field.__name__ or None context = self.context view_context = get_widget_form(self) # For EditForms and non-Forms (in tests), the vocabulary is looked # up on the context, otherwise on the view if IEditForm.providedBy(view_context): if self.is_subform_widget(): view_context = self.form.parentForm.context elif not ISimpleItem.providedBy(context): view_context = self.form.context else: view_context = context elif not IForm.providedBy(view_context): view_context = context else: pass # view_context is defined above already root_search_mode = (args['pattern_options'].get('mode', None) and 'basePath' not in args['pattern_options']) args['pattern_options'] = dict_merge( get_relateditems_options( view_context, args['value'], self.separator, vocabulary_name, self.vocabulary_view, field_name, ), args['pattern_options'], ) if root_search_mode: # Delete default basePath option in search mode, when no basePath # was explicitly set. del args['pattern_options']['basePath'] if (not self.vocabulary_override and field and getattr(field, 'vocabulary', None)): # widget vocab takes precedence over field form_url = self.request.getURL() source_url = '{0:s}/++widget++{1:s}/@@getSource'.format( form_url, self.name, ) args['pattern_options']['vocabularyUrl'] = source_url return args
def _base_args(self): """Method which will calculate _base class arguments. Returns (as python dictionary): - `pattern`: pattern name - `pattern_options`: pattern options - `name`: field name - `value`: field value :returns: Arguments which will be passed to _base :rtype: dict """ args = super(AjaxSelectWidget, self)._base_args() args['name'] = self.name args['value'] = self.value args.setdefault('pattern_options', {}) field_name = self.field and self.field.__name__ or None context = self.context view_context = get_widget_form(self) # For EditForms and non-Forms (in tests), the vocabulary is looked # up on the context, otherwise on the view if ( IEditForm.providedBy(view_context) or not IForm.providedBy(view_context) ): view_context = context vocabulary_name = self.vocabulary field = None if IChoice.providedBy(self.field): args['pattern_options']['maximumSelectionSize'] = 1 field = self.field elif ICollection.providedBy(self.field): field = self.field.value_type if IChoice.providedBy(field): args['pattern_options']['allowNewItems'] = 'false' args['pattern_options'] = dict_merge( get_ajaxselect_options(view_context, args['value'], self.separator, vocabulary_name, self.vocabulary_view, field_name), args['pattern_options']) if field and getattr(field, 'vocabulary', None): form_url = self.request.getURL() source_url = '{0:s}/++widget++{1:s}/@@getSource'.format( form_url, self.name ) args['pattern_options']['vocabularyUrl'] = source_url # ISequence represents an orderable collection if ISequence.providedBy(self.field) or self.orderable: args['pattern_options']['orderable'] = True if self.vocabulary == 'plone.app.vocabularies.Keywords': membership = getToolByName(context, 'portal_membership') user = membership.getAuthenticatedMember() registry = getUtility(IRegistry) roles_allowed_to_add_keywords = registry.get( 'plone.roles_allowed_to_add_keywords', []) roles = set(user.getRolesInContext(context)) allowNewItems = 'false' if roles.intersection(roles_allowed_to_add_keywords): allowNewItems = 'true' args['pattern_options']['allowNewItems'] = allowNewItems return args