def get_failures(self):
        """
        Retourne la liste (au format JSON) des collecteurs Vigilo en panne.
        Déclenche un appel à la méthode flash si cette liste est non vide.
        """

        # On vérifie que l'utilisateurs dispose des permissions appropriées
        All(
            not_anonymous(msg=_("You need to be authenticated")),
            Any(
                config.is_manager,
                has_permission('%s-access' % config.app_name.lower()),
                msg=_("You don't have access to %s") % config.app_name
            )
        ).check_authorization(request.environ)

        # On récupère la liste des connecteurs en panne
        failures = self.check_connectors_freshness()

        # Si cette liste n'est pas vide, on affiche un message à l'utilisateur
        if failures:
            flash(_(
                    'Vigilo has detected a breakdown on the following '
                    'collector(s): %(list)s'
                  ) % {'list': ', '.join(failures)},
                  'error'
            )

        # Dans les 2 cas (liste vide ou non), on la retourne au format JSON
        return dict(failures=failures)

    def login(self):
        """This is where the login form should be rendered."""
        if auth.check(not_anonymous()):
            # if we're not anonymous then we're logged in and need to be
            # redirected
            log.debug('already logged in')
            redirect(url('/page/test'))

        # Without the login counter, we won't be able to tell if the user has
        # tried to log in with the wrong credentials
        if 'repoze.who.logins' in request.environ:
            login_counter = request.environ['repoze.who.logins']
        else:
            login_counter = 0

        if login_counter > 0:
            log.debug('Wrong Login credentials')
            #flash('Wrong credentials')
        tpl.login_counter = login_counter
        tpl.came_from = request.params.get('came_from') or url('/')

        if 'login_failed' in request.params:
            tpl.login_failed = True
        else:
            tpl.login_failed = False
        return render('/login.mako')

    def post_login(self):
        """ Handle logic post a user's login

        I want to create a login_handler that's redirected to after login. This
        would check

        - if user was logged in, if not then send back to login
        - if user is admin, go to job list
        - if user can add joblist then go to *
        - if user is read only go to job list that's trimmed down a bit

        On the post login page adjust the max age on the existing cookie to XX
        remember me timeframe
        """
        if auth.check(not_anonymous()):
            log.debug('checked auth')
        else:
            # login failed, redirect back to login
            log.debug('failed auth')
            redirect(url(controller="accounts",
                action="login",
                login_failed=True)
            )

        # expire this cookie into the future
        ck = request.cookies['authtkt']
        response.set_cookie('authtkt', ck,
                max_age=60 * 60 * 24 * 7,
                path='/'
        )

        redirect(url('/page/test'))

    def index(self):
	admin=False
	if predicates.not_anonymous():
		if predicates.has_permission('admin'):
			admin=True
	kernels = DBSession.query(Kernel).order_by('name')
	return dict(kernels=kernels, num_items=kernels.count(),
		    admin=admin)

