Python flask_login 模块，login_required() 实例源码

def login_required(role=0, group='open'):
        """
        This is a redefinition of the decorator login_required,
        to include a 'role' argument to allow users with different
        roles access different views and a group access to close some
        views by groups. For example:
        @login_required(role=0, group='ntuwn')   0 = for all
        """
        def wrapper(fn):
            @wraps(fn)
            def decorated_view(*args, **kwargs):
                if not current_user.is_authenticated:
                    return login_manager.unauthorized()
                if current_user.role < role:
                    return login_manager.unauthorized()
                if group != 'open' and current_user.group != group:
                    return login_manager.unauthorized()

                return fn(*args, **kwargs)
            return decorated_view
        return wrapper

def setUp(self):
        app = flask.Flask(__name__)
        app.config['TESTING'] = True
        app.config['KRB5_SERVICE_NAME'] = 'HTTP'
        app.config['KRB5_HOSTNAME'] = 'example.org'

        login_manager = flask_login.LoginManager(app)
        manager = flask_kerberos_login.KerberosLoginManager(app)

        @manager.save_user
        def save_user(peer_name):
            user = User(str(peer_name))
            # persist our user to the login manager
            login_manager.reload_user(user)

        @app.route('/')
        @flask_login.login_required
        def index():
            return flask_login.current_user.id

        self.app = app
        self.manager = manager

def reporter_required(func):
    @wraps(func)
    def decorated_view(*args, **kwargs):
        if not current_user.role.is_reporter:
            return forbidden()
        return func(*args, **kwargs)
    return login_required(decorated_view)

def security_team_required(func):
    @wraps(func)
    def decorated_view(*args, **kwargs):
        if not current_user.role.is_security_team:
            return forbidden()
        return func(*args, **kwargs)
    return login_required(decorated_view)

def administrator_required(func):
    @wraps(func)
    def decorated_view(*args, **kwargs):
        if not current_user.role.is_administrator:
            return forbidden()
        return func(*args, **kwargs)
    return login_required(decorated_view)

def login_required(*args, **kwargs):
        """Forward flask_login login_required method"""
        return login_required(*args, **kwargs)

def swagger_login(func):
    @wraps(func)
    def login_pass(*args, **kwargs):
        return func(*args, **kwargs)

    if isAdmin() or func.func_name != 'specs':
        return login_pass
    return login.login_required(func)

def index():
    return render_template('index.html', curid = 0)

# @app.route('/login', methods=['GET', 'POST'])
# def login():
#     if flask.request.method == 'GET':
#         return render_template('login.html', curid = 0)
#     email = flask.request.form['email']
#     print("IN /LOGIN: THIS IS THE email RESULT:", str(email))
#
#     cur.execute("""SELECT hashpswd, sid from students where email = %s;""", (email,))
#     lst = cur.fetchall()
#     if len(lst) != 0:
#         print("IN /LOGIN: THIS IS lst RESULT:", str(lst))
#         conn.commit()
#         print("IN /LOGIN: THIS IS check_password_hash RESULT:", str(check_password_hash(lst[0][0], flask.request.form['pw'])))
#         if check_password_hash(lst[0][0], flask.request.form['pw']):
#             user = User()
#             user.id = lst[0][1]
#             flask_login.login_user(user)
#             return flask.redirect(flask.url_for('protected'))
#     return 'Bad login'
#
# @app.route('/protected')
# @flask_login.login_required
# def protected():
#     return 'Logged in as: ' + flask_login.current_user.id

def permissions_wrapper(handler):
    """ Decorator that produces a decorator for checking permissions.
    """
    def callback(function, args, kwargs, dargs, dkwargs):
        authorized = handler(args, kwargs, *dargs, **dkwargs)
        if not authorized:
            flask.abort(403)
        elif type(authorized) is int:
            flask.abort(authorized)
        else:
            return function(*args, **kwargs)
    # If the handler has no argument, declare a
    # simple decorator, otherwise declare a nested decorator
    # There are at least two mandatory arguments
    if handler.__code__.co_argcount > 2:
        def decorator(*dargs, **dkwargs):
            def inner(function):
                @functools.wraps(function)
                def wrapper(*args, **kwargs):
                    return callback(function, args, kwargs, dargs, dkwargs)
                wrapper._audit_permissions = handler, dargs
                return flask_login.login_required(wrapper)
            return inner
    else:
        def decorator(function):
            @functools.wraps(function)
            def wrapper(*args, **kwargs):
                return callback(function, args, kwargs, (), {})
            wrapper._audit_permissions = handler, []
            return flask_login.login_required(wrapper)
    return decorator