Ejemplo n.º 1
0
    def test_vocabulary_wrong_cts(self):
        vocab = DcatFieldVocabulary([constants.CT_HARVESTER])

        vocabulary = vocab(self.portal)
        self.assertTrue(IVocabularyTokenized.providedBy(vocabulary))

        self.assertEqual(len(vocabulary), 0)
Ejemplo n.º 2
0
    def test_vocabulary_no_cts(self):
        vocab = DcatFieldVocabulary([])

        vocabulary = vocab(self.portal)
        self.assertTrue(IVocabularyTokenized.providedBy(vocabulary))

        self.assertEqual(len(vocabulary), 0)
Ejemplo n.º 3
0
    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()
        # XXX with elephanvocabulary, "real" vocab is stored on vocabulary.vocab
        vocab = getattr(self.field.vocabulary, "vocab", self.field.vocabulary)
        if value is not None and IVocabularyTokenized.providedBy(vocab):
            try:
                term = self.field.vocabulary.getTerm(value)
            # If not found, get it from the z3c.form that maybe uses a MissingTerms adapter...
            except LookupError:
                try:
                    view = self.context.restrictedTraverse("@@view")
                    view.update()
                    # widget_name is the field name prefixed with behavior if any
                    widget_name = [field for field in get_schema_fields(self.context, prefix=True)
                                   if field[1].__name__ == self.field.__name__][0][0]
                    widget = view.widgets[widget_name]
                    term = widget.terms.getTerm(value)
                except Exception:
                    # at worse use value as title
                    term = SimpleTerm(value, title=value)
            finally:
                value = {"token": term.token, "title": term.title}

        return json_compatible(value)
Ejemplo n.º 4
0
    def write(self, field, name, type, elementName='field'):

        element = super(ChoiceHandler, self).write(field, name, type, elementName)

        # write vocabulary or values list

        # Named vocabulary
        if field.vocabularyName is not None and field.vocabulary is None:
            attributeField = self.fieldAttributes['vocabulary']
            child = valueToElement(attributeField, field.vocabularyName, name='vocabulary', force=True)
            element.append(child)

        # Listed vocabulary - attempt to convert to a simple list of values
        elif field.vocabularyName is None and IVocabularyTokenized.providedBy(field.vocabulary):
            value = []
            for term in field.vocabulary:
                if (not isinstance(term.value, (str, unicode), )
                    or term.token != term.value.encode('unicode_escape')):
                    raise NotImplementedError(u"Cannot export a vocabulary that is not "
                                               "based on a simple list of values")
                value.append(term.value)

            attributeField = self.fieldAttributes['values']
            child = valueToElement(attributeField, value, name='values', force=True)
            element.append(child)

        # Anything else is not allowed - we can't export ISource/IVocabulary or
        #  IContextSourceBinder objects.
        else:
            raise NotImplementedError(u"Choice fields with vocabularies not based on "
                                        "a simple list of values or a named vocabulary "
                                        "cannot be exported")

        return element
Ejemplo n.º 5
0
    def write(self, field, name, type, elementName='field'):

        element = super(ChoiceHandler, self).write(field, name, type, elementName)

        # write vocabulary or values list

        # Named vocabulary
        if field.vocabularyName is not None and field.vocabulary is None:
            attributeField = self.fieldAttributes['vocabulary']
            child = valueToElement(
                attributeField,
                field.vocabularyName,
                name='vocabulary',
                force=True
            )
            element.append(child)

        # Listed vocabulary - attempt to convert to a simple list of values
        elif field.vocabularyName is None \
             and IVocabularyTokenized.providedBy(field.vocabulary):
            value = []
            for term in field.vocabulary:
                if (not isinstance(term.value, (str, text_type), ) or
                        term.token.encode('utf-8') !=  # token is 'str'
                        term.value.encode('unicode_escape')):
                    raise NotImplementedError(
                        u"Cannot export a vocabulary that is not "
                        u"based on a simple list of values"
                    )
                if term.title and term.title != term.value:
                    value.append((term.value, term.title))
                else:
                    value.append(term.value)

            attributeField = self.fieldAttributes['values']
            if any(map(lambda v: isinstance(v, tuple), value)):
                _pair = lambda v: v if len(v) == 2 else (v[0],) * 2
                value = OrderedDict(map(_pair, value))
                attributeField = OrderedDictField(
                    key_type=zope.schema.TextLine(),
                    value_type=zope.schema.TextLine(),
                    )
            child = valueToElement(
                attributeField,
                value,
                name='values',
                force=True
            )
            element.append(child)

        # Anything else is not allowed - we can't export ISource/IVocabulary or
        #  IContextSourceBinder objects.
        else:
            raise NotImplementedError(
                u"Choice fields with vocabularies not based on "
                u"a simple list of values or a named vocabulary "
                u"cannot be exported"
            )

        return element
