Python traversal.find_interface函数代码示例

 def __init__(self, context, profile, request):
     super(BlogAlert, self).__init__(context, profile, request)
     self._community = find_community(context)
     blogentry = find_interface(context, IBlogEntry)
     if blogentry is None:
         # Comments can also be made against forum topics
         blogentry = find_interface(context, IForumTopic)
     self._blogentry = blogentry

def overview(request):
    site_resource = find_resource(request.context, '/site/b')
    site_interface = find_interface(request.context, Site)
    camera = find_interface(request.context, Camera)
    txt = "{:s}\n{:s}\n{:s}\n{:s}".format(site_resource, site_interface, camera, request.context)
    response = Response(txt)
    response.content_type = 'text/plain'
    return response

 def __acl__(self):
     meeting = find_interface(self, IMeeting)
     if meeting.get_workflow_state() == 'closed':
         return ACL['closed']
     ai = find_interface(self, IAgendaItem)
     ai_state = ai.get_workflow_state()
     #If ai is private, use private
     if ai_state == 'private':
         return ACL['private']
     return ACL['open']

 def __init__(self, key=None, parent=None,**kwargs):
     self.__name__ = key
     self.__parent__ = parent
     # Reference request
     self.request = find_root(self).request
     # Reference app and site
     self.__app__ = find_interface(self, i.IApp)
     self.__site__ = find_interface(self, i.ISite)
     # Assign kwargs to self (used as self.XXX not self['xxx'])
     for key in kwargs:
         setattr(self, key, kwargs[key])

 def __acl__(self):
     meeting = find_interface(self, IMeeting)
     acl = get_acl_registry()
     if meeting.get_workflow_state() == 'closed':
         return acl.get_acl('DiscussionPost:closed')
     ai = find_interface(self, IAgendaItem)
     ai_state = ai.get_workflow_state()
     #If ai is private, use private
     if ai_state == 'private':
         return acl.get_acl('DiscussionPost:private')
     return acl.get_acl('DiscussionPost:open')

 def __init__(self, context, profile, request):
     super(CommentAlert, self).__init__(context, profile, request)
     assert IComment.providedBy(context)
     self.alert = None
     if find_interface(self.context, IBlogEntry) or find_interface(context, IForumTopic):  # noqa
         # it is a blog alert
         self.alert = CommentBlogEntryAlert(self.context, self.profile, self.request)
     else:
         if find_interface(self.context, ICommunityFile):
             self.alert = CommunityFileCommentAlert(self.context, self.profile,
                                                    self.request)

 def _close_poll(self):
     request = self.request
     
     m = find_interface(self.poll, IMeeting)
     m.set_workflow_state(request, 'ongoing')
     
     ai = find_interface(self.poll, IAgendaItem)
     ai.set_workflow_state(request, 'upcoming')
     ai.set_workflow_state(request, 'ongoing')
     
     self.poll.set_workflow_state(request, 'upcoming')
     self.poll.set_workflow_state(request, 'ongoing')
     self.poll.set_workflow_state(request, 'closed')

def feed_discussion_post_added(obj, event):
    """ Will add a feed entry when a discussion post is added if agenda item is not private.
    """
    request = get_current_request()
    userid = authenticated_userid(request)
    agenda_item = find_interface(obj, IAgendaItem)
    if agenda_item.get_workflow_state() == "private":
        return
    msg = _(
        u"${userid} has written a post in ${agenda_item}.", mapping={"userid": userid, "agenda_item": agenda_item.title}
    )
    meeting = find_interface(obj, IMeeting)
    feed_handler = request.registry.getAdapter(meeting, IFeedHandler)
    feed_handler.add(obj.uid, msg, tags=("discussion_post", "added"))

    def discussion_answer(self):
        content_type = 'DiscussionPost'
        ai = find_interface(self.context, IAgendaItem)
        add_permission = self.api.content_types_add_perm(content_type)
        if not has_permission(add_permission, ai, self.request):
            raise HTTPForbidden("You're not allowed to add '%s' in this context." % content_type)
        
        schema_name = self.api.get_schema_name(content_type, 'add')
        schema = createSchema(schema_name).bind(context = self.context, request = self.request, api = self.api)
        
        url = self.request.resource_url(self.context, 'answer')
        form = Form(schema, 
                    action=url, 
                    buttons=(button_add,),
                    formid="answer-form-%s" % self.context.uid, 
                    use_ajax=False,
                    ajax_options=ajax_options)
        self.api.register_form_resources(form)
        
        self.response['user_image_tag'] = self.api.user_profile.get_image_tag(request = self.request)
        self.response['content_type'] = content_type
        
        post = self.request.POST
        if 'add' in post:
            controls = post.items()
            try:
                #appstruct is deforms convention. It will be the submitted data in a dict.
                appstruct = form.validate(controls)
            except ValidationFailure, e:
                self.response['form'] = e.render()
                if self.request.is_xhr:
                    return Response(render("templates/ajax_edit.pt", self.response, request = self.request))
                return self.response
            
            kwargs = {}
            kwargs['text'] = appstruct['text']
            if self.api.userid:
                kwargs['creators'] = [self.api.userid]

            ai = find_interface(self.context, IAgendaItem)
            
            obj = createContent(content_type, **kwargs)
            name = generate_slug(ai, obj.title)
            ai[name] = obj

            #Success, redirect
            url = self.request.resource_url(ai, anchor=obj.uid)
            if self.request.is_xhr:
                return Response(headers = [('X-Relocate', url)])
            return HTTPFound(location=url)

 def survey_dt(self):
     survey = find_interface(self.context, ISurvey)
     if not survey:
         return
     tz = survey.get_time_zone()
     loc = get_locale_name(self.request)
     return createObject('dt_helper', tz, loc)