def logout(request):
    """Log out the user."""
    get_log().info("logout")
    check_predicate(request, predicates.not_anonymous(msg='Must be logged in'))
    cookie = request.environ['repoze.who.plugins']['cookie']
    headers = cookie.forget(request.environ, None)
    # TODO: read logout URL from config?
    raise pyramid.httpexceptions.HTTPFound("/", headers=headers)

    def default(self, *args):
	admin=False
	if predicates.not_anonymous():
		if predicates.has_permission('admin'):
			admin=True
	license_name = args[0]
	license = License.by_license_name(license_name)
	return dict(license=license,
		    admin=admin)

 def __call__(self, environ, start_response):
     # need to check path_info to avoid infinite loop
     if not_anonymous().is_met(environ) or environ['PATH_INFO'] == self._signin_url:
         return self._app(environ, start_response)
     else:
         status = "301 Redirect"
         headers = [("Location", self._signin_url),]
         start_response(status, headers)
         return ["Not logged in",]

    def _fn(context, request):
        try:
            log.info("checking / requiring login")
            p = predicates.not_anonymous(msg='Must be logged in')
            p.check_authorization(request.environ)

        except predicates.NotAuthorizedError:
            log.debug("login required.")
            redirect('/login?came_from={}'.format(request.path))

        else:
            log.debug("logged in.")

        return request_handler(request)

 def post_login(self):         
     identity = request.environ.get('repoze.who.identity')
     if not identity:
         session['failedlogin'] +=1
         session.save()
         #h.flash(_("Incorrect User name or Password"))
         if session['failedlogin']>3:    
             session['failedlogin'] = 0
             session.save()
             #return "To many login atempts!"
         return HTTPForbidden(request=request,body="Incorrect User name or Password")            
     if identity['user'].pending:
         session['failedlogin'] = 0 
         session.save()
         h.flash(_('Your account is still pending. Check your email for activation link'))
         #return redirect logout
         return redirect(url(controller="account",action="logout"))
         #return render(path.join(get_lang()[0],'derived/account/login.mako'))
     if identity['user'].deleted:
         session['failedlogin'] = 0 
         session.save()        
         h.flash(_('Your account has been deleted!'))
         return redirect(url(controller="account",action="logout"))
         #return render(path.join(get_lang()[0],'derived/account/login.mako'))
     
     session['user'] = identity['user'].id
    
     if is_met(not_anonymous()):
         session['failedlogin'] = 0            
         session['user_selection']={}
         session['product_selection']={}
         session['invoice_selection']={}        
     session.save()
     if 'came_from' in session:
         came_from = session['came_from']
         del session['came_from']
         session.save()
         return redirect(came_from)
     return render(path.join(get_lang()[0],'derived/account/login.mako'))        

 def _check_security(self):
     predicate = getattr(self, 'allow_only', None)
     if predicate is None:
         return True
     try:
         predicate.check_authorization(pylons.request.environ)
     except WhatNotAuthorizedError, e:
         reason = unicode(e)
         if hasattr(self, '_failed_authorization'):
             # Should shortcircut the rest, but if not we will still
             # deny authorization
             self._failed_authorization(reason)
         if not_anonymous().is_met(request.environ):
             # The user is authenticated but not allowed.
             code = 403
             status = 'error'
         else:
             # The user has not been not authenticated.
             code = 401
             status = 'warning'
         pylons.response.status = code
         flash(reason, status=status)
         abort(code, comment=reason)

 def not_met_util(self):
     if not_met(not_anonymous()):
         return 'You are anonymous'
     return 'You are not anonymous'

from repoze.what.predicates import not_anonymous  # pylint: disable-msg=E0611
# pylint: disable-msg=E0611
from repoze.what.plugins.pylonshq import ControllerProtector

from baruwa.lib.base import BaseController
from baruwa.model.meta import Session
from baruwa.lib.mq import FANOUT_XCHG
from baruwa.model.settings import DomSigImg, UserSigImg
from baruwa.forms.misc import Fmgr
from baruwa.tasks.settings import delete_sig
from baruwa.lib.auth.predicates import check_domain_ownership, check_dom_access

log = logging.getLogger(__name__)