Ejemplo n.º 6
0
 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)
Ejemplo n.º 7
0
    def test_vocabulary_unexistend_cts(self):
        vocab = DcatFieldVocabulary(['hello_world'])

        vocabulary = vocab(self.portal)
        self.assertTrue(IVocabularyTokenized.providedBy(vocabulary))

        self.assertEqual(len(vocabulary), 0)
Ejemplo n.º 8
0
    def write(self, field, name, type, elementName='field'):

        element = super(ChoiceHandler, self).write(field, name, type, elementName)

        # write vocabulary or values list

        # Named vocabulary
        if field.vocabularyName is not None and field.vocabulary is None:
            attributeField = self.fieldAttributes['vocabulary']
            child = valueToElement(
                attributeField,
                field.vocabularyName,
                name='vocabulary',
                force=True
            )
            element.append(child)

        # Listed vocabulary - attempt to convert to a simple list of values
        elif field.vocabularyName is None \
             and IVocabularyTokenized.providedBy(field.vocabulary):
            value = []
            for term in field.vocabulary:
                if (not isinstance(term.value, (str, unicode), )
                    or term.token != term.value.encode('unicode_escape')):
                    raise NotImplementedError(
                        u"Cannot export a vocabulary that is not "
                        u"based on a simple list of values"
                    )
                if term.title and term.title != term.value:
                    value.append((term.value, term.title))
                else:
                    value.append(term.value)

            attributeField = self.fieldAttributes['values']
            if any(map(lambda v: isinstance(v, tuple), value)):
                _pair = lambda v: v if len(v) == 2 else (v[0],) * 2
                value = OrderedDict(map(_pair, value))
                attributeField = OrderedDictField(
                    key_type=zope.schema.TextLine(),
                    value_type=zope.schema.TextLine(),
                    )
            child = valueToElement(
                attributeField,
                value,
                name='values',
                force=True
            )
            element.append(child)

        # Anything else is not allowed - we can't export ISource/IVocabulary or
        #  IContextSourceBinder objects.
        else:
            raise NotImplementedError(
                u"Choice fields with vocabularies not based on "
                u"a simple list of values or a named vocabulary "
                u"cannot be exported"
            )

        return element
    def test_vocab_renewal_periods(self):
        vocab_name = "collective.contract_management.RenewalPeriods"
        factory = getUtility(IVocabularyFactory, vocab_name)
        self.assertTrue(IVocabularyFactory.providedBy(factory))

        vocabulary = factory(self.portal)
        self.assertTrue(IVocabularyTokenized.providedBy(vocabulary))
        self.assertEqual(vocabulary.getTerm("3").title, _(u"3 months"))
Ejemplo n.º 10
0
    def test_vocab_s_d_g_vocabulary(self):
        vocab_name = 'collective.behavior.sdg.SDGsVocabulary'
        factory = getUtility(IVocabularyFactory, vocab_name)
        self.assertTrue(IVocabularyFactory.providedBy(factory))

        vocabulary = factory(self.portal)
        self.assertTrue(IVocabularyTokenized.providedBy(vocabulary))
        self.assertEqual(vocabulary.getTerm('13').title, u'Climate action')
    def test_vocab_reminder_types(self):
        vocab_name = "collective.contract_management.ReminderTypes"
        factory = getUtility(IVocabularyFactory, vocab_name)
        self.assertTrue(IVocabularyFactory.providedBy(factory))

        vocabulary = factory(self.portal)
        self.assertTrue(IVocabularyTokenized.providedBy(vocabulary))
        self.assertEqual(vocabulary.getTerm("14").title, _(u"14 days"))
