コード例 #1
0
 def getViewTypeTitles(self):
     return {
         "browser": _("Browser"),
         "xmlrpc": _("XML-RPC"),
         "http": _("HTTP"),
         "ftp": _("FTP"),
         "other": _("Other"),
         }
コード例 #2
0
def getInterfaceInfoDictionary(iface):
    """Return a PT-friendly info dictionary for an interface."""
    if isinstance(iface, zope.interface.declarations.Implements):
        iface = iface.inherit
    if iface is None:
        return None
    return {'module': getattr(iface, '__module__', _('<unknown>')),
            'name': getattr(iface, '__name__', _('<unknown>'))}
コード例 #3
0
 def unlock(self):
     lock = self.storage.getLock(self.context)
     if lock is None:
         raise interfaces.LockingError(_("Object is not locked"))
     principal = self._findPrincipal()
     if lock.principal_id != principal.id:
         raise interfaces.LockingError(_("Principal is not lock owner"))
     self.storage.delLock(self.context)
     event.notify(interfaces.UnlockedEvent(self.context))
コード例 #4
0
class IAllIndex(zope.interface.Interface):
    """Index all objects of a specified interface.
    Collects all instances, not any property value.
    """

    interface = zope.schema.Choice(
        title=_(u"Interface"),
        description=_(u"Collect objects of this interface"),
        vocabulary="Interfaces",
        required=False,
        )
コード例 #5
0
    def invalidate(self):
        "Invalidate the current cached value."

        cache = getCacheForObject(self.context)
        location = getLocationForCache(self.context)
        if cache and location:
            cache.invalidate(location)
            return self.form(message=_("cache-invalidated", u"Invalidated."))
        else:
            return self.form(message=_("no-cache-associated",
                                       u"No cache associated with object."))
コード例 #6
0
class IAllIndex(zope.interface.Interface):
    """I index objects by first adapting them to an interface, then
       retrieving a field on the adapted object.
    """

    interface = zope.schema.Choice(
        title=_(u"Interface"),
        description=_(u"Objects will be adapted to this interface"),
        vocabulary="Interfaces",
        required=False,
    )
コード例 #7
0
class IWidgetDirective(Interface):
    """
    Register a widget
    """
    factory = GlobalObject(
        title=_("Factory"),
        description=_("Python name of a factory which can create the"
                      " implementation object.  This must identify an"
                      " object in a module using the full dotted name."),
        required=True,
    )
コード例 #8
0
 def _findPrincipal(self):
     # Find the current principal. Note that it is possible for there
     # to be more than one principal - in this case we throw an error.
     interaction = zope.security.management.getInteraction()
     principal = None
     for p in interaction.participations:
         if principal is None:
             principal = p.principal
         else:
             raise interfaces.LockingError(_("Multiple principals found"))
     if principal is None:
         raise interfaces.LockingError(_("No principal found"))
     return principal
コード例 #9
0
class IRSSListing(Interface):
    """A content type, which displays an RSS feed in the same way as
    RSS Portlet does.
    """

    # Cloned from: plone.app.portlets.portlets.rss.IRSSPortlet
    count = schema.Int(title=_(u'Number of items to display', domain="plone"),
                       description=_(u'How many items to list.',
                                     domain="plone"),
                       required=True,
                       default=5)
    url = schema.Text(
        title=_(u'List of RSS feed URLs', domain="jyu.rsslisting"),
        description=
        _(u'List of links to the RSS feeds to display. Please, enter only one link per line.',
          domain="jyu.rsslisting"),
        required=True,
        default=u'')
    timeout = schema.Int(
        title=_(u'Feed reload timeout', domain="plone"),
        description=_(
            u'Time in minutes after which the feed should be reloaded.',
            domain="plone"),
        required=True,
        default=100)

    showMoreEnabled = schema.Bool(
        title=_(u'Show link to show more', domain="jyu.rsslisting"),
        description=
        _(u'When set there will be link at the end to show all the results. If there is more than one RSS feed defined, only the first RSS feed will be linked.',
          domain="jyu.rsslisting"),
        required=False,
    )
コード例 #10
0
class IBrowserSubMenuItem(IBrowserMenuItem):
    """A menu item that points to a sub-menu."""

    submenuId = TextLine(title=_("Sub-Menu Id"),
                         description=_(
                             "The menu id of the menu that describes the "
                             "sub-menu below this item."),
                         required=True)

    action = TextLine(title=_("The URL to display if the item is selected"),
                      description=_(
                          "When a user selects a browser menu item, the URL "
                          "given in the action is displayed. The action is "
                          "usually given as a relative URL, relative to the "
                          "object the menu item is for."),
                      required=False)