@ControllerProtector(not_anonymous())
class FilemanagerController(BaseController):
    "FM controller"
    def __before__(self):
        "set context"
        BaseController.__before__(self)
        if self.identity:
            c.user = self.identity['user']
        else:
            c.user = None

    # pylint: disable-msg=R0912,R0915,R0914,W0142,W0622
    def index(self, domainid=None, userid=None):
        "Index"
        action = request.GET.get('action', None)
        if not action:

                c.paginator = paginate.Page(users, page=int(request.params.get("page", page)), items_per_page=10)
                return render(path.join(get_lang()[0], "/derived/user/staff/index.mako"))

    def customer(self):
        c.menu_items = h.top_menu(self.menu_items, _("Customers"))
        if is_met(in_group("customer")) or is_met(in_group("admin")):
            user = request.environ.get("repoze.who.identity")["user"]
            values = create_dict(user)
            return render_customer_form(self.menu_items, user.id, values)

    @checkframe(url(controller="user", action="index"))
    def index(self, page=1):
        c.contents = h.readContents(session[_("pages.dat")][_("Customers")])[0]
        return render(path.join(get_lang()[0], "derived/user/index.mako"))

    @ActionProtector(not_anonymous())
    def edit(self, id):
        user = Session.query(User).filter_by(id=id).one()
        identity = request.environ.get("repoze.who.identity")
        if is_met(has_permission("edit_user")):
            c.menu_items = h.top_menu(self.menu_items, _("Customers"))
            values = create_dict(user)
            return render_form(self.menu_items, values, action="update", id=user.id)
        elif identity["user"] == user:
            values = create_dict(user)
            return render_customer_form(self.menu_items, user.id, values)
        else:
            h.flash("You are not authorized to edit this user data!")
            came_from = str(request.GET.get("came_from", "")) or url(controller="user", action="index")
            return redirect(h.url(came_from))

             filter(SapnsShortcut.shortcut_id == id_shortcut).\
             delete()
         
         dbs.flush()
          
         _key = '%d_%d' % (sc.user_id, sc.parent_id)
         cache.get_cache('user_get_shortcuts').remove_value(key=_key)
     
         return dict(status=True)
 
     except Exception, e:
         logger.error(e)
         return dict(status=False)
 
 @expose('json')
 @require(predicates.not_anonymous())
 def bookmark(self, id_shortcut, **params):
     logger = logging.getLogger(__name__ + '/bookmark')
     try:
         logger.info('Bookmarking shortcut [%s]' % id_shortcut)
         user = dbs.query(SapnsUser).get(request.identity['user'].user_id)
         
         dboard = user.get_dashboard()
         dboard.add_child(id_shortcut)
         
         _key = '%d_%d' % (user.user_id, dboard.shortcut_id)
         cache.get_cache('user_get_shortcuts').remove_value(key=_key)
         
         return dict(status=True)
         
     except Exception, e:

 def index(self):
     debug = not_anonymous(msg='log in!')\
         .is_met(cherrypy.request.wsgi_environ)
     gatherings = Session.query(Gathering).all()
     return {'gatherings': gatherings, 'debug': debug}

from baruwa.lib.auth.predicates import OnlySuperUsers
from baruwa.tasks.settings import update_serial
from baruwa.model.accounts import Group
from baruwa.forms.organizations import RelayForm, RelayEditForm
from baruwa.forms.organizations import ImportCSVForm
from baruwa.tasks import importdomains
from baruwa.lib.audit.msgs import organizations as auditmsgs
from baruwa.lib.api import org_add_form, create_org, edit_org, delete_org, \
    update_if_changed, org_delete_form, relay_update_if_changed, add_relay, \
    edit_relay, delete_relay, get_org, get_relay


log = logging.getLogger(__name__)


@ControllerProtector(All(not_anonymous(), OnlySuperUsers()))
class OrganizationsController(BaseController):
    "Organizations controller"
    def __before__(self):
        "set context"
        BaseController.__before__(self)
        if self.identity:
            c.user = self.identity['user']
        else:
            c.user = None
        c.selectedtab = 'organizations'

    def index(self, page=1, format=None):
        "index page"
        total_found = 0
        search_time = 0

 def boolean_predicate(self):
     p = not_anonymous()
     return 'The predicate is %s' % bool(p)

from baruwa.model.meta import Session
from baruwa.model.auth import LDAPSettings, RadiusSettings
from baruwa.model.accounts import Group, domain_owners
from baruwa.model.accounts import organizations_admins as oa
from baruwa.model.domains import DomainAlias
from baruwa.model.domains import Domain, DeliveryServer, AuthServer
from baruwa.forms.domains import BulkDelDomains, AddLDAPSettingsForm
from baruwa.forms.domains import AddDomainForm, AddDeliveryServerForm
from baruwa.forms.domains import AddAuthForm, AUTH_PROTOCOLS, EditDomainAlias
from baruwa.forms.domains import AddDomainAlias, AddRadiusSettingsForm
from baruwa.lib.audit.msgs.domains import *

log = logging.getLogger(__name__)


@ControllerProtector(All(not_anonymous(), OnlyAdminUsers()))
class DomainsController(BaseController):
    def __before__(self):
        "set context"
        BaseController.__before__(self)
        if self.identity:
            c.user = self.identity["user"]
        else:
            c.user = None
        c.selectedtab = "domains"

    def _get_server(self, destinationid):
        "utility"
        try:
            cachekey = u"deliveryserver-%s" % destinationid
            q = (