Ejemplo n.º 12
0
 def setter(self, source):
     # Verify if this is a source or a vocabulary
     if IVocabularyTokenized.providedBy(source):
         self._source = source
     else:
         # Be sure to reset the source
         self._source = None
         self._vocabularyFactory = source
    def test_vocab_plone_users(self):
        vocab_name = "Products.EasyNewsletter.PloneUsers"
        factory = getUtility(IVocabularyFactory, vocab_name)
        self.assertTrue(IVocabularyFactory.providedBy(factory))

        vocabulary = factory(self.portal)
        self.assertTrue(IVocabularyTokenized.providedBy(vocabulary))
        self.assertEqual(
            vocabulary.getTerm(self.jane.getId()).title, _("Jane Doe - [email protected]")
        )
Ejemplo n.º 14
0
    def test_vocabulary(self):
        vocab_name = "example.z3cformwidgets.OtherFiles"
        factory = getUtility(IVocabularyFactory, vocab_name)
        self.assertTrue(IVocabularyFactory.providedBy(factory))

        vocabulary = factory(self.portal)
        self.assertTrue(IVocabularyTokenized.providedBy(vocabulary))
        self.assertEqual(
            vocabulary.getTerm('a').title,
            _(u'a'),
        )
Ejemplo n.º 15
0
    def test_vocab_countries(self):
        vocab_name = 'collective.vocabularies.iso.Countries'
        factory = getUtility(IVocabularyFactory, vocab_name)
        self.assertTrue(IVocabularyFactory.providedBy(factory))

        vocabulary = factory(self.portal)
        self.assertTrue(IVocabularyTokenized.providedBy(vocabulary))
        self.assertEqual(
            vocabulary.getTerm('sony-a7r-iii').title,
            _(u'Sony Aplha 7R III'),
        )
    def test_vocab_output_templates(self):
        vocab_name = "Products.EasyNewsletter.OutputTemplates"
        factory = getUtility(IVocabularyFactory, vocab_name)
        self.assertTrue(IVocabularyFactory.providedBy(factory))

        vocabulary = factory(self.portal)
        self.assertTrue(IVocabularyTokenized.providedBy(vocabulary))
        self.assertEqual(
            vocabulary.getTerm("output_default").title,
            _("Default output template"),
        )
Ejemplo n.º 17
0
    def test_vocab_partners(self):
        vocab_name = 'foecluster.km.Partners'
        factory = getUtility(IVocabularyFactory, vocab_name)
        self.assertTrue(IVocabularyFactory.providedBy(factory))

        vocabulary = factory(self.portal)
        self.assertTrue(IVocabularyTokenized.providedBy(vocabulary))
        self.assertEqual(
            vocabulary.getTerm('sony-a7r-iii').title,
            _(u'Sony Aplha 7R III'),
        )
    def test_vocab_network_operators(self):
        vocab_name = 'docpool.doksys.NetworkOperators'
        factory = getUtility(IVocabularyFactory, vocab_name)
        self.assertTrue(IVocabularyFactory.providedBy(factory))

        vocabulary = factory(self.portal)
        self.assertTrue(IVocabularyTokenized.providedBy(vocabulary))
        self.assertEqual(
            vocabulary.getTerm('sony-a7r-iii').title,
            _(u'Sony Aplha 7R III'),
        )
