Here are the examples of the python api flask_login.LoginManager taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
36 Examples
3
Example 1
def init_app(app):
from flask_login import LoginManager
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.user_loader(load_user)
login_manager.login_view = "/login"
# Setup Flask-Security
security = Security()
security = security.init_app(app, AppEngineUserDatastore(User, Role))
security.send_mail_task(send_mail)
from flask_social_blueprint.core import SocialBlueprint
SocialBlueprint.init_bp(app, SocialConnection, url_prefix="/_social")
3
Example 2
def init_app(app):
# Flask-Login
# https://flask-login.readthedocs.org/en/latest/
from flask_login import LoginManager
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.user_loader(load_user)
login_manager.login_view = "/login"
# Setup Flask-Security
security = Security()
security = security.init_app(app, SQLAlchemyUserDatastore(db, User, Role))
security.send_mail_task(send_mail)
from flask_social_blueprint.core import SocialBlueprint
SocialBlueprint.init_bp(app, SocialConnection, url_prefix="/_social")
3
Example 3
def init_login():
login_manager = login.LoginManager()
login_manager.init_app(app)
# Create user loader function
@login_manager.user_loader
def load_user(user_id):
return db.session.query(User).get(user_id)
3
Example 4
def init_login():
login_manager = login.LoginManager()
login_manager.setup_app(app)
# Create user loader function
@login_manager.user_loader
def load_user(user_id):
return User.objects(id=user_id).first()
3
Example 5
Project: open-event-orga-server Source File: admin.py
@staticmethod
def init_login(app):
from flask import request, url_for, redirect
"""Init login"""
login_manager = login.LoginManager()
login_manager.init_app(app)
# Create user loader function
@login_manager.user_loader
def load_user(user_id):
return db.session.query(User).get(user_id)
@login_manager.unauthorized_handler
def unauthorized():
return redirect(url_for('admin.login_view', next=request.url))
3
Example 6
Project: maple-blog Source File: extensions.py
def register_login(app):
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = "auth.login"
login_manager.session_protection = "strong"
login_manager.login_message = _("Please login to access this page.")
from maple.user.models import User
@login_manager.user_loader
def user_loader(id):
user = User.query.get(int(id))
return user
3
Example 7
def __init__(self, app=None, login_manager=None):
if login_manager:
self.login_manager = login_manager
else:
self.login_manager = LoginManager()
if app:
self._app = app
self.init_app(app)
3
Example 8
def register(self, app, *args, **kwargs):
" Activate loginmanager and principal. "
if not self._login_manager or self.app != app:
self._login_manager = LoginManager()
self._login_manager.user_callback = self.user_loader
self._login_manager.setup_app(app)
self._login_manager.login_view = 'urls.index'
self._login_manager.login_message = u'You need to be signed in for this page.'
self.app = app
if not self._principal:
self._principal = Principal(app)
identity_loaded.connect(self.identity_loaded)
super(UserManager, self).register(app, *args, **kwargs)
3
Example 9
Project: sqlalchemy-continuum Source File: test_flask.py
def setup_method(self, method):
TestCase.setup_method(self, method)
self.app = Flask(__name__)
self.app.secret_key = 'secret'
self.app.debug = True
self.setup_views()
login_manager = LoginManager()
login_manager.init_app(self.app)
self.client = self.app.test_client()
self.context = self.app.test_request_context()
self.context.push()
@login_manager.user_loader
def load_user(id):
return self.session.query(self.User).get(id)
3
Example 10
def __init__(self):
self.ghe_host = get_config_param('host')
self.login_manager = flask_login.LoginManager()
self.login_manager.login_view = 'airflow.login'
self.flask_app = None
self.ghe_oauth = None
self.api_rev = None
3
Example 11
def __init__(self):
# self.google_host = get_config_param('host')
self.login_manager = flask_login.LoginManager()
self.login_manager.login_view = 'airflow.login'
self.flask_app = None
self.google_oauth = None
self.api_rev = None
3
Example 12
def _get_login_manager(app, anonymous_user):
lm = LoginManager()
lm.anonymous_user = anonymous_user or AnonymousUser
lm.login_view = '%s.login' % cv('BLUEPRINT_NAME', app=app)
lm.user_loader(_user_loader)
lm.token_loader(_token_loader)
if cv('FLASH_MESSAGES', app=app):
lm.login_message, lm.login_message_category = cv('MSG_LOGIN', app=app)
lm.needs_refresh_message, lm.needs_refresh_message_category = cv('MSG_REFRESH', app=app)
else:
lm.login_message = None
lm.needs_refresh_message = None
lm.init_app(app)
return lm
3
Example 13
Project: flask-login Source File: test_login.py
def test_static_loads_anonymous(self):
app = Flask(__name__)
app.static_url_path = '/static'
app.secret_key = 'this is a temp key'
lm = LoginManager()
lm.init_app(app)
with app.test_client() as c:
c.get('/static/favicon.ico')
self.assertTrue(current_user.is_anonymous)
3
Example 14
Project: flask-login Source File: test_login.py
def test_static_loads_without_accessing_session(self):
app = Flask(__name__)
app.static_url_path = '/static'
app.secret_key = 'this is a temp key'
lm = LoginManager()
lm.init_app(app)
with app.test_client() as c:
with listen_to(user_accessed) as listener:
c.get('/static/favicon.ico')
listener.assert_heard_none(app)
3
Example 15
Project: flask-login Source File: test_login.py
def test_no_user_loader_raises(self):
login_manager = LoginManager(self.app, add_context_processor=True)
with self.app.test_request_context():
session['user_id'] = '2'
with self.assertRaises(Exception) as cm:
login_manager.reload_user()
expected_exception_message = 'No user_loader has been installed'
self.assertTrue(
str(cm.exception).startswith(expected_exception_message))
3
Example 16
Project: flask-login Source File: test_login.py
def test_login_url_generation_with_view(self):
app = Flask(__name__)
login_manager = LoginManager()
login_manager.init_app(app)
@app.route('/login')
def login():
return ''
with app.test_request_context():
self.assertEqual('/login?next=%2Fprotected',
login_url('login', '/protected'))
0
Example 17
Project: flask-dance Source File: test_sqla.py
def test_sqla_flask_login(app, db, blueprint, request):
login_manager = LoginManager(app)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
class OAuth(db.Model, OAuthConsumerMixin):
user_id = db.Column(db.Integer, db.ForeignKey(User.id))
user = db.relationship(User)
blueprint.backend = SQLAlchemyBackend(OAuth, db.session, user=current_user)
db.create_all()
def done():
db.session.remove()
db.drop_all()
request.addfinalizer(done)
# create some users
u1 = User(name="Alice")
u2 = User(name="Bob")
u3 = User(name="Chuck")
db.session.add_all([u1, u2, u3])
db.session.commit()
# configure login manager
@login_manager.user_loader
def load_user(userid):
return User.query.get(userid)
with record_queries(db.engine) as queries:
with app.test_client() as client:
# reset the session before the request
with client.session_transaction() as sess:
sess["test-service_oauth_state"] = "random-string"
# set alice as the logged in user
sess["user_id"] = u1.id
# make the request
resp = client.get(
"/login/test-service/authorized?code=secret-code&state=random-string",
base_url="https://a.b.c",
)
# check that we redirected the client
assert resp.status_code == 302
assert resp.headers["Location"] == "https://a.b.c/oauth_done"
assert len(queries) == 4
# lets do it again, with Bob as the logged in user -- he gets a different token
responses.reset()
responses.add(
responses.POST,
"https://example.com/oauth/access_token",
body='{"access_token":"abcdef","token_type":"bearer","scope":"bob"}',
)
with record_queries(db.engine) as queries:
with app.test_client() as client:
# reset the session before the request
with client.session_transaction() as sess:
sess["test-service_oauth_state"] = "random-string"
# set bob as the logged in user
sess["user_id"] = u2.id
# make the request
resp = client.get(
"/login/test-service/authorized?code=secret-code&state=random-string",
base_url="https://a.b.c",
)
# check that we redirected the client
assert resp.status_code == 302
assert resp.headers["Location"] == "https://a.b.c/oauth_done"
assert len(queries) == 4
# check the database
authorizations = OAuth.query.all()
assert len(authorizations) == 2
u1_oauth = OAuth.query.filter_by(user=u1).one()
assert u1_oauth.provider == "test-service"
assert u1_oauth.token == {
"access_token": "foobar",
"token_type": "bearer",
"scope": [""],
}
u2_oauth = OAuth.query.filter_by(user=u2).one()
assert u2_oauth.provider == "test-service"
assert u2_oauth.token == {
"access_token": "abcdef",
"token_type": "bearer",
"scope": ["bob"],
}
u3_oauth = OAuth.query.filter_by(user=u3).all()
assert len(u3_oauth) == 0
0
Example 18
Project: flask-dance Source File: test_sqla.py
@requires_blinker
def test_sqla_flask_login_anon_to_authed(app, db, blueprint, request):
login_manager = LoginManager(app)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
class OAuth(db.Model, OAuthConsumerMixin):
user_id = db.Column(db.Integer, db.ForeignKey(User.id))
user = db.relationship(User)
blueprint.backend = SQLAlchemyBackend(OAuth, db.session, user=current_user)
db.create_all()
def done():
db.session.remove()
db.drop_all()
request.addfinalizer(done)
# configure login manager
@login_manager.user_loader
def load_user(userid):
return User.query.get(userid)
# create a user object when OAuth succeeds
def logged_in(sender, token):
assert token
assert blueprint == sender
resp = sender.session.get("/user")
user = User(name=resp.json()["name"])
login_user(user)
db.session.add(user)
db.session.commit()
flask.flash("Signed in successfully")
oauth_authorized.connect(logged_in, blueprint)
request.addfinalizer(lambda: oauth_authorized.disconnect(logged_in, blueprint))
# mock out the `/user` API call
responses.add(
responses.GET,
"https://example.com/user",
body='{"name":"josephine"}',
)
with record_queries(db.engine) as queries:
with app.test_client() as client:
with client.session_transaction() as sess:
sess["test-service_oauth_state"] = "random-string"
# make the request
resp = client.get(
"/login/test-service/authorized?code=secret-code&state=random-string",
base_url="https://a.b.c",
)
# check that we redirected the client
assert resp.status_code == 302
assert resp.headers["Location"] == "https://a.b.c/oauth_done"
assert len(queries) == 5
# check the database
users = User.query.all()
assert len(users) == 1
user = users[0]
assert user.name == "josephine"
authorizations = OAuth.query.all()
assert len(authorizations) == 1
oauth = authorizations[0]
assert oauth.provider == "test-service"
assert oauth.token == {
"access_token": "foobar",
"token_type": "bearer",
"scope": [""],
}
assert oauth.user_id == user.id
0
Example 19
Project: flask-dance Source File: test_sqla.py
def test_sqla_flask_login_preload_logged_in_user(app, db, blueprint, request):
# need a URL to hit, so that tokens will be loaded, but result is irrelevant
responses.add(
responses.GET,
"https://example.com/noop",
)
login_manager = LoginManager(app)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
class OAuth(db.Model, OAuthConsumerMixin):
user_id = db.Column(db.Integer, db.ForeignKey(User.id))
user = db.relationship(User)
blueprint.backend = SQLAlchemyBackend(OAuth, db.session, user=current_user)
db.create_all()
def done():
db.session.remove()
db.drop_all()
request.addfinalizer(done)
# create some users, and tokens for some of them
alice = User(name="Alice")
alice_token = {"access_token": "alice123", "token_type": "bearer"}
alice_oauth = OAuth(user=alice, token=alice_token, provider="test-service")
bob = User(name="Bob")
bob_token = {"access_token": "bob456", "token_type": "bearer"}
bob_oauth = OAuth(user=bob, token=bob_token, provider="test-service")
chuck = User(name="Chuck")
# chuck doesn't get a token
db.session.add_all([alice, alice_oauth, bob, bob_oauth, chuck])
db.session.commit()
# configure login manager
@login_manager.user_loader
def load_user(userid):
return User.query.get(userid)
# create a simple view
@app.route("/")
def index():
return "success"
with app.test_request_context("/"):
login_user(alice)
# hit /noop to load tokens
blueprint.session.get("/noop")
# now the flask-dance session should have Alice's token loaded
assert blueprint.session.token == alice_token
with app.test_request_context("/"):
# set bob as the logged in user
login_user(bob)
# hit /noop to load tokens
blueprint.session.get("/noop")
# now the flask-dance session should have Bob's token loaded
assert blueprint.session.token == bob_token
with app.test_request_context("/"):
# now let's try chuck
login_user(chuck)
blueprint.session.get("/noop")
assert blueprint.session.token == None
with app.test_request_context("/"):
# no one is logged in -- this is an anonymous user
logout_user()
blueprint.session.get("/noop")
assert blueprint.session.token == None
0
Example 20
def init_app(app):
# Flask-Login
# https://flask-login.readthedocs.org/en/latest/
from flask_login import LoginManager
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.user_loader(load_user)
login_manager.login_view = "/login"
# Setup Flask-Security
security = Security()
security = security.init_app(app, MongoEngineUserDatastore(db, User, Role))
security.send_mail_task(send_mail)
from flask_social_blueprint.core import SocialBlueprint
SocialBlueprint.init_bp(app, SocialConnection, url_prefix="/_social")
@app.before_first_request
def before_first_request():
for m in [User, Role, SocialConnection]:
m.drop_collection()
0
Example 21
Project: burp-ui Source File: __init__.py
def init(conf=None, verbose=0, logfile=None, gunicorn=True, unittest=False, debug=False):
"""Initialize the whole application.
:param conf: Configuration file to use
:type conf: str
:param verbose: Set the verbosity level
:type verbose: int
:param logfile: Store the logs in the given file
:type logfile: str
:param gunicorn: Enable gunicorn engine instead of flask's default
:type gunicorn: bool
:param unittest: Are we running tests (used for test only)
:type unittest: bool
:param debug: Enable debug mode
:type debug: bool
:returns: A :class:`burpui.server.BUIServer` object
"""
from flask import g
from flask_login import LoginManager
from flask_bower import Bower
from flask_babel import gettext
from .utils import basic_login_from_request, ReverseProxied, lookup_file
from .server import BUIServer as BurpUI
from .sessions import session_manager
from .routes import view, mypad
from .api import api, apibp
from .ext.cache import cache
from .ext.i18n import babel, get_locale
logger = logging.getLogger('burp-ui')
# The debug argument used to be a boolean so we keep supporting this format
if isinstance(verbose, bool):
if verbose:
verbose = logging.DEBUG
else:
verbose = logging.CRITICAL
else:
levels = [
logging.CRITICAL,
logging.ERROR,
logging.WARNING,
logging.INFO,
logging.DEBUG
]
if verbose >= len(levels):
verbose = len(levels) - 1
if not verbose:
verbose = 0
verbose = levels[verbose]
if logfile:
from logging.handlers import RotatingFileHandler
handler = RotatingFileHandler(
logfile,
maxBytes=1024 * 1024 * 100,
backupCount=5
)
else:
from logging import StreamHandler
handler = StreamHandler()
if verbose > logging.DEBUG:
LOG_FORMAT = (
'[%(asctime)s] %(levelname)s in '
'%(module)s.%(funcName)s: %(message)s'
)
else:
LOG_FORMAT = (
'-' * 80 + '\n' +
'%(levelname)s in %(module)s.%(funcName)s ' +
'[%(pathname)s:%(lineno)d]:\n' +
'%(message)s\n' +
'-' * 80
)
handler.setLevel(verbose)
handler.setFormatter(Formatter(LOG_FORMAT))
logger.setLevel(verbose)
logger.addHandler(handler)
logger.debug(
'conf: {}\n'.format(conf) +
'verbose: {}\n'.format(logging.getLevelName(verbose)) +
'logfile: {}\n'.format(logfile) +
'gunicorn: {}\n'.format(gunicorn) +
'debug: {}\n'.format(debug) +
'unittest: {}'.format(unittest)
)
if not unittest:
from ._compat import patch_json
patch_json()
# We initialize the core
app = BurpUI()
if verbose:
app.enable_logger()
app.gunicorn = gunicorn
app.config['CFG'] = None
# Some config
# FIXME: strange behavior when bundling errors
# app.config['BUNDLE_ERRORS'] = True
app.config['REMEMBER_COOKIE_HTTPONLY'] = True
if debug and not gunicorn: # pragma: no cover
app.config['DEBUG'] = True and not unittest
app.config['TESTING'] = True and not unittest
# Still need to test conf file here because the init function can be called
# by gunicorn directly
if conf:
app.config['CFG'] = lookup_file(conf, guess=False)
else:
app.config['CFG'] = lookup_file()
logger.info('Using configuration: {}'.format(app.config['CFG']))
app.setup(app.config['CFG'])
if debug:
app.config.setdefault('TEMPLATES_AUTO_RELOAD', True)
app.config['TEMPLATES_AUTO_RELOAD'] = True
app.config['DEBUG'] = True
app.jinja_env.globals.update(
isinstance=isinstance,
list=list,
mypad=mypad,
version_id='{}-{}'.format(__version__, __release__),
config=app.config
)
# manage application secret key
if app.secret_key and (app.secret_key.lower() == 'none' or
(app.secret_key.lower() == 'random' and gunicorn)):
logger.warning('Your setup is not secure! Please consider setting a'
' secret key in your configuration file')
app.secret_key = 'Burp-UI'
if not app.secret_key or app.secret_key.lower() == 'random':
from base64 import b64encode
app.secret_key = b64encode(os.urandom(256))
app.wsgi_app = ReverseProxied(app.wsgi_app, app)
# Manage gunicorn special tricks & improvements
if gunicorn: # pragma: no cover
logger.info('Using gunicorn')
from werkzeug.contrib.fixers import ProxyFix
app.wsgi_app = ProxyFix(app.wsgi_app)
if app.storage and app.storage.lower() != 'default':
try:
# Session setup
if not app.session_db or app.session_db.lower() != 'none':
from redis import Redis
from .ext.session import sess
host, port, pwd = get_redis_server(app)
db = 0
if app.session_db and app.session_db.lower() != 'default':
try:
(_, _, pwd, host, port, db) = \
parse_db_setting(app.session_db)
except ValueError as exp:
logger.warning(str(exp))
try:
db = int(db)
except ValueError:
db = 0
logger.debug('Using redis://guest:cuem@{}:{}/{}'.format(
host,
port,
db)
)
red = Redis(host=host, port=port, db=db, password=pwd)
app.config['SESSION_TYPE'] = 'redis'
app.config['SESSION_REDIS'] = red
app.config['SESSION_USE_SIGNER'] = app.secret_key is not None
app.config['SESSION_PERMANENT'] = False
sess.init_app(app)
session_manager.backend = red
# Cache setup
if not app.cache_db or app.cache_db.lower() != 'none':
host, port, pwd = get_redis_server(app)
db = 1
if app.cache_db and app.cache_db.lower() != 'default':
try:
(_, _, pwd, host, port, db) = \
parse_db_setting(app.cache_db)
except ValueError as exp:
logger.warning(str(exp))
try:
db = int(db)
except ValueError:
db = 1
logger.debug('Using redis://guest:****@{}:{}/{}'.format(
host,
port,
db)
)
cache.init_app(
app,
config={
'CACHE_TYPE': 'redis',
'CACHE_REDIS_HOST': host,
'CACHE_REDIS_PORT': port,
'CACHE_REDIS_PASSWORD': pwd,
'CACHE_REDIS_DB': db
}
)
# clear cache at startup in case we removed or added servers
with app.app_context():
cache.clear()
else:
cache.init_app(app)
except Exception as e:
logger.warning('Unable to initialize redis: {}'.format(str(e)))
cache.init_app(app)
else:
cache.init_app(app)
# Create celery app if enabled
create_celery(app, warn=False)
if app.config['WITH_CELERY']:
# may fail in case redis is not running (this can happen while running
# the bui-manage script)
try:
from .api.async import force_scheduling_now
force_scheduling_now()
except:
pass
# Initialize i18n
babel.init_app(app)
# Create SQLAlchemy if enabled
create_db(app)
# We initialize the API
api.version = __version__
api.release = __release__
api.__url__ = __url__
api.__doc__ = __doc__
api.load_all()
app.register_blueprint(apibp)
# Then we load our routes
view.__url__ = __url__
view.__doc__ = __doc__
app.register_blueprint(view)
# And the login_manager
app.login_manager = LoginManager()
app.login_manager.login_view = 'view.login'
app.login_manager.login_message_category = 'info'
app.login_manager.session_protection = 'strong'
# This is just to have the strings in the .po files
app.login_manager.login_message = gettext(
'Please log in to access this page.'
)
app.login_manager.needs_refresh_message = gettext(
'Please reauthenticate to access this page.'
)
# This will be called at runtime and will then translate the strings
app.login_manager.localize_callback = gettext
app.login_manager.init_app(app)
# Initialize Session Manager
session_manager.init_app(app)
# Initialize Bower ext
app.config.setdefault(
'BOWER_COMPONENTS_ROOT',
os.path.join('static', 'vendor')
)
app.config.setdefault('BOWER_REPLACE_URL_FOR', True)
bower = Bower()
bower.init_app(app)
@app.before_request
def setup_request():
g.locale = get_locale()
# make sure to store secure cookie if required
if app.scookie:
from flask import request
criteria = [
request.is_secure,
request.headers.get('X-Forwarded-Proto', 'http') == 'https'
]
app.config['SESSION_COOKIE_SECURE'] = \
app.config['REMEMBER_COOKIE_SECURE'] = any(criteria)
@app.login_manager.user_loader
def load_user(userid):
"""User loader callback"""
if app.auth != 'none':
return app.uhandler.user(userid)
return None
@app.login_manager.request_loader
def load_user_from_request(request):
"""User loader from request callback"""
if app.auth != 'none':
return basic_login_from_request(request, app)
@app.after_request
def after_request(response):
if getattr(g, 'basic_session', False):
session_manager.invalidate_current_session()
return response
return app
0
Example 22
Project: flask-bitmapist Source File: test_extension.py
def test_flask_login_user_login(app):
# LoginManager could be set up in app fixture in conftest.py instead
login_manager = LoginManager()
login_manager.init_app(app)
# TODO: once event is marked, user id exists in MonthEvents and test will
# continue to pass, regardless of continued success; set to current
# microsecond to temporarily circuemvent, but there should be a better
# way to fix user_id assignment (or tear down redis or something)
user_id = datetime.now().microsecond
with app.test_request_context():
# set up and log in user
user = User()
user.id = user_id
login_user(user)
# test that user was logged in
assert current_user.is_active
assert current_user.is_authenticated
assert current_user == user
# test that user id was marked with 'user:logged_in' event
assert user_id in MonthEvents('user:logged_in', now.year, now.month)
0
Example 23
Project: flask-bitmapist Source File: test_extension.py
def test_flask_login_user_logout(app):
login_manager = LoginManager()
login_manager.init_app(app)
user_id = datetime.now().microsecond
with app.test_request_context():
# set up, log in, and log out user
user = User()
user.id = user_id
login_user(user)
logout_user()
# test that user was logged out
assert not current_user.is_active
assert not current_user.is_authenticated
assert not current_user == user
# test that user id was marked with 'user:logged_out' event
assert user_id in MonthEvents('user:logged_out', now.year, now.month)
0
Example 24
def __init__(self, appbuilder):
super(BaseSecurityManager, self).__init__(appbuilder)
app = self.appbuilder.get_app
# Base Security Config
app.config.setdefault('AUTH_ROLE_ADMIN', 'Admin')
app.config.setdefault('AUTH_ROLE_PUBLIC', 'Public')
app.config.setdefault('AUTH_TYPE', AUTH_DB)
# Self Registration
app.config.setdefault('AUTH_USER_REGISTRATION', False)
app.config.setdefault('AUTH_USER_REGISTRATION_ROLE', self.auth_role_public)
# LDAP Config
if self.auth_type == AUTH_LDAP:
if 'AUTH_LDAP_SERVER' not in app.config:
raise Exception("No AUTH_LDAP_SERVER defined on config with AUTH_LDAP authentication type.")
app.config.setdefault('AUTH_LDAP_SEARCH', '')
app.config.setdefault('AUTH_LDAP_BIND_USER', '')
app.config.setdefault('AUTH_LDAP_APPEND_DOMAIN', '')
app.config.setdefault('AUTH_LDAP_BIND_PASSWORD', '')
app.config.setdefault('AUTH_LDAP_ALLOW_SELF_SIGNED', False)
app.config.setdefault('AUTH_LDAP_UID_FIELD', 'uid')
app.config.setdefault('AUTH_LDAP_FIRSTNAME_FIELD', 'givenName')
app.config.setdefault('AUTH_LDAP_LASTNAME_FIELD', 'sn')
app.config.setdefault('AUTH_LDAP_EMAIL_FIELD', 'mail')
if self.auth_type == AUTH_OID:
self.oid = OpenID(app)
if self.auth_type == AUTH_OAUTH:
from flask_oauthlib.client import OAuth
self.oauth = OAuth()
self.oauth_remotes = dict()
for _provider in self.oauth_providers:
provider_name = _provider['name']
log.debug("OAuth providers init {0}".format(provider_name))
obj_provider = self.oauth.remote_app(provider_name, **_provider['remote_app'])
obj_provider._tokengetter = self.oauth_tokengetter
if not self.oauth_user_info:
self.oauth_user_info = self.get_oauth_user_info
self.oauth_remotes[provider_name] = obj_provider
self.lm = LoginManager(app)
self.lm.login_view = 'login'
self.lm.user_loader(self.load_user)
0
Example 25
def init_app(app):
"""Initialize Flask_Login LoginManager with our app"""
login_module = get_login_module()
if not login_module:
return
login_manager = flask_login.LoginManager()
login_manager.init_app(app)
# login_manager.session_protection = 'strong'
# pylint: disable=unused-variable
@app.login_manager.unauthorized_handler
def unauthorized():
"""Called when the user tries to access an endpoint guarded with
login_required but they are not authorized.
Endpoints like /dashboard, /program/1, etc. redirect the user to the
/login page.
Endpoints like /api /query, /import, etc. resolve with 401 UNAUTHORIZED
and a simple json error object.
"""
if (re.match(r'^(\/api|\/query|\/search)', request.path) or
request.headers.get('X-Requested-By') == 'gGRC'):
return json.dumps({'error': 'unauthorized'}), 401
return redirect(login_url('/login', request.url))
app.route('/login')(login_module.login)
app.route('/logout')(login_module.logout)
app.login_manager.user_loader(user_loader)
if hasattr(login_module, 'before_request'):
app.before_request(login_module.before_request)
0
Example 26
Project: timesketch Source File: __init__.py
def create_app(config=None):
"""Create the Flask app instance that is used throughout the application.
Args:
config: Path to configuration file as a string or an object with config
directives.
Returns:
Application object (instance of flask.Flask).
"""
# Setup the Flask app and load the config.
app = Flask(
__name__, template_folder=u'ui/templates', static_folder=u'ui/static')
if not config:
config = u'/etc/timesketch.conf'
if isinstance(config, unicode):
os.environ[u'TIMESKETCH_SETTINGS'] = config
try:
app.config.from_envvar(u'TIMESKETCH_SETTINGS')
except IOError:
sys.stderr.write(
u'Config file {0} does not exist.\n'.format(config))
sys.exit()
else:
app.config.from_object(config)
# Make sure that SECRET_KEY is configured.
if not app.config[u'SECRET_KEY']:
sys.stderr.write(u'ERROR: Secret key not present. '
u'Please update your configuration.\n'
u'To generate a key you can use openssl:\n\n'
u'$ openssl rand -base64 32\n\n')
sys.exit()
# Setup the database.
configure_engine(app.config[u'SQLALCHEMY_DATABASE_URI'])
db = init_db()
# Alembic migration support:
# http://alembic.zzzcomputing.com/en/latest/
migrate = Migrate()
migrate.init_app(app, db)
# Register blueprints. Blueprints are a way to organize your Flask
# Flask application. See this for more information:
# http://flask.pocoo.org/docs/latest/blueprints/
app.register_blueprint(user_views)
app.register_blueprint(home_views)
app.register_blueprint(sketch_views)
app.register_blueprint(story_views)
# Setup URL routes for the API.
api_v1 = Api(app, prefix=u'/api/v1')
api_v1.add_resource(SketchListResource, u'/sketches/')
api_v1.add_resource(SketchResource, u'/sketches/<int:sketch_id>/')
api_v1.add_resource(
AggregationResource, u'/sketches/<int:sketch_id>/aggregation/')
api_v1.add_resource(ExploreResource, u'/sketches/<int:sketch_id>/explore/')
api_v1.add_resource(EventResource, u'/sketches/<int:sketch_id>/event/')
api_v1.add_resource(
EventAnnotationResource, u'/sketches/<int:sketch_id>/event/annotate/')
api_v1.add_resource(ViewListResource, u'/sketches/<int:sketch_id>/views/')
api_v1.add_resource(
ViewResource, u'/sketches/<int:sketch_id>/views/<int:view_id>/')
api_v1.add_resource(SearchTemplateListResource, u'/searchtemplate/')
api_v1.add_resource(
SearchTemplateResource, u'/searchtemplate/<int:searchtemplate_id>/')
api_v1.add_resource(UploadFileResource, u'/upload/')
api_v1.add_resource(TaskResource, u'/tasks/')
api_v1.add_resource(
StoryListResource, u'/sketches/<int:sketch_id>/stories/')
api_v1.add_resource(
StoryResource, u'/sketches/<int:sketch_id>/stories/<int:story_id>/')
api_v1.add_resource(
QueryResource, u'/sketches/<int:sketch_id>/explore/query/')
# Register error handlers
# pylint: disable=unused-variable
@app.errorhandler(ApiHTTPError)
def handle_api_http_error(error):
"""Error handler for API HTTP errors.
Returns:
HTTP response object (instance of flask.wrappers.Response)
"""
return error.build_response()
# Setup the login manager.
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = u'user_views.login'
# This is used by the flask_login extension.
# pylint: disable=unused-variable
@login_manager.user_loader
def load_user(user_id):
"""Based on a user_id (database primary key for a user) this function
loads a user from the database. It is used by the Flask-Login extension
to setup up the session for the user.
Args:
user_id: Integer primary key for the user.
Returns:
A user object (Instance of timesketch.models.user.User).
"""
return User.query.get(user_id)
# Setup CSRF protection for the whole application
CsrfProtect(app)
return app
0
Example 27
Project: Flask-Blogging Source File: test_signals.py
def setUp(self):
FlaskBloggingTestCase.setUp(self)
self._create_storage()
self.app.config["BLOGGING_URL_PREFIX"] = "/blog"
self.app.config["BLOGGING_PLUGINS"] = ["test.plugin"]
self.engine = self._create_blogging_engine()
self.login_manager = LoginManager(self.app)
@self.login_manager.user_loader
@self.engine.user_loader
def load_user(user_id):
return TestUser(user_id)
@self.app.route("/login/<username>/", methods=["POST"],
defaults={"blogger": 0})
@self.app.route("/login/<username>/<int:blogger>/", methods=["POST"])
def login(username, blogger):
this_user = TestUser(username)
login_user(this_user)
if blogger:
identity_changed.send(current_app._get_current_object(),
identity=Identity(username))
return redirect("/")
@self.app.route("/logout/")
def logout():
logout_user()
identity_changed.send(current_app._get_current_object(),
identity=AnonymousIdentity())
return redirect("/")
for i in range(20):
tags = ["hello"] if i < 10 else ["world"]
user = "testuser" if i < 10 else "newuser"
self.storage.save_post(title="Sample Title%d" % i,
text="Sample Text%d" % i,
user_id=user, tags=tags)
0
Example 28
Project: Flask-Blogging Source File: test_views.py
def setUp(self):
FlaskBloggingTestCase.setUp(self)
self._create_storage()
self.app.config["BLOGGING_URL_PREFIX"] = "/blog"
self.app.config["BLOGGING_PLUGINS"] = []
self.engine = self._create_blogging_engine()
self.login_manager = LoginManager(self.app)
@self.login_manager.user_loader
@self.engine.user_loader
def load_user(user_id):
return TestUser(user_id)
@self.app.route("/login/<username>/", methods=["POST"],
defaults={"blogger": 0})
@self.app.route("/login/<username>/<int:blogger>/", methods=["POST"])
def login(username, blogger):
this_user = TestUser(username)
login_user(this_user)
if blogger:
identity_changed.send(current_app._get_current_object(),
identity=Identity(username))
return redirect("/")
@self.app.route("/logout/")
def logout():
logout_user()
identity_changed.send(current_app._get_current_object(),
identity=AnonymousIdentity())
return redirect("/")
for i in range(20):
tags = ["hello"] if i < 10 else ["world"]
user = "testuser" if i < 10 else "newuser"
self.storage.save_post(title="Sample Title%d" % i,
text="Sample Text%d" % i,
user_id=user, tags=tags)
0
Example 29
Project: postgresql-audit Source File: test_flask_integration.py
@pytest.fixture
def login_manager():
return LoginManager()
0
Example 30
def test_init_app(self):
login_manager = LoginManager()
login_manager.init_app(self.app, add_context_processor=True)
self.assertIsInstance(login_manager, LoginManager)
0
Example 31
def test_class_init(self):
login_manager = LoginManager(self.app, add_context_processor=True)
self.assertIsInstance(login_manager, LoginManager)
0
Example 32
Project: flask-login Source File: test_login.py
def test_login_disabled_is_set(self):
login_manager = LoginManager(self.app, add_context_processor=True)
self.assertFalse(login_manager._login_disabled)
0
Example 33
def setUp(self):
self.app = Flask(__name__)
self.login_manager = LoginManager()
self.login_manager.init_app(self.app)
self.login_manager._login_disabled = False
class SecretEndpoint(MethodView):
decorators = [
login_required,
fresh_login_required,
]
def options(self):
return u''
def get(self):
return u''
self.app.add_url_rule('/secret',
view_func=SecretEndpoint.as_view('secret'))
0
Example 34
Project: flask-login Source File: test_login.py
def setUp(self):
self.app = Flask(__name__)
self.app.config['SECRET_KEY'] = 'deterministic'
self.app.config['SESSION_PROTECTION'] = None
self.remember_cookie_name = 'remember'
self.app.config['REMEMBER_COOKIE_NAME'] = self.remember_cookie_name
self.login_manager = LoginManager()
self.login_manager.init_app(self.app)
self.login_manager._login_disabled = False
@self.app.route('/')
def index():
return u'Welcome!'
@self.app.route('/secret')
def secret():
return self.login_manager.unauthorized()
@self.app.route('/login-notch')
def login_notch():
return unicode(login_user(notch))
@self.app.route('/login-notch-remember')
def login_notch_remember():
return unicode(login_user(notch, remember=True))
@self.app.route('/login-notch-permanent')
def login_notch_permanent():
session.permanent = True
return unicode(login_user(notch))
@self.app.route('/needs-refresh')
def needs_refresh():
return self.login_manager.needs_refresh()
@self.app.route('/confirm-login')
def _confirm_login():
confirm_login()
return u''
@self.app.route('/username')
def username():
if current_user.is_authenticated:
return current_user.name
return u'Anonymous'
@self.app.route('/is-fresh')
def is_fresh():
return unicode(login_fresh())
@self.app.route('/logout')
def logout():
return unicode(logout_user())
@self.login_manager.user_loader
def load_user(user_id):
return USERS[int(user_id)]
@self.login_manager.header_loader
def load_user_from_header(header_value):
if header_value.startswith('Basic '):
header_value = header_value.replace('Basic ', '', 1)
try:
user_id = base64.b64decode(header_value)
except TypeError:
pass
return USERS.get(int(user_id))
@self.login_manager.request_loader
def load_user_from_request(request):
user_id = request.args.get('user_id')
try:
user_id = int(float(user_id))
except TypeError:
pass
return USERS.get(user_id)
@self.app.route('/empty_session')
def empty_session():
return unicode(u'modified=%s' % session.modified)
# This will help us with the possibility of typoes in the tests. Now
# we shouldn't have to check each response to help us set up state
# (such as login pages) to make sure it worked: we will always
# get an exception raised (rather than return a 404 response)
@self.app.errorhandler(404)
def handle_404(e):
raise e
unittest.TestCase.setUp(self)
0
Example 35
Project: flask-login Source File: test_login.py
def setUp(self):
self.app = Flask(__name__)
self.app.config['SECRET_KEY'] = 'deterministic'
self.app.config['SESSION_PROTECTION'] = None
self.remember_cookie_name = 'remember'
self.app.config['REMEMBER_COOKIE_NAME'] = self.remember_cookie_name
self.login_manager = LoginManager()
self.login_manager.init_app(self.app)
self.login_manager._login_disabled = False
@self.app.route('/')
def index():
return u'Welcome!'
@self.app.route('/login-germanjapanese-remember')
def login_germanjapanese_remember():
return unicode(login_user(germanjapanese, remember=True))
@self.app.route('/username')
def username():
if current_user.is_authenticated:
return current_user.name
return u'Anonymous'
@self.app.route('/userid')
def user_id():
if current_user.is_authenticated:
return current_user.id
return u'wrong_id'
@self.login_manager.user_loader
def load_user(user_id):
return USERS[unicode(user_id)]
# This will help us with the possibility of typoes in the tests. Now
# we shouldn't have to check each response to help us set up state
# (such as login pages) to make sure it worked: we will always
# get an exception raised (rather than return a 404 response)
@self.app.errorhandler(404)
def handle_404(e):
raise e
unittest.TestCase.setUp(self)
0
Example 36
Project: vulyk Source File: users.py
def init_social_login(app, db):
"""
Login manager initialisation.
:param app: Main application instance
:type app: flask.Flask
:param db: MongoDB wrapper instance
:type db: flask_mongoengine.MongoEngine
"""
app.register_blueprint(social_auth)
init_social(app, db)
login_manager = login.LoginManager()
login_manager.login_view = 'index'
login_manager.login_message = ''
login_manager.init_app(app)
@login_manager.user_loader
def load_user(userid):
try:
user = User.objects.get(id=userid)
if user:
user.last_login = datetime.datetime.now()
user.save()
return user
except (TypeError, ValueError, User.DoesNotExist):
return None
@app.before_request
def global_user():
g.user = login.current_user
@app.context_processor
def inject_user():
try:
return {'user': g.user}
except AttributeError:
return {'user': None}
app.context_processor(backends)