def get_navigation(context, request, links):

    items = []

    for link in links:
        state = 'notcurrent'
        view_iface = link['view_iface']
        nav_ifaces = link['nav_ifaces']
        view_name = link['view_name']

        if view_iface.providedBy(context):
            if request.view_name == view_name:
                state = 'current'
        else:
            for nav_iface in nav_ifaces:
                if nav_iface.providedBy(context):
                    state = 'current'
                    break

        viewcontext = find_interface(context, view_iface)

        if viewcontext is not None:

            items.append(
                {'state':state,
                 'href':resource_url(viewcontext, request, view_name),
                 'title':link['title'],
                 })

    return items

 def course_module(self):
     if self.request.has_permission('perm:Edit', self.context):
         jqueryui.need()
         touchpunch_js.need()
     response = {}
     response['course'] = find_interface(self.context, ICourse)
     response['course_modules'] = response['course'].items()
     response['in_course'] = self.fikaProfile.in_course(response['course'])
     response['course_module_toggle'] = self._render_course_module_toggle
     response['course_pagination'] = render_course_pagination
     response['module_segments'] = self.context.values()
     response['is_assessment'] = {}
     for segment in self.context.values():
         response['is_assessment'][segment.__name__] = isinstance(segment, Assessment)
         if isinstance(segment, ImageSlideshow):
             lightbox_js.need()
             lightbox_css.need()
             break
         for segmentcontent in segment.values():
             if isinstance(segmentcontent, ImageSlideshow):
                 lightbox_js.need()
                 lightbox_css.need()
                 break
     response['addable_types'] = {}
     factories = get_content_factories(self.request.registry)
     for (obj, addable) in get_addable_content(self.request.registry).items():
         if 'Segment' in addable:
             factory = factories.get(obj, None)
             response['addable_types'][obj] = getattr(factory, 'icon', 'file')
     return response

def proposal_redirect_to_agenda_item(context, request):
    ai = find_interface(context, IAgendaItem)
    if ai:
        query = request.GET
        url = request.resource_url(ai, query=query, anchor=context.uid)
        return HTTPFound(location=url)
    raise NotFound("Couldn't locate Agenda Item from this context.")

def jquery_member_search_view(context, request):
    prefix = request.params['val'].lower()
    community = find_interface(context, ICommunity)
    member_names = community.member_names
    moderator_names = community.moderator_names
    community_member_names = member_names.union(moderator_names)
    query = dict(
        member_name='%s*' % prefix,
        sort_index='title',
        limit=20,
        )
    searcher = ICatalogSearch(context)
    try:
        total, docids, resolver = searcher(**query)
        profiles = filter(None, map(resolver, docids))
        records = [dict(
                    id = profile.__name__,
                    text = profile.title,
                    )
                   for profile in profiles
                   if profile.__name__ not in community_member_names
                   and profile.security_state != 'inactive']
    except ParseError:
        records = []
    result = JSONEncoder().encode(records)
    return Response(result, content_type="application/x-json")

def notify_policycompass(event):
    """Push comments of IExternalResource ressources to elastic search."""
    comment = event.object
    external_resource = find_interface(comment, IExternalResource)

    if external_resource is None:
        return

    resource_name = get_sheet_field(external_resource, IName, 'name')
    match = re.match(
        '(?P<type>visualization|event|dataset|metric|model|indicator)'
        '_(?P<id>[0-9]+)',
        resource_name)

    # this is not a known policycompass external resource
    if match is None:
        return

    resource_type = match.group('type')
    resource_id = match.group('id')

    settings = event.registry.settings
    pcompass_endpoint = settings.get('adhocracy_pcompass.pcompass_endpoint',
                                     'http://localhost:8000')
    url = '{base}/api/v1/searchmanager/updateindexitem/{res_type}/{res_id}' \
        .format(base=pcompass_endpoint,
                res_type=resource_type,
                res_id=resource_id)

    r = requests.post(url)
    if r.status_code != 200:  # indexing error on pcompass
        msg = 'Notifying policy compass about "{}_{}" failed with "{}"'.format(
            resource_type, resource_type, r.text)
        raise ValueError(msg)