def update(self):
        request = self.request
        nextURL = request.get("nextURL")

        if not IUnauthenticatedPrincipal.providedBy(request.principal):
            getUtility(IAuthentication).logout(request)

        if nextURL:
            self.redirect(nextURL)
        elif not IUnauthenticatedPrincipal.providedBy(request.principal):
            self.redirect("logout.html")

 def getURL(self, type=""):
     principal = self.request.principal
     if IUnauthenticatedPrincipal.providedBy(principal):
         return
     homeFolder = IHomeFolder(principal).homeFolder
     homeFolder = grok.url(self.request, homeFolder, type)
     return homeFolder

    def publishTraverse(self, request, name):
        context = self.context

        view = queryMultiAdapter((context, request), name=name)
        if view is not None:
            return view

        if not IUnauthenticatedPrincipal.providedBy(request.principal):
            try:
                taskId = int(name)
            except:
                taskId = None

            if taskId:
                task = getUtility(IIntIds).queryObject(taskId)
                if task is not None:
                    space = context.__parent__
                    if space.principalId != request.principal.id:
                        space = IPersonalSpace(request.principal, None)
                        if space is None:
                            raise NotFound(context, name, request)
                        else:
                            request.response.redirect(
                                '%s/mytasks/%s/'%(
                                    absoluteURL(space, request), name))

                    return LocationProxy(task, context, name)

        if name in context:
            return context[name]

        raise NotFound(context, name, request)

 def isAvailable(self):
     if not IUnauthenticatedPrincipal.providedBy(self.request.principal):
         return False
     configlet = component.getUtility(IConfiglet, name="product.zojax-authentication-twitter")
     if not configlet.consumerKey or not configlet.consumerSecret:
         return False
     return True

 def __call__(self):
     request = self.request
     if not IUnauthenticatedPrincipal.providedBy(request.principal) and "worldcookery.Login" in request:
         camefrom = request.get("camefrom", ".")
         request.response.redirect(camefrom)
     else:
         return self.template()

    def __call__(self):
        request = self.request
        siteURL = u'%s/'%absoluteURL(getSite(), request)

        if not IUnauthenticatedPrincipal.providedBy(request.principal):
            request.response.redirect(siteURL)
            return u''

        if not 'openid_form_submitted' in request:
            request.response.redirect(siteURL)
            return u''

        identifier = request.get('openid_identifier')
        if not identifier:
            IStatusMessage(request).add(
                _(u"Please specify your OpenID identifier."))
            request.response.redirect(siteURL)
            return u''

        authenticator = getUtility(IOpenIdAuthenticator)
        session = ISession(request)[SESSION_KEY]
        consumer = Consumer(session, authenticator.store)

        try:
            authRequest = consumer.begin(identifier)
            redirectURL = authRequest.redirectURL(
                siteURL, getReturnToURL(request))
        except Exception, err:
            IStatusMessage(request).add(err, 'error')
            redirectURL = siteURL

 def __call__(self):
     if IUnauthenticatedPrincipal.providedBy(self.request.principal):
         self.request.response.redirect(
                     ui_utils.url.absoluteURL(
                     getSite(), self.request)+"/login"
                     )
     return super(ChangePasswordForm, self).__call__()

def get_user_context_roles():
    """Get the list of user's roles (including whether admin or not)--this 
    is the info needed (in addition to the field's modes) to further 
    filter whether a field is visible or not for a given (user, mode).
    
    Wraps common.get_context_roles(context), with the following differcnes: 
    - auto retrieves the context, needed param by common.get_context_roles()
    - handles case when user is not authenticated
    - handles case for when user is "admin"
    """
    request = common.get_request()
    if request is None:
        context = None
        principal = None
    else:
        context = common.get_traversed_context(request)
        principal = request.principal
    if IUnauthenticatedPrincipal.providedBy(principal):
        roles = ["bungeni.Anonymous"]
    else: 
        roles = common.get_context_roles(context)
        if common.is_admin(context):
            roles.append("bungeni.Admin")
    log.debug(""" [get_user_context_roles]
    PRINCIPAL: %s
    CONTEXT: %s
    ROLES: %s
    """ % (principal, context, roles))
    return roles

    def render(self):
        if not IUnauthenticatedPrincipal.providedBy(self.request.principal):
            auth = component.getUtility(IAuthentication)
            ILogout(auth).logout(self.request)

        self.flash(_(u'You are now logged out'), type=u'message')
        return self.redirect(self.application_url())

 def publishTraverse(self, request, name,view):
     if view is None:
         view = queryMultiAdapter((self.context, request), name='main.html')
     principal = request.principal
     if IUnauthenticatedPrincipal.providedBy(principal):
         alsoProvides(request,IAdvertLayer)
     return view

    def __call__(self, *args, **kw):
        request = self.request
        context = self.context
        siteURL = u'%s/'%absoluteURL(context, request)

        if not IUnauthenticatedPrincipal.providedBy(request.principal):
            self.redirect(siteURL)
            return u''

        if not 'openid_form_submitted' in request:
            self.redirect(siteURL)
            return u''

        identifier = request.get('openid_identifier')
        if not identifier or identifier == 'http://':
            IStatusMessage(request).add(
                _(u"Please specify your OpenID identifier."))
            self.redirect(u'%slogin.html'%siteURL)
            return u''

        authenticator = getUtility(IUsersPlugin)
        session = ISession(request)[SESSION_KEY]
        consumer = Consumer(session, authenticator.store)

        try:
            authRequest = consumer.begin(identifier)
            redirectURL = authRequest.redirectURL(
                siteURL, getReturnToURL(request))
        except Exception, err:
            IStatusMessage(request).add(err, 'error')
            self.redirect(u'%slogin.html'%siteURL)
            return u''