コード例 #11
0
    def __call__(self):
        """Create breadcrumbs for an interface object.

        The breadcrumbs are rooted at the code browser.
        """
        docroot = findAPIDocumentationRoot(self.context)
        codeModule = traverse(docroot, "Code")
        crumbs = [{
            'name': _('[top]'),
            'url': absoluteURL(codeModule, self.request)
        }]
        # We need the __module__ of the interface, not of a location proxy,
        # so we have to remove all proxies.
        iface = removeAllProxies(self.context)
        mod_names = iface.__module__.split('.')
        obj = codeModule
        for name in mod_names:
            try:
                obj = traverse(obj, name)
            except KeyError: # pragma: no cover
                # An unknown (root) module, such as logging
                continue
            crumbs.append({
                'name': name,
                'url': absoluteURL(obj, self.request)
            })
        crumbs.append({
            'name': iface.__name__,
            'url': absoluteURL(self.context, self.request)
        })
        return crumbs
コード例 #12
0
def getUtilityInfoDictionary(reg):
    """Return a PT-friendly info dictionary for a factory."""
    component = reg.component
    # Check whether we have an instance of some custom type or not
    # Unfortunately, a lot of utilities have a `__name__` attribute, so we
    # cannot simply check for its absence
    # TODO: Once we support passive display of instances, this insanity can go
    #       away.
    if not isinstance(component, (types.MethodType, types.FunctionType,
                                  six.class_types,
                                  InterfaceClass)):
        component = getattr(component, '__class__', component)

    path = getPythonPath(component)

    # provided interface id
    iface_id = '%s.%s' % (reg.provided.__module__, reg.provided.getName())

    # Determine the URL
    if isinstance(component, InterfaceClass):
        url = 'Interface/%s' % path
    else:
        url = None
        if isReferencable(path):
            url = 'Code/%s' % path.replace('.', '/')

    return {'name': six.text_type(reg.name) or _('<i>no name</i>'),
            'url_name': utilitymodule.encodeName(reg.name or '__noname__'),
            'iface_id': iface_id,
            'path': path,
            'url': url}
コード例 #13
0
    def manage_delMessage(self, message, REQUEST, RESPONSE):
        """ """
        message_key = self.message_decode(message)
        self.get_message_catalog().del_message(message_key)

        url = get_url(REQUEST.URL1 + '/manage_messages',
                      REQUEST['batch_start'], REQUEST['batch_size'],
                      REQUEST['regex'], REQUEST.get('lang', ''),
                      REQUEST.get('empty', 0),
                      manage_tabs_message=_(u'Saved changes.'))
        RESPONSE.redirect(url)
コード例 #14
0
 def lock(self, timeout=None, principal=None):
     if principal is None:
         principal = self._findPrincipal()
     principal_id = principal.id
     lock = self.storage.getLock(self.context)
     if lock is not None:
         raise interfaces.LockingError(_("Object is already locked"))
     lock = LockInfo(self.context, principal_id, timeout)
     self.storage.setLock(self.context, lock)
     event.notify(interfaces.LockedEvent(self.context, lock))
     return lock
コード例 #15
0
class ILockInfo(IMapping):
    """
    An ILockInfo implementation is responsible for
    """

    target = interface.Attribute("""the actual locked object.""")

    principal_id = schema.TextLine(
        description=_("id of the principal owning the lock")
    )

    created = schema.Float(
        description=_("time value indicating the creation time"),
        required=False
    )

    timeout = schema.Float(
        description=_("time value indicating the lock timeout from creation"),
        required=False
    )