Ejemplo n.º 19
0
    def test_vocab_aggregation_templates(self):
        vocab_name = "Products.EasyNewsletter.AggregationTemplates"
        factory = getUtility(IVocabularyFactory, vocab_name)
        self.assertTrue(IVocabularyFactory.providedBy(factory))

        vocabulary = factory(self.portal)
        self.assertTrue(IVocabularyTokenized.providedBy(vocabulary))
        self.assertEqual(
            vocabulary.getTerm("aggregation_generic_listing").title,
            _("Generic Listing"),
        )
    def test_vocab_political_parties(self):
        vocab_name = 'sinar.plone.vocabularies.PoliticalParties'
        factory = getUtility(IVocabularyFactory, vocab_name)
        self.assertTrue(IVocabularyFactory.providedBy(factory))

        vocabulary = factory(self.portal)
        self.assertTrue(IVocabularyTokenized.providedBy(vocabulary))
        self.assertEqual(
            vocabulary.getTerm('sony-a7r-iii').title,
            _(u'Sony Aplha 7R III'),
        )
    def test_vocab_available_things(self):
        vocab_name = 'gisweb.trigeau.AvailableThings'
        factory = getUtility(IVocabularyFactory, vocab_name)
        self.assertTrue(IVocabularyFactory.providedBy(factory))

        vocabulary = factory(self.portal)
        self.assertTrue(IVocabularyTokenized.providedBy(vocabulary))
        self.assertEqual(
            vocabulary.getTerm('sony-a7r-iii').title,
            _(u'Sony Aplha 7R III'),
        )
    def test_vocab_voc_ore_inizio(self):
        vocab_name = 'rg.prenotazioni.VocOreInizio'
        factory = getUtility(IVocabularyFactory, vocab_name)
        self.assertTrue(IVocabularyFactory.providedBy(factory))

        vocabulary = factory(self.portal)
        self.assertTrue(IVocabularyTokenized.providedBy(vocabulary))
        self.assertEqual(
            vocabulary.getTerm('sony-a7r-iii').title,
            _(u'Sony Aplha 7R III'),
        )
Ejemplo n.º 23
0
    def test_vocab_salutations(self):
        vocab_name = 'Products.EasyNewsletter.Salutations'
        factory = getUtility(IVocabularyFactory, vocab_name)
        self.assertTrue(IVocabularyFactory.providedBy(factory))

        vocabulary = factory(self.portal)
        self.assertTrue(IVocabularyTokenized.providedBy(vocabulary))
        self.assertEqual(
            vocabulary.getTerm('ms').title,
            _(u'Ms'),
        )
Ejemplo n.º 24
0
    def test_vocabulary(self):
        vocab_name = "example.z3cformwidgets.AvailableThings"
        factory = getUtility(IVocabularyFactory, vocab_name)
        self.assertTrue(IVocabularyFactory.providedBy(factory))

        vocabulary = factory(self.portal)
        self.assertTrue(IVocabularyTokenized.providedBy(vocabulary))
        self.assertEqual(
            vocabulary.getTerm('sony-a7r-iii').title,
            _(u'Sony Aplha 7R III'),
        )
Ejemplo n.º 25
0
    def test_vocab_class_room(self):
        vocab_name = 'cshm.content.ClassRoom'
        factory = getUtility(IVocabularyFactory, vocab_name)
        self.assertTrue(IVocabularyFactory.providedBy(factory))

        vocabulary = factory(self.portal)
        self.assertTrue(IVocabularyTokenized.providedBy(vocabulary))
        self.assertEqual(
            vocabulary.getTerm('sony-a7r-iii').title,
            _(u'Sony Aplha 7R III'),
        )
    def test_vocab_crop_categories(self):
        vocab_name = 'gaipa.backend.CropCategories'
        factory = getUtility(IVocabularyFactory, vocab_name)
        self.assertTrue(IVocabularyFactory.providedBy(factory))

        vocabulary = factory(self.portal)
        self.assertTrue(IVocabularyTokenized.providedBy(vocabulary))
        self.assertEqual(
            vocabulary.getTerm(self.mycrop.absolute_url_path()).title,
            u'My Crop',
        )