def get_request_context_roles(request):
    """Get the list of user's roles (including whether admin or not) relevant 
    for this request layer.
    
    Wraps get_context_roles(context), with the following differences:
    - auto determines the context, a needed param for get_context_roles()
    - when within a public layer, always returns ["bungeni.Anonymous"]
    - handles case when user is not authenticated
    - handles case for when user is "admin"
    """
    request = request or get_request()
    if request is None:
        context = None
        principal = None
    else:
        context = get_traversed_context(request)
        principal = request.principal
    # within a public layer, just proceed as "bungeni.Anonymous"
    if is_public_layer(request):
        return ["bungeni.Anonymous"]
    # other layers
    if IUnauthenticatedPrincipal.providedBy(principal):
        roles = ["bungeni.Anonymous"]
    else: 
        roles = get_context_roles(context, principal)
        if is_admin(context):
            roles.append("bungeni.Admin")
    log.debug(""" [get_request_context_roles]
    PRINCIPAL: %s
    CONTEXT: %s
    ROLES: %s
    """ % (principal, context, roles))
    return roles

 def isAvailable(self):
     if IUnauthenticatedPrincipal.providedBy(self.request.principal):
         return False
     if self.oid is None:
         return False
     else:
         return True

    def isAvailable(self):
        request = self.request
        principal = request.principal

        if not IUnauthenticatedPrincipal.providedBy(principal):
            return False

        auth = getUtility(IAuthentication)
        login = queryMultiAdapter((auth, request), ILoginService)

        if login is not None:
            if login.isChallenging():
                return False

            if IPluggableAuthentication.providedBy(auth):
                for name, creds in auth.getCredentialsPlugins():
                    if IDefaultCredentialsPlugin.providedBy(creds):
                        self.nextURL = login.nextURL()

                        if self.hasOpenId:
                            include("portlet-login")

                        return True

        return False

 def test_context_roles(self, mode):
     """EXPERIMENTAL sample code to get a user's roles and whether is_admin 
     or not -- this is the info needed (in addition to the field's modes) 
     to further filter whether a field is visible or not for a 
     given (user, mode).
     """
     request = common.get_request()
     if request is None:
         context = None
         principal = None
     else:
         context = common.get_traversed_context(request)
         principal = request.principal
     if IUnauthenticatedPrincipal.providedBy(principal):
         roles = None
     else: 
         roles = common.get_context_roles(context)
     print """!+ModelDescriptor TEST_CONTEXT_ROLES [%s]
     PRINCIPAL: %s
     CONTEXT: %s
     MODE: %s
     ROLES: %s
     IS ADMIN: %s""" % (self,
         principal, 
         context,
         mode,
         roles, 
         common.is_admin(context)
     )

    def isAvailable(self):
        if IUnauthenticatedPrincipal.providedBy(self.request.principal):
            return False

        principal = self.context.__principal__
        principalId = principal.id

        if self.request.principal.id == principalId:
            return False

        invitations = [
            invitation.object.id for invitation in
            getUtility(IInvitations).getInvitationsByPrincipal(
                principalId, ('invitation.member',))]

        for group in getUtility(ICatalog).searchResults(
            type = {'any_of': ('content.group',)},
            members = {'any_of': (self.request.principal.id,)}):

            if group.id in invitations:
                continue

            if principalId not in group.members and \
                    checkPermission('zojax.InviteGroupMember', group):
                return True

        return False

    def canAssignPrincipal(self, principal):
        if (not IUnauthenticatedPrincipal.providedBy(principal) and
            IPrincipal.providedBy(principal) and
            not IGroup.providedBy(principal) and
            checkPermissionForPrincipal(principal,'zojax.PersonalSpace',self)):
            return True

        return False

    def isAvailable(self):
        if IUnauthenticatedPrincipal.providedBy(self.request.principal):
            return False

        if not self.context.members.isMember(self.request.principal.id):
            return super(JoinAction, self).isAvailable()

        return False

 def handle_login(self, action, data):
     if IUnauthenticatedPrincipal.providedBy(self.request.principal):
         self.status = _(u"Invalid account credentials")
     else:
         site_url = ui_utils.url.absoluteURL(getSite(), self.request)
         camefrom = self.request.get('camefrom', site_url+'/')
         self.status = _("You are now logged in")
         self.request.response.redirect( camefrom )

    def isAvailable(self):
        if IUnauthenticatedPrincipal.providedBy(self.request.principal):
            return False

        for name, adapter in getAdapters((self.context,), IContentNotification):
            return True

        return False