Python interfaces.ITitledTokenizedTerm类代码示例

 def items(self):
     items = []
     if self.terms is not None:
         # update() has been called
         if ((not self.required or self.prompt)
             and not bool(self.multiple)):
             message = self.noValueMessage
             if self.prompt:
                 message = self.promptMessage
             items.append({
                 'id': self.id + '-novalue',
                 'value': self.noValueToken,
                 'content': message,
                 'selected': self.value == []
                 })
         for count, term in enumerate(self.terms):
             selected = self.isSelected(term)
             id = '%s-%i' % (self.id, count)
             content = term.token
             if ITitledTokenizedTerm.providedBy(term):
                 content = translate(
                     term.title,
                     context=self.request,
                     default=term.title)
             items.append(
                 {'id':id,
                  'value':term.token,
                  'content':content,
                  'selected':selected})
     return items

 def test_get_term_by_token(self):
     # we can get a term by its token
     source = RedisAutocompleteSource(
         host=self.redis_host, port=self.redis_port,
         zset_name="autocomplete-foo")
     result = source.getTermByToken(u'1')
     self.assertTrue(ITitledTokenizedTerm.providedBy(result))

 def cmp(self, term, query):
     # ajax search widget does a search on this vocabulary,
     # if we have titled terms, we have to compare against the title
     # otherwise use the value.
     if ITitledTokenizedTerm.providedBy(term):
         return query in term.title.lower()
     return query in term.value.lower()

    def items(self):
        # TODO: check if we should cache the return list
        if self.terms is None:  # update() not yet called
            return ()
        vocab = getUtility(
            IVocabularyFactory, "org.bccvl.site.algorithm_category_vocab")(self.context)
        items = OrderedDict((cat.value, [])
                            for cat in chain((SimpleTerm(None),), vocab))
        for count, term in enumerate(self.terms):
            alg = term.brain.getObject()
            # skip algorithm without category
            # if alg.algorithm_category is None or alg.algorithm_category not in items:
            #     continue
            itemList = items[alg.algorithm_category]
            checked = self.isChecked(term)
            id = '%s-%i' % (self.id, count)
            if ITitledTokenizedTerm.providedBy(term):
                label = translate(
                    term.title, context=self.request, default=term.title)
            else:
                label = util.toUnicode(term.value)

            catterm = SimpleTerm(None)
            if alg.algorithm_category in vocab:
                catterm = vocab.getTerm(alg.algorithm_category)
            itemList.append({'id': id, 'name': self.name + ':list', 'value': term.token,
                             'label': label, 'checked': checked,
                             'subject': term.brain.Subject,
                             'description': term.brain.Description,
                             'category': catterm,
                             'pos': len(itemList)})
        return items.values()

    def users(self):
        context = self.context
        memtool = getToolByName(context, 'portal_membership')
        vocabulary = queryUtility(schema.interfaces.IVocabularyFactory,
                                  name='ftw.notification.base.users',
                                  context=context)
        if vocabulary:
            users = vocabulary(context)

            finalized = []
            for t in users:
                userid = t.value
                member = memtool.getMemberById(userid)
                if member is None:
                    continue

                title = t.title if ITitledTokenizedTerm.providedBy(t) else t.value
                user = dict(title=title,
                            value=t.value,
                            email=member.getProperty("email", ""),
                            selected=t.value in self.pre_select)
                finalized.append(user)

            finalized.sort(key=lambda user: user['title'].lower())
        return finalized

 def test_iter(self):
     # we can iterate over all elements
     source = RedisAutocompleteSource(
         host=self.redis_host, port=self.redis_port,
         zset_name="autocomplete-foo")
     elem_list = [x for x in source]
     self.assertEqual(len(elem_list), 4)
     self.assertTrue(ITitledTokenizedTerm.providedBy(elem_list[0]))

    def render_default_title(self, item, value):
        """Render the default title colum with the term's title."""

        term = self.terms.getTerm(item)

        if ITitledTokenizedTerm.providedBy(term):
            label = translate(term.title, context=self.request,
                              default=term.title)
        else:
            label = util.toUnicode(term.value)
        return label

 def test_get_term_contained(self):
     # we can get contained terms as ITerm
     source = RedisSource(host=self.redis_host, port=self.redis_port)
     term = source.getTerm(u'foo')
     assert ITitledTokenizedTerm.providedBy(term)
     self.assertTrue(hasattr(term, 'value'))
     self.assertEqual(term.value, u'foo')
     self.assertTrue(hasattr(term, 'token'))
     self.assertEqual(term.token, 'Zm9v')
     self.assertTrue(hasattr(term, 'title'))
     self.assertEqual(term.title, u'bar')

 def addItem(idx, group, term, prefix=''):
     selected = self.isSelected(term)
     if selected:
         ignored.remove(term.token)
     id = '%s-%s%i' % (self.id, prefix, idx)
     content = term.token
     if ITitledTokenizedTerm.providedBy(term):
         content = translate(
             term.title, context=self.request, default=term.title)
     optgroups[group].append(
         {'id': id, 'value': term.token, 'content': content,
          'selected': selected})

    def render_default_title(self, item, value):
        """Render the default title colum with the term's title."""
        if isinstance(item, NullObject):
            return _(u'label_none', default=u'None')

        term = self.terms.getTerm(item)

        if ITitledTokenizedTerm.providedBy(term):
            label = translate(term.title, context=self.request,
                              default=term.title)
        else:
            label = util.toUnicode(term.value)
        return label

    def textForValue(self, term):
        """Extract a string from the `term`.

        The `term` must be a vocabulary tokenized term.

        This can be overridden to support more complex `term`
        objects. The token is returned here since it's the only thing
        known to be a string, or str()able.

        """
        if ITitledTokenizedTerm.providedBy(term):
            return self.translate(term.title)
        return term.token

 def items(self):
     if self.terms is None:  # update() has not been called yet
         return ()
     items = []
     if self.multiple is None:
         message = self.noValueMessage
         if self.prompt:
             message = self.promptMessage
         items.append({
             'id': self.id + '-novalue',
             'value': self.noValueToken,
             'content': message,
             'selected': self.value == []
             })
     unordered_items = {}
     optgroups = []
     for count, term in enumerate(self.terms):
         # Exctract optgroups in an ordered list, so we can use this to
         # preserve the main order of optgroups.
         if not term.optgroup in optgroups:
             optgroups.append(term.optgroup)
         selected = self.isSelected(term)
         id = '%s-%i' % (self.id, count)
         content = term.title
         if ITitledTokenizedTerm.providedBy(term):
             content = self.getContent(term)
         if not term.optgroup in unordered_items:
             unordered_items[term.optgroup] = []
         unordered_items[term.optgroup].append({
             'id': id,
             'value': term.token,
             'content': content,
             'selected': selected,
         })
     for group in optgroups:
         if not group:
             for ding in unordered_items[group]:
                 items.append({
                     'id': ding['id'],
                     'value': ding['value'],
                     'content': ding['content'],
                     'selected': ding['value'] == []
                     })
         else:
             item = {}
             item['title'] = group
             item['member'] = unordered_items[group]
             items.append(item)
     self.getSize(items)
     return items

    def _overrideValue(self, widget, value):
        if value:
            widget.value = ['selected']

        widget.items = []
        for count, term in enumerate(widget.terms):
            checked = widget.isChecked(term)
            id = '%s-%i' % (widget.id, count)
            label = term.token
            if ITitledTokenizedTerm.providedBy(term):
                label = translate(term.title, context=widget.request,
                                  default=term.title)
            widget.items.append({'id': id, 'name': widget.name + ':list',
                'value': term.token, 'label': label, 'checked': checked})

 def displayValue(self):
     value = {}
     for token in self.value:
         # Ignore no value entries. They are in the request only.
         if token == self.noValueToken:
             continue
         term = self.terms.getTermByToken(token)
         if ITitledTokenizedTerm.providedBy(term):
             content = self.getContent(term)
         else:
             value.append(term.value)
         if not term.optgroup in value:
             value[term.optgroup] = []
         value[term.optgroup].append(content)
     return value

 def items(self):
     # TODO: check if we should cache the return list
     if self.terms is None:  # update() not yet called
         return ()
     items = []
     for count, term in enumerate(self.terms):
         checked = self.isChecked(term)
         id = '%s-%i' % (self.id, count)
         if ITitledTokenizedTerm.providedBy(term):
             label = translate(term.title, context=self.request,
                               default=term.title)
         else:
             label = util.toUnicode(term.value)
         items.append ({'id': id, 'name': self.name + ':list', 'value':term.token,
                'label':label, 'checked': checked,
                'subject': term.brain.Subject})
     return items