Ejemplo n.º 27
0
    def test_vocab_submission_method(self):
        vocab_name = 'ocds.contenttypes.SubmissionMethod'
        factory = getUtility(IVocabularyFactory, vocab_name)
        self.assertTrue(IVocabularyFactory.providedBy(factory))

        vocabulary = factory(self.portal)
        self.assertTrue(IVocabularyTokenized.providedBy(vocabulary))
        self.assertEqual(
            vocabulary.getTerm('sony-a7r-iii').title,
            _(u'Sony Aplha 7R III'),
        )
    def test_vocab_interest_level(self):
        vocab_name = 'politikus.bods.InterestLevel'
        factory = getUtility(IVocabularyFactory, vocab_name)
        self.assertTrue(IVocabularyFactory.providedBy(factory))

        vocabulary = factory(self.portal)
        self.assertTrue(IVocabularyTokenized.providedBy(vocabulary))
        self.assertEqual(
            vocabulary.getTerm('sony-a7r-iii').title,
            _(u'Sony Aplha 7R III'),
        )
    def test_vocab_tender_status(self):
        vocab_name = 'ocds.contenttypes.TenderStatus'
        factory = getUtility(IVocabularyFactory, vocab_name)
        self.assertTrue(IVocabularyFactory.providedBy(factory))

        vocabulary = factory(self.portal)
        self.assertTrue(IVocabularyTokenized.providedBy(vocabulary))
        self.assertEqual(
            vocabulary.getTerm('sony-a7r-iii').title,
            _(u'Sony Aplha 7R III'),
        )
Ejemplo n.º 30
0
    def test_vocab_resource_type(self):
        vocab_name = 'sinar.resource.ResourceType'
        factory = getUtility(IVocabularyFactory, vocab_name)
        self.assertTrue(IVocabularyFactory.providedBy(factory))

        vocabulary = factory(self.portal)
        self.assertTrue(IVocabularyTokenized.providedBy(vocabulary))
        self.assertEqual(
            vocabulary.getTerm('sony-a7r-iii').title,
            _(u'Sony Aplha 7R III'),
        )
Ejemplo n.º 31
0
    def __call__(self, value):
        if isinstance(value, dict) and "token" in value:
            value = value["token"]
        if IVocabularyTokenized.providedBy(self.field.vocabulary):
            try:
                value = self.field.vocabulary.getTermByToken(value).value
            except LookupError:
                pass

        self.field.validate(value)
        return value
Ejemplo n.º 32
0
    def test_vocab_map_category(self):
        vocab_name = 'alpha.content.MapCategory'
        factory = getUtility(IVocabularyFactory, vocab_name)
        self.assertTrue(IVocabularyFactory.providedBy(factory))

        vocabulary = factory(self.portal)
        self.assertTrue(IVocabularyTokenized.providedBy(vocabulary))
        self.assertEqual(
            vocabulary.getTerm('sony-a7r-iii').title,
            _(u'Sony Aplha 7R III'),
        )
    def test_vocab_organizations_vocab(self):
        vocab_name = 'popolo.contenttypes.OrganizationsVocab'
        factory = getUtility(IVocabularyFactory, vocab_name)
        self.assertTrue(IVocabularyFactory.providedBy(factory))

        vocabulary = factory(self.portal)
        self.assertTrue(IVocabularyTokenized.providedBy(vocabulary))
        self.assertEqual(
            vocabulary.getTerm('sony-a7r-iii').title,
            _(u'Sony Aplha 7R III'),
        )
Ejemplo n.º 34
0
    def test_vocab_plone_groups(self):
        vocab_name = 'Products.EasyNewsletter.PloneGroups'
        factory = getUtility(IVocabularyFactory, vocab_name)
        self.assertTrue(IVocabularyFactory.providedBy(factory))

        vocabulary = factory(self.portal)
        self.assertTrue(IVocabularyTokenized.providedBy(vocabulary))

        self.assertEqual(
            vocabulary.getTerm(self.vip.getId()).title,
            _(u'VIP'),
        )