コード例 #16
0
class IBrowserMenu(Interface):
    """Menu

    Menus are objects that can return a list of menu items they contain. How
    they generate this list is up to them. Commonly, however, they will look
    up adapters that provide the ``IBrowserMenuItem`` interface.
    """

    id = TextLine(title=_("Menu Id"),
                  description=_("The id uniquely identifies this menu."),
                  required=True)

    title = TextLine(
        title=_("Menu title"),
        description=_("The title provides the basic label for the menu."),
        required=False)

    description = Text(title=_("Menu description"),
                       description=_(
                           "A description of the menu. This might be shown "
                           "on menu pages or in pop-up help for menus."),
                       required=False)

    def getMenuItems(object, request):
        """Return a TAL-friendly list of menu items.
コード例 #17
0
    def manage_delMessage(self, message, REQUEST, RESPONSE):
        """ """
        message_key = self.message_decode(message)
        self.get_message_catalog().del_message(message_key)

        url = get_url(REQUEST.URL1 + '/manage_messages',
                      REQUEST['batch_start'],
                      REQUEST['batch_size'],
                      REQUEST['regex'],
                      REQUEST.get('lang', ''),
                      REQUEST.get('empty', 0),
                      manage_tabs_message=_(u'Saved changes.'))
        RESPONSE.redirect(url)
コード例 #18
0
    def manage_editMessage(self, message, language, translation,
                           REQUEST, RESPONSE):
        """Modifies a message.
        """
        message_encoded = message
        message_key = self.message_decode(message_encoded)
        self.get_message_catalog()\
            .edit_message(message_key, language, translation)

        url = get_url(REQUEST.URL1 + '/manage_messages',
                      REQUEST['batch_start'], REQUEST['batch_size'],
                      REQUEST['regex'], REQUEST.get('lang', ''),
                      REQUEST.get('empty', 0),
                      msg=message_encoded,
                      manage_tabs_message=_(u'Saved changes.'))
        RESPONSE.redirect(url)
コード例 #19
0
    def manage_editMessage(self, message, language, translation, REQUEST,
                           RESPONSE):
        """Modifies a message.
        """
        message_encoded = message
        message_key = self.message_decode(message_encoded)
        self.get_message_catalog()\
            .edit_message(message_key, language, translation)

        url = get_url(REQUEST.URL1 + '/manage_messages',
                      REQUEST['batch_start'],
                      REQUEST['batch_size'],
                      REQUEST['regex'],
                      REQUEST.get('lang', ''),
                      REQUEST.get('empty', 0),
                      msg=message_encoded,
                      manage_tabs_message=_(u'Saved changes.'))
        RESPONSE.redirect(url)
コード例 #20
0
def getFactoryInfoDictionary(reg):
    """Return a PT-friendly info dictionary for a factory."""
    factory = reg.component
    callable = factory

    # Usually only zope.component.factory.Factory instances have this attribute
    if IFactory.providedBy(factory) and hasattr(factory, '_callable'):
        callable = factory._callable
    elif hasattr(callable, '__class__'):
        callable = callable.__class__

    path = getPythonPath(callable)

    return {'name': six.text_type(reg.name) or _('<i>no name</i>'),
            'title': getattr(factory, 'title', u''),
            'description': renderText(getattr(factory, 'description', u''),
                                      module=callable.__module__),
            'url': isReferencable(path) and path.replace('.', '/') or None}
コード例 #21
0
ファイル: utilities.py プロジェクト: jean/zope.app.apidoc
    def __call__(self):
        """Create breadcrumbs for a module or an object in a module or package.

        We cannot reuse the system's bread crumbs, since they go all the
        way up to the root, but we just want to go to the root module.
        """
        obj = self.context
        crumbs = []
        while not IDocumentationModule.providedBy(obj):
            crumbs.append(
                {'name': getName(obj),
                 'url': absoluteURL(obj, self.request)}
                )
            obj = getParent(obj)

        crumbs.append(
            {'name': _('[top]'),
             'url': absoluteURL(obj, self.request)}
            )
        crumbs.reverse()
        return crumbs
コード例 #22
0
ファイル: presentation.py プロジェクト: jean/zope.app.apidoc
def getViewInfoDictionary(reg):
    """Build up an information dictionary for a view registration."""
    # get configuration info
    if isinstance(reg.info, (str, unicode)):
        doc = reg.info
        zcml = None
    else:
        doc = None
        zcml = getParserInfoInfoDictionary(reg.info)

    info = {'name' : unicode(reg.name) or _('<i>no name</i>'),
            'type' : getPythonPath(getPresentationType(reg.required[-1])),
            'factory' : getViewFactoryData(reg.factory),
            'required': [getInterfaceInfoDictionary(iface)
                         for iface in reg.required],
            'provided' : getInterfaceInfoDictionary(reg.provided),
            'doc': doc,
            'zcml': zcml
            }

    # Educated guess of the attribute name
    info.update(getPermissionIds('publishTraverse', klass=reg.factory))

    return info
コード例 #23
0
ファイル: rsslisting.py プロジェクト: Gomez/jyu.rsslisting
from Products.ATContentTypes.content import base
from Products.ATContentTypes.content import schemata
from Products.ATContentTypes.content.schemata import finalizeATCTSchema

from jyu.rsslisting.interfaces.rsslisting import IRSSListing
from jyu.rsslisting.config import PROJECTNAME

from zope.i18nmessageid import Message as _ # requires explicit domain

RSSListingSchema = schemata.ATContentTypeSchema.copy() + atapi.Schema((

    atapi.IntegerField('count',
        required=True,
        searchable=True,
        storage=atapi.AnnotationStorage(),
        widget=atapi.IntegerWidget(label=_(u'Number of items to display', domain="plone"),
                                   description=_(u'How many items to list.', domain="plone")),
        default=5,
        ),

    atapi.TextField('url',
        required=True,
        searchable=True,
#        validators=(('isURL'),),
        storage=atapi.AnnotationStorage(),
        widget=atapi.TextAreaWidget(label=_(u'List of RSS feed URLs', domain="jyu.rsslisting"),
                                    description=_(u'List of links to the RSS feeds to display. Please, enter only one link per line.',
                                                  domain="jyu.rsslisting")),
        ),

    atapi.IntegerField('timeout',
コード例 #24
0
 def breaklock(self):
     lock = self.storage.getLock(self.context)
     if lock is None:
         raise interfaces.LockingError(_("Object is not locked"))
     self.storage.delLock(self.context)
     event.notify(interfaces.BreakLockEvent(self.context))
コード例 #25
0
                                       name='absolute_url')
        try:
            return absolute_url()
        except TypeError:
            # In case the cache object is a global one and does not have a
            # location, then we just return None. 
            return None

    def invalidate(self):
        "Invalidate the current cached value."

        cache = getCacheForObject(self.context)
        location = getLocationForCache(self.context)
        if cache and location:
            cache.invalidate(location)
            return self.form(message=_("cache-invalidated", u"Invalidated."))
        else:
            return self.form(message=_("no-cache-associated",
                                       u"No cache associated with object."))

    def action(self):
        "Change the cacheId"
        try:
            cacheId = self.cacheId_widget.getInputValue()
        except WidgetInputError, e:
            #return self.form(errors=e.errors)
            return repr(e.errors)
        else:
            self.cacheable.setCacheId(cacheId)
            return self.form(message=_(u"Saved changes."))
コード例 #26
0
 def getViewClassTitles(self):
     return {
         "specific": _("Specific views"),
         "extended": _("Extended views"),
         "generic": _("Generic views"),
         }
コード例 #27
0
 def check_content_type(self):
     if self.request.get_header("Content-Type") != "application/x-snarf":
         raise ValueError(_("Content-Type is not application/x-snarf"))
コード例 #28
0
class ITingIndexSchema(IAttributeIndex):
    default_fields = BytesLine(
        title=_(u"Default fields"),
        description=_(
            "Look in these fields by default (consider dedicated_storage=True)"
        ),
        required=True,
        default='')
    storage = Choice(
        title=_(u"Storage"),
        description=_(u"Component for storing wordID-to-documentID-mappings"),
        required=True,
        default=config.DEFAULT_STORAGE,
        vocabulary="TextIndexNG3 Storages")
    dedicated_storage = Bool(
        title=_(u"Dedicated storage"),
        description=_(
            u"Use seperate index for each field (allows per field search)"),
        required=True,
        default=config.defaults['dedicated_storage'])
    languages = BytesLine(
        title=_(u"Languages"),
        description=_(
            u"Languages supported by this index (space seperated list)"),
        default=config.DEFAULT_LANGUAGE,
        constraint=re.compile('[a-z]+(\s+[a-z]+)*').match)
    use_stemmer = Bool(
        title=_(u"Stemming"),
        description=
        _(u"Compare words according to their word stems (a kind of similarity search)"
          ),
        default=False,
        required=config.defaults['use_stemmer'])
    use_stopwords = Bool(
        title=_(u"Stopwords"),
        description=
        _(u"Enable to prvent looking for words like 'and' or 'a' which are unlike to be useful in search queries"
          ),
        required=True,
        default=config.defaults['use_stopwords'])
    use_normalizer = Bool(
        title=_(u"Normalize"),
        description=
        _(u"Enable to normalize words language specific (e.g. ä -> ae , è -> e)"
          ),
        required=True,
        default=config.defaults['use_normalizer'])
    ranking = Bool(
        title=_(u"Ranking"),
        description=
        _(u"Enable ranking according to word frequency of documents (selects different storage)"
          ),
        required=True,
        default=config.defaults['ranking'])
    autoexpand_limit = Int(
        title=_(u"Autoexpand limit"),
        description=_(u"Lower limit for automatic right-*-wildcard-search"),
        required=True,
        default=config.defaults['autoexpand_limit'])
    splitter = Choice(
        title=_(u"Splitter"),
        description=_(u"Splitter to be used to turn text into words"),
        required=True,
        default=config.DEFAULT_SPLITTER,
        vocabulary="TextIndexNG3 Splitters")
    lexicon = Choice(
        title=_(u"Lexicon"),
        description=_(u"Component to be used for storing word-to-id-mappings"),
        required=True,
        default=config.DEFAULT_LEXICON,
        vocabulary="TextIndexNG3 Lexicons")
    index_unknown_languages = Bool(
        title=_(u"Index unknown languages"),
        description=
        _(u"Assigns unknown languages the first language of the languages selected for this index"
          ),
        required=True,
        default=config.defaults['index_unknown_languages'],
    )
    splitter_additional_chars = BytesLine(
        title=_(u"Non-seperators"),
        description=_(
            u"Characters that should *not* be threaded as separators"),
        required=True,
        default=config.defaults['splitter_additional_chars'])
    splitter_casefolding = Bool(
        title=_(u"Case-insensitive"),
        description=_(u"Make this index case insensitive"),
        required=True,
        default=config.defaults['splitter_casefolding'])
    query_parser = Choice(title=_(u"Query Parser"),
                          description=_(u"Parser to be used for this index"),
                          required=True,
                          default=config.DEFAULT_PARSER,
                          vocabulary="TextIndexNG3 Query Parsers")
コード例 #29
0
    def get_namespace(self, REQUEST):
        """For the management interface, allows to filter the messages to
        show.
        """
        # Check whether there are languages or not
        languages = self.get_languages_mapping()
        if not languages:
            return {}

        # Input
        batch_start = REQUEST.get('batch_start', 0)
        batch_size = REQUEST.get('batch_size', 15)
        empty = REQUEST.get('empty', 0)
        regex = REQUEST.get('regex', '')
        message = REQUEST.get('msg', None)

        # Build the namespace
        namespace = {}
        namespace['batch_size'] = batch_size
        namespace['empty'] = empty
        namespace['regex'] = regex

        # The language
        lang = REQUEST.get('lang', None) or languages[0]['code']
        namespace['language'] = lang

        # Filter the messages
        query = regex.strip()
        try:
            query = re.compile(query)
        except:
            query = re.compile('')

        messages = []
        for m, t in self.get_message_catalog().messages():
            if query.search(m) and (not empty or not t.get(lang, '').strip()):
                messages.append(m)
        messages.sort(filter_sort)
        # How many messages
        n = len(messages)
        namespace['n_messages'] = n

        # Calculate the start
        while batch_start >= n:
            batch_start = batch_start - batch_size
        if batch_start < 0:
            batch_start = 0
        namespace['batch_start'] = batch_start
        # Select the batch to show
        batch_end = batch_start + batch_size
        messages = messages[batch_start:batch_end]
        # Batch links
        namespace['previous'] = get_url(REQUEST.URL, batch_start - batch_size,
                                        batch_size, regex, lang, empty)
        namespace['next'] = get_url(REQUEST.URL, batch_start + batch_size,
                                    batch_size, regex, lang, empty)

        # Get the message
        message_encoded = None
        #translations = {}
        translation = None
        if message is None:
            if messages:
                message = messages[0]
                translation = self.get_message_catalog()\
                                  .gettext(message, lang, '')
                message = to_unicode(message)
                message_encoded = self.message_encode(message)
        else:
            message_encoded = message
            message = self.message_decode(message_encoded)
            #translations = self.get_translations(message)
            translation = self.get_message_catalog().gettext(message, lang, '')
            message = to_unicode(message)
        namespace['message'] = message
        namespace['message_encoded'] = message_encoded
        #namespace['translations'] = translations
        namespace['translation'] = translation

        # Calculate the current message
        namespace['messages'] = []
        for x in messages:
            x = to_unicode(x)
            x_encoded = self.message_encode(x)
            url = get_url(REQUEST.URL,
                          batch_start,
                          batch_size,
                          regex,
                          lang,
                          empty,
                          msg=x_encoded)
            namespace['messages'].append({
                'message': x,
                'message_encoded': x_encoded,
                'current': x == message,
                'url': url
            })

        # The languages
        for language in languages:
            code = language['code']
            language['name'] = _(language['name'])
            language['url'] = get_url(REQUEST.URL,
                                      batch_start,
                                      batch_size,
                                      regex,
                                      code,
                                      empty,
                                      msg=message_encoded)
        namespace['languages'] = languages

        return namespace
コード例 #30
0
    def get_namespace(self, REQUEST):
        """For the management interface, allows to filter the messages to
        show.
        """
        # Check whether there are languages or not
        languages = self.get_languages_mapping()
        if not languages:
            return {}

        # Input
        batch_start = REQUEST.get('batch_start', 0)
        batch_size = REQUEST.get('batch_size', 15)
        empty = REQUEST.get('empty', 0)
        regex = REQUEST.get('regex', '')
        message = REQUEST.get('msg', None)

        # Build the namespace
        namespace = {}
        namespace['batch_size'] = batch_size
        namespace['empty'] = empty
        namespace['regex'] = regex

        # The language
        lang = REQUEST.get('lang', None) or languages[0]['code']
        namespace['language'] = lang

        # Filter the messages
        query = regex.strip()
        try:
            query = re.compile(query)
        except:
            query = re.compile('')

        messages = []
        for m, t in self.get_message_catalog().messages():
            if query.search(m) and (not empty or not t.get(lang, '').strip()):
                messages.append(m)
        messages.sort(filter_sort)
        # How many messages
        n = len(messages)
        namespace['n_messages'] = n

        # Calculate the start
        while batch_start >= n:
            batch_start = batch_start - batch_size
        if batch_start < 0:
            batch_start = 0
        namespace['batch_start'] = batch_start
        # Select the batch to show
        batch_end = batch_start + batch_size
        messages = messages[batch_start:batch_end]
        # Batch links
        namespace['previous'] = get_url(REQUEST.URL, batch_start - batch_size,
            batch_size, regex, lang, empty)
        namespace['next'] = get_url(REQUEST.URL, batch_start + batch_size,
            batch_size, regex, lang, empty)

        # Get the message
        message_encoded = None
        #translations = {}
        translation = None
        if message is None:
            if messages:
                message = messages[0]
                translation = self.get_message_catalog()\
                                  .gettext(message, lang, '')
                message = to_unicode(message)
                message_encoded = self.message_encode(message)
        else:
            message_encoded = message
            message = self.message_decode(message_encoded)
            #translations = self.get_translations(message)
            translation = self.get_message_catalog().gettext(message, lang, '')
            message = to_unicode(message)
        namespace['message'] = message
        namespace['message_encoded'] = message_encoded
        #namespace['translations'] = translations
        namespace['translation'] = translation

        # Calculate the current message
        namespace['messages'] = []
        for x in messages:
            x = to_unicode(x)
            x_encoded = self.message_encode(x)
            url = get_url(
                REQUEST.URL, batch_start, batch_size, regex, lang, empty,
                msg=x_encoded)
            namespace['messages'].append({
                'message': x,
                'message_encoded': x_encoded,
                'current': x == message,
                'url': url})

        # The languages
        for language in languages:
            code = language['code']
            language['name'] = _(language['name'])
            language['url'] = get_url(REQUEST.URL, batch_start, batch_size,
                regex, code, empty, msg=message_encoded)
        namespace['languages'] = languages

        return namespace
コード例 #31
0
    def status(self):
        setUpWidget(self, 'principal', self.principal_field, IInputWidget)
        if not self.principal_widget.hasInput():
            return u''
        try:
            principal = self.principal_widget.getInputValue()
        except MissingInputError:
            return u''

        self.principal = principal

        # Make sure we can use the principal id in a form by base64ing it
        principal_token = unicode(principal).encode('base64').strip().replace(
            '=', '_')

        roles = [role for name, role in getUtilitiesFor(IRole)]
        roles.sort(lambda x, y: cmp(x.title, y.title))
        principal_roles = IPrincipalRoleManager(self.context)

        self.roles = []
        for role in roles:
            name = principal_token + '.role.'+role.id
            field = zope.schema.Choice(__name__= name,
                                       title=role.title,
                                       vocabulary=settings_vocabulary)
            setUpWidget(self, name, field, IInputWidget,
                        principal_roles.getSetting(role.id, principal))
            self.roles.append(getattr(self, name+'_widget'))

        perms = [perm for name, perm in getUtilitiesFor(IPermission)]
        perms.sort(lambda x, y: cmp(x.title, y.title))
        principal_perms = IPrincipalPermissionManager(self.context)

        self.permissions = []
        for perm in perms:
            if perm.id == 'zope.Public':
                continue
            name = principal_token + '.permission.'+perm.id
            field = zope.schema.Choice(__name__=name,
                                       title=perm.title,
                                       vocabulary=settings_vocabulary)
            setUpWidget(self, name, field, IInputWidget,
                        principal_perms.getSetting(perm.id, principal))
            self.permissions.append(
                getattr(self, name+'_widget'))

        if 'GRANT_SUBMIT' not in self.request:
            return u''

        for role in roles:
            name = principal_token + '.role.'+role.id
            role_widget = getattr(self, name+'_widget')
            if role_widget.hasInput():
                try:
                    setting = role_widget.getInputValue()
                except MissingInputError:
                    pass
                else:
                    # Arrgh!
                    if setting is Allow:
                        principal_roles.assignRoleToPrincipal(
                            role.id, principal)
                    elif setting is Deny:
                        principal_roles.removeRoleFromPrincipal(
                            role.id, principal)
                    else:
                        principal_roles.unsetRoleForPrincipal(
                            role.id, principal)

        for perm in perms:
            if perm.id == 'zope.Public':
                continue
            name = principal_token + '.permission.'+perm.id
            perm_widget = getattr(self, name+'_widget')
            if perm_widget.hasInput():
                try:
                    setting = perm_widget.getInputValue()
                except MissingInputError:
                    pass
                else:
                    # Arrgh!
                    if setting is Allow:
                        principal_perms.grantPermissionToPrincipal(
                            perm.id, principal)
                    elif setting is Deny:
                        principal_perms.denyPermissionToPrincipal(
                            perm.id, principal)
                    else:
                        principal_perms.unsetPermissionForPrincipal(
                            perm.id, principal)

        return _('Grants updated.')
コード例 #32
0
class IBrowserMenuItem(Interface):
    """Menu type

    An interface that defines a menu.
    """

    title = TextLine(
        title=_("Menu item title"),
        description=_("The title provides the basic label for the menu item."),
        required=True)

    description = Text(
        title=_("Menu item description"),
        description=_("A description of the menu item. This might be shown "
                      "on menu pages or in pop-up help for menu items."),
        required=False)

    action = TextLine(title=_("The URL to display if the item is selected"),
                      description=_(
                          "When a user selects a browser menu item, the URL"
                          "given in the action is displayed. The action is "
                          "usually given as a relative URL, relative to the "
                          "object the menu item is for."),
                      required=True)

    order = Int(title=_("Menu item ordering hint"),
                description=_(
                    "This attribute provides a hint for menu item ordering."
                    "Menu items will generally be sorted by the `for_`"
                    "attribute and then by the order."))

    filter_string = TextLine(
        title=_("A condition for displaying the menu item"),
        description=_("The condition is given as a TALES expression. The "
                      "expression has access to the variables:\n"
                      "\n"
                      "context -- The object the menu is being displayed "
                      "for\n"
                      "\n"
                      "request -- The browser request\n"
                      "\n"
                      "nothing -- None\n"
                      "\n"
                      "The menu item will not be displayed if there is a \n"
                      "filter and the filter evaluates to a false value."),
        required=False)

    icon = URI(title=_("Icon URI"),
               description=_("URI of the icon representing this menu item"))

    def available():
        """Test whether the menu item should be displayed
