Python SimpleVocabulary.getTermByToken方法代码示例

# 需要导入模块: from zope.schema.vocabulary import SimpleVocabulary [as 别名]
# 或者: from zope.schema.vocabulary.SimpleVocabulary import getTermByToken [as 别名]
class KeywordSource(object):
    implements(IQuerySource)

    def __init__(self, context):
        self.context = context
        self.vocab = SimpleVocabulary(
            [SimpleVocabulary.createTerm(DATA[x], x, DATA[x])
             for x in DATA]
        )

    def __contains__(self, term):
        return self.vocab.__contains__(term)

    def __iter__(self):
        return self.vocab.__iter__()

    def __len__(self):
        return self.vocab.__len__()

    def getTerm(self, value):
        return self.vocab.getTerm(value)

    def getTermByToken(self, value):
        return self.vocab.getTermByToken(value)

    def search(self, query_string):
        q = query_string.lower()
        return [kw
                for kw in self.vocab._terms
                if q.lower() in kw.value]

# 需要导入模块: from zope.schema.vocabulary import SimpleVocabulary [as 别名]
# 或者: from zope.schema.vocabulary.SimpleVocabulary import getTermByToken [as 别名]
class KeywordSource(object):
    interface.implements(IQuerySource)

    def __init__(self, context):
        self.context = context
        catalog = getToolByName(context, 'portal_catalog')
        self.keywords = catalog.uniqueValuesFor('Subject')
        terms = []
        for x in self.keywords:
            terms.append(SimpleTerm(x, x, unicode(x)))
        self.vocab = SimpleVocabulary(terms)

    def __contains__(self, term):
        return self.vocab.__contains__(term)

    def __iter__(self):
        return self.vocab.__iter__()

    def __len__(self):
        return self.vocab.__len__()

    def getTerm(self, value):
        return self.vocab.getTerm(value)

    def getTermByToken(self, value):
        return self.vocab.getTermByToken(value)

    def search(self, query_string):
        q = query_string.lower()
        return [self.getTerm(kw) for kw in self.keywords if q in kw.lower()]

# 需要导入模块: from zope.schema.vocabulary import SimpleVocabulary [as 别名]
# 或者: from zope.schema.vocabulary.SimpleVocabulary import getTermByToken [as 别名]
    def _subscription_field(self):
        subscription_terms = []
        self_subscribed = False
        is_really_muted = self.user_is_muted
        if is_really_muted:
            subscription_terms.insert(0, self._unmute_user_term)
        for person in self._subscribers_for_current_user:
            if person.id == self.user.id:
                if is_really_muted:
                    # We've already added the unmute option.
                    continue
                else:
                    if self.user_is_subscribed_directly:
                        subscription_terms.append(
                            self._update_subscription_term)
                    subscription_terms.insert(
                        0, self._unsubscribe_current_user_term)
                    self_subscribed = True
            else:
                subscription_terms.append(
                    SimpleTerm(
                        person, person.name,
                        structured(
                            'unsubscribe <a href="%s">%s</a> from this bug',
                            canonical_url(person),
                            person.displayname).escapedtext))
        if not self_subscribed:
            if not is_really_muted:
                subscription_terms.insert(0,
                    SimpleTerm(
                        self.user, self.user.name,
                        'subscribe me to this bug'))
            elif not self.user_is_subscribed_directly:
                subscription_terms.insert(0,
                    SimpleTerm(
                        'update-subscription', 'update-subscription',
                        'unmute bug mail from this bug and subscribe me to '
                        'this bug'))

        # Add punctuation to the list of terms.
        if len(subscription_terms) > 1:
            for term in subscription_terms[:-1]:
                term.title += ','
            subscription_terms[-2].title += ' or'
            subscription_terms[-1].title += '.'

        subscription_vocabulary = SimpleVocabulary(subscription_terms)
        if self.user_is_subscribed_directly or self.user_is_muted:
            default_subscription_value = self._update_subscription_term.value
        else:
            default_subscription_value = (
                subscription_vocabulary.getTermByToken(self.user.name).value)

        subscription_field = Choice(
            __name__='subscription', title=_("Subscription options"),
            vocabulary=subscription_vocabulary, required=True,
            default=default_subscription_value)
        return subscription_field

# 需要导入模块: from zope.schema.vocabulary import SimpleVocabulary [as 别名]
# 或者: from zope.schema.vocabulary.SimpleVocabulary import getTermByToken [as 别名]
class KeywordSource(object):
    implements(IQuerySource)

    def __init__(self, context):
        self.context = context
        catalog = getToolByName(context, 'portal_catalog')
        self.keywords = catalog.uniqueValuesFor('Subject')

        def safe_str(s):
            if type(s) == unicode:
                return s.encode("utf-8", "replace")
            else:
                return s

        def safe_unicode(s):
            if type(s) == str:
                return unicode(s, "utf-8", "replace")
            else:
                return s

        # XXX: plone.z3cform monkeypatches z3c.forms to decode
        # all form values in query to unicode; in short, one cannot
        # use non-ascii characters in tokens (z3c.form expects tokens
        # to be encoded strings, but plone.z3cform breaks this)

        self.vocab = SimpleVocabulary([
            SimpleTerm(safe_unicode(x), quote(safe_str(x)), safe_unicode(x))
            for x in self.keywords])

    def __contains__(self, term):
        return self.vocab.__contains__(term)

    def __iter__(self):
        return self.vocab.__iter__()

    def __len__(self):
        return self.vocab.__len__()

    def getTerm(self, value):
        def safe_unicode(s):
            if type(s) == str:
                return unicode(s, "utf-8", "replace")
            else:
                return s
        return self.vocab.getTerm(safe_unicode(value))

    def getTermByToken(self, value):
        return self.vocab.getTermByToken(value)

    def search(self, query_string):
        q = query_string.lower()
        return [self.getTerm(kw) for kw in self.keywords if q in kw.lower()]

# 需要导入模块: from zope.schema.vocabulary import SimpleVocabulary [as 别名]
# 或者: from zope.schema.vocabulary.SimpleVocabulary import getTermByToken [as 别名]
class CustomSearchableTextSource(SearchableTextSource):
    implements(ISource)
    classProvides(IContextSourceBinder)

    def __init__(self, context, base_query={}, default_query=None):
        super(CustomSearchableTextSource, self).__init__(context, base_query=base_query, default_query=default_query)
        self.vocabulary = SimpleVocabulary([SimpleTerm(a, a, a) for a in self.baseTerms()])

    def baseTerms(self):
        query = self.base_query.copy()
        try:
            results = (x.getPath()[len(self.portal_path):] for x in self.catalog(**query))
        except ParseError:
            return []

        if query.has_key('path'):
            path = query['path']['query'][len(self.portal_path):]
            if path != '':
                return itertools.chain((path,), results)
        return results

    def search(self, query_string):
        results = super(CustomSearchableTextSource, self).search(query_string)
        return SimpleVocabulary([SimpleTerm(a, a, a) for a in results])

    def __contains__(self, value):
        return self.vocabulary.__contains__(value)

    def __iter__(self):
        return self.vocabulary.__iter__()

    def getTerm(self, value):
        return self.vocabulary.getTerm(value)


    def getTermByToken(self, token):
        return self.vocabulary.getTermByToken(token)

# 需要导入模块: from zope.schema.vocabulary import SimpleVocabulary [as 别名]
# 或者: from zope.schema.vocabulary.SimpleVocabulary import getTermByToken [as 别名]
 def getTermByToken(self, token):
     try:
         return SimpleVocabulary.getTermByToken(self, token)
     except LookupError:
         return self.createTerm(token)