Ejemplo n.º 35
0
    def test_uvf(self):
        '''
        Test the UniqeValueFactory
        '''
        uvf = UniqueValuesFactory('_does_not_matter_here_')
        # empty index
        mock_context = MockContext(
            MockCatalog( values=[] )
            )
        vocabulary = uvf(mock_context)
        assert len(vocabulary) == 0
        assert IVocabularyTokenized.providedBy(vocabulary)

        # index with a value
        mock_context = MockContext(
            MockCatalog( values = ['value'] )
            )
        vocabulary = uvf(mock_context)
        assert IVocabularyTokenized.providedBy(vocabulary)
        assert len(vocabulary) == 1
        assert 'value' in vocabulary
Ejemplo n.º 36
0
 def getChoices(self, form):
     source = self.source
     if source is None:
         factory = self.vocabularyFactory
         assert factory is not None, \
             "No vocabulary source available."
         if (IContextSourceBinder.providedBy(factory) or
             IVocabularyFactory.providedBy(factory)):
             source = factory(form.context)
         elif IFormSourceBinder.providedBy(factory):
             source = factory(form)
         assert IVocabularyTokenized.providedBy(source), \
             "No valid vocabulary available, %s is not valid for %s" % (
             source, self)
     return source
    def test_returns_vocabulary_with_terms(self):
        vocabulary_registry = getVocabularyRegistry()
        vocabulary = vocabulary_registry.get(None, u"Available Listing Views")

        self.assertTrue(IVocabularyTokenized.providedBy(vocabulary))
        self.assertEqual(len(vocabulary), 2)
    def __call__(self):
        self.request.response.setHeader(
            'Content-Type', 'application/json; charset=utf-8')

        field = self.request['field']
        slavename = self.request['name']
        slaveid = self.request['slaveID']
        masterid = self.request['masterID']
        value = self.request['value']

        for slave in self.widget.getSlaves():
            # Loop until we find the slave we want
            if slave['name'] != slavename:
                continue

            action = slave.get('action')
            if action not in ['vocabulary', 'value', 'attr']:
                continue

            # --- VALUE --------------------------------------------------------
            if action == 'value':
                value = self.getVocabulary(slave, value, '')
                return json.dumps(translate(value, self.request))

            # --- ATTR- --------------------------------------------------------
            if action == 'attr':
                result = self.getVocabulary(slave, value, None)
                if isinstance(result, dict) and 'attr' in result and 'value' in result:
                    return json.dumps(result)
                else:
                    raise ValueError('Bad attr dictionary for %s.' % slavename)

            # --- VOCABULARY ---------------------------------------------------
            vocabulary = self.getVocabulary(slave, value)

            if isinstance(vocabulary, (tuple, list)):
                vocabulary = self.createVocaabulary(vocabulary)

            widget = self.widget.form.widgets.get(slave['name'])
            if widget is None:
                raise ValueError('Can not find widget: %s' % slave['name'])

            if (IContextSourceBinder.providedBy(vocabulary)
                or IVocabularyTokenized.providedBy(vocabulary)):

                if hasattr(widget.field, 'value_type'):
                    widget.field.value_type.vocabulary = vocabulary
                else:
                    widget.field.vocabulary = vocabulary
                widget.terms = None
                widget.updateTerms()
                widget.update()
                # widget may define items as a property or as a method
                items = widget.items if not callable(widget.items) else widget.items() 
                responseJSON = {'items': items}

                # disable select box if term length = 'disable_length'
                #if len(widget.terms) == slave.get('disable_length', None):
                #    responseJSON['disabled'] = True

                return json.dumps(responseJSON)

        raise ValueError('No such master-slave combo')
Ejemplo n.º 39
0
 def test_Interface(self):
     self.failUnless(IVocabulary.providedBy(self.vocab))
     self.failUnless(IVocabularyTokenized.providedBy(self.vocab))
Ejemplo n.º 40
0
 def assertVocabulary(self, voc, values):
     self.assertTrue(IVocabularyTokenized.providedBy(voc))
     self.assertEqual(
         [(term.value, term.token, term.title) for term in voc],
         values
     )