コード例 #33
0
 def sizeForDisplay(self):
     num_items = self._get_size()
     if num_items == 1:
         return _('1 item')
     return _('${items} items', mapping={'items': str(num_items)})
コード例 #34
0
ファイル: codemodule.py プロジェクト: jean/zope.app.apidoc
 def getDocString(self):
     """See Module class."""
     return _('Zope 3 root.')
コード例 #35
0
        elif interfaces.IPreferenceGroup.providedBy(obj):
            parent = getParent(obj)
            matches = interfaces.IPreferenceCategory.providedBy(parent)

        return matches


class PreferencesTree(CookieTreeView):
    """Preferences Tree using the stateful cookie tree."""
    def tree(self):
        root = getRoot(self.context)
        filter = PreferenceGroupFilter()
        return self.cookieTree(root, filter)


pref_msg = _("${name} Preferences")


class EditPreferenceGroup(EditView):
    def __init__(self, context, request):
        self.__used_for__ = removeSecurityProxy(context.__schema__)
        self.schema = removeSecurityProxy(context.__schema__)

        if self.schema is None:
            self.schema = NoneInterface
            zope.interface.alsoProvides(removeSecurityProxy(context),
                                        NoneInterface)

        name = translate(context.__title__,
                         context=request,
                         default=context.__title__)
コード例 #36
0
ファイル: book.py プロジェクト: jean/zope.app.apidoc
class BookModule(OnlineHelp):
    """Represent a book compiled from various `README.txt` and other `*.txt`
    documentation files.
    """

    implements(IBookModule)

    # See zope.app.apidoc.interfaces.IDocumentationModule
    title = _('Book')

    # See zope.app.apidoc.interfaces.IDocumentationModule
    description = _("""
    This is a developer's book compiled from all existing documentation
    files. It is not meant to be a complete or cohesive work, but each chapter
    in itself is a little story. Think about it like a collection of fairy
    tales.
    """)


# Global Book Instance
path = os.path.join(os.path.dirname(zope.app.apidoc.bookmodule.__file__),
                    'intro.txt')
book = BookModule(_('Book'), path)

def _clear():
    global book
    book.__init__(book.title, book.path)

from zope.testing import cleanup
cleanup.addCleanUp(_clear)
コード例 #37
0
ファイル: role.py プロジェクト: jean/zope.securitypolicy
#
##############################################################################
"""Role implementation
"""
__docformat__ = 'restructuredtext'

from persistent import Persistent

from zope.interface import implementer
from zope.component import getUtilitiesFor
from zope.location import Location

from zope.securitypolicy.interfaces import IRole

from zope.i18nmessageid import ZopeMessageFactory as _
NULL_ID = _('<role not activated>')


@implementer(IRole)
class Role(object):

    def __init__(self, id, title, description=""):
        self.id = id
        self.title = title
        self.description = description


@implementer(IRole)
class LocalRole(Persistent, Location):

    def __init__(self, title, description=""):
コード例 #38
0
 def test_translation_msgid(self):
     t = PageTemplate()
     t.write("""<p tal:replace="options/msgid">text</p>""")
     self.assertEqual(t(msgid=_("x")), "translated")
コード例 #39
0
ファイル: base.py プロジェクト: jean/z3c.baseregistry
#
##############################################################################
"""Setting bases for local sites.

$Id$
"""
__docformat__ = "reStructuredText"
import zope.interface
import zope.component
import zope.schema
from zope.i18nmessageid import ZopeMessageFactory as _
from zope.formlib import form
from zope.security.proxy import removeSecurityProxy
from zope.site.interfaces import ILocalSiteManager

BASENAME = _('-- Global Base Registry --')
PARENTNAME = _('-- Parent Local Registry --')

class BaseComponentsVocabulary(zope.schema.vocabulary.SimpleVocabulary):
    """A vocabulary for ``IComponents`` utilities."""

    zope.interface.classProvides(zope.schema.interfaces.IVocabularyFactory)

    def __init__(self, context):
        terms = []
        utils = set()
        
        # add available registry utilities
        for name, util in \
            zope.component.getUtilitiesFor(
                zope.component.interfaces.IComponents, context):
コード例 #40
0
 def getDocString(self):
     return _('Zope 3 root.')
コード例 #41
0
from zope.securitypolicy.interfaces import IPrincipalPermissionManager
from zope.securitypolicy.interfaces import IPrincipalRoleManager
from zope.securitypolicy.interfaces import IRole
from zope.securitypolicy.vocabulary import GrantVocabulary

from zope.authentication.principal import PrincipalSource
from zope.formlib.interfaces import IInputWidget
from zope.formlib.interfaces import MissingInputError
from zope.formlib.utility import setUpWidget
from zope.formlib.widget import renderElement
from zope.formlib.widgets import RadioWidget
from zope.security.interfaces import IPermission


settings_vocabulary = GrantVocabulary(
    [SimpleTerm(Allow, token="allow", title=_('Allow')),
     SimpleTerm(Unset, token="unset", title=_('Unset')),
     SimpleTerm(Deny,  token='deny',  title=_('Deny')),
     ])


class GrantWidget(RadioWidget):
    """Grant widget for building a colorized matrix.

    The matrix shows anytime the status if you edit the radio widgets.
    This special widget shows the radio input field without labels.
    The labels are added in the header of the table. The order of the radio
    input fields is 'Allowed', 'Unset', 'Deny'.

    """
    orientation = "horizontal"
コード例 #42
0
from Products.ATContentTypes.content import schemata
from Products.ATContentTypes.content.schemata import finalizeATCTSchema

from jyu.rsslisting.interfaces.rsslisting import IRSSListing
from jyu.rsslisting.config import PROJECTNAME

from zope.i18nmessageid import Message as _  # requires explicit domain

RSSListingSchema = schemata.ATContentTypeSchema.copy() + atapi.Schema((
    atapi.IntegerField(
        'count',
        required=True,
        searchable=True,
        storage=atapi.AnnotationStorage(),
        widget=atapi.IntegerWidget(
            label=_(u'Number of items to display', domain="plone"),
            description=_(u'How many items to list.', domain="plone")),
        default=5,
    ),
    atapi.TextField(
        'url',
        required=True,
        searchable=True,
        #        validators=(('isURL'),),
        storage=atapi.AnnotationStorage(),
        widget=atapi.TextAreaWidget(
            label=_(u'List of RSS feed URLs', domain="jyu.rsslisting"),
            description=
            _(u'List of links to the RSS feeds to display. Please, enter only one link per line.',
              domain="jyu.rsslisting")